1 #ifndef DALI_GRAPHICS_API_TYPES
2 #define DALI_GRAPHICS_API_TYPES
5 * Copyright (c) 2021 Samsung Electronics Co., Ltd.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
39 * @brief Structure describes 2D offset
48 * @brief Structure describes 2D dimensions
57 * @brief Structure describes 2D rectangle (offset, extent)
68 * @brief Structure represents area of viewport
76 float minDepth = 0.0f;
77 float maxDepth = 0.0f;
81 * @brief Describes vertex attribute input rate
83 enum class VertexInputRate
85 PER_VERTEX, ///< Attribute read per vertex
86 PER_INSTANCE ///< Attribute read per instance
90 * @brief Vertex input format
92 * When UNDEFINED, the reflection is used to determine what
93 * the actual format is.
95 enum class VertexInputFormat
109 * @brief Logic operators used by color blending state
110 * when logicOpEnable is set.
133 * @brief Blend factors
135 enum class BlendFactor
140 ONE_MINUS_SRC_COLOR = 3,
142 ONE_MINUS_DST_COLOR = 5,
144 ONE_MINUS_SRC_ALPHA = 7,
146 ONE_MINUS_DST_ALPHA = 9,
148 ONE_MINUS_CONSTANT_COLOR = 11,
150 ONE_MINUS_CONSTANT_ALPHA = 13,
151 SRC_ALPHA_SATURATE = 14,
153 ONE_MINUS_SRC1_COLOR = 16,
155 ONE_MINUS_SRC1_ALPHA = 18,
159 * @brief Blend operators
165 REVERSE_SUBTRACT = 2,
171 * @brief Compare operators
186 * @brief Stencil operators
201 * @brief Backface culling modes
212 * @brief Polygon drawing modes
214 enum class PolygonMode
222 * @brief Front face direction
231 * @brief Primitive geometry topology
233 enum class PrimitiveTopology
245 * @brief Sampler address ( wrapping ) mode
247 enum class SamplerAddressMode
257 * @brief Filtering mode
259 enum class SamplerFilter
268 enum class SamplerMipmapMode
276 * @brief Describes pipeline's color blend state
278 struct ColorBlendState
280 bool logicOpEnable = false;
281 LogicOp logicOp = {};
282 float blendConstants[4] = {0.0f, 0.0f, 0.0f, 0.0f};
283 bool blendEnable = false;
284 BlendFactor srcColorBlendFactor = BlendFactor::ZERO;
285 BlendFactor dstColorBlendFactor = BlendFactor::ZERO;
286 BlendOp colorBlendOp = {};
287 BlendFactor srcAlphaBlendFactor = BlendFactor::ZERO;
288 BlendFactor dstAlphaBlendFactor = BlendFactor::ZERO;
289 BlendOp alphaBlendOp = {};
290 uint32_t colorComponentWriteBits = {0u};
292 auto& SetLogicOpEnable(bool value)
294 logicOpEnable = value;
298 auto& SetLogicOp(LogicOp value)
304 auto& SetBlendConstants(float value[4])
306 std::copy(value, value + 4, blendConstants);
310 auto& SetBlendEnable(bool value)
316 auto& SetSrcColorBlendFactor(BlendFactor value)
318 srcColorBlendFactor = value;
322 auto& SetDstColorBlendFactor(BlendFactor value)
324 dstColorBlendFactor = value;
328 auto& SetColorBlendOp(BlendOp value)
330 colorBlendOp = value;
334 auto& SetSrcAlphaBlendFactor(BlendFactor value)
336 srcAlphaBlendFactor = value;
340 auto& SetDstAlphaBlendFactor(BlendFactor value)
342 dstAlphaBlendFactor = value;
346 auto& SetAlphaBlendOp(BlendOp value)
348 alphaBlendOp = value;
352 auto& SetColorComponentsWriteBits(uint32_t value)
354 colorComponentWriteBits = value;
360 * @brief Program State
364 const Program* program{nullptr};
366 auto& SetProgram(const Program& value)
374 * @brief Framebuffer state.
376 struct FramebufferState
378 const Framebuffer* framebuffer{nullptr};
380 auto& SetFramebuffer(const Framebuffer& value)
382 framebuffer = &value;
388 * @brief Describes pipeline's viewport and scissor state
392 Viewport viewport{0.0, 0.0, 0.0, 0.0};
393 Rect2D scissor{0, 0, 0, 0};
394 bool scissorTestEnable{false};
396 auto& SetViewport(const Viewport& value)
402 auto& SetScissor(const Rect2D& value)
408 auto& SetScissorTestEnable(bool value)
410 scissorTestEnable = value;
416 * @brief Describes stencil operation state
418 struct StencilOpState
422 StencilOp depthFailOp{};
423 CompareOp compareOp{};
424 uint32_t compareMask{0u};
425 uint32_t writeMask{0u};
426 uint32_t reference{0u};
428 auto& SetFailOp(StencilOp value)
434 auto& SetPassOp(StencilOp value)
440 auto& SetDepthFailOp(StencilOp value)
446 auto& SetCompareOp(CompareOp value)
452 auto& SetCompareMask(uint32_t value)
458 auto& SetWriteMask(uint32_t value)
464 auto& SetReference(uint32_t value)
472 * @brief Describes pipeline's viewport and scissor state
474 struct DepthStencilState
476 bool depthTestEnable{false};
477 bool depthWriteEnable{false};
478 CompareOp depthCompareOp{};
480 bool stencilTestEnable{false};
481 StencilOpState front{};
482 StencilOpState back{};
484 auto& SetDepthTestEnable(bool value)
486 depthTestEnable = value;
490 auto& SetDepthWriteEnable(bool value)
492 depthWriteEnable = value;
496 auto& SetDepthCompareOp(CompareOp value)
498 depthCompareOp = value;
502 auto& SetFront(StencilOpState value)
508 auto& SetBack(StencilOpState value)
514 auto& SetStencilTestEnable(bool value)
516 stencilTestEnable = value;
522 * @brief Rasterization state descriptor
524 struct RasterizationState
527 PolygonMode polygonMode{};
528 FrontFace frontFace{};
530 auto& SetCullMode(CullMode value)
536 auto& SetPolygonMode(PolygonMode value)
542 auto& SetFrontFace(FrontFace value)
550 * @brief Input assembly state descriptor.
552 * Structure describes the topology for submitted
555 struct InputAssemblyState
557 PrimitiveTopology topology{};
558 bool primitiveRestartEnable{true};
560 auto& SetTopology(PrimitiveTopology value)
566 auto& SetPrimitiveRestartEnable(bool value)
568 primitiveRestartEnable = true;
574 * @brief Pipeline dynamic state bits
576 namespace PipelineDynamicStateBits
578 const uint32_t VIEWPORT_BIT = 1 << 0;
579 const uint32_t SCISSOR_BIT = 1 << 1;
580 const uint32_t LINE_WIDTH_BIT = 1 << 2;
581 const uint32_t DEPTH_BIAS_BIT = 1 << 3;
582 const uint32_t BLEND_CONSTANTS_BIT = 1 << 4;
583 const uint32_t DEPTH_BOUNDS_BIT = 1 << 5;
584 const uint32_t STENCIL_COMPARE_MASK_BIT = 1 << 6;
585 const uint32_t STENCIL_WRITE_MASK_BIT = 1 << 7;
586 const uint32_t STENCIL_REFERENCE_BIT = 1 << 8;
587 } // namespace PipelineDynamicStateBits
589 const uint32_t PIPELINE_DYNAMIC_STATE_COUNT(9u);
591 using PipelineDynamicStateMask = uint32_t;
594 * @brief Structure describes vertex input state of the pipeline.
595 * It specifies buffer binding and attribute format to be used.
597 struct VertexInputState
599 VertexInputState() = default;
602 * @brief Vertex buffer binding
606 Binding(uint32_t _stride, VertexInputRate _inputRate)
608 inputRate(_inputRate)
612 VertexInputRate inputRate;
616 * @brief Attribute description
620 Attribute(uint32_t _location, uint32_t _binding, uint32_t _offset, VertexInputFormat _format)
621 : location(_location),
631 VertexInputFormat format;
634 VertexInputState(std::vector<Binding> _bufferBindings, std::vector<Attribute> _attributes)
635 : bufferBindings(std::move(_bufferBindings)),
636 attributes(std::move(_attributes))
640 std::vector<Binding> bufferBindings{};
641 std::vector<Attribute> attributes{};
645 * @brief List of all possible formats
646 * Not all formats may be supported
651 // GLES compatible, luminance doesn't exist in Vulkan
657 R4G4B4A4_UNORM_PACK16,
658 B4G4R4A4_UNORM_PACK16,
661 R5G5B5A1_UNORM_PACK16,
662 B5G5R5A1_UNORM_PACK16,
663 A1R5G5B5_UNORM_PACK16,
706 A8B8G8R8_UNORM_PACK32,
707 A8B8G8R8_SNORM_PACK32,
708 A8B8G8R8_USCALED_PACK32,
709 A8B8G8R8_SSCALED_PACK32,
710 A8B8G8R8_UINT_PACK32,
711 A8B8G8R8_SINT_PACK32,
712 A8B8G8R8_SRGB_PACK32,
713 A2R10G10B10_UNORM_PACK32,
714 A2R10G10B10_SNORM_PACK32,
715 A2R10G10B10_USCALED_PACK32,
716 A2R10G10B10_SSCALED_PACK32,
717 A2R10G10B10_UINT_PACK32,
718 A2R10G10B10_SINT_PACK32,
719 A2B10G10R10_UNORM_PACK32,
720 A2B10G10R10_SNORM_PACK32,
721 A2B10G10R10_USCALED_PACK32,
722 A2B10G10R10_SSCALED_PACK32,
723 A2B10G10R10_UINT_PACK32,
724 A2B10G10R10_SINT_PACK32,
748 R16G16B16A16_USCALED,
749 R16G16B16A16_SSCALED,
777 R11G11B10_UFLOAT_PACK32,
778 B10G11R11_UFLOAT_PACK32,
779 E5B9G9R9_UFLOAT_PACK32,
789 BC1_RGBA_UNORM_BLOCK,
803 ETC2_R8G8B8_UNORM_BLOCK,
804 ETC2_R8G8B8_SRGB_BLOCK,
805 ETC2_R8G8B8A1_UNORM_BLOCK,
806 ETC2_R8G8B8A1_SRGB_BLOCK,
807 ETC2_R8G8B8A8_UNORM_BLOCK,
808 ETC2_R8G8B8A8_SRGB_BLOCK,
811 EAC_R11G11_UNORM_BLOCK,
812 EAC_R11G11_SNORM_BLOCK,
813 ASTC_4x4_UNORM_BLOCK,
815 ASTC_5x4_UNORM_BLOCK,
817 ASTC_5x5_UNORM_BLOCK,
819 ASTC_6x5_UNORM_BLOCK,
821 ASTC_6x6_UNORM_BLOCK,
823 ASTC_8x5_UNORM_BLOCK,
825 ASTC_8x6_UNORM_BLOCK,
827 ASTC_8x8_UNORM_BLOCK,
829 ASTC_10x5_UNORM_BLOCK,
830 ASTC_10x5_SRGB_BLOCK,
831 ASTC_10x6_UNORM_BLOCK,
832 ASTC_10x6_SRGB_BLOCK,
833 ASTC_10x8_UNORM_BLOCK,
834 ASTC_10x8_SRGB_BLOCK,
835 ASTC_10x10_UNORM_BLOCK,
836 ASTC_10x10_SRGB_BLOCK,
837 ASTC_12x10_UNORM_BLOCK,
838 ASTC_12x10_SRGB_BLOCK,
839 ASTC_12x12_UNORM_BLOCK,
840 ASTC_12x12_SRGB_BLOCK,
841 PVRTC1_2BPP_UNORM_BLOCK_IMG,
842 PVRTC1_4BPP_UNORM_BLOCK_IMG,
843 PVRTC2_2BPP_UNORM_BLOCK_IMG,
844 PVRTC2_4BPP_UNORM_BLOCK_IMG,
845 PVRTC1_2BPP_SRGB_BLOCK_IMG,
846 PVRTC1_4BPP_SRGB_BLOCK_IMG,
847 PVRTC2_2BPP_SRGB_BLOCK_IMG,
848 PVRTC2_4BPP_SRGB_BLOCK_IMG,
852 * @brief Flags specifying a buffer usage
854 enum class BufferUsage
856 TRANSFER_SRC = 1 << 0,
857 TRANSFER_DST = 1 << 1,
858 UNIFORM_TEXEL_BUFFER = 1 << 2,
859 STORAGE_TEXEL_BUFFER = 1 << 3,
860 UNIFORM_BUFFER = 1 << 4,
861 STORAGE_BUFFER = 1 << 5,
862 INDEX_BUFFER = 1 << 6,
863 VERTEX_BUFFER = 1 << 7,
864 INDIRECT_BUFFER = 1 << 8,
867 using BufferUsageFlags = uint32_t;
869 inline BufferUsageFlags operator|(BufferUsageFlags flags, BufferUsage usage)
871 flags |= static_cast<uint32_t>(usage);
876 * @brief Buffer property bits
878 * Use these bits to set BufferPropertiesFlags.
880 enum class BufferPropertiesFlagBit : uint32_t
882 CPU_ALLOCATED = 1 << 0, ///< Buffer is allocated on the CPU side
883 TRANSIENT_MEMORY = 1 << 1, ///< Buffer memory will be short-lived
887 * @brief BufferPropetiesFlags alters behaviour of implementation
889 using BufferPropertiesFlags = uint32_t;
891 inline BufferPropertiesFlags operator|(BufferPropertiesFlags flags, BufferPropertiesFlagBit usage)
893 flags |= static_cast<uint32_t>(usage);
898 * @brief The structure describes memory requirements of GPU resource (texture, buffer)
900 struct MemoryRequirements
906 using TextureUpdateFlags = uint32_t;
907 enum class TextureUpdateFlagBits
909 KEEP_SOURCE = 1 << 0,
913 * @brief Texture update info
915 * Describes the texture update to be executed by
916 * Controller::UpdateTextures()
918 struct TextureUpdateInfo
920 Texture* dstTexture{};
921 Offset2D dstOffset2D;
925 uint32_t srcReference{};
926 Extent2D srcExtent2D{};
927 uint32_t srcOffset{};
929 Format srcFormat{}; ///< Should match dstTexture's format, otherwise conversion may occur
933 * @brief Texture update source info
935 * Describes the source of data (memory, buffer or another texture)
936 * to be used when updating textures using Controller::UpdateTextures().
938 struct TextureUpdateSourceInfo
966 * @brief Properties of texture
968 struct TextureProperties
970 Format format; ///< Texture format
971 Format format1; ///< Texture format (if emulated)
972 bool emulated; ///< Format is emulated (for example RGB as RGBA)
973 bool compressed; ///< Texture is compressed
974 bool packed; ///< Texture is packed
975 Extent2D extent2D; ///< Size of texture
976 bool directWriteAccessEnabled; ///< Direct write access (mappable textures)
980 * @brief Texture tiling that directly refers to the tiling
981 * mode supported by the Vulkan. Other implementations
982 * of the backend may ignore the value.
984 enum class TextureTiling
991 * @brief Texture color attachment used by FramebufferCreateInfo
993 struct ColorAttachment
995 uint32_t attachmentId;
1002 * @brief Depth stencil attachment used by FramebufferCreateInfo
1004 struct DepthStencilAttachment
1007 Texture* depthTexture;
1008 Texture* stencilTexture;
1009 uint32_t depthLevel;
1010 uint32_t stencilLevel;
1014 * @brief Submit flags
1016 using SubmitFlags = uint32_t;
1021 enum class SubmitFlagBits : uint32_t
1023 FLUSH = 1 << 0, // Flush immediately
1024 DONT_OPTIMIZE = 1 << 1 // Tells controller not to optimize commands
1027 template<typename T>
1028 inline SubmitFlags operator|(T flags, SubmitFlagBits bit)
1030 return static_cast<SubmitFlags>(flags) | static_cast<SubmitFlags>(bit);
1034 * @brief Describes command buffers submission
1038 std::vector<CommandBuffer*> cmdBuffer;
1043 * @brief Shader language enum
1045 enum class ShaderLanguage
1055 * @brief Pipeline stages
1057 enum class PipelineStage
1064 TESSELATION_CONTROL,
1065 TESSELATION_EVALUATION,
1070 * @brief Vertex attribute format
1072 * TODO: to be replaced with Format
1074 enum class VertexInputAttributeFormat
1085 * @brief Uniform class
1087 enum class UniformClass
1091 COMBINED_IMAGE_SAMPLER,
1098 * @brief Type of texture
1100 enum class TextureType
1108 * @brief The information of the uniform
1112 std::string name{""};
1113 UniformClass uniformClass{UniformClass::UNDEFINED};
1114 uint32_t binding{0u};
1115 uint32_t bufferIndex{0u};
1116 uint32_t offset{0u};
1117 uint32_t location{0u};
1119 bool operator==(const UniformInfo& rhs)
1121 return name == rhs.name &&
1122 uniformClass == rhs.uniformClass &&
1123 binding == rhs.binding &&
1124 bufferIndex == rhs.bufferIndex &&
1125 offset == rhs.offset &&
1126 location == rhs.location;
1131 * @brief The information of the uniform block
1133 struct UniformBlockInfo
1135 std::string name{""};
1136 uint32_t descriptorSet{0u};
1137 uint32_t binding{0u};
1139 std::vector<UniformInfo> members{};
1143 * @brief Describes pipeline's shading stages
1145 * Shader state binds shader and pipeline stage that the
1146 * shader will be executed. The shader may be created with
1147 * pipeline stage and the pipelineStage member may be ignored
1148 * by setting inheritPipelineStage to true.
1152 const Shader* shader{nullptr}; // shader to attach
1153 PipelineStage pipelineStage{}; // pipeline stage to execute the shader
1154 bool inheritPipelineStage{false}; // stage inheritance
1156 auto& SetShader(const Shader& value)
1162 auto& SetPipelineStage(PipelineStage value)
1164 pipelineStage = value;
1168 auto& SetInheritPipelineStage(bool value)
1170 inheritPipelineStage = value;
1176 * @brief Flag determining usage of texture
1178 using TextureUsageFlags = uint32_t;
1179 enum class TextureUsageFlagBits : uint32_t
1182 COLOR_ATTACHMENT = 1 << 1,
1183 DEPTH_STENCIL_ATTACHMENT = 1 << 2,
1187 template<typename T>
1188 inline TextureUsageFlags operator|(T flags, TextureUsageFlagBits bit)
1190 return static_cast<TextureUsageFlags>(flags) | static_cast<TextureUsageFlags>(bit);
1193 using TextureFormat = Dali::Graphics::Format;
1196 * @brief Texture mipmap disable/enable enum
1198 enum class TextureMipMapFlag
1205 * @brief Depth/stencil attachment flag
1207 enum class TextureDepthStencilFlag
1216 * @brief Layout of texture
1218 * Specifies how the memory will be allocated, organized and accessed.
1220 enum class TextureLayout
1222 LINEAR, ///< Creates linear memory, mapping possible
1223 OPTIMAL ///< Usually, read-only memory, driver-optimal layout
1227 * @brief Level of command buffer
1229 enum class CommandBufferLevel
1231 PRIMARY, ///< Primary buffer can be executed on its own
1232 SECONDARY ///< Secondary buffer must be executed within scope of Primary buffer
1236 * @brief Enum indicating whether shader source
1237 * is text-based or binary.
1239 enum class ShaderSourceMode
1246 * @brief Memory usage flags to be set when mapping the buffer
1248 using MemoryUsageFlags = uint32_t;
1249 enum class MemoryUsageFlagBits : uint32_t
1253 PERSISTENT = 1 << 2,
1254 ASYNCHRONOUS = 1 << 3,
1258 template<typename T>
1259 inline MemoryUsageFlags operator|(T flags, MemoryUsageFlagBits bit)
1261 return static_cast<MemoryUsageFlags>(flags) | static_cast<MemoryUsageFlags>(bit);
1265 * @brief Describes buffer mapping details
1267 struct MapBufferInfo
1270 MemoryUsageFlags usage;
1276 * @brief Describes buffer mapping details
1277 * TODO: mapping by texture level and layer
1279 struct MapTextureInfo
1282 MemoryUsageFlags usage;
1288 * @brief GraphicsStructureType enum is used by all create info structures
1289 * in order to identify by the implementation which structure it is
1292 enum class GraphicsStructureType : uint32_t
1294 BUFFER_CREATE_INFO_STRUCT,
1295 COMMAND_BUFFER_CREATE_INFO_STRUCT,
1296 FRAMEBUFFER_CREATE_INFO_STRUCT,
1297 PROGRAM_CREATE_INFO_STRUCT,
1298 PIPELINE_CREATE_INFO_STRUCT,
1299 RENDERPASS_CREATE_INFO_STRUCT,
1300 SAMPLER_CREATE_INFO_STRUCT,
1301 SHADER_CREATE_INFO_STRUCT,
1302 TEXTURE_CREATE_INFO_STRUCT,
1303 RENDER_TARGET_CREATE_INFO_STRUCT,
1304 SYNC_OBJECT_CREATE_INFO_STRUCT
1308 * @brief Enum describes load operation associated
1309 * with particular framebuffer attachment
1311 enum class AttachmentLoadOp
1313 LOAD, ///< Load previous content
1314 CLEAR, ///< Clear the attachment
1315 DONT_CARE ///< Let driver decide
1319 * @brief Enum describes store operation associated
1320 * with particular framebuffer attachment
1322 enum class AttachmentStoreOp
1324 STORE, ///< Store content (color attachemnts)
1325 DONT_CARE ///< Let driver decide (depth/stencil attachemnt with no intention of reading)
1329 * @brief The structure describes the read/write
1330 * modes of a single framebuffer attachment
1332 * The attachment description specifies what is going to
1333 * happen to the attachment at the beginning and end of the
1336 * The stencil operation is separated as it may be set
1337 * independent from the depth component (use loadOp, storeOp
1338 * to set up the depth component and stencilLoadOp, stencilStoreOp
1339 * for stencil component).
1341 struct AttachmentDescription
1344 * @brief Sets load operation for the attachment
1346 * @param value Load operation
1347 * @return this structure
1349 auto& SetLoadOp(AttachmentLoadOp value)
1356 * @brief Sets store operation for the attachment
1358 * @param value Store operation
1359 * @return this structure
1361 auto& SetStoreOp(AttachmentStoreOp value)
1368 * @brief Sets load operation for the stencil part of attachment
1370 * @param value load operation
1371 * @return this structure
1373 auto& SetStencilLoadOp(AttachmentLoadOp value)
1375 stencilLoadOp = value;
1380 * @brief Sets store operation for the stencil part of attachment
1382 * @param value store operation
1383 * @return this structure
1385 auto& SetStencilStoreOp(AttachmentStoreOp value)
1387 stencilStoreOp = value;
1391 AttachmentLoadOp loadOp{};
1392 AttachmentStoreOp storeOp{};
1393 AttachmentLoadOp stencilLoadOp{};
1394 AttachmentStoreOp stencilStoreOp{};
1398 * @brief Helper function to be used by the extension developers
1400 * The value of custom type must be unique and recognizable by the
1403 * @param customValue Custom value of GraphicsStructureType
1404 * @return Integer converted to GraphicsStructureType
1406 inline GraphicsStructureType GraphicsExtensionType(uint32_t customValue)
1408 return static_cast<GraphicsStructureType>(customValue);
1412 * @brief The allocation callbacks may be passed when the object is created.
1414 struct AllocationCallbacks
1416 void* userData = nullptr; ///< User data passed to the allocator
1417 void* (*allocCallback)(size_t size, size_t alignment, void* userData) = nullptr;
1418 void* (*reallocCallback)(void* original, size_t size, size_t alignment, void* userData) = nullptr;
1419 void (*freeCallback)(void* memory, void* userData) = nullptr;
1423 * @brief The ExtensionCreateInfo structure should be a base of any
1424 * extension create info structure. The structure isn't virtual
1425 * so the implementation must prevent slicing it.
1427 struct ExtensionCreateInfo
1429 GraphicsStructureType type{};
1430 ExtensionCreateInfo* nextExtension{};
1434 * @brief Default deleter for graphics unique pointers
1436 * Returned unique_ptr may require custom deleter. To get it working
1437 * with std::unique_ptr the custom type is used with polymorphic deleter
1440 struct DefaultDeleter
1442 DefaultDeleter() = default;
1445 * @brief Conversion constructor
1447 * This constructor will set the lambda for type passed
1450 template<class P, template<typename> typename U>
1451 DefaultDeleter(const U<P>& deleter)
1453 deleteFunction = [](T* object) { U<P>()(static_cast<P*>(object)); };
1457 * @brief Conversion constructor from DefaultDelete<P>
1459 * This constructor transfers deleteFunction only
1462 explicit DefaultDeleter(const DefaultDeleter<P>& deleter)
1464 deleteFunction = decltype(deleteFunction)(deleter.deleteFunction);
1468 * @brief Default deleter
1470 * Default deleter will use standard 'delete' call in order
1471 * to discard graphics objects unless a custom deleter was
1474 * @param[in] object Object to delete
1476 void operator()(T* object)
1480 deleteFunction(object);
1488 void (*deleteFunction)(T* object){nullptr}; ///< Custom delete function
1492 * Surface type is just a void* to any native object.
1494 using Surface = void;
1497 * @brief Enum describing preTransform of render target
1499 enum class RenderTargetTransformFlagBits
1501 TRANSFORM_IDENTITY_BIT = 0x00000001,
1502 ROTATE_90_BIT = 0x00000002,
1503 ROTATE_180_BIT = 0x00000004,
1504 ROTATE_270_BIT = 0x00000008,
1505 HORIZONTAL_MIRROR_BIT = 0x00000010,
1506 HORIZONTAL_MIRROR_ROTATE_90_BIT = 0x00000020,
1507 HORIZONTAL_MIRROR_ROTATE_180_BIT = 0x00000040,
1508 HORIZONTAL_MIRROR_ROTATE_270_BIT = 0x00000080,
1511 using RenderTargetTransformFlags = uint32_t;
1513 template<typename T>
1514 inline RenderTargetTransformFlags operator|(T flags, RenderTargetTransformFlagBits bit)
1516 return static_cast<RenderTargetTransformFlags>(flags) | static_cast<RenderTargetTransformFlags>(bit);
1520 * unique_ptr defined in the Graphics scope
1522 template<class T, class D = DefaultDeleter<T>>
1523 using UniquePtr = std::unique_ptr<T, D>;
1526 * @brief MakeUnique<> version that returns Graphics::UniquePtr
1527 * @param[in] args Arguments for construction
1530 template<class T, class Deleter = DefaultDeleter<T>, class... Args>
1531 std::enable_if_t<!std::is_array<T>::value, Graphics::UniquePtr<T>>
1532 MakeUnique(Args&&... args)
1534 return UniquePtr<T>(new T(std::forward<Args>(args)...), Deleter());
1537 } // namespace Graphics
1540 #endif //DALI_GRAPHICS_API_TYPES_H