.. _program_listing_file_include_flamegpu_runtime_messaging_MessageSpatial3D_MessageSpatial3DHost.h:

Program Listing for File MessageSpatial3DHost.h
===============================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_flamegpu_runtime_messaging_MessageSpatial3D_MessageSpatial3DHost.h>` (``include/flamegpu/runtime/messaging/MessageSpatial3D/MessageSpatial3DHost.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #ifndef INCLUDE_FLAMEGPU_RUNTIME_MESSAGING_MESSAGESPATIAL3D_MESSAGESPATIAL3DHOST_H_
   #define INCLUDE_FLAMEGPU_RUNTIME_MESSAGING_MESSAGESPATIAL3D_MESSAGESPATIAL3DHOST_H_
   
   #include <memory>
   #include <string>
   
   #include "flamegpu/simulation/detail/CUDAMessage.h"
   #include "flamegpu/util/nvtx.h"
   #include "flamegpu/runtime/messaging/MessageSpatial3D.h"
   #include "flamegpu/runtime/messaging/MessageSpatial2D/MessageSpatial2DHost.h"
   #include "flamegpu/runtime/messaging/MessageBruteForce/MessageBruteForceHost.h"
   
   namespace flamegpu {
   
   class MessageSpatial3D::CUDAModelHandler : public MessageSpecialisationHandler {
    public:
        explicit CUDAModelHandler(detail::CUDAMessage& a);
       ~CUDAModelHandler() override { }
       void init(detail::CUDAScatter &scatter, unsigned int streamId, cudaStream_t stream) override;
       void buildIndex(detail::CUDAScatter &scatter, unsigned int streamId, cudaStream_t stream) override;
       void allocateMetaDataDevicePtr(cudaStream_t stream) override;
       void freeMetaDataDevicePtr() override;
       const void *getMetaDataDevicePtr() const override { return d_data; }
   
    private:
       void resizeCubTemp(cudaStream_t stream);
       void resizeKeysVals(unsigned int newSize);
       unsigned int binCount = 0;
       size_t d_CUB_temp_storage_bytes = 0;
       unsigned int *d_CUB_temp_storage = nullptr;
       unsigned int *d_histogram = nullptr;
       unsigned int *d_keys = nullptr, *d_vals = nullptr;
       size_t d_keys_vals_storage_bytes = 0;
       MetaData hd_data;
       MetaData *d_data = nullptr;
       detail::CUDAMessage &sim_message;
   };
   
   struct MessageSpatial3D::Data : public MessageSpatial2D::Data {
       friend class ModelDescription;
       friend struct ModelData;
       float minZ;
       float maxZ;
       virtual ~Data() = default;
   
       std::unique_ptr<MessageSpecialisationHandler> getSpecialisationHander(detail::CUDAMessage &owner) const override;
   
       std::type_index getType() const override;
       flamegpu::MessageSortingType getSortingType() const override;
   
    protected:
       Data *clone(const std::shared_ptr<const ModelData> &newParent) override;
       Data(std::shared_ptr<const ModelData>, const Data &other);
       Data(std::shared_ptr<const ModelData>, const std::string &message_name);
   };
   
   class MessageSpatial3D::CDescription : public MessageSpatial2D::CDescription {
       friend struct Data;
   
    public:
       explicit CDescription(std::shared_ptr<Data> data);
       explicit CDescription(std::shared_ptr<const Data> data);
       CDescription(const CDescription& other_agent) = default;
       CDescription(CDescription&& other_agent) = default;
       CDescription& operator=(const CDescription& other_agent) = default;
       CDescription& operator=(CDescription&& other_agent) = default;
       bool operator==(const CDescription& rhs) const;
       bool operator!=(const CDescription& rhs) const;
   
       float getMinZ() const;
       float getMaxZ() const;
   };
   class MessageSpatial3D::Description : public CDescription {
    public:
       explicit Description(std::shared_ptr<Data> data);
       Description(const Description& other_message) = default;
       Description(Description&& other_message) = default;
       Description& operator=(const Description& other_message) = default;
       Description& operator=(Description&& other_message) = default;
   
       using MessageBruteForce::CDescription::setPersistent;
       using MessageBruteForce::CDescription::newVariable;
   #ifdef SWIG
       using MessageBruteForce::CDescription::newVariableArray;
   #endif
   
       using MessageSpatial2D::CDescription::setRadius;
       using MessageSpatial2D::CDescription::setMinX;
       using MessageSpatial2D::CDescription::setMinY;
       using MessageSpatial2D::CDescription::setMin;
       using MessageSpatial2D::CDescription::setMaxX;
       using MessageSpatial2D::CDescription::setMaxY;
       using MessageSpatial2D::CDescription::setMax;
   
       void setMinZ(float z);
       void setMaxZ(float z);
       void setMin(float x, float y, float z);
       void setMax(float x, float y, float z);
   };
   
   }  // namespace flamegpu
   
   #endif  // INCLUDE_FLAMEGPU_RUNTIME_MESSAGING_MESSAGESPATIAL3D_MESSAGESPATIAL3DHOST_H_