GxUnitModel.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_SHADER_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxUnitModel : public GxUnitModelBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS_NAME(GxUnitModel, GxUnitModelBase, "シェーダーモデル")
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::UNIT)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxUnitModel)
 
    
    enum class INTERNAL_RENDER_PASS
    {
        SINGLE_PASS,                
        SEMI_TRANSPARENCE_DEPTH,    
        SEMI_TRANSPARENCE_COLOR,    
    };
 
private:
    static constexpr u32 PREV_RENDER_MATRIX_DEFAULT_COUNT = GxMath::VALUE_4;
 
protected:
    enum class SHADER_PASS
    {
        SHADOW_0,                       
        SHADOW_1,                       
        SHADOW_2,                       
        SHADOW_POINT_0,                 
        SHADOW_POINT_1,                 
        SHADOW_POINT_2,                 
        PRE,                            
        NORMAL,                         
        NORMAL_PBR,                     
        SEMI_TRANSPARENCE,              
        SEMI_TRANSPARENCE_PBR,          
        MOTIONBLUR_ON,                  
        MOTIONBLUR_OFF,                 
        ENV_MAP,                        
        LIGHT_PROBE_MAP,                
        HIGH_SPEED,                     
        VERTEX_LIT_NORMAL,              
        VERTEX_LIT_SEMI_TRANSPARENCE,   
        PRE_SHADOW,                     
        POLYGON_LINE,                   
#if GX_ENABLE_TESSELLATION
        SHADOW_0_TESSELLATION,                      
        SHADOW_1_TESSELLATION,                      
        SHADOW_2_TESSELLATION,                      
        SHADOW_POINT_0_TESSELLATION,                
        SHADOW_POINT_1_TESSELLATION,                
        SHADOW_POINT_2_TESSELLATION,                
        PRE_TESSELLATION,                           
        NORMAL_TESSELLATION,                        
        NORMAL_PBR_TESSELLATION,                    
        SEMI_TRANSPARENCE_TESSELLATION,             
        SEMI_TRANSPARENCE_PBR_TESSELLATION,         
        MOTIONBLUR_ON_TESSELLATION,                 
        MOTIONBLUR_OFF_TESSELLATION,                
        VERTEX_LIT_NORMAL_TESSELLATION,             
        VERTEX_LIT_SEMI_TRANSPARENCE_TESSELLATION,  
        PRE_SHADOW_TESSELLATION,                    
        POLYGON_LINE_TESSELLATION,                  
#endif //GX_ENABLE_TESSELLATION
    };
 
    enum class SHADER_HANDLE
    {
        INVERS_VIEW_MATRIX,             
        FISH_EYE_PARAMETER,             
        NORMAL,                         
        DIFFUSE,                        
        SPECULAR,                       
        FOG_COLOR,                      
        METALLIC_ROUGHNESS,             
        BRDF,                           
        TOON_RIM_LIGHT,                 
        PREVIOUS_WORLD_VIEW_MATRIX,     
        INVERS_PROJECTION_MATRIX,       
        SHADOW_MATRIX,                  
        SHADOW_FAR,                     
        SHADOW_BUFFER_SIZE,             
        SHADOW_LERP,                    
        OPACITY_MAP_SAMPLER,            
        DEPTH_MAP_SAMPLER,              
        SHADOW_BUFFER_SAMPLER,          
        APPLY_LIGHTING,                 
        APPLY_LIGHTING_SEMITRANSPARENCE,
        CASCADE_SHADOW_MAP,             
        DIRECTIONAL_SHADOW,             
        DIRECTIONAL_SHADOW_MASK,        
        SHADOW_LIGHT_COLOR,             
        SHADOW_LIGHT_AMBIENT_COLOR,     
        SHADOW_LIGHT_DIRECTION,         
        POINT_SHADOW,                   
        POINT_SHADOW_MAP,               
        LIGHTING_COUNT,                 
        POINT_LIGHT_COLOR,              
        POINT_LIGHT_POSITION,           
        POINT_LIGHT_PARAM,              
        POINT_LIGHT_ORIENTATION,        
        POINT_LIGHT_SPOT,               
        POINT_SHADOW_LIGHT_COLOR,       
        POINT_SHADOW_LIGHT_POSITION,    
        POINT_SHADOW_LIGHT_PARAM,       
        POINT_SHADOW_LIGHT_ORIENTATION, 
        POINT_SHADOW_LIGHT_SPOT,        
        POINT_SHADOW_MATRIX,            
        ENVIRONMENT_SAMPLER,            
        CHROMA_KEY,                     
#if GX_DEVELOP
        CHROMA_KEY_COLOR,               
#endif  // GX_DEVELOP
        FACE_FORWARD,                   
        APPLY_COLOR_MAP_SECOND,         
        MULTI_MAP,                      
        COLOR_MAP_COMPOSITE,            
        TRANSFORM_SKINNING,             
        TRANSFORM_OFFSET,               
        HIGH_SPEED_VERTEX_SHADER_MODE,  
        ALPHA_TEST,                     
        ALPHA_TEST_PARAMETER,           
        VERTEX_OFFSET_PARAMETER,        
        VERTEX_OFFSET_PARAMETER_2,      
        SEMITRANSPARENCE_PRIORITY_OFFSET,   
        REFRACTION_PARAMETER,           
        SSR_PARAMETER,                  
        CONTROL_PARAMETER,              
        APPLY_LIGHT_MAP,                
        LIGHT_PROBE_POSITION,           
        LIGHT_PROBE_EXTENT,             
        LIGHT_PROBE_SAMPLER,            
        LIGHT_PROBE_RED,                
        LIGHT_PROBE_RED_1,              
        LIGHT_PROBE_RED_2,              
        LIGHT_PROBE_GREEN,              
        LIGHT_PROBE_GREEN_1,            
        LIGHT_PROBE_GREEN_2,            
        LIGHT_PROBE_BLUE,               
        LIGHT_PROBE_BLUE_1,             
        LIGHT_PROBE_BLUE_2,             
        HIGH_SPEED_COLOR_MAP_SAMPLER_STATE, 
        LIGHTING_ENABLE,                
        SHADOW_ENABLE,                  
        SHADOW_PARAMETER,               
#if defined(_PS4) || defined(_PS5)
        COLOR_MAP_SAMPLER,              
        COLOR_MAP_SAMPLER_MATERIAL,     
#endif //_PS4 || _PS5
#if defined(_WIN64)
        APPLY_INTERSECTION_BLEND,       
#endif // _WIN64
        MAX,                            
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxUnitModel(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    void                    postAsyncUpdate(void) override;
    void                    forceAsyncUpdate(void) override;
 
public:
    b32                     setModelResource(GxResModel* pResModel) override;
    virtual b32             checkDoRender(const GxRenderMaterial* pMaterial);
 
protected:
    b32                     renderInitialize(RENDER_VIEW view, RENDER_SUB_VIEW subView) override;
    void                    renderMeshGroupAll(void) override;
    void                    renderMeshGroup(const GxResModel::GxMeshGroup* pMeshGroup) override;
    void                    renderMesh(u32 startIndex, u32 count, const GxRenderMaterial* pMaterial, u32 instanceStartIndex, u32 instanceCount) override;
    virtual void            renderMeshNormal(u32 startIndex, u32 count, const GxRenderMaterial* pMaterial, u32 instanceStartIndex, u32 instanceCount);
    virtual void            renderMeshShadow(u32 startIndex, u32 count, const GxRenderMaterial* pMaterial, u32 instanceStartIndex, u32 instanceCount);
    virtual void            renderMeshPointShadow(u32 startIndex, u32 count, const GxRenderMaterial* pMaterial, u32 instanceStartIndex, u32 instanceCount);
    virtual void            renderMeshEnv(u32 startIndex, u32 count, const GxRenderMaterial* pMaterial, u32 instanceStartIndex, u32 instanceCount);
    virtual void            renderMeshPolygonLine(u32 startIndex, u32 count, const GxRenderMaterial* pMaterial, u32 instanceStartIndex, u32 instanceCount);
#if GX_ENABLE_OCCLUSION_CULLING
    void                    renderOcclusionQuery(u32 startIndex, u32 count, const GxRenderMaterial* pMaterial, u32 instanceStartIndex, u32 instanceCount);
#endif //GX_ENABLE_OCCLUSION_CULLING
 
    b32                     setRenderMaterial(GxRenderMaterial* pMaterial, const GxResModel::GxMeshGroup* pMeshGroup) override;
    b32                     setRenderState(const GxRenderMaterial* pMaterial) override;
    void                    updateLightContext(b32 updateContext);
 
    virtual void            updateMeshCullingFlagShadow(RENDER_VIEW view, CULLING_FRUSTUM frustumtype, u32 cascadeLevel);
    virtual void            updateMeshCullingFlagPointShadow(RENDER_VIEW view, CULLING_FRUSTUM frustumtype, GxUnitLightBase* pLight);
    virtual void            updateMeshCullingFlagEnvironmentMap(RENDER_VIEW view, CULLING_FRUSTUM frustumtype);
    virtual void            updateInstanceCullingFlagShadow(RENDER_VIEW view, CULLING_FRUSTUM frustumtype, u32 cascadeLevel);
    virtual void            updateInstanceCullingFlagPointShadow(GxUnitLightBase* pLight, RENDER_VIEW view, CULLING_FRUSTUM frustumType);
    virtual void            updateInstanceCullingFlagEnvironmentMap(RENDER_VIEW view, CULLING_FRUSTUM frustumType);
    b32                     isHitBox(const GxShapeBox& box0, const GxShapeBox& box1);
    f32                     getLengthSegOnSeparateAxis(const GxVector3& sep, const GxVector3& e0, const GxVector3& e1, const GxVector3& e2);
    f32                     getLengthSegOnSeparateAxis(const GxVector3& sep, const GxVector3& e0, const GxVector3& e1);
    b32                     hasSemiTransparenceMaterial(void);
    b32                     isUseSemiTransparenceDepthPass(void);
    void                    renderInitializeSemiTransparence(void);
    u32                     getRenderPolygonCount(u32 startIndex, u32 count, u32 instanceStartIndex, u32 instanceCount);
 
    void                    updateShowLod(const GxUnitCameraBase* pCamera) override;
    virtual void            loadShaderHandles(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE b32             isEnableObjectMotionBlur(void) const { return _enableObjectMotionBlur; }
    GX_FORCE_INLINE void            setEnableObjectMotionBlur(b32 enable) { _enableObjectMotionBlur = enable; }
 
    GX_FORCE_INLINE b32             isEnableEnvironmentMapElement(void) const { return _enableEnvironmentMapElement; }
    GX_FORCE_INLINE void            setEnableEnvironmentMapElement(b32 enable) { _enableEnvironmentMapElement = enable; }
 
    GX_FORCE_INLINE b32             isEnableShadow(void) const { return _enableShadow; }
    GX_FORCE_INLINE void            setEnableShadow(b32 enable) { _enableShadow = enable; }
 
#if GX_DEVELOP
    GX_FORCE_INLINE b32             isMaskEnable(void) const { return _maskEnable; }
    GX_FORCE_INLINE void            setMaskEnable(b32 enable) { _maskEnable = enable; }
#endif  // GX_DEVELOP
 
#if GX_DEVELOP
    constexpr u32                   getPolygonCount(void) const { return _polygonCount; }
    constexpr u32                   getDrawCallCountOpacity(void) const { return _drawCallCountOpacity; }
    constexpr u32                   getDrawCallCountSemiTransparence(void) const { return _drawCallCountSemiTransparence; }
    constexpr u32                   getDrawCallCountShadow(void) const { return _drawCallCountShadow; }
    constexpr u32                   getDrawCallCountEnv(void) const { return _drawCallCountEnv; }
#endif  // GX_DEVELOP
    // 半透明描画時の優先度固定フラグを取得
    GX_FORCE_INLINE b32             isEnableSemiTransparencePriority(void) const { return _enableSemiTransparencePriority; }
    // 半透明描画時の優先度固定フラグを設定
    GX_FORCE_INLINE void            setEnableSemiTransparencePriority(b32 enable) { _enableSemiTransparencePriority = enable; }
    // 半透明描画時の優先度固定値を取得
    constexpr f32                   getSemiTransparencePriority(void) const { return _semiTransparencePriority; }
    // 半透明描画時の優先度固定値を設定、値の範囲は0.0fから1.0f。1.0fで最後に描画される。
    constexpr void                  setSemiTransparencePriority(f32 value) { _semiTransparencePriority = value; }
    // 設定されたマトリクスとカメラから半透明描画優先度を求める
    f32                             getCurrentSemiTransparencePriority(u32 startIndex);
 
protected:
    GX_FORCE_INLINE void setShaderPass(const GxRenderMaterial* pMaterial, SHADER_PASS pass) { pMaterial->_drawShaderInfo._pShaderCode->setPass(static_cast<u32>(pass)); }
    constexpr GX_HANDLE getShaderHandle(SHADER_HANDLE shaderHandle) const { return _handles[static_cast<u32>(shaderHandle)]; }
    constexpr void setShaderHandle(SHADER_HANDLE shaderHandle, GX_HANDLE handle) { _handles[static_cast<u32>(shaderHandle)] = handle; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32                             _enableObjectMotionBlur;        
    b32                             _enableEnvironmentMapElement;   
    b32                             _enableShadow;                  
    b32                             _autoSetNormalReflectance;      
    GxMatrixAffineGpu               _prevRenderMatrixBuffer[PREV_RENDER_MATRIX_DEFAULT_COUNT];  
    GxMatrixAffineGpu*              _pPrevRenderMatrix;             
    u32                             _pointLightCount;               
    u32                             _pointShadowLightCount;         
    INTERNAL_RENDER_PASS            _internalRenderPass;            
#if GX_DEVELOP
    b32                             _maskEnable;                    
    u32                             _polygonCount;                  
    u32                             _renderPolygonCountOpacity;     
    u32                             _renderPolygonCountSemiTransparence;    
    u32                             _renderPolygonCountShadow;      
    u32                             _renderPolygonCountPolygonLine; 
 
    u32                             _drawCallCountOpacity;          
    u32                             _drawCallCountSemiTransparence; 
    u32                             _drawCallCountShadow;           
    u32                             _drawCallCountEnv;              
    u32                             _drawCallCountPolygonLine;      
#endif //GX_DEVELOP
    b32                             _vertexLitFlag;                 
    b32                             _enableSemiTransparencePriority;
    f32                             _semiTransparencePriority;      
 
    static GX_HANDLE                _handles[static_cast<u32>(SHADER_HANDLE::MAX)];     
 
    static b32                      _isUsableShaderHandle;          
private:
    static GxCriticalSection        _shaderHandleCriticalSection;   
 
};
 
GX_SHADER_NAMESPACE_END()