From f7df90447bd365c34a64a1db5d53e907522cb134 Mon Sep 17 00:00:00 2001 From: BZLZHH Date: Fri, 3 Oct 2025 12:42:30 +0800 Subject: [PATCH] [Feat] (MG_Util/Converters): Implement converters related to RenderState enum. --- CMakeLists.txt | 4 + .../GLState/RenderState/RenderState.h | 210 +++++++++--------- .../GLToMG/RenderStateEnumConverter.cpp | 192 ++++++++++++++++ .../GLToMG/RenderStateEnumConverter.h | 13 ++ .../MGToGL/RenderStateEnumConverter.cpp | 193 ++++++++++++++++ .../MGToGL/RenderStateEnumConverter.h | 13 ++ .../MGToStr/RenderStateEnumConverter.cpp | 192 ++++++++++++++++ .../MGToStr/RenderStateEnumConverter.h | 13 ++ 8 files changed, 725 insertions(+), 105 deletions(-) create mode 100644 MobileGL/MG_Util/Converters/GLToMG/RenderStateEnumConverter.cpp create mode 100644 MobileGL/MG_Util/Converters/GLToMG/RenderStateEnumConverter.h create mode 100644 MobileGL/MG_Util/Converters/MGToGL/RenderStateEnumConverter.cpp create mode 100644 MobileGL/MG_Util/Converters/MGToGL/RenderStateEnumConverter.h create mode 100644 MobileGL/MG_Util/Converters/MGToStr/RenderStateEnumConverter.cpp create mode 100644 MobileGL/MG_Util/Converters/MGToStr/RenderStateEnumConverter.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 6f8ce71c..ecd6d090 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -33,6 +33,7 @@ set(SOURCE_FILES MobileGL/MG_Util/Converters/GLToStr/GLEnumConverter.cpp MobileGL/MG_Util/Converters/MGToStr/DataTypeConverter.cpp + MobileGL/MG_Util/Converters/MGToStr/RenderStateEnumConverter.cpp MobileGL/MG_Util/Converters/MGToStr/GLExtensionConverter.cpp MobileGL/MG_Util/Converters/MGToStr/BufferEnumConverter.cpp MobileGL/MG_Util/Converters/MGToStr/FramebufferEnumConverter.cpp @@ -43,10 +44,12 @@ set(SOURCE_FILES MobileGL/MG_Util/Converters/MGToGL/FramebufferEnumConverter.cpp MobileGL/MG_Util/Converters/MGToGL/TextureEnumConverter.cpp MobileGL/MG_Util/Converters/MGToGL/DataTypeConverter.cpp + MobileGL/MG_Util/Converters/MGToGL/RenderStateEnumConverter.cpp MobileGL/MG_Util/Converters/GLToMG/BufferEnumConverter.cpp MobileGL/MG_Util/Converters/GLToMG/FramebufferEnumConverter.cpp MobileGL/MG_Util/Converters/GLToMG/TextureEnumConverter.cpp MobileGL/MG_Util/Converters/GLToMG/DataTypeConverter.cpp + MobileGL/MG_Util/Converters/GLToMG/RenderStateEnumConverter.cpp MobileGL/MG_Util/Converters/MGToMG/TextureEnumConverter.cpp MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.cpp @@ -59,6 +62,7 @@ set(SOURCE_FILES MobileGL/MG_Impl/EGLImpl/Temporary/TemporaryEGLImpl.cpp # @INSERTION_POINT:SOURCE_FILE_GLIMPL@ # + #MobileGL/MG_Impl/GLImpl/RenderState/GL_RenderState.cpp MobileGL/MG_Impl/GLImpl/Framebuffer/Validators.cpp MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.cpp MobileGL/MG_Impl/GLImpl/Program/GL_Program.cpp diff --git a/MobileGL/MG_State/GLState/RenderState/RenderState.h b/MobileGL/MG_State/GLState/RenderState/RenderState.h index 90f7a51f..08416e05 100644 --- a/MobileGL/MG_State/GLState/RenderState/RenderState.h +++ b/MobileGL/MG_State/GLState/RenderState/RenderState.h @@ -3,113 +3,113 @@ #include namespace MobileGL { + enum class BlendFactor { + Zero, + One, + SrcColor, + OneMinusSrcColor, + DstColor, + OneMinusDstColor, + SrcAlpha, + OneMinusSrcAlpha, + DstAlpha, + OneMinusDstAlpha, + ConstantColor, + OneMinusConstantColor, + ConstantAlpha, + OneMinusConstantAlpha, + BlendFactorCount, + Unknown = -1 + }; + + enum class DepthFunc { + Never, + Less, + Equal, + LessEqual, + Greater, + NotEqual, + GreaterEqual, + Always, + DepthFuncCount, + Unknown = -1 + }; + + enum class PixelStoreParam { + // Pack Parameters + PackAlignment, + PackRowLength, + PackImageHeight, + PackSkipRows, + PackSkipPixels, + PackSkipImages, + PackSwapBytes, + PackLsbFirst, + + // Unpack Parameters + UnpackAlignment, + UnpackRowLength, + UnpackImageHeight, + UnpackSkipRows, + UnpackSkipPixels, + UnpackSkipImages, + UnpackSwapBytes, + UnpackLsbFirst, + + PixelStoreParamCount, + Unknown = -1 + }; + + enum class CullFaceMode { + Front, + Back, + FrontAndBack, + CullFaceModeCount, + Unknown = -1 + }; + + enum class CapabilityInput { + Blend, + ClipDistance0, + ClipDistance1, + ClipDistance2, + ClipDistance3, + ClipDistance4, + ClipDistance5, + ClipDistance6, + ClipDistance7, + ColorLogicOp, + CullFace, + DebugOutput, + DebugOutputSynchronous, + DepthClamp, + DepthTest, + Dither, + FramebufferSrgb, + LineSmooth, + Multisample, + PolygonOffsetFill, + PolygonOffsetLine, + PolygonOffsetPoint, + PolygonSmooth, + PrimitiveRestart, + PrimitiveRestartFixedIndex, + RasterizerDiscard, + SampleAlphaToCoverage, + SampleAlphaToOne, + SampleCoverage, + SampleShading, + SampleMask, + ScissorTest, + StencilTest, + TextureCubeMapSeamless, + ProgramPointSize, + CapabilityInputCount, + Unknown = -1 + }; + namespace MG_State { namespace GLState { - enum class BlendFactor { - Zero, - One, - SrcColor, - OneMinusSrcColor, - DstColor, - OneMinusDstColor, - SrcAlpha, - OneMinusSrcAlpha, - DstAlpha, - OneMinusDstAlpha, - ConstantColor, - OneMinusConstantColor, - ConstantAlpha, - OneMinusConstantAlpha, - BlendFactorCount, - Unknown = -1 - }; - - enum class DepthFunc { - Never, - Less, - Equal, - LessEqual, - Greater, - NotEqual, - GreaterEqual, - Always, - DepthFuncCount, - Unknown = -1 - }; - - enum class PixelStoreParam { - // Pack Parameters - PackAlignment, - PackRowLength, - PackImageHeight, - PackSkipRows, - PackSkipPixels, - PackSkipImages, - PackSwapBytes, - PackLsbFirst, - - // Unpack Parameters - UnpackAlignment, - UnpackRowLength, - UnpackImageHeight, - UnpackSkipRows, - UnpackSkipPixels, - UnpackSkipImages, - UnpackSwapBytes, - UnpackLsbFirst, - - PixelStoreParamCount, - Unknown = -1 - }; - - enum class CullFaceMode { - Front, - Back, - FrontAndBack, - CullFaceModeCount, - Unknown = -1 - }; - - enum class CapabilityInput { - Blend, - ClipDistance0, - ClipDistance1, - ClipDistance2, - ClipDistance3, - ClipDistance4, - ClipDistance5, - ClipDistance6, - ClipDistance7, - ColorLogicOp, - CullFace, - DebugOutput, - DebugOutputSynchronous, - DepthClamp, - DepthTest, - Dither, - FramebufferSrgb, - LineSmooth, - Multisample, - PolygonOffsetFill, - PolygonOffsetLine, - PolygonOffsetPoint, - PolygonSmooth, - PrimitiveRestart, - PrimitiveRestartFixedIndex, - RasterizerDiscard, - SampleAlphaToCoverage, - SampleAlphaToOne, - SampleCoverage, - SampleShading, - SampleMask, - ScissorTest, - StencilTest, - TextureCubeMapSeamless, - ProgramPointSize, - CapabilityInputCount, - Unknown = -1 - }; - class RenderState { public: RenderState(); diff --git a/MobileGL/MG_Util/Converters/GLToMG/RenderStateEnumConverter.cpp b/MobileGL/MG_Util/Converters/GLToMG/RenderStateEnumConverter.cpp new file mode 100644 index 00000000..aaf1525a --- /dev/null +++ b/MobileGL/MG_Util/Converters/GLToMG/RenderStateEnumConverter.cpp @@ -0,0 +1,192 @@ +#include "RenderStateEnumConverter.h" + +namespace MobileGL { + namespace MG_Util { + BlendFactor ConvertGLEnumToBlendFactor(GLenum v) { + switch (v) { + case GL_ZERO: + return BlendFactor::Zero; + case GL_ONE: + return BlendFactor::One; + case GL_SRC_COLOR: + return BlendFactor::SrcColor; + case GL_ONE_MINUS_SRC_COLOR: + return BlendFactor::OneMinusSrcColor; + case GL_DST_COLOR: + return BlendFactor::DstColor; + case GL_ONE_MINUS_DST_COLOR: + return BlendFactor::OneMinusDstColor; + case GL_SRC_ALPHA: + return BlendFactor::SrcAlpha; + case GL_ONE_MINUS_SRC_ALPHA: + return BlendFactor::OneMinusSrcAlpha; + case GL_DST_ALPHA: + return BlendFactor::DstAlpha; + case GL_ONE_MINUS_DST_ALPHA: + return BlendFactor::OneMinusDstAlpha; + case GL_CONSTANT_COLOR: + return BlendFactor::ConstantColor; + case GL_ONE_MINUS_CONSTANT_COLOR: + return BlendFactor::OneMinusConstantColor; + case GL_CONSTANT_ALPHA: + return BlendFactor::ConstantAlpha; + case GL_ONE_MINUS_CONSTANT_ALPHA: + return BlendFactor::OneMinusConstantAlpha; + default: + return BlendFactor::Unknown; + } + } + + DepthFunc ConvertGLEnumToDepthFunc(GLenum v) { + switch (v) { + case GL_NEVER: + return DepthFunc::Never; + case GL_LESS: + return DepthFunc::Less; + case GL_EQUAL: + return DepthFunc::Equal; + case GL_LEQUAL: + return DepthFunc::LessEqual; + case GL_GREATER: + return DepthFunc::Greater; + case GL_NOTEQUAL: + return DepthFunc::NotEqual; + case GL_GEQUAL: + return DepthFunc::GreaterEqual; + case GL_ALWAYS: + return DepthFunc::Always; + default: + return DepthFunc::Unknown; + } + } + + PixelStoreParam ConvertGLEnumToPixelStoreParam(GLenum v) { + switch (v) { + case GL_PACK_ALIGNMENT: + return PixelStoreParam::PackAlignment; + case GL_PACK_ROW_LENGTH: + return PixelStoreParam::PackRowLength; + case GL_PACK_IMAGE_HEIGHT: + return PixelStoreParam::PackImageHeight; + case GL_PACK_SKIP_ROWS: + return PixelStoreParam::PackSkipRows; + case GL_PACK_SKIP_PIXELS: + return PixelStoreParam::PackSkipPixels; + case GL_PACK_SKIP_IMAGES: + return PixelStoreParam::PackSkipImages; + case GL_PACK_SWAP_BYTES: + return PixelStoreParam::PackSwapBytes; + case GL_PACK_LSB_FIRST: + return PixelStoreParam::PackLsbFirst; + case GL_UNPACK_ALIGNMENT: + return PixelStoreParam::UnpackAlignment; + case GL_UNPACK_ROW_LENGTH: + return PixelStoreParam::UnpackRowLength; + case GL_UNPACK_IMAGE_HEIGHT: + return PixelStoreParam::UnpackImageHeight; + case GL_UNPACK_SKIP_ROWS: + return PixelStoreParam::UnpackSkipRows; + case GL_UNPACK_SKIP_PIXELS: + return PixelStoreParam::UnpackSkipPixels; + case GL_UNPACK_SKIP_IMAGES: + return PixelStoreParam::UnpackSkipImages; + case GL_UNPACK_SWAP_BYTES: + return PixelStoreParam::UnpackSwapBytes; + case GL_UNPACK_LSB_FIRST: + return PixelStoreParam::UnpackLsbFirst; + default: + return PixelStoreParam::Unknown; + } + } + + CullFaceMode ConvertGLEnumToCullFaceMode(GLenum v) { + switch (v) { + case GL_FRONT: + return CullFaceMode::Front; + case GL_BACK: + return CullFaceMode::Back; + case GL_FRONT_AND_BACK: + return CullFaceMode::FrontAndBack; + default: + return CullFaceMode::Unknown; + } + } + + CapabilityInput ConvertGLEnumToCapabilityInput(GLenum v) { + switch (v) { + case GL_BLEND: + return CapabilityInput::Blend; + case GL_CLIP_DISTANCE0: + return CapabilityInput::ClipDistance0; + case GL_CLIP_DISTANCE1: + return CapabilityInput::ClipDistance1; + case GL_CLIP_DISTANCE2: + return CapabilityInput::ClipDistance2; + case GL_CLIP_DISTANCE3: + return CapabilityInput::ClipDistance3; + case GL_CLIP_DISTANCE4: + return CapabilityInput::ClipDistance4; + case GL_CLIP_DISTANCE5: + return CapabilityInput::ClipDistance5; + case GL_CLIP_DISTANCE6: + return CapabilityInput::ClipDistance6; + case GL_CLIP_DISTANCE7: + return CapabilityInput::ClipDistance7; + case GL_COLOR_LOGIC_OP: + return CapabilityInput::ColorLogicOp; + case GL_CULL_FACE: + return CapabilityInput::CullFace; + case GL_DEBUG_OUTPUT: + return CapabilityInput::DebugOutput; + case GL_DEBUG_OUTPUT_SYNCHRONOUS: + return CapabilityInput::DebugOutputSynchronous; + case GL_DEPTH_CLAMP: + return CapabilityInput::DepthClamp; + case GL_DEPTH_TEST: + return CapabilityInput::DepthTest; + case GL_DITHER: + return CapabilityInput::Dither; + case GL_FRAMEBUFFER_SRGB: + return CapabilityInput::FramebufferSrgb; + case GL_LINE_SMOOTH: + return CapabilityInput::LineSmooth; + case GL_MULTISAMPLE: + return CapabilityInput::Multisample; + case GL_POLYGON_OFFSET_FILL: + return CapabilityInput::PolygonOffsetFill; + case GL_POLYGON_OFFSET_LINE: + return CapabilityInput::PolygonOffsetLine; + case GL_POLYGON_OFFSET_POINT: + return CapabilityInput::PolygonOffsetPoint; + case GL_POLYGON_SMOOTH: + return CapabilityInput::PolygonSmooth; + case GL_PRIMITIVE_RESTART: + return CapabilityInput::PrimitiveRestart; + case GL_PRIMITIVE_RESTART_FIXED_INDEX: + return CapabilityInput::PrimitiveRestartFixedIndex; + case GL_RASTERIZER_DISCARD: + return CapabilityInput::RasterizerDiscard; + case GL_SAMPLE_ALPHA_TO_COVERAGE: + return CapabilityInput::SampleAlphaToCoverage; + case GL_SAMPLE_ALPHA_TO_ONE: + return CapabilityInput::SampleAlphaToOne; + case GL_SAMPLE_COVERAGE: + return CapabilityInput::SampleCoverage; + case GL_SAMPLE_SHADING: + return CapabilityInput::SampleShading; + case GL_SAMPLE_MASK: + return CapabilityInput::SampleMask; + case GL_SCISSOR_TEST: + return CapabilityInput::ScissorTest; + case GL_STENCIL_TEST: + return CapabilityInput::StencilTest; + case GL_TEXTURE_CUBE_MAP_SEAMLESS: + return CapabilityInput::TextureCubeMapSeamless; + case GL_PROGRAM_POINT_SIZE: + return CapabilityInput::ProgramPointSize; + default: + return CapabilityInput::Unknown; + } + } + } // namespace MG_Util +} // namespace MobileGL \ No newline at end of file diff --git a/MobileGL/MG_Util/Converters/GLToMG/RenderStateEnumConverter.h b/MobileGL/MG_Util/Converters/GLToMG/RenderStateEnumConverter.h new file mode 100644 index 00000000..3b17d128 --- /dev/null +++ b/MobileGL/MG_Util/Converters/GLToMG/RenderStateEnumConverter.h @@ -0,0 +1,13 @@ +#pragma once +#include +#include + +namespace MobileGL { + namespace MG_Util { + BlendFactor ConvertGLEnumToBlendFactor(GLenum value); + DepthFunc ConvertGLEnumToDepthFunc(GLenum value); + PixelStoreParam ConvertGLEnumToPixelStoreParam(GLenum value); + CullFaceMode ConvertGLEnumToCullFaceMode(GLenum value); + CapabilityInput ConvertGLEnumToCapabilityInput(GLenum value); + } // namespace MG_Util +} // namespace MobileGL \ No newline at end of file diff --git a/MobileGL/MG_Util/Converters/MGToGL/RenderStateEnumConverter.cpp b/MobileGL/MG_Util/Converters/MGToGL/RenderStateEnumConverter.cpp new file mode 100644 index 00000000..9674c326 --- /dev/null +++ b/MobileGL/MG_Util/Converters/MGToGL/RenderStateEnumConverter.cpp @@ -0,0 +1,193 @@ +#include "RenderStateEnumConverter.h" + +namespace MobileGL { + namespace MG_Util { + + GLenum ConvertBlendFactorToGLEnum(BlendFactor v) { + switch (v) { + case BlendFactor::Zero: + return GL_ZERO; + case BlendFactor::One: + return GL_ONE; + case BlendFactor::SrcColor: + return GL_SRC_COLOR; + case BlendFactor::OneMinusSrcColor: + return GL_ONE_MINUS_SRC_COLOR; + case BlendFactor::DstColor: + return GL_DST_COLOR; + case BlendFactor::OneMinusDstColor: + return GL_ONE_MINUS_DST_COLOR; + case BlendFactor::SrcAlpha: + return GL_SRC_ALPHA; + case BlendFactor::OneMinusSrcAlpha: + return GL_ONE_MINUS_SRC_ALPHA; + case BlendFactor::DstAlpha: + return GL_DST_ALPHA; + case BlendFactor::OneMinusDstAlpha: + return GL_ONE_MINUS_DST_ALPHA; + case BlendFactor::ConstantColor: + return GL_CONSTANT_COLOR; + case BlendFactor::OneMinusConstantColor: + return GL_ONE_MINUS_CONSTANT_COLOR; + case BlendFactor::ConstantAlpha: + return GL_CONSTANT_ALPHA; + case BlendFactor::OneMinusConstantAlpha: + return GL_ONE_MINUS_CONSTANT_ALPHA; + default: + return GL_UNKNOWN_MGL; + } + } + + GLenum ConvertDepthFuncToGLEnum(DepthFunc v) { + switch (v) { + case DepthFunc::Never: + return GL_NEVER; + case DepthFunc::Less: + return GL_LESS; + case DepthFunc::Equal: + return GL_EQUAL; + case DepthFunc::LessEqual: + return GL_LEQUAL; + case DepthFunc::Greater: + return GL_GREATER; + case DepthFunc::NotEqual: + return GL_NOTEQUAL; + case DepthFunc::GreaterEqual: + return GL_GEQUAL; + case DepthFunc::Always: + return GL_ALWAYS; + default: + return GL_UNKNOWN_MGL; + } + } + + GLenum ConvertPixelStoreParamToGLEnum(PixelStoreParam v) { + switch (v) { + case PixelStoreParam::PackAlignment: + return GL_PACK_ALIGNMENT; + case PixelStoreParam::PackRowLength: + return GL_PACK_ROW_LENGTH; + case PixelStoreParam::PackImageHeight: + return GL_PACK_IMAGE_HEIGHT; + case PixelStoreParam::PackSkipRows: + return GL_PACK_SKIP_ROWS; + case PixelStoreParam::PackSkipPixels: + return GL_PACK_SKIP_PIXELS; + case PixelStoreParam::PackSkipImages: + return GL_PACK_SKIP_IMAGES; + case PixelStoreParam::PackSwapBytes: + return GL_PACK_SWAP_BYTES; + case PixelStoreParam::PackLsbFirst: + return GL_PACK_LSB_FIRST; + case PixelStoreParam::UnpackAlignment: + return GL_UNPACK_ALIGNMENT; + case PixelStoreParam::UnpackRowLength: + return GL_UNPACK_ROW_LENGTH; + case PixelStoreParam::UnpackImageHeight: + return GL_UNPACK_IMAGE_HEIGHT; + case PixelStoreParam::UnpackSkipRows: + return GL_UNPACK_SKIP_ROWS; + case PixelStoreParam::UnpackSkipPixels: + return GL_UNPACK_SKIP_PIXELS; + case PixelStoreParam::UnpackSkipImages: + return GL_UNPACK_SKIP_IMAGES; + case PixelStoreParam::UnpackSwapBytes: + return GL_UNPACK_SWAP_BYTES; + case PixelStoreParam::UnpackLsbFirst: + return GL_UNPACK_LSB_FIRST; + default: + return GL_UNKNOWN_MGL; + } + } + + GLenum ConvertCullFaceModeToGLEnum(CullFaceMode v) { + switch (v) { + case CullFaceMode::Front: + return GL_FRONT; + case CullFaceMode::Back: + return GL_BACK; + case CullFaceMode::FrontAndBack: + return GL_FRONT_AND_BACK; + default: + return GL_UNKNOWN_MGL; + } + } + + GLenum ConvertCapabilityInputToGLEnum(CapabilityInput v) { + switch (v) { + case CapabilityInput::Blend: + return GL_BLEND; + case CapabilityInput::ClipDistance0: + return GL_CLIP_DISTANCE0; + case CapabilityInput::ClipDistance1: + return GL_CLIP_DISTANCE1; + case CapabilityInput::ClipDistance2: + return GL_CLIP_DISTANCE2; + case CapabilityInput::ClipDistance3: + return GL_CLIP_DISTANCE3; + case CapabilityInput::ClipDistance4: + return GL_CLIP_DISTANCE4; + case CapabilityInput::ClipDistance5: + return GL_CLIP_DISTANCE5; + case CapabilityInput::ClipDistance6: + return GL_CLIP_DISTANCE6; + case CapabilityInput::ClipDistance7: + return GL_CLIP_DISTANCE7; + case CapabilityInput::ColorLogicOp: + return GL_COLOR_LOGIC_OP; + case CapabilityInput::CullFace: + return GL_CULL_FACE; + case CapabilityInput::DebugOutput: + return GL_DEBUG_OUTPUT; + case CapabilityInput::DebugOutputSynchronous: + return GL_DEBUG_OUTPUT_SYNCHRONOUS; + case CapabilityInput::DepthClamp: + return GL_DEPTH_CLAMP; + case CapabilityInput::DepthTest: + return GL_DEPTH_TEST; + case CapabilityInput::Dither: + return GL_DITHER; + case CapabilityInput::FramebufferSrgb: + return GL_FRAMEBUFFER_SRGB; + case CapabilityInput::LineSmooth: + return GL_LINE_SMOOTH; + case CapabilityInput::Multisample: + return GL_MULTISAMPLE; + case CapabilityInput::PolygonOffsetFill: + return GL_POLYGON_OFFSET_FILL; + case CapabilityInput::PolygonOffsetLine: + return GL_POLYGON_OFFSET_LINE; + case CapabilityInput::PolygonOffsetPoint: + return GL_POLYGON_OFFSET_POINT; + case CapabilityInput::PolygonSmooth: + return GL_POLYGON_SMOOTH; + case CapabilityInput::PrimitiveRestart: + return GL_PRIMITIVE_RESTART; + case CapabilityInput::PrimitiveRestartFixedIndex: + return GL_PRIMITIVE_RESTART_FIXED_INDEX; + case CapabilityInput::RasterizerDiscard: + return GL_RASTERIZER_DISCARD; + case CapabilityInput::SampleAlphaToCoverage: + return GL_SAMPLE_ALPHA_TO_COVERAGE; + case CapabilityInput::SampleAlphaToOne: + return GL_SAMPLE_ALPHA_TO_ONE; + case CapabilityInput::SampleCoverage: + return GL_SAMPLE_COVERAGE; + case CapabilityInput::SampleShading: + return GL_SAMPLE_SHADING; + case CapabilityInput::SampleMask: + return GL_SAMPLE_MASK; + case CapabilityInput::ScissorTest: + return GL_SCISSOR_TEST; + case CapabilityInput::StencilTest: + return GL_STENCIL_TEST; + case CapabilityInput::TextureCubeMapSeamless: + return GL_TEXTURE_CUBE_MAP_SEAMLESS; + case CapabilityInput::ProgramPointSize: + return GL_PROGRAM_POINT_SIZE; + default: + return GL_UNKNOWN_MGL; + } + } + } // namespace MG_Util +} // namespace MobileGL \ No newline at end of file diff --git a/MobileGL/MG_Util/Converters/MGToGL/RenderStateEnumConverter.h b/MobileGL/MG_Util/Converters/MGToGL/RenderStateEnumConverter.h new file mode 100644 index 00000000..10a3d788 --- /dev/null +++ b/MobileGL/MG_Util/Converters/MGToGL/RenderStateEnumConverter.h @@ -0,0 +1,13 @@ +#pragma once +#include +#include + +namespace MobileGL { + namespace MG_Util { + GLenum ConvertBlendFactorToGLEnum(BlendFactor value); + GLenum ConvertDepthFuncToGLEnum(DepthFunc value); + GLenum ConvertPixelStoreParamToGLEnum(PixelStoreParam value); + GLenum ConvertCullFaceModeToGLEnum(CullFaceMode value); + GLenum ConvertCapabilityInputToGLEnum(CapabilityInput value); + } // namespace MG_Util +} // namespace MobileGL \ No newline at end of file diff --git a/MobileGL/MG_Util/Converters/MGToStr/RenderStateEnumConverter.cpp b/MobileGL/MG_Util/Converters/MGToStr/RenderStateEnumConverter.cpp new file mode 100644 index 00000000..7f6e6266 --- /dev/null +++ b/MobileGL/MG_Util/Converters/MGToStr/RenderStateEnumConverter.cpp @@ -0,0 +1,192 @@ +#include "RenderStateEnumConverter.h" + +namespace MobileGL { + namespace MG_Util { + String ConvertBlendFactorToString(BlendFactor v) { + switch (v) { + case BlendFactor::Zero: + return "Zero"; + case BlendFactor::One: + return "One"; + case BlendFactor::SrcColor: + return "SrcColor"; + case BlendFactor::OneMinusSrcColor: + return "OneMinusSrcColor"; + case BlendFactor::DstColor: + return "DstColor"; + case BlendFactor::OneMinusDstColor: + return "OneMinusDstColor"; + case BlendFactor::SrcAlpha: + return "SrcAlpha"; + case BlendFactor::OneMinusSrcAlpha: + return "OneMinusSrcAlpha"; + case BlendFactor::DstAlpha: + return "DstAlpha"; + case BlendFactor::OneMinusDstAlpha: + return "OneMinusDstAlpha"; + case BlendFactor::ConstantColor: + return "ConstantColor"; + case BlendFactor::OneMinusConstantColor: + return "OneMinusConstantColor"; + case BlendFactor::ConstantAlpha: + return "ConstantAlpha"; + case BlendFactor::OneMinusConstantAlpha: + return "OneMinusConstantAlpha"; + default: + return "Unknown"; + } + } + + String ConvertDepthFuncToString(DepthFunc v) { + switch (v) { + case DepthFunc::Never: + return "Never"; + case DepthFunc::Less: + return "Less"; + case DepthFunc::Equal: + return "Equal"; + case DepthFunc::LessEqual: + return "LessEqual"; + case DepthFunc::Greater: + return "Greater"; + case DepthFunc::NotEqual: + return "NotEqual"; + case DepthFunc::GreaterEqual: + return "GreaterEqual"; + case DepthFunc::Always: + return "Always"; + default: + return "Unknown"; + } + } + + String ConvertPixelStoreParamToString(PixelStoreParam v) { + switch (v) { + case PixelStoreParam::PackAlignment: + return "PackAlignment"; + case PixelStoreParam::PackRowLength: + return "PackRowLength"; + case PixelStoreParam::PackImageHeight: + return "PackImageHeight"; + case PixelStoreParam::PackSkipRows: + return "PackSkipRows"; + case PixelStoreParam::PackSkipPixels: + return "PackSkipPixels"; + case PixelStoreParam::PackSkipImages: + return "PackSkipImages"; + case PixelStoreParam::PackSwapBytes: + return "PackSwapBytes"; + case PixelStoreParam::PackLsbFirst: + return "PackLsbFirst"; + case PixelStoreParam::UnpackAlignment: + return "UnpackAlignment"; + case PixelStoreParam::UnpackRowLength: + return "UnpackRowLength"; + case PixelStoreParam::UnpackImageHeight: + return "UnpackImageHeight"; + case PixelStoreParam::UnpackSkipRows: + return "UnpackSkipRows"; + case PixelStoreParam::UnpackSkipPixels: + return "UnpackSkipPixels"; + case PixelStoreParam::UnpackSkipImages: + return "UnpackSkipImages"; + case PixelStoreParam::UnpackSwapBytes: + return "UnpackSwapBytes"; + case PixelStoreParam::UnpackLsbFirst: + return "UnpackLsbFirst"; + default: + return "Unknown"; + } + } + + String ConvertCullFaceModeToString(CullFaceMode v) { + switch (v) { + case CullFaceMode::Front: + return "Front"; + case CullFaceMode::Back: + return "Back"; + case CullFaceMode::FrontAndBack: + return "FrontAndBack"; + default: + return "Unknown"; + } + } + + String ConvertCapabilityInputToString(CapabilityInput v) { + switch (v) { + case CapabilityInput::Blend: + return "Blend"; + case CapabilityInput::ClipDistance0: + return "ClipDistance0"; + case CapabilityInput::ClipDistance1: + return "ClipDistance1"; + case CapabilityInput::ClipDistance2: + return "ClipDistance2"; + case CapabilityInput::ClipDistance3: + return "ClipDistance3"; + case CapabilityInput::ClipDistance4: + return "ClipDistance4"; + case CapabilityInput::ClipDistance5: + return "ClipDistance5"; + case CapabilityInput::ClipDistance6: + return "ClipDistance6"; + case CapabilityInput::ClipDistance7: + return "ClipDistance7"; + case CapabilityInput::ColorLogicOp: + return "ColorLogicOp"; + case CapabilityInput::CullFace: + return "CullFace"; + case CapabilityInput::DebugOutput: + return "DebugOutput"; + case CapabilityInput::DebugOutputSynchronous: + return "DebugOutputSynchronous"; + case CapabilityInput::DepthClamp: + return "DepthClamp"; + case CapabilityInput::DepthTest: + return "DepthTest"; + case CapabilityInput::Dither: + return "Dither"; + case CapabilityInput::FramebufferSrgb: + return "FramebufferSrgb"; + case CapabilityInput::LineSmooth: + return "LineSmooth"; + case CapabilityInput::Multisample: + return "Multisample"; + case CapabilityInput::PolygonOffsetFill: + return "PolygonOffsetFill"; + case CapabilityInput::PolygonOffsetLine: + return "PolygonOffsetLine"; + case CapabilityInput::PolygonOffsetPoint: + return "PolygonOffsetPoint"; + case CapabilityInput::PolygonSmooth: + return "PolygonSmooth"; + case CapabilityInput::PrimitiveRestart: + return "PrimitiveRestart"; + case CapabilityInput::PrimitiveRestartFixedIndex: + return "PrimitiveRestartFixedIndex"; + case CapabilityInput::RasterizerDiscard: + return "RasterizerDiscard"; + case CapabilityInput::SampleAlphaToCoverage: + return "SampleAlphaToCoverage"; + case CapabilityInput::SampleAlphaToOne: + return "SampleAlphaToOne"; + case CapabilityInput::SampleCoverage: + return "SampleCoverage"; + case CapabilityInput::SampleShading: + return "SampleShading"; + case CapabilityInput::SampleMask: + return "SampleMask"; + case CapabilityInput::ScissorTest: + return "ScissorTest"; + case CapabilityInput::StencilTest: + return "StencilTest"; + case CapabilityInput::TextureCubeMapSeamless: + return "TextureCubeMapSeamless"; + case CapabilityInput::ProgramPointSize: + return "ProgramPointSize"; + default: + return "Unknown"; + } + } + } // namespace MG_Util +} // namespace MobileGL \ No newline at end of file diff --git a/MobileGL/MG_Util/Converters/MGToStr/RenderStateEnumConverter.h b/MobileGL/MG_Util/Converters/MGToStr/RenderStateEnumConverter.h new file mode 100644 index 00000000..1b110a6c --- /dev/null +++ b/MobileGL/MG_Util/Converters/MGToStr/RenderStateEnumConverter.h @@ -0,0 +1,13 @@ +#pragma once +#include +#include + +namespace MobileGL { + namespace MG_Util { + String ConvertBlendFactorToString(BlendFactor value); + String ConvertDepthFuncToString(DepthFunc value); + String ConvertPixelStoreParamToString(PixelStoreParam value); + String ConvertCullFaceModeToString(CullFaceMode value); + String ConvertCapabilityInputToString(CapabilityInput value); + } // namespace MG_Util +} // namespace MobileGL \ No newline at end of file