fullscreenShader.h

//
// Copyright 2018 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_HDX_FULLSCREENSHADER_H
#define PXR_IMAGING_HDX_FULLSCREENSHADER_H

#include "pxr/pxr.h"

#include "pxr/imaging/hdx/api.h"
#include "pxr/imaging/hd/types.h"
#include "pxr/base/gf/vec4i.h"
#include "pxr/imaging/hgi/buffer.h"
#include "pxr/imaging/hgi/graphicsPipeline.h"
#include "pxr/imaging/hgi/resourceBindings.h"
#include "pxr/imaging/hgi/shaderProgram.h"
#include "pxr/imaging/hgi/texture.h"

#include <map>
#include <vector>

PXR_NAMESPACE_OPEN_SCOPE

class Hgi;

class HdxFullscreenShader
{
public:
    HDX_API
    HdxFullscreenShader(Hgi* hgi, std::string const& debugName);

    HDX_API
    ~HdxFullscreenShader();

    HDX_API
    void SetProgram(
        TfToken const& glslfx,
        TfToken const& shaderName,
        HgiShaderFunctionDesc &fragDesc,
        HgiShaderFunctionDesc vertDesc = GetFullScreenVertexDesc()
        );

    HDX_API
    void BindBuffer(HgiBufferHandle const& buffer, uint32_t bindingIndex);

    HDX_API
    void BindTextures(
        TfTokenVector const& names,
        HgiTextureHandleVector const& textures);

    HDX_API
    void SetDepthState(HgiDepthStencilState const& state);

    HDX_API
    void SetBlendState(
        bool enableBlending,
        HgiBlendFactor srcColorBlendFactor,
        HgiBlendFactor dstColorBlendFactor,
        HgiBlendOp colorBlendOp,
        HgiBlendFactor srcAlphaBlendFactor,
        HgiBlendFactor dstAlphaBlendFactor,
        HgiBlendOp alphaBlendOp);

    HDX_API
    void SetShaderConstants(
        uint32_t byteSize,
        const void* data);

    HDX_API
    void Draw(HgiTextureHandle const& colorDst,
              HgiTextureHandle const& depthDst);

    HDX_API
    void Draw(HgiTextureHandle const& colorDst,
              HgiTextureHandle const& colorResolveDst,
              HgiTextureHandle const& depthDst,
              HgiTextureHandle const& depthResolveDst,
              GfVec4i const& viewport);

private:
    HdxFullscreenShader() = delete;

    using TextureMap = std::map<TfToken, HgiTextureHandle>;
    using BufferMap = std::map<uint32_t, HgiBufferHandle>;

    // Utility function to create buffer resources.
    void _CreateBufferResources();

    // Destroy shader program and the shader functions it holds.
    void _DestroyShaderProgram();

    // Utility to create resource bindings
    bool _CreateResourceBindings(TextureMap const& textures);

    // Utility to create default vertex buffer descriptor
    void _CreateVertexBufferDescriptor();

    // Utility to create a pipeline
    bool _CreatePipeline(
        HgiTextureHandle const& colorDst,
        HgiTextureHandle const& depthDst,
        bool depthWrite);

    // Utility to create a texture sampler
    bool _CreateSampler();

    // Internal draw method
    void _Draw(
        TextureMap const& textures, 
        HgiTextureHandle const& colorDst,
        HgiTextureHandle const& colorResolveDst,
        HgiTextureHandle const& depthDst,
        HgiTextureHandle const& depthResolveDst,
        GfVec4i const &viewport,
        bool depthWrite);
    
    static HgiShaderFunctionDesc GetFullScreenVertexDesc();

    // Print shader compile errors.
    void _PrintCompileErrors();

    class Hgi* _hgi;

    std::string _debugName;

    TextureMap _textures;
    BufferMap _buffers;

    TfToken _glslfx;
    TfToken _shaderName;

    HgiBufferHandle _indexBuffer;
    HgiBufferHandle _vertexBuffer;
    HgiShaderProgramHandle _shaderProgram;
    HgiResourceBindingsHandle _resourceBindings;
    HgiGraphicsPipelineHandle _pipeline;
    HgiSamplerHandle _sampler;
    HgiVertexBufferDesc _vboDesc;

    HgiDepthStencilState _depthState;

    bool _blendingEnabled;
    HgiBlendFactor _srcColorBlendFactor;
    HgiBlendFactor _dstColorBlendFactor;
    HgiBlendOp _colorBlendOp;
    HgiBlendFactor _srcAlphaBlendFactor;
    HgiBlendFactor _dstAlphaBlendFactor;
    HgiBlendOp _alphaBlendOp;

    HgiAttachmentDesc _attachment0;
    HgiAttachmentDesc _depthAttachment;

    std::vector<uint8_t> _constantsData;
};

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_IMAGING_HDX_FULLSCREENSHADER_H