GxRender.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
enum RENDER
{
    RENDER_BUFFER_COUNT_MAX         = 3,                        
#if defined(_PS4) || defined(_PS5)
    RENDER_TARGET_COUNT_MAX         = GxMath::VALUE_8,          
#else //_PS4 || _PS5
    RENDER_TARGET_COUNT_MAX         = GxMath::VALUE_4,          
#endif // !(_PS4 || _PS5)
    RENDER_VERTEX_STREAM_COUNT_MAX  = GxMath::VALUE_16,         
    RENDER_VERTEX_SHADER_MODEL      = 30,                       
    RENDER_PIXEL_SHADER_MODEL       = 30,                       
    RENDER_SHADER_CONST_MAX         = GxMath::VALUE_4K,         
#if defined(_NX64)
    RENDER_UNIFORM_BLOCK_COUNT_MAX  = 14,                       
    RENDER_UNIFORM_BLOCK_CONST_MAX  = GxMath::VALUE_4K,         
#endif //_NX64
#if defined(_WINDOWS) || defined(_PS5)
    RENDER_TEXTURE_SAMPLER_COUNT_MAX    = GxMath::VALUE_32,     
#else //_WINDOWS || _PS5
    RENDER_TEXTURE_SAMPLER_COUNT_MAX    = GxMath::VALUE_16,     
#endif // !(_WINDOWS || _PS5)
    RENDER_TEXTURE_SAMPLER_UAV_COUNT_MAX = GxMath::VALUE_16,    
    RENDER_TEXTURE_COUNT_MAX            = GxMath::VALUE_4K,     
    RENDER_QUERY_COUNT_MAX          = GxMath::VALUE_4K,         
    RENDER_MARKER_NAME_LENGTH           = 31,                   
    RENDER_MARKER_NEST_COUNT            = GxMath::VALUE_8,      
    RENDER_INSTANCE_COUNT           = GxMath::VALUE_32,         
    RENDER_VERTEX_ELEMENT_COUNT     = GxMath::VALUE_16,         
    RENDER_VERTEX_INDEX_MAX_32      = 0xFFFFF,                  
    RENDER_VERTEX_INDEX_MAX_16      = 0xFFFF,                   
    RENDER_FRAME_SKIP_COUNT_MAX     = 10,                       
};
 
//===========================================================================
//===========================================================================
#if GX_USE_DX12
enum class RENDER_SHADER
{
    VERTEX,     
#if GX_ENABLE_TESSELLATION
    HULL,       
    DOMAIN_,    
    GEOMETRY,   
#endif //GX_ENABLE_TESSELLATION
    PIXEL,      
    DRAW_MAX,   
#if GX_ENABLE_COMPUTE_SHADER
    COMPUTE = DRAW_MAX, 
    MAX,        
#else //GX_ENABLE_COMPUTE_SHADER
    MAX = DRAW_MAX,     
#endif // !GX_ENABLE_COMPUTE_SHADER
};
#else //GX_USE_DX12
enum class RENDER_SHADER
{
    VERTEX,     
    PIXEL,      
#if GX_ENABLE_TESSELLATION
    HULL,       
    DOMAIN_,    
    GEOMETRY,   
#endif //GX_ENABLE_TESSELLATION
    DRAW_MAX,   
#if GX_ENABLE_COMPUTE_SHADER
    COMPUTE = DRAW_MAX, 
    MAX,        
#else //GX_ENABLE_COMPUTE_SHADER
    MAX = DRAW_MAX,     
#endif // !GX_ENABLE_COMPUTE_SHADER
};
#endif // !GX_USE_DX12
 
//===========================================================================
//===========================================================================
enum class RENDER_FRAME_RATE
{
    AUTOMATIC,              
    FORCE_IMMEDIATE,        
#if !defined(_PS4) && !defined(_PS5)
    _90,                    
#endif // !_PS4 && !_PS5
    _60,                    
#if !defined(_PS4) && !defined(_PS5)
    _45,                    
#endif // !_PS4 && !_PS5
    _30,                    
    _20,                    
    MAX,                    
};
#if GX_DEVELOP
GX_ENUM_BEGIN(RENDER_FRAME_RATE)
    GX_ENUM_VALUE("ディスプレイ依存", RENDER_FRAME_RATE::AUTOMATIC),
    GX_ENUM_VALUE("無制限", RENDER_FRAME_RATE::FORCE_IMMEDIATE),
#if !defined(_PS4) && !defined(_PS5)
    GX_ENUM_VALUE("90FPS", RENDER_FRAME_RATE::_90),
#endif // !_PS4 && !_PS5
    GX_ENUM_VALUE("60FPS", RENDER_FRAME_RATE::_60),
#if !defined(_PS4) && !defined(_PS5)
    GX_ENUM_VALUE("45FPS", RENDER_FRAME_RATE::_45),
#endif // !_PS4 && !_PS5
    GX_ENUM_VALUE("30FPS", RENDER_FRAME_RATE::_30),
    GX_ENUM_VALUE("20FPS", RENDER_FRAME_RATE::_20),
GX_ENUM_END()
#endif //GX_DEVELOP
 
//===========================================================================
//===========================================================================
enum class RENDER_PRIMITIVE_TYPE
{
    POINT_LIST,         
    LINE_LIST,          
    LINE_STRIP,         
    TRIANGLE_LIST,      
    TRIANGLE_STRIP,     
#if GX_ENABLE_TESSELLATION
    PATCH_LIST_3,       
#endif  // GX_ENABLE_TESSELLATION
    MAX,                
};
 
//===========================================================================
//===========================================================================
enum class RENDER_INDEX_TYPE
{
    UNKNOWN,                
    _16,                    
    _32,                    
    MAX,                    
};
 
