#pragma once #include #include #include #include #include #include #include #include #include #include #include namespace mbgl { class Color; class PaintParameters; enum class RenderPass : uint8_t; namespace gfx { class ColorMode; class CullFaceMode; enum class DepthMaskType : bool; class DrawableTweaker; class DrawMode; class ShaderProgramBase; class VertexAttributeArray; using DrawPriority = int64_t; using DrawableTweakerPtr = std::shared_ptr; using ShaderProgramBasePtr = std::shared_ptr; using Texture2DPtr = std::shared_ptr; class Drawable { public: /// @brief Map from sampler location to texture info using Textures = std::unordered_map; protected: Drawable(std::string name); public: virtual ~Drawable(); struct DrawSegment; using UniqueDrawSegment = std::unique_ptr; const util::SimpleIdentity& getId() const { return uniqueID; } /// Draw the drawable virtual void draw(PaintParameters&) const = 0; /// Drawable name is used for debugging and troubleshooting const std::string& getName() const { return name; } void setName(std::string value) { name = std::move(value); } /// Which shader to use when rendering this drawable const gfx::ShaderProgramBasePtr& getShader() const { return shader; } void setShader(gfx::ShaderProgramBasePtr value) { shader = std::move(value); } /// The pass on which we'll be rendered mbgl::RenderPass getRenderPass() const { return renderPass; } void setRenderPass(mbgl::RenderPass value) { renderPass = value; } /// Test whether to draw this drawable in a given render pass. bool hasRenderPass(const mbgl::RenderPass value) const { return (mbgl::underlying_type(renderPass) & mbgl::underlying_type(value)) != 0; } /// Test whether to draw this drawable in a given render pass. /// If multiple render pass bits are set, all must be present. bool hasAllRenderPasses(const mbgl::RenderPass value) const { const auto underlying_value = mbgl::underlying_type(value); return (mbgl::underlying_type(renderPass) & underlying_value) == underlying_value; } /// Width for lines int32_t getLineWidth() const { return lineWidth; } void setLineWidth(int32_t value) { lineWidth = value; } /// @brief Remove an attached texture from this drawable at the given sampler location /// @param location Texture sampler location void removeTexture(int32_t location); /// @brief Return the textures attached to this drawable /// @return Texture and sampler location pairs const Textures& getTextures() const { return textures; }; /// @brief Get the texture at the given sampler location. const gfx::Texture2DPtr& getTexture(int32_t location) const; /// @brief Set the collection of textures bound to this drawable /// @param textures_ A Textures collection to set void setTextures(const Textures& textures_) noexcept { textures = textures_; } void setTextures(Textures&& textures_) noexcept { textures = std::move(textures_); } /// @brief Attach the given texture to this drawable at the given sampler location. /// @param texture Texture2D instance /// @param location A sampler location in the shader being used with this drawable. void setTexture(gfx::Texture2DPtr texture, int32_t location); /// Whether the drawble should be drawn bool getEnabled() const { return enabled; } void setEnabled(bool value) { enabled = value; } /// Whether to render to the color target bool getEnableColor() const { return enableColor; } void setEnableColor(bool value) { enableColor = value; } /// Whether to do stenciling (based on the Tile ID or 3D) bool getEnableStencil() const { return enableStencil; } void setEnableStencil(bool value) { enableStencil = value; } /// not used for anything yet DrawPriority getDrawPriority() const { return drawPriority; } void setDrawPriority(DrawPriority value) { drawPriority = value; } /// Determines depth range within the layer for 2D drawables int32_t getSubLayerIndex() const { return subLayerIndex; } void setSubLayerIndex(int32_t value) { subLayerIndex = value; } /// Depth writability for 2D drawables DepthMaskType getDepthType() const { return depthType; } void setDepthType(DepthMaskType value) { depthType = value; } /// Uses 3D depth mode bool getIs3D() const { return is3D; } void setIs3D(bool value) { is3D = value; } /// Is custom bool getIsCustom() const { return isCustom; } void setIsCustom(bool value) { isCustom = value; } /// The ID of the tile that this drawable represents, if any const std::optional& getTileID() const { return tileID; } void setTileID(const OverscaledTileID& value) { tileID = value; } const gfx::CullFaceMode& getCullFaceMode() const; void setCullFaceMode(const gfx::CullFaceMode&); const gfx::ColorMode& getColorMode() const; void setColorMode(const gfx::ColorMode&); /// Get the vertex attributes that override default values in the shader program virtual const gfx::VertexAttributeArray& getVertexAttributes() const = 0; virtual gfx::VertexAttributeArray& mutableVertexAttributes() = 0; virtual void setVertexAttributes(const gfx::VertexAttributeArray&) = 0; virtual void setVertexAttributes(gfx::VertexAttributeArray&&) = 0; /// Provide raw data for vertices /// Incompatible with adding primitives virtual void setVertices(std::vector&&, std::size_t, AttributeDataType) = 0; /// Create a segment wrapper virtual void setIndexData(std::vector indexes, std::vector segments) = 0; /// Get the tweakers attached to this drawable const std::vector& getTweakers() const { return tweakers; } void addTweaker(DrawableTweakerPtr value) { tweakers.emplace_back(std::move(value)); } void setTweakers(std::vector value) { tweakers = std::move(value); } void clearTweakers() { tweakers.clear(); } /// Get the uniform buffers attached to this drawable virtual const gfx::UniformBufferArray& getUniformBuffers() const = 0; virtual gfx::UniformBufferArray& mutableUniformBuffers() = 0; const UniqueDrawableData& getData() const { return drawableData; } void setData(UniqueDrawableData&& value) { drawableData = std::move(value); } protected: bool enabled = true; bool enableColor = true; bool enableStencil = false; bool is3D = false; bool isCustom = false; std::string name; const util::SimpleIdentity uniqueID; gfx::ShaderProgramBasePtr shader; mbgl::RenderPass renderPass; std::optional tileID; DrawPriority drawPriority = 0; int32_t lineWidth = 1; int32_t subLayerIndex = 0; DepthMaskType depthType; // = DepthMaskType::ReadOnly; UniqueDrawableData drawableData{}; struct Impl; std::unique_ptr impl; Textures textures; std::vector tweakers; }; using DrawablePtr = std::shared_ptr; using UniqueDrawable = std::unique_ptr; /// Comparator for sorting drawable pointers primarily by draw priority struct DrawableLessByPriority { DrawableLessByPriority(bool descending = false) : desc(descending) {} bool operator()(const Drawable& left, const Drawable& right) const { const auto& a = desc ? right : left; const auto& b = desc ? left : right; if (a.getDrawPriority() != b.getDrawPriority()) { return a.getDrawPriority() < b.getDrawPriority(); } return a.getId() < b.getId(); } bool operator()(const Drawable* left, const Drawable* right) const { return operator()(*left, *right); } bool operator()(const UniqueDrawable& left, const UniqueDrawable& right) const { return operator()(*left, *right); } bool operator()(const DrawablePtr& left, const DrawablePtr& right) const { const auto& a = desc ? right : left; const auto& b = desc ? left : right; // nulls are less than non-nulls return (a && b) ? operator()(*a, *b) : (!a && b); } private: bool desc; }; } // namespace gfx } // namespace mbgl