[Feat] (MG_Util/Converters): Implement converters related to RenderState enum.

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

MobileGL/MG_State/GLState/RenderState/RenderState.h

@@ -3,113 +3,113 @@
 #include <Includes.h>
 
 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();

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

MobileGL/MG_Util/Converters/GLToMG/RenderStateEnumConverter.h

@@ -0,0 +1,13 @@
+#pragma once
+#include <Includes.h>
+#include <MG_State/GLState/RenderState/RenderState.h>
+
+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

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

MobileGL/MG_Util/Converters/MGToGL/RenderStateEnumConverter.h

@@ -0,0 +1,13 @@
+#pragma once
+#include <Includes.h>
+#include <MG_State/GLState/RenderState/RenderState.h>
+
+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

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

MobileGL/MG_Util/Converters/MGToStr/RenderStateEnumConverter.h

@@ -0,0 +1,13 @@
+#pragma once
+#include <Includes.h>
+#include <MG_State/GLState/RenderState/RenderState.h>
+
+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