//===========================================================================
//===========================================================================
enum RENDER_ATTRIBUTE
{
    RENDER_ATTRIBUTE_DYNAMIC        = (1 << 0),     
    RENDER_ATTRIBUTE_WRITEONLY      = (1 << 1),     
    RENDER_ATTRIBUTE_MANAGED        = (1 << 2),     
    RENDER_ATTRIBUTE_USE_MAIN_MEMORY = (1 << 3),    
    RENDER_ATTRIBUTE_SWIZZLE        = (1 << 4),     
    RENDER_ATTRIBUTE_RENDER_TARGET  = (1 << 5),     
    RENDER_ATTRIBUTE_DEPTH_STENCIL  = (1 << 6),     
    RENDER_ATTRIBUTE_USER_MANAGED   = (1 << 7),     
    RENDER_ATTRIBUTE_SURFACE_ONLY   = (1 << 8),     
    RENDER_ATTRIBUTE_RENDER_DISABLE = (1 << 9),     
    RENDER_ATTRIBUTE_DYNAMIC_GPU    = (1 << 10),    
    RENDER_ATTRIBUTE_WRITEONCE      = (1 << 11),    
 
#if GX_DEVELOP
    RENDER_ATTRIBUTE_DEVELOP        = (1 << 12),    
#endif  // GX_DEVELOP
 
    RENDER_ATTRIBUTE_NO_CMASK       = (1 << 13),    
    RENDER_ATTRIBUTE_NO_FMASK       = (1 << 14),    
    RENDER_ATTRIBUTE_USE_HTILE      = (1 << 15),    
    RENDER_ATTRIBUTE_NO_MAP_BUFFER  = (1 << 16),    
};
 
//===========================================================================
//===========================================================================
enum RENDER_MAPPING
{
    RENDER_MAPPING_NO_WAIT      = (1 << 0), 
//  RENDER_MAPPINGNO_FLASH      = (1 << 1), //!< キャッシュフラッシュを行わない(Xboxのみ有効)
    RENDER_MAPPING_NO_OVERWRITE = (1 << 2), 
    RENDER_MAPPING_READONLY     = (1 << 3), 
    RENDER_MAPPING_WRITEONLY    = (1 << 4), 
//  RENDER_MAPPINGRAW           = (1 << 5), //!< ハード依存のフォーマットで直接アクセス
};
 
//===========================================================================
//===========================================================================
enum class RENDER_VERTEX_ELEMENT_TYPE
{
    SHORTN  = (0x0100),     
    FLOAT   = (0x0200),     
    FLOAT1  = (0x0201),     
    FLOAT2  = (0x0202),     
    FLOAT3  = (0x0203),     
    FLOAT4  = (0x0204),     
    HALF    = (0x0300),     
    HALF2   = (0x0302),     
    HALF4   = (0x0304),     
    FLOAT16_2= (0x0302),    
    FLOAT16_4= (0x0304),    
    UBYTEN  = (0x0400),     
    UBYTE4N = (0x0404),     
    COLOR   = (0x1404),     
    SHORT   = (0x0500),     
    SHORT2  = (0x0502),     
    SHORT4  = (0x0504),     
    UBYTE   = (0x0700),     
    UBYTE4  = (0x0704),     
};
 
//===========================================================================
//===========================================================================
enum class RENDER_STREAM_FREQUENCY_TYPE
{
    INDEXED,                
    INSTANCE,               
};
 
//===========================================================================
//===========================================================================
enum class RENDER_SEMANTICS
{
    POSITION,       
    BLENDWEIGHT,    
    NORMAL,         
    COLOR0,         
    COLOR1,         
    FOG,            
    PSIZE,          
    BLENDINDICES,   
    TEXCOORD0,      
    TEXCOORD1,      
    TEXCOORD2,      
    TEXCOORD3,      
    TEXCOORD4,      
    TEXCOORD5,      
    TEXCOORD6,      
    TEXCOORD7,      
    TEXCOORD8,      
    TEXCOORD9,      
    VFACE,          
    VPOS,           
    COLOR2,         
    COLOR3,         
    DEPTH,          
    SPRITETEXCOORD, 
    MAX,            
    TANGENT = TEXCOORD6,        
    BINORMAL    = TEXCOORD7,    
    VERTEX_INPUT_MAX,   
};
 
//===========================================================================
//===========================================================================
enum class RENDER_FORMAT : u32
{
    // タイプ取得:
    // (_format & RENDER_FORMAT_TYPE_MASK) == RENDER_FORMAT_TYPE_INTEGER で比較
    // RENDER_FORMAT はタイプ毎に 4bit なので 15 種類まで 
    TYPE_MASK               = 0xF0, 
 
    UNKNOWN                 = 0x00, 
 
    // 整数
    TYPE_INTEGER            = 0x10, 
    R8G8B8A8                = 0x10, 
    R8G8B8X8,                       
    R8X8X8A8,                       
    R8,                             
    A8,                             
    R8G8B8A8_SRGB,                  
#if defined(_PS4) || defined(_PS5)
    R32_UINT,                       
    R10G10B10A2_UNORM,              
#elif defined(_NX64)
    R8G8,                           
#endif  // _NX64
 
    // 浮動小数点
    TYPE_FLOAT              = 0x80, 
    R32F                    = 0x80, 
    R32G32B32A32F,                  
    R16G16F,                        
    R16G16B16A16F,                  
    R11G11B10F,                     
    
    // DXT
    TYPE_DXT                = 0xD0, 
    DXT1                    = 0xD0, 
    DXT3,                           
    DXT5,                           
    BC6H,                           
    BC7,                            
    DXT1_SRGB,                      
    DXT3_SRGB,                      
    DXT5_SRGB,                      
    BC7_SRGB,                       
 
    TYPE_DEPTH_STENCIL  = 0xE0,     
    D16                 = 0xE0,     
    D24S8               = 0xE1,     
#if defined(_PS4) || defined(_PS5)
    // FMASK
    TYPE_FMASK          = 0xC5,     
    FMASK_S2F1          = 0xC0,     
    FMASK_S4F1,                     
    FMASK_S8F1,                     
    FMASK_S2F2,                     
    FMASK_S4F2,                     
    FMASK_S4F4,                     
#endif // _PS4 || _PS5
 
