renderPassState.h

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_IMAGING_HD_ST_RENDER_PASS_STATE_H
#define PXR_IMAGING_HD_ST_RENDER_PASS_STATE_H
 
#include "pxr/pxr.h"
#include "pxr/imaging/hdSt/api.h"
#include "pxr/imaging/hd/renderPassState.h"
#include "pxr/imaging/hgi/graphicsCmdsDesc.h"
 
#include <memory>
 
PXR_NAMESPACE_OPEN_SCOPE
 
struct HgiGraphicsPipelineDesc;
struct HgiDepthStencilState;
struct HgiMultiSampleState;
struct HgiRasterizationState;
class HgiCapabilities;
 
using HdResourceRegistrySharedPtr = std::shared_ptr<class HdResourceRegistry>;
using HdStRenderPassStateSharedPtr = std::shared_ptr<class HdStRenderPassState>;
 
using HdBufferArrayRangeSharedPtr = std::shared_ptr<class HdBufferArrayRange>;
 
using HdStShaderCodeSharedPtr = std::shared_ptr<class HdStShaderCode>;
using HdStLightingShaderSharedPtr = std::shared_ptr<class HdStLightingShader>;
using HdStRenderPassShaderSharedPtr =
    std::shared_ptr<class HdStRenderPassShader>;
using HdSt_FallbackLightingShaderSharedPtr =
    std::shared_ptr<class HdSt_FallbackLightingShader>;
using HdSt_GeometricShaderSharedPtr =
    std::shared_ptr<class HdSt_GeometricShader>;
using HdStShaderCodeSharedPtrVector = std::vector<HdStShaderCodeSharedPtr>;
class HdRenderIndex;
class HdSt_ResourceBinder;
 
class HdStRenderPassState : public HdRenderPassState
{
public:
    HDST_API
    HdStRenderPassState();
    HDST_API
    HdStRenderPassState(HdStRenderPassShaderSharedPtr const &shader);
    HDST_API
    ~HdStRenderPassState() override;
 
    HDST_API
    void
    Prepare(HdResourceRegistrySharedPtr const &resourceRegistry) override;
 
    HDST_API
    void Bind(HgiCapabilities const &hgiCapabilities);
    HDST_API
    void Unbind(HgiCapabilities const &hgiCapabilities);
 
    HDST_API
    void SetResolveAovMultiSample(bool state);
    HDST_API
    bool GetResolveAovMultiSample() const;
 
    HDST_API
    void SetLightingShader(HdStLightingShaderSharedPtr const &lightingShader);
    HdStLightingShaderSharedPtr const & GetLightingShader() const {
        return _lightingShader;
    }
 
    HDST_API
    void SetRenderPassShader(HdStRenderPassShaderSharedPtr const &renderPassShader);
    HdStRenderPassShaderSharedPtr const &GetRenderPassShader() const {
        return _renderPassShader;
    }
 
    HDST_API
    void ApplyStateFromGeometricShader(
        HdSt_ResourceBinder const &binder,
        HdSt_GeometricShaderSharedPtr const &geometricShader);
 
    HDST_API
    void ApplyStateFromCamera();
 
    HDST_API
    void SetUseSceneMaterials(bool state);
    bool GetUseSceneMaterials() const {
        return _useSceneMaterials;
    }
 
    HDST_API
    HdStShaderCodeSharedPtrVector GetShaders() const;
 
    HDST_API
    size_t GetShaderHash() const;
 
    HDST_API
    void SetCameraFramingState(GfMatrix4d const &worldToViewMatrix,
                               GfMatrix4d const &projectionMatrix,
                               GfVec4d const &viewport,
                               ClipPlanesVector const & clipPlanes);
    
    GfMatrix4d GetCullMatrix() const { return _cullMatrix; }
 
    HDST_API
    GfMatrix4d GetWorldToViewMatrix() const override;
 
    HDST_API
    GfMatrix4d GetProjectionMatrix() const override;
 
    HDST_API ClipPlanesVector const & GetClipPlanes() const override;
 
    HDST_API
    GfVec4i ComputeViewport() const;
 
    // Helper to get graphics cmds descriptor describing textures
    // we render into and the blend state, constructed from
    // AOV bindings.
    //
    HDST_API
    HgiGraphicsCmdsDesc MakeGraphicsCmdsDesc(
                HdRenderIndex const * renderIndex) const;
 
    // Helper to initialize graphics pipeline descriptor state including
    // any additional state from the geometric shader.
    HDST_API
    void InitGraphicsPipelineDesc(
                HgiGraphicsPipelineDesc * pipeDesc,
                HdSt_GeometricShaderSharedPtr const & geometricShader,
                bool firstDrawBatch) const;
 
    HDST_API
    uint64_t GetGraphicsPipelineHash(
        HdSt_GeometricShaderSharedPtr const & geometricShader,
        bool firstDrawBatch) const;
 
    // A 4d-vector v encodes a 2d-transform as follows:
    // (x, y) |-> (v[0] * x + v[2], v[1] * y + v[3]).
    using AxisAlignedAffineTransform = GfVec4f;
 
    // Computes the transform from pixel coordinates to the horizontally
    // normalized filmback space which has the following properties:
    // 1. x = -1 and +1 corresponds to the left and right edge of the filmback,
    //    respectively.
    // 2. (0, 0) corresponds to the center of the filmback.
    // 3. Moving a unit in either the x- or y-direction moves by the same
    //    distance on the filmback. In other words, y = -1/a and +1/a
    //    corresponds to the bottom and top edge of the filmback, respectively,
    //    where a is the camera's aspect ratio.
    HDST_API
    AxisAlignedAffineTransform
    ComputeImageToHorizontallyNormalizedFilmback() const;
 
private:
    bool _UseAlphaMask() const;
    unsigned int _GetFramebufferHeight() const;
    GfRange2f _ComputeFlippedFilmbackWindow() const;
 
    // Helper to set up the aov attachment desc so that it matches the blend
    // setting of the render pipeline state.
    // If an aovIndex is specified then the color mask will be correlated.
    void _InitAttachmentDesc(HgiAttachmentDesc &attachmentDesc,
                             HdRenderPassAovBinding const & binding,
                             HdRenderBuffer const * renderBuffer,
                             int aovIndex) const;
 
    void _InitPrimitiveState(
                HgiGraphicsPipelineDesc * pipeDesc,
                HdSt_GeometricShaderSharedPtr const & geometricShader) const;
    void _InitAttachmentState(HgiGraphicsPipelineDesc * pipeDesc,
                              bool firstDrawBatch) const;
    void _InitDepthStencilState(HgiDepthStencilState * depthState) const;
    void _InitMultiSampleState(HgiMultiSampleState * multisampleState) const;
    void _InitRasterizationState(
                HgiRasterizationState * rasterizationState,
                HdSt_GeometricShaderSharedPtr const & geometricShader) const;
 
    // ---------------------------------------------------------------------- //
    // Camera state used when no HdCamera available
    // ---------------------------------------------------------------------- //
    
    GfMatrix4d _worldToViewMatrix;
    GfMatrix4d _projectionMatrix;
    ClipPlanesVector _clipPlanes;
 
    GfMatrix4d _cullMatrix; // updated during Prepare(..)
 
    // ---------------------------------------------------------------------- //
    // Shader Objects
    // ---------------------------------------------------------------------- //
    HdStRenderPassShaderSharedPtr _renderPassShader;
    HdSt_FallbackLightingShaderSharedPtr _fallbackLightingShader;
    HdStLightingShaderSharedPtr _lightingShader;
 
    HdBufferArrayRangeSharedPtr _renderPassStateBar;
    size_t _clipPlanesBufferSize;
    float _alphaThresholdCurrent;
    bool _resolveMultiSampleAov;
    bool _useSceneMaterials;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif  // PXR_IMAGING_HD_ST_RENDER_PASS_STATE_H