    TYPE_PVRTC          = 0xB0,     
    PVRTC2              = 0xB0,     
    PVRTC4,                         
    PVRTCII2,                       
    PVRTCII4,                       
};
#if GX_DEVELOP
GX_ENUM_BEGIN(RENDER_FORMAT)
    GX_ENUM_VALUE("未定義", RENDER_FORMAT::UNKNOWN),
    GX_ENUM_VALUE("R8G8B8A8", RENDER_FORMAT::R8G8B8A8),
    GX_ENUM_VALUE("R8G8B8X8", RENDER_FORMAT::R8G8B8X8),
    GX_ENUM_VALUE("R8X8X8A8", RENDER_FORMAT::R8X8X8A8),
    GX_ENUM_VALUE("R8", RENDER_FORMAT::R8),
    GX_ENUM_VALUE("A8", RENDER_FORMAT::A8),
    GX_ENUM_VALUE("R8G8B8A8_SRGB", RENDER_FORMAT::R8G8B8A8_SRGB),
#if defined(_PS4) || defined(_PS5)
    GX_ENUM_VALUE("R32_UINT", RENDER_FORMAT::R32_UINT),
    GX_ENUM_VALUE("R32_R10G10B10A2_UNORMUINT", RENDER_FORMAT::R10G10B10A2_UNORM),
#elif defined(_NX64)
    GX_ENUM_VALUE("R8G8", RENDER_FORMAT::R8G8),
#endif //_NX64
    GX_ENUM_VALUE("R32F", RENDER_FORMAT::R32F),
    GX_ENUM_VALUE("R32G32B32A32F", RENDER_FORMAT::R32G32B32A32F),
    GX_ENUM_VALUE("R16G16F", RENDER_FORMAT::R16G16F),
    GX_ENUM_VALUE("R16G16B16A16F", RENDER_FORMAT::R16G16B16A16F),
    GX_ENUM_VALUE("R11G11B10F", RENDER_FORMAT::R11G11B10F),
    GX_ENUM_VALUE("DXT1", RENDER_FORMAT::DXT1),
    GX_ENUM_VALUE("DXT3", RENDER_FORMAT::DXT3),
    GX_ENUM_VALUE("DXT5", RENDER_FORMAT::DXT5),
    GX_ENUM_VALUE("BC6H", RENDER_FORMAT::BC6H),
    GX_ENUM_VALUE("BC7", RENDER_FORMAT::BC7),
    GX_ENUM_VALUE("DXT1_SRGB", RENDER_FORMAT::DXT1_SRGB),
    GX_ENUM_VALUE("DXT3_SRGB", RENDER_FORMAT::DXT3_SRGB),
    GX_ENUM_VALUE("DXT5_SRGB", RENDER_FORMAT::DXT5_SRGB),
    GX_ENUM_VALUE("BC7_SRGB", RENDER_FORMAT::BC7_SRGB),
    GX_ENUM_VALUE("D16", RENDER_FORMAT::D16),
    GX_ENUM_VALUE("D24S8", RENDER_FORMAT::D24S8),
#if defined(_PS4) || defined(_PS5)
    GX_ENUM_VALUE("FMASK_S2F1", RENDER_FORMAT::FMASK_S2F1),
    GX_ENUM_VALUE("FMASK_S4F1", RENDER_FORMAT::FMASK_S4F1),
    GX_ENUM_VALUE("FMASK_S8F1", RENDER_FORMAT::FMASK_S8F1),
    GX_ENUM_VALUE("FMASK_S2F2", RENDER_FORMAT::FMASK_S2F2),
    GX_ENUM_VALUE("FMASK_S4F2", RENDER_FORMAT::FMASK_S4F2),
    GX_ENUM_VALUE("FMASK_S4F4", RENDER_FORMAT::FMASK_S4F4),
#endif // _PS4 || _PS5
    GX_ENUM_VALUE("PVRTC2", RENDER_FORMAT::PVRTC2),
    GX_ENUM_VALUE("PVRTC4", RENDER_FORMAT::PVRTC4),
    GX_ENUM_VALUE("PVRTCII2", RENDER_FORMAT::PVRTCII2),
    GX_ENUM_VALUE("PVRTCII4", RENDER_FORMAT::PVRTCII4),
GX_ENUM_END()
#endif //GX_DEVELOP
 
//===========================================================================
//===========================================================================
enum class RENDER_ANTI_ALIASING
{
    NONE    = 0x00,     
 
    MSAAx2  = 0x10,     
    MSAAx4  = 0x11,     
 
    SSAAx2  = 0x20,     
    SSAAx4  = 0x21,     
};
#if GX_DEVELOP
GX_ENUM_BEGIN(RENDER_ANTI_ALIASING)
    GX_ENUM_VALUE("NONE", RENDER_ANTI_ALIASING::NONE),
    GX_ENUM_VALUE("MSAAx2", RENDER_ANTI_ALIASING::MSAAx2),
    GX_ENUM_VALUE("MSAAx4", RENDER_ANTI_ALIASING::MSAAx4),
    GX_ENUM_VALUE("SSAAx2", RENDER_ANTI_ALIASING::SSAAx2),
    GX_ENUM_VALUE("SSAAx4", RENDER_ANTI_ALIASING::SSAAx4),
GX_ENUM_END()
#endif //GX_DEVELOP
 
//===========================================================================
//===========================================================================
enum class RENDER_TEXTURE_TYPE : u32
{
    UNKNOWN,                
    _1D,                    
    _2D,                    
    _3D,                    
    CUBE,                   
    DEPTHSTENCIL,           
};
#if GX_DEVELOP
GX_ENUM_BEGIN(RENDER_TEXTURE_TYPE)
    GX_ENUM_VALUE("UNKNOWN", RENDER_TEXTURE_TYPE::UNKNOWN),
    GX_ENUM_VALUE("1D", RENDER_TEXTURE_TYPE::_1D),
    GX_ENUM_VALUE("2D", RENDER_TEXTURE_TYPE::_2D),
    GX_ENUM_VALUE("3D", RENDER_TEXTURE_TYPE::_3D),
    GX_ENUM_VALUE("CUBE", RENDER_TEXTURE_TYPE::CUBE),
    GX_ENUM_VALUE("DEPTH_STENCIL", RENDER_TEXTURE_TYPE::DEPTHSTENCIL),
GX_ENUM_END()
#endif //GX_DEVELOP
 
//===========================================================================
//===========================================================================
enum class RENDER_CUBEMAP_FACE
{
    POSITIVE_X,             
    NEGATIVE_X,             
    POSITIVE_Y,             
    NEGATIVE_Y,             
    POSITIVE_Z,             
    NEGATIVE_Z,             
    MAX,                    
};
 
//===========================================================================
//===========================================================================
enum class RENDER_VIEW : u32
{
    _0 = 0,     
    _1,         
    _2,         
    _3,         
    _4,         
    _5,         
    _6,         
    _7,         
    RESERVE_0,  
    RESERVE_1,  
    RESERVE_2,  
    RESERVE_3,  
    GPGPU,      
    HUD,        
#if GX_DEVELOP
    DEVELOP,    
#else //GX_DEVELOP
    RESERVE_4,  
#endif  // !GX_DEVELOP
    OETF,       
    MAX,        
    _3D_MAX = RESERVE_0,    
    INVALID = MAX,          
};
#if GX_DEVELOP
GX_ENUM_BEGIN(RENDER_VIEW)
    GX_ENUM_VALUE("無効なビュー", RENDER_VIEW::INVALID),
    GX_ENUM_VALUE("ビュー０", RENDER_VIEW::_0),
    GX_ENUM_VALUE("ビュー１", RENDER_VIEW::_1),
    GX_ENUM_VALUE("ビュー２", RENDER_VIEW::_2),
    GX_ENUM_VALUE("ビュー３", RENDER_VIEW::_3),
    GX_ENUM_VALUE("ビュー４", RENDER_VIEW::_4),
    GX_ENUM_VALUE("ビュー５", RENDER_VIEW::_5),
    GX_ENUM_VALUE("GPGPU用", RENDER_VIEW::GPGPU),
    GX_ENUM_VALUE("開発用", RENDER_VIEW::DEVELOP),
GX_ENUM_END()
#endif //GX_DEVELOP
 
//===========================================================================
//===========================================================================
enum class RENDER_SUB_VIEW : u32
{
    SHADOW_START,
    SHADOW_0 = SHADOW_START,                
    SHADOW_1,                               
    SHADOW_2,                               
    SHADOW_3,                               
    SHADOW_END = SHADOW_3,
    POINT_SHADOW_START,
    POINT_SHADOW_0 = POINT_SHADOW_START,    
    POINT_SHADOW_1,                         
    POINT_SHADOW_END = POINT_SHADOW_1,
    NORMAL,                                 
    CUBE_MAP_START,
    CUBE_MAP_0 = CUBE_MAP_START,            
    CUBE_MAP_1,                             
    CUBE_MAP_2,                             
    CUBE_MAP_3,                             
    CUBE_MAP_4,                             
    CUBE_MAP_5,                             
    CUBE_MAP_END = CUBE_MAP_5,
    MOTIONBLUR,                             
    POST,                                   
    RESERVE_7,                              
    MAX,                                    
};
 
//===========================================================================
//===========================================================================
enum class RENDER_PASS : u32
{
    _0,
    SHADOW = _0,                        
    PRE_Z,                              
    OCCLUSION_QUERY,                    
    MULTI_SAMPLE_Z,                     
    MULTI_SAMPLE,                       
    LIGHTING,                           
    FILTER = LIGHTING,                  
    PROCEDURAL,                         
    OPACITY,                            
    MULTI_SAMPLE_PRE_Z,                 
    OVERPAINT_OFFSCREEN_PRE_Z,          
    SEMI_TRANSPARENCE,                  
    REDUCTION,                          
    OVERPAINT_PRE,                      
    ENCODE,                             
    HUD = ENCODE,                       
    EFFECT,                             
    EFFECT_AFTER_FILTER = EFFECT,       
    EFFECT_AFTER_HUD = EFFECT,          
    OVERPAINT,                          
    TOOL,                               
    MAX = 32,                           
};
 
//===========================================================================
//===========================================================================
static constexpr u32 RENDER_SUB_PRIORITY_LIMIT = ((1 << 20) - 1);   
 
//===========================================================================
//===========================================================================
enum class RENDER_STATE
{
    FILL_MODE,                  
    LAST_PIXEL_FILL,            
    FACE_CULLING_MODE,          
    COLOR_WRITE_MASK,           
    SCISSOR_TEST_ENABLE,        
    POINT_SPRITE_ENABLE,        
    MULTISAMPLE_ANTIALIAS,      
    ALPHA_TO_COVERAGE_ENABLE,   
    DEPTH_BIAS,                 
    DEPTH_BIAS_CLAMP,           
    SLOPE_SCALED_DEPTH_BIAS,    
    MAX,                        
};
 
#define RENDER_STATE_VALUE_CAST(value) (*reinterpret_cast<const u32*>(&value))
 
//===========================================================================
//===========================================================================
enum class RENDER_COMPARISON_FUNCTION : u32
{
    NEVER,          
    LESS,           
    EQUAL,          
    LESS_EQUAL,     
    GREATER,        
    NOT_EQUAL,      
    GREATER_EQUAL,  
    ALWAYS,         
    MAX,            
};
#if GX_DEVELOP
GX_ENUM_BEGIN(RENDER_COMPARISON_FUNCTION)
    GX_ENUM_VALUE("常に失敗", RENDER_COMPARISON_FUNCTION::NEVER),
    GX_ENUM_VALUE("常に成功", RENDER_COMPARISON_FUNCTION::ALWAYS),
    GX_ENUM_VALUE("等しい時成功", RENDER_COMPARISON_FUNCTION::EQUAL),
    GX_ENUM_VALUE("等しくない時成功", RENDER_COMPARISON_FUNCTION::NOT_EQUAL),
    GX_ENUM_VALUE("より小さい時成功", RENDER_COMPARISON_FUNCTION::LESS),
    GX_ENUM_VALUE("等しいかより小さい時成功", RENDER_COMPARISON_FUNCTION::LESS_EQUAL),
    GX_ENUM_VALUE("より大きい時成功", RENDER_COMPARISON_FUNCTION::GREATER),
    GX_ENUM_VALUE("等しいかより大きい時成功", RENDER_COMPARISON_FUNCTION::GREATER_EQUAL),
GX_ENUM_END()
#endif //GX_DEVELOP
 
//===========================================================================
//===========================================================================
struct GxRenderDepthTestState
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    static const GxRenderDepthTestState DISABLE;    
    static const GxRenderDepthTestState BASIC;      
    static const GxRenderDepthTestState TESTONLY;   
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxRenderDepthTestState(void) : _access32(0) {}
    GxRenderDepthTestState(u32 enable, RENDER_COMPARISON_FUNCTION function, u32 writeEnable);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    union
    {
        struct
        {
#if GX_BITFIELD_LITTLEENDIAN
            u32     _enable:1;              
            RENDER_COMPARISON_FUNCTION _function:3;         
            u32     _writeEnable:1;         
            u32     _reserve:27;            
#else //GX_BITFIELD_LITTLEENDIAN
            u32     _reserve:27;            
            u32     _writeEnable:1;         
            RENDER_COMPARISON_FUNCTION _function:3;         
            u32     _enable:1;              
#endif // !GX_BITFIELD_LITTLEENDIAN
        };
        u32     _access32;                  
    };
 
};
 
//===========================================================================
//===========================================================================
struct GxRenderStencilTestState
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    static const GxRenderStencilTestState   DISABLE;    
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxRenderStencilTestState(void) : _access64(0) {}
    GxRenderStencilTestState(u32 enable, u32 function, u32 reference, u32 readMask, u32 writeMask, u32 operationFail, u32 operationZFail, u32 operationPass);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    union
    {
        struct
        {
#if GX_BITFIELD_LITTLEENDIAN
            u32     _enable : 1;            
            u32     _function : 3;          
            u32     _reference : 8;         
            u32     _readMask : 8;          
            u32     _writeMask : 8;         
            u32     _operationFail : 3;     
            u32     _operationZFail : 3;    
            u32     _operationPass : 3;     
            u32     _reserve : 27;          
#else //GX_BITFIELD_LITTLEENDIAN
            u32     _reserve : 27;          
            u32     _operationPass : 3;     
            u32     _operationZFail : 3;    
            u32     _operationFail : 3;     
            u32     _writeMask : 8;         
            u32     _readMask : 8;          
            u32     _reference : 8;         
            u32     _function : 3;          
            u32     _enable : 1;            
#endif // !GX_BITFIELD_LITTLEENDIAN
        };
        u64     _access64;                  
    };
 
};
 
//===========================================================================
//===========================================================================
enum class RENDER_STENCIL_OPERATION
{
    KEEP,               
    ZERO,               
    REPLACE,            
    INCREMENT_CLAMP,    
    DECREMENT_CLAMP,    
    INVERT,             
    INCREMENT_WRAP,     
    DECREMENT_WRAP,     
};
 
//===========================================================================
//===========================================================================
struct GxRenderAlphaTestState : public GxStructBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_STRUCT(GxRenderAlphaTestState)
 
    
    static const GxRenderAlphaTestState     DISABLE;
    static const GxRenderAlphaTestState     BASIC;      
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxRenderAlphaTestState(void) : _access32(0) { _enable = true; }
    GxRenderAlphaTestState(u32 enable, RENDER_COMPARISON_FUNCTION function, u32 reference);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE void    getPropertyEnable(void* const pValue) { *static_cast<b32*>(pValue) = _enable; }
    GX_FORCE_INLINE void    setPropertyEnable(const void* const pValue)  { _enable = *static_cast<b32*>(const_cast<void*>(pValue)); }
    GX_FORCE_INLINE void    getPropertyFunction(void* const pValue) { *static_cast<u32*>(pValue) = static_cast<s32>(_function); }
    GX_FORCE_INLINE void    setPropertyFunction(const void* const pValue)  { _function = static_cast<RENDER_COMPARISON_FUNCTION>(*static_cast<u32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void    getPropertyReference(void* const pValue) { *static_cast<u32*>(pValue) = _reference; }
    GX_FORCE_INLINE void    setPropertyReference(const void* const pValue)  { _reference = *static_cast<u32*>(const_cast<void*>(pValue)); }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    union
    {
        struct
        {
#if GX_BITFIELD_LITTLEENDIAN
            u32     _enable:1;              
            RENDER_COMPARISON_FUNCTION _function:3;         
            u32     _reference:8;           
            u32     _reserve:20;            
#else //GX_BITFIELD_LITTLEENDIAN
            u32     _reserve:20;            
            u32     _reference:8;           
            RENDER_COMPARISON_FUNCTION _function:3;         
            u32     _enable:1;              
#endif // !GX_BITFIELD_LITTLEENDIAN
        };
        u32     _access32;                  
    };
 
};
 
//===========================================================================
//===========================================================================
enum class RENDER_BLEND_OPERATION : u32
{
    ADD,                
    SUBTRACT,           
    REVERSE_SUBTRACT,   
    MIN,                
    MAX,                
};
 
//===========================================================================
//===========================================================================
enum class RENDER_BLEND_FACTOR : u32
{
    ZERO,               
    ONE,                
    SRC_COLOR,          
    INVERSE_SRC_COLOR,  
    SRC_ALPHA,          
    INVERSE_SRC_ALPHA,  
    DST_COLOR,          
    INVERSE_DST_COLOR,  
    DST_ALPHA,          
    INVERSE_DST_ALPHA,  
};
 
//===========================================================================
//===========================================================================
struct GxRenderBlendState
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    static const GxRenderBlendState DISABLE;
    static const GxRenderBlendState BASIC;
    static const GxRenderBlendState ADD;
    static const GxRenderBlendState COLORADD;
    static const GxRenderBlendState SUB;
    static const GxRenderBlendState COLORSUB;
    static const GxRenderBlendState MUL;        
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxRenderBlendState(void) : _access32(0) {}
    GxRenderBlendState(u32 enable, RENDER_BLEND_OPERATION colorOperation, RENDER_BLEND_FACTOR colorFactorSrc, RENDER_BLEND_FACTOR colorFactorDst, RENDER_BLEND_OPERATION alphaOperation, RENDER_BLEND_FACTOR alphaFactorSrc, RENDER_BLEND_FACTOR alphaFactorDst);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    union
    {
        struct
        {
#if GX_BITFIELD_LITTLEENDIAN
            u32                     _enable : 1;                
            RENDER_BLEND_OPERATION  _colorOperation : 3;        
            RENDER_BLEND_FACTOR     _colorFactorSrc : 4;        
            RENDER_BLEND_FACTOR     _colorFactorDst : 4;        
            RENDER_BLEND_OPERATION  _alphaOperation : 3;        
            RENDER_BLEND_FACTOR     _alphaFactorSrc : 4;        
            RENDER_BLEND_FACTOR     _alphaFactorDst : 4;        
            u32                     _reserve : 9;               
#else //GX_BITFIELD_LITTLEENDIAN
            u32                     _reserve : 9;               
            RENDER_BLEND_FACTOR     _alphaFactorDst : 4;        
            RENDER_BLEND_FACTOR     _alphaFactorSrc : 4;        
            RENDER_BLEND_OPERATION  _alphaOperation : 3;        
            RENDER_BLEND_FACTOR     _colorFactorDst : 4;        
            RENDER_BLEND_FACTOR     _colorFactorSrc : 4;        
            RENDER_BLEND_OPERATION  _colorOperation : 3;        
            u32                     _enable : 1;                
#endif // !GX_BITFIELD_LITTLEENDIAN
        };
        u32     _access32;                                      
    };
 
};
 
//===========================================================================
//===========================================================================
enum class RENDER_FILL_MODE
{
    POINT,                  
    LINE,                   
    FILL,                   
};
 
//===========================================================================
//===========================================================================
enum class RENDER_FACE_CULLING_MODE
{
    NONE,               
    FRONT,              
    BACK,               
};
#if GX_DEVELOP
GX_ENUM_BEGIN(RENDER_FACE_CULLING_MODE)
    GX_ENUM_VALUE("フロントフェース", RENDER_FACE_CULLING_MODE::FRONT),
    GX_ENUM_VALUE("バックフェース", RENDER_FACE_CULLING_MODE::BACK),
GX_ENUM_END()
#endif //GX_DEVELOP
 
//===========================================================================
//===========================================================================
enum RENDER_COLOR_WRITE_ENABLE
{
    RENDER_COLOR_WRITE_ENABLE_RED       = (0x1 << 0),           
    RENDER_COLOR_WRITE_ENABLE_GREEN     = (0x1 << 1),           
    RENDER_COLOR_WRITE_ENABLE_BLUE      = (0x1 << 2),           
    RENDER_COLOR_WRITE_ENABLE_ALPHA     = (0x1 << 3),           
    RENDER_COLOR_WRITE_ENABLE_COLOR_ONLY = RENDER_COLOR_WRITE_ENABLE_RED | RENDER_COLOR_WRITE_ENABLE_GREEN | RENDER_COLOR_WRITE_ENABLE_BLUE,    
    RENDER_COLOR_WRITE_ENABLE_ALL       = RENDER_COLOR_WRITE_ENABLE_COLOR_ONLY | RENDER_COLOR_WRITE_ENABLE_ALPHA,   
};
 
//===========================================================================
//===========================================================================
enum class RENDER_SAMPLER_ADDRESS_MODE : u32
{
    WRAP,           
    MIRROR,         
    CLAMP,          
    BORDER,         
};
#if GX_DEVELOP
GX_ENUM_BEGIN(RENDER_SAMPLER_ADDRESS_MODE)
    GX_ENUM_VALUE("ラップ", RENDER_SAMPLER_ADDRESS_MODE::WRAP),
    GX_ENUM_VALUE("ミラー", RENDER_SAMPLER_ADDRESS_MODE::MIRROR),
    GX_ENUM_VALUE("クランプ", RENDER_SAMPLER_ADDRESS_MODE::CLAMP),
    GX_ENUM_VALUE("境界カラー", RENDER_SAMPLER_ADDRESS_MODE::BORDER),
GX_ENUM_END()
#endif //GX_DEVELOP
 
//===========================================================================
//===========================================================================
enum class RENDER_SAMPLER_BORDER_COLOR : u32
{
    BLACK,          
    WHITE,          
};
#if GX_DEVELOP
GX_ENUM_BEGIN(RENDER_SAMPLER_BORDER_COLOR)
    GX_ENUM_VALUE("黒", RENDER_SAMPLER_BORDER_COLOR::BLACK),
    GX_ENUM_VALUE("白", RENDER_SAMPLER_BORDER_COLOR::WHITE),
GX_ENUM_END()
#endif //GX_DEVELOP
 
//===========================================================================
//===========================================================================
enum class RENDER_SAMPLER_FILTER : u32
{
    NONE,               
    POINT,              
    LINEAR,             
    ANISOTROPIC,        
};
#if GX_DEVELOP
GX_ENUM_BEGIN(RENDER_SAMPLER_FILTER)
    GX_ENUM_VALUE("ポイント", RENDER_SAMPLER_FILTER::POINT),
    GX_ENUM_VALUE("線形補間", RENDER_SAMPLER_FILTER::LINEAR),
    GX_ENUM_VALUE("異方性", RENDER_SAMPLER_FILTER::ANISOTROPIC),
GX_ENUM_END()
#endif //GX_DEVELOP
 
//===========================================================================
//===========================================================================
enum class RENDER_SAMPLER_ANISOTROPY_MAX : u32
{
    _1,         
    _2,         
    _4,         
    _6,         
    _8,         
    _10,        
    _12,        
    _16,        
};
#if GX_DEVELOP
GX_ENUM_BEGIN(RENDER_SAMPLER_ANISOTROPY_MAX)
    GX_ENUM_VALUE("x1", RENDER_SAMPLER_ANISOTROPY_MAX::_1),
    GX_ENUM_VALUE("x2", RENDER_SAMPLER_ANISOTROPY_MAX::_2),
    GX_ENUM_VALUE("x4", RENDER_SAMPLER_ANISOTROPY_MAX::_4),
    GX_ENUM_VALUE("x6", RENDER_SAMPLER_ANISOTROPY_MAX::_6),
    GX_ENUM_VALUE("x8", RENDER_SAMPLER_ANISOTROPY_MAX::_8),
    GX_ENUM_VALUE("x10", RENDER_SAMPLER_ANISOTROPY_MAX::_10),
    GX_ENUM_VALUE("x12", RENDER_SAMPLER_ANISOTROPY_MAX::_12),
    GX_ENUM_VALUE("x16", RENDER_SAMPLER_ANISOTROPY_MAX::_16),
GX_ENUM_END()
#endif //GX_DEVELOP
 
//===========================================================================
//===========================================================================
enum class RENDER_SAMPLER_COMPARISON : u32
{
    NONE,           
    SHADOW,         
};
 
//===========================================================================
//===========================================================================
struct GxRenderSamplerState : public GxStructBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_STRUCT(GxRenderSamplerState)
 
    
    static const GxRenderSamplerState DEFAULT;  
 
    // 文字列定義
    static const GX_CSTR TEXT_ADDRESS_U;
    static const GX_CSTR TEXT_ADDRESS_V;
    static const GX_CSTR TEXT_ADDRESS_W;
    static const GX_CSTR TEXT_BORDER_COLOR;
    static const GX_CSTR TEXT_MAG_FILTER;
    static const GX_CSTR TEXT_MIN_FILTER;
    static const GX_CSTR TEXT_MIPMAP_FILTER;
    static const GX_CSTR TEXT_MIPMAP_LOD_BIAS;
    static const GX_CSTR TEXT_MIPMAP_LEVEL_MAX;
    static const GX_CSTR TEXT_ANISOTROPHY_MAX;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxRenderSamplerState(void) : _access32(0) {}
    GxRenderSamplerState(RENDER_SAMPLER_ADDRESS_MODE addressU, RENDER_SAMPLER_ADDRESS_MODE addressV, RENDER_SAMPLER_ADDRESS_MODE addressW, RENDER_SAMPLER_BORDER_COLOR borderColor, RENDER_SAMPLER_FILTER magFilter, RENDER_SAMPLER_FILTER minFilter, RENDER_SAMPLER_FILTER mipmapFilter, u32 mipmapLodBias, u32 mipmapLevelMax, RENDER_SAMPLER_ANISOTROPY_MAX anisotropyMax);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
public:
    GX_FORCE_INLINE void    getPropertyAddressU(void* const pValue) { *static_cast<u32*>(pValue) = static_cast<s32>(_addressU); }
    GX_FORCE_INLINE void    setPropertyAddressU(const void* const pValue)  { _addressU = static_cast<RENDER_SAMPLER_ADDRESS_MODE>(*static_cast<u32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void    getPropertyAddressV(void* const pValue) { *static_cast<u32*>(pValue) = static_cast<s32>(_addressV); }
    GX_FORCE_INLINE void    setPropertyAddressV(const void* const pValue)  { _addressV = static_cast<RENDER_SAMPLER_ADDRESS_MODE>(*static_cast<u32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void    getPropertyAddressW(void* const pValue) { *static_cast<u32*>(pValue) = static_cast<s32>(_addressW); }
    GX_FORCE_INLINE void    setPropertyAddressW(const void* const pValue)  { _addressW = static_cast<RENDER_SAMPLER_ADDRESS_MODE>(*static_cast<u32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void    getPropertyBorderColor(void* const pValue) { *static_cast<u32*>(pValue) = static_cast<s32>(_borderColor); }
    GX_FORCE_INLINE void    setPropertyBorderColor(const void* const pValue)  { _borderColor = static_cast<RENDER_SAMPLER_BORDER_COLOR>(*static_cast<u32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void    getPropertyMagFilter(void* const pValue) { *static_cast<u32*>(pValue) = static_cast<s32>(_magFilter); }
    GX_FORCE_INLINE void    setPropertyMagFilter(const void* const pValue)  { _magFilter = static_cast<RENDER_SAMPLER_FILTER>(*static_cast<u32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void    getPropertyMinFilter(void* const pValue) { *static_cast<u32*>(pValue) = static_cast<s32>(_minFilter); }
    GX_FORCE_INLINE void    setPropertyMinFilter(const void* const pValue)  { _minFilter = static_cast<RENDER_SAMPLER_FILTER>(*static_cast<u32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void    getPropertyMipmapFilter(void* const pValue) { *static_cast<u32*>(pValue) = static_cast<s32>(_mipmapFilter); }
    GX_FORCE_INLINE void    setPropertyMipmapFilter(const void* const pValue)  { _mipmapFilter = static_cast<RENDER_SAMPLER_FILTER>(*static_cast<u32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void    getPropertyMipmapLodBias(void* const pValue) { *static_cast<f32*>(pValue) = _mipmapLodBias / 32.0f; }
    GX_FORCE_INLINE void    setPropertyMipmapLodBias(const void* const pValue)  { _mipmapLodBias = static_cast<s32>(32 * *static_cast<f32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void    getPropertyMipmapLevelMax(void* const pValue) { *static_cast<u32*>(pValue) = _mipmapLevelMax; }
    GX_FORCE_INLINE void    setPropertyMipmapLevelMax(const void* const pValue)  { _mipmapLevelMax = *static_cast<u32*>(const_cast<void*>(pValue)); }
    GX_FORCE_INLINE void    getPropertyAnisotropyMax(void* const pValue) { *static_cast<u32*>(pValue) = static_cast<s32>(_anisotropyMax); }
    GX_FORCE_INLINE void    setPropertyAnisotropyMax(const void* const pValue)  { _anisotropyMax = static_cast<RENDER_SAMPLER_ANISOTROPY_MAX>(*static_cast<u32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void    getPropertyComparison(void* const pValue) { *static_cast<u32*>(pValue) = static_cast<s32>(_comparison); }
    GX_FORCE_INLINE void    setPropertyComparison(const void* const pValue)  { _comparison = static_cast<RENDER_SAMPLER_COMPARISON>(*static_cast<u32*>(const_cast<void*>(pValue))); }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    union
    {
        struct
        {
#if GX_BITFIELD_LITTLEENDIAN
            RENDER_SAMPLER_ADDRESS_MODE     _addressU:2;            
            RENDER_SAMPLER_ADDRESS_MODE     _addressV:2;            
            RENDER_SAMPLER_ADDRESS_MODE     _addressW:2;            
            RENDER_SAMPLER_BORDER_COLOR     _borderColor:1;         
            RENDER_SAMPLER_FILTER           _magFilter:2;           
            RENDER_SAMPLER_FILTER           _minFilter:2;           
            RENDER_SAMPLER_FILTER           _mipmapFilter:2;        
            s32                             _mipmapLodBias:10;      
            u32                             _mipmapLevelMax:4;      
            RENDER_SAMPLER_ANISOTROPY_MAX   _anisotropyMax:3;       
            RENDER_SAMPLER_COMPARISON       _comparison:1;          
            u32                             _reserve:1;         
#else // GX_BITFIELD_LITTLEENDIAN
            u32                             _reserve:1;         
            RENDER_SAMPLER_COMPARISON       _comparison:1;          
            RENDER_SAMPLER_ANISOTROPY_MAX   _anisotropyMax:3;       
            u32                             _mipmapLevelMax:4;      
            s32                             _mipmapLodBias:10;      
            RENDER_SAMPLER_FILTER           _mipmapFilter:2;        
            RENDER_SAMPLER_FILTER           _minFilter:2;           
            RENDER_SAMPLER_FILTER           _magFilter:2;           
            RENDER_SAMPLER_BORDER_COLOR     _borderColor:1;         
            RENDER_SAMPLER_ADDRESS_MODE     _addressW:2;            
            RENDER_SAMPLER_ADDRESS_MODE     _addressV:2;            
            RENDER_SAMPLER_ADDRESS_MODE     _addressU:2;            
#endif // !GX_BITFIELD_LITTLEENDIAN
        };
        u32     _access32;                                          
    };
 
};
 
//===========================================================================
//===========================================================================
enum RENDER_CLEAR_FLAG
{
    RENDER_CLEAR_FLAG_TARGET_0      = (0x1<<0),         
    RENDER_CLEAR_FLAG_TARGET_1      = (0x1<<1),         
    RENDER_CLEAR_FLAG_TARGET_2      = (0x1<<2),         
    RENDER_CLEAR_FLAG_TARGET_3      = (0x1<<3),         
#if defined(_PS4) || defined(_PS5)
    RENDER_CLEAR_FLAG_TARGET_4      = (0x1<<4),         
    RENDER_CLEAR_FLAG_TARGET_5      = (0x1<<5),         
    RENDER_CLEAR_FLAG_TARGET_6      = (0x1<<6),         
    RENDER_CLEAR_FLAG_TARGET_7      = (0x1<<7),         
    RENDER_CLEAR_FLAG_DEPTH         = (0x1<<8),         
    RENDER_CLEAR_FLAG_STENCIL       = (0x1<<9),         
#else   // _PS4 || _PS5
    RENDER_CLEAR_FLAG_DEPTH         = (0x1<<4),         
    RENDER_CLEAR_FLAG_STENCIL       = (0x1<<5),         
#endif  // !(_PS4 || _PS5)
    RENDER_CLEAR_FLAG_TARGET        = RENDER_CLEAR_FLAG_TARGET_0            
                                    | RENDER_CLEAR_FLAG_TARGET_1
                                    | RENDER_CLEAR_FLAG_TARGET_2
                                    | RENDER_CLEAR_FLAG_TARGET_3
#if defined(_PS4) || defined(_PS5)
                                    | RENDER_CLEAR_FLAG_TARGET_4
                                    | RENDER_CLEAR_FLAG_TARGET_5
                                    | RENDER_CLEAR_FLAG_TARGET_6
                                    | RENDER_CLEAR_FLAG_TARGET_7
#endif  // _PS4 || _PS5
                                    ,
    RENDER_CLEAR_FLAG_DEPTH_STENCIL = RENDER_CLEAR_FLAG_DEPTH | RENDER_CLEAR_FLAG_STENCIL,          
                                    
    RENDER_CLEAR_FLAG_ALL           = RENDER_CLEAR_FLAG_TARGET | RENDER_CLEAR_FLAG_DEPTH_STENCIL,   
};
 
//===========================================================================
//===========================================================================
enum class RENDER_QUERY_TYPE
{
    TIMESTAMP,              
    OCCULUSION,             
};
 
//===========================================================================
//===========================================================================
struct GxRenderTextureAndSamplerIndex
{
    u8      _textureIndex;      
    u8      _samplerIndex;      
    u8      _isUav;             
    u8      _padding;           
};
 
#if defined(_PS4)
#if GX_ENABLE_NEO
enum class GX_NEO_RENDER_MODE
{
    NONE,   
    _4KG,   
    _4KCB,  
    MAX,    
};
#if GX_DEVELOP
GX_ENUM_BEGIN(GX_NEO_RENDER_MODE)
    GX_ENUM_VALUE("未設定", GX_NEO_RENDER_MODE::NONE),
    GX_ENUM_VALUE("4Kジオメトリ", GX_NEO_RENDER_MODE::_4KG),
    GX_ENUM_VALUE("4Kチェッカーボード", GX_NEO_RENDER_MODE::_4KCB),
GX_ENUM_END()
#endif //GX_DEVELOP
#endif  // GX_ENABLE_NEO
#endif  // _PS4
 
GX_CORE_NAMESPACE_END()