From 99174e4e5fb4b7079da80b35a6dfd68f3fd56a1c Mon Sep 17 00:00:00 2001 From: lbavoil Date: Fri, 25 Mar 2016 13:01:54 +0100 Subject: GFSDK_HBAO+_distro_r3.0_cl20573789 --- samples/D3D11/src/InputDumpReader.h | 539 ++++++++++++++++++++++++++++++++++++ 1 file changed, 539 insertions(+) create mode 100644 samples/D3D11/src/InputDumpReader.h (limited to 'samples/D3D11/src/InputDumpReader.h') diff --git a/samples/D3D11/src/InputDumpReader.h b/samples/D3D11/src/InputDumpReader.h new file mode 100644 index 0000000..fa8eee1 --- /dev/null +++ b/samples/D3D11/src/InputDumpReader.h @@ -0,0 +1,539 @@ +// This code contains NVIDIA Confidential Information and is disclosed +// under the Mutual Non-Disclosure Agreement. +// +// Notice +// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES +// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO +// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT, +// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. +// +// NVIDIA Corporation assumes no responsibility for the consequences of use of such +// information or for any infringement of patents or other rights of third parties that may +// result from its use. No license is granted by implication or otherwise under any patent +// or patent rights of NVIDIA Corporation. No third party distribution is allowed unless +// expressly authorized by NVIDIA. Details are subject to change without notice. +// This code supersedes and replaces all information previously supplied. +// NVIDIA Corporation products are not authorized for use as critical +// components in life support devices or systems without express written approval of +// NVIDIA Corporation. +// +// Copyright © 2008-2015 NVIDIA Corporation. All rights reserved. +// +// NVIDIA Corporation and its licensors retain all intellectual property and proprietary +// rights in and to this software and related documentation and any modifications thereto. +// Any use, reproduction, disclosure or distribution of this software and related +// documentation without an express license agreement from NVIDIA Corporation is +// strictly prohibited. +// + +#pragma once +#include "GFSDK_SSAO.h" +#include "InputDumpWriter.h" + +namespace GFSDK +{ +namespace SSAO +{ +namespace D3D11 +{ + +class InputDumpReader +{ +public: + InputDumpReader() + : m_pFile(NULL) + { + } + + ~InputDumpReader() + { + SafeCloseFile(); + } + + struct InputDumpData + { + InputDumpData() + { + memset(this, 0, sizeof(*this)); + } + void Release() + { + SAFE_RELEASE(InputData.DepthData.pFullResDepthTextureSRV); + SAFE_RELEASE(InputData.NormalData.pFullResNormalTextureSRV); + SAFE_RELEASE(pDepthTexture); + SAFE_RELEASE(pNormalTexture); + } + GFSDK_SSAO_InputData_D3D11 InputData; + GFSDK_SSAO_Parameters Parameters; + ID3D11Texture2D* pDepthTexture; + ID3D11Texture2D* pNormalTexture; + }; + + enum Status + { + STATUS_OK, + STATUS_NULL_ARGUMENT, + STATUS_FOPEN_ERROR, + STATUS_FREAD_ERROR, + STATUS_FILE_VERSION_MISMATCH, + STATUS_BUILD_VERSION_MISMATCH, + STATUS_STRUCT_SIZE_MISMATCH, + STATUS_CREATE_TEXTURE_ERROR, + STATUS_CREATE_SRV_ERROR, + }; + + #define READ_STRUCT(S, FP)\ + {\ + UINT StructSize = 0;\ + if (fread(&StructSize, sizeof(StructSize), 1, FP) != 1)\ + {\ + return STATUS_FREAD_ERROR;\ + }\ + if (StructSize != sizeof(S))\ + {\ + return STATUS_STRUCT_SIZE_MISMATCH;\ + }\ + if (fread(&S, sizeof(S), 1, FP) != 1)\ + {\ + return STATUS_FREAD_ERROR;\ + }\ + } + + Status Read( + ID3D11Device* pDevice, + InputDumpData* pInputDumpData, + const char* pDumpFilename) + { + InputDumpReader::Status Status = STATUS_OK; + + if (!pDevice || !pInputDumpData || !pDumpFilename) + { + return STATUS_NULL_ARGUMENT; + } + + SafeCloseFile(); + if (fopen_s(&m_pFile, pDumpFilename, "rb") || !m_pFile) + { + return STATUS_FOPEN_ERROR; + } + + UINT FileVersion = 0; + if (fread(&FileVersion, sizeof(FileVersion), 1, m_pFile) != 1) + { + return STATUS_FREAD_ERROR; + } + + if (FileVersion != InputDumpWriter::FILE_VERSION) + { + return STATUS_FILE_VERSION_MISMATCH; + } + + GFSDK_SSAO_Version Version; + READ_STRUCT(Version, m_pFile); + + const GFSDK_SSAO_Version BuildVersion; + if (BuildVersion.Major != Version.Major || + BuildVersion.Minor != Version.Minor) + { + return STATUS_BUILD_VERSION_MISMATCH; + } + + Status = ReadInputData(pDevice, pInputDumpData, m_pFile); + if (Status != STATUS_OK) + { + return Status; + } + + Status = ReadParameters(pDevice, pInputDumpData, m_pFile); + if (Status != STATUS_OK) + { + return Status; + } + + Status = ReadTexture(pDevice, pInputDumpData->pDepthTexture, pInputDumpData->InputData.DepthData.pFullResDepthTextureSRV, m_pFile); + if (Status != STATUS_OK) + { + return Status; + } + + if (pInputDumpData->InputData.NormalData.Enable) + { + Status = ReadTexture(pDevice, pInputDumpData->pNormalTexture, pInputDumpData->InputData.NormalData.pFullResNormalTextureSRV, m_pFile); + if (Status != STATUS_OK) + { + return Status; + } + } + + return STATUS_OK; + } + +private: + void SafeCloseFile() + { + if (m_pFile) + { + fclose(m_pFile); + m_pFile = NULL; + } + } + + static Status ReadInputData( + ID3D11Device* pDevice, + InputDumpData* pInputDumpData, + FILE *pFile) + { + GFSDK_SSAO_InputDepthData LoadedDepthData; + READ_STRUCT(LoadedDepthData, pFile); + + GFSDK_SSAO_InputNormalData LoadedNormalData; + READ_STRUCT(LoadedNormalData, pFile); + + GFSDK_SSAO_InputData_D3D11& InputData = pInputDumpData->InputData; + memset(&InputData, 0, sizeof(InputData)); + memcpy(&InputData.DepthData, &LoadedDepthData, sizeof(LoadedDepthData)); + memcpy(&InputData.NormalData, &LoadedNormalData, sizeof(LoadedNormalData)); + + return STATUS_OK; + } + + static Status ReadParameters( + ID3D11Device* pDevice, + InputDumpData* pInputDumpData, + FILE *pFile) + { + GFSDK_SSAO_Parameters LoadedParameters; + READ_STRUCT(LoadedParameters, pFile); + + GFSDK_SSAO_Parameters& Parameters = pInputDumpData->Parameters; + memset(&Parameters, 0, sizeof(Parameters)); + memcpy(&Parameters, &LoadedParameters, sizeof(LoadedParameters)); + + return STATUS_OK; + } + +protected: + static Status ReadTexture( + ID3D11Device* pDevice, + ID3D11Texture2D*& pOutTexture, + ID3D11ShaderResourceView*& pOutSRV, + FILE *pFile) + { + D3D11_TEXTURE2D_DESC TextureDesc; + if (fread(&TextureDesc, sizeof(TextureDesc), 1, pFile) != 1) + { + return STATUS_FREAD_ERROR; + } + + D3D11_SHADER_RESOURCE_VIEW_DESC SrvDesc; + if (fread(&SrvDesc, sizeof(SrvDesc), 1, pFile) != 1) + { + return STATUS_FREAD_ERROR; + } + + UINT RowPitch = 0; + if (fread(&RowPitch, sizeof(RowPitch), 1, pFile) != 1) + { + return STATUS_FREAD_ERROR; + } + + BYTE* pData = new BYTE[TextureDesc.Height * RowPitch]; + assert(pData); + + if (fread(pData, TextureDesc.Height * RowPitch, 1, pFile) != 1) + { + return STATUS_FREAD_ERROR; + } + + TextureDesc.Usage = D3D11_USAGE_IMMUTABLE; + TextureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + TextureDesc.CPUAccessFlags = 0; + TextureDesc.MiscFlags = 0; + + D3D11_SUBRESOURCE_DATA SubresourceData; + SubresourceData.pSysMem = pData; + SubresourceData.SysMemPitch = RowPitch; + SubresourceData.SysMemSlicePitch = 0; + + assert(!pOutTexture); + if (pDevice->CreateTexture2D(&TextureDesc, &SubresourceData, &pOutTexture) != S_OK) + { + return STATUS_CREATE_TEXTURE_ERROR; + } + + delete[] pData; + + assert(!pOutSRV); + if (pDevice->CreateShaderResourceView(pOutTexture, &SrvDesc, &pOutSRV) != S_OK) + { + return STATUS_CREATE_SRV_ERROR; + } + + return STATUS_OK; + } + + FILE* m_pFile; +}; + +class InputDumpReader_2 : public InputDumpReader +{ +public: + static Status Read( + ID3D11Device* pDevice, + InputDumpReader::InputDumpData* pInputDumpData, + const char* pDumpFilename) + { + Status ReadStatus = STATUS_OK; + + if (!pDevice || !pInputDumpData || !pDumpFilename) + { + return STATUS_NULL_ARGUMENT; + } + + FILE *pFile = NULL; + if (fopen_s(&pFile, pDumpFilename, "rb") || !pFile) + { + return STATUS_FOPEN_ERROR; + } + + UINT FileVersion = 0; + if (fread(&FileVersion, sizeof(FileVersion), 1, pFile) != 1) + { + return STATUS_FREAD_ERROR; + } + + if (FileVersion != 2) + { + return STATUS_FILE_VERSION_MISMATCH; + } + + GFSDK_SSAO_Version Version; + if (fread(&Version, sizeof(Version), 1, pFile) != 1) + { + return STATUS_FREAD_ERROR; + } + + ReadStatus = ReadStructs(pFile, pInputDumpData); + if (ReadStatus != STATUS_OK) + { + return ReadStatus; + } + + ReadStatus = InputDumpReader::ReadTexture(pDevice, pInputDumpData->pDepthTexture, pInputDumpData->InputData.DepthData.pFullResDepthTextureSRV, pFile); + if (ReadStatus != STATUS_OK) + { + return ReadStatus; + } + + if (pInputDumpData->InputData.NormalData.Enable) + { + ReadStatus = InputDumpReader::ReadTexture(pDevice, pInputDumpData->pNormalTexture, pInputDumpData->InputData.NormalData.pFullResNormalTextureSRV, pFile); + if (ReadStatus != STATUS_OK) + { + return ReadStatus; + } + } + + fclose(pFile); + + return STATUS_OK; + } + +private: + struct InputViewport + { + GFSDK_SSAO_UINT TopLeftX; + GFSDK_SSAO_UINT TopLeftY; + GFSDK_SSAO_UINT Width; + GFSDK_SSAO_UINT Height; + GFSDK_SSAO_FLOAT MinDepth; + GFSDK_SSAO_FLOAT MaxDepth; + + InputViewport() + : TopLeftX(0) + , TopLeftY(0) + , Width(0) + , Height(0) + , MinDepth(0.f) + , MaxDepth(1.f) + { + } + }; + + struct Matrix + { + Matrix() + { + memset(this, 0, sizeof(*this)); + } + Matrix(const GFSDK_SSAO_FLOAT* pMatrix) + { + memcpy(&Data, pMatrix, sizeof(Data)); + } + GFSDK_SSAO_FLOAT Data[16]; + }; + + struct InputDepthData + { + GFSDK_SSAO_DepthTextureType DepthTextureType; // HARDWARE_DEPTHS, HARDWARE_DEPTHS_SUB_RANGE or VIEW_DEPTHS + Matrix ProjectionMatrix; // 4x4 perspective matrix from the depth generation pass + GFSDK_SSAO_MatrixLayout ProjectionMatrixLayout; // Memory layout of the projection matrix + GFSDK_SSAO_FLOAT MetersToViewSpaceUnits; // DistanceInViewSpaceUnits = MetersToViewSpaceUnits * DistanceInMeters + + InputDepthData() + : DepthTextureType(GFSDK_SSAO_HARDWARE_DEPTHS) + , ProjectionMatrixLayout(GFSDK_SSAO_ROW_MAJOR_ORDER) + , MetersToViewSpaceUnits(1.f) + { + } + }; + + struct InputDepthData_D3D11 : InputDepthData + { + ID3D11ShaderResourceView* pFullResDepthTextureSRV; // Full-resolution depth texture + InputViewport Viewport; // Viewport from the depth generation pass + + InputDepthData_D3D11() + : pFullResDepthTextureSRV(NULL) + { + } + }; + + struct InputNormalData + { + GFSDK_SSAO_BOOL Enable; // To use the provided normals (instead of reconstructed ones) + Matrix WorldToViewMatrix; // 4x4 WorldToView matrix from the depth generation pass + GFSDK_SSAO_MatrixLayout WorldToViewMatrixLayout; // Memory layout of the WorldToView matrix + GFSDK_SSAO_FLOAT DecodeScale; // Optional pre-matrix scale + GFSDK_SSAO_FLOAT DecodeBias; // Optional pre-matrix bias + + InputNormalData() + : Enable(false) + , WorldToViewMatrixLayout(GFSDK_SSAO_ROW_MAJOR_ORDER) + , DecodeScale(1.f) + , DecodeBias(0.f) + { + } + }; + + struct InputNormalData_D3D11 : InputNormalData + { + ID3D11ShaderResourceView* pFullResNormalTextureSRV; // Full-resolution world-space normal texture + + InputNormalData_D3D11() + : pFullResNormalTextureSRV(NULL) + { + } + }; + + struct InputData_D3D11 + { + InputDepthData_D3D11 DepthData; // Required + InputNormalData_D3D11 NormalData; // Optional GBuffer normals + }; + + + struct OutputParameters + { + GFSDK_SSAO_BlendMode BlendMode; // Blend mode used to composite the AO to the output render target + + OutputParameters() + : BlendMode(GFSDK_SSAO_OVERWRITE_RGB) + { + } + }; + + struct CustomBlendState_D3D11 + { + ID3D11BlendState* pBlendState; // Custom blend state to composite the AO with + const GFSDK_SSAO_FLOAT* pBlendFactor; // Relevant only if pBlendState uses D3D11_BLEND_BLEND_FACTOR + + CustomBlendState_D3D11() + : pBlendState(NULL) + , pBlendFactor(NULL) + { + } + }; + + struct Parameters_D3D11 + { + GFSDK_SSAO_FLOAT Radius; // The AO radius in meters + GFSDK_SSAO_FLOAT Bias; // To hide low-tessellation artifacts // 0.0~1.0 + GFSDK_SSAO_FLOAT DetailAO; // Scale factor for the detail AO, the greater the darker // 0.0~2.0 + GFSDK_SSAO_FLOAT CoarseAO; // Scale factor for the coarse AO, the greater the darker // 0.0~2.0 + GFSDK_SSAO_FLOAT PowerExponent; // The final AO output is pow(AO, powerExponent) + GFSDK_SSAO_DepthStorage DepthStorage; // Quality / performance tradeoff + GFSDK_SSAO_DepthClampMode DepthClampMode; // To hide possible false-occlusion artifacts near screen borders + GFSDK_SSAO_DepthThreshold DepthThreshold; // Optional Z threshold, to hide possible depth-precision artifacts + GFSDK_SSAO_BlurParameters Blur; // Optional AO blur, to blur the AO before compositing it + + Parameters_D3D11() + : Radius(1.f) + , Bias(0.1f) + , DetailAO(0.f) + , CoarseAO(1.f) + , PowerExponent(2.f) + , DepthStorage(GFSDK_SSAO_FP32_VIEW_DEPTHS) + , DepthClampMode(GFSDK_SSAO_CLAMP_TO_EDGE) + { + } + }; + + static Status ReadStructs(FILE *pFile, InputDumpReader::InputDumpData* pOut) + { + InputDepthData InputDepthData; + if (fread(&InputDepthData, sizeof(InputDepthData), 1, pFile) != 1) + { + return STATUS_FREAD_ERROR; + } + + InputViewport InputViewport; + if (fread(&InputViewport, sizeof(InputViewport), 1, pFile) != 1) + { + return STATUS_FREAD_ERROR; + } + + InputNormalData InputNormalData; + if (fread(&InputNormalData, sizeof(InputNormalData), 1, pFile) != 1) + { + return STATUS_FREAD_ERROR; + } + + GFSDK_SSAO_InputData_D3D11& OutInputData = pOut->InputData; + memset(&OutInputData, 0, sizeof(OutInputData)); + + OutInputData.DepthData.DepthTextureType = InputDepthData.DepthTextureType; + memcpy(&OutInputData.DepthData.ProjectionMatrix.Data, &InputDepthData.ProjectionMatrix, sizeof(InputDepthData.ProjectionMatrix)); + OutInputData.DepthData.ProjectionMatrix.Layout = InputDepthData.ProjectionMatrixLayout; + OutInputData.DepthData.MetersToViewSpaceUnits = InputDepthData.MetersToViewSpaceUnits; + OutInputData.DepthData.Viewport.Enable = 0; + + OutInputData.NormalData.Enable = InputNormalData.Enable; + memcpy(&OutInputData.NormalData.WorldToViewMatrix.Data, &InputNormalData.WorldToViewMatrix, sizeof(InputNormalData.WorldToViewMatrix)); + OutInputData.NormalData.WorldToViewMatrix.Layout = InputNormalData.WorldToViewMatrixLayout; + OutInputData.NormalData.DecodeScale = InputNormalData.DecodeScale; + OutInputData.NormalData.DecodeBias = InputNormalData.DecodeBias; + + Parameters_D3D11 Parameters; + if (fread(&Parameters, sizeof(Parameters), 1, pFile) != 1) + { + return STATUS_FREAD_ERROR; + } + + pOut->Parameters.Radius = Parameters.Radius; + pOut->Parameters.Bias = Parameters.Bias; + pOut->Parameters.DetailAO = Parameters.DetailAO; + pOut->Parameters.CoarseAO = Parameters.CoarseAO; + pOut->Parameters.DepthStorage = Parameters.DepthStorage; + pOut->Parameters.PowerExponent = Parameters.PowerExponent; + pOut->Parameters.DepthClampMode = Parameters.DepthClampMode; + pOut->Parameters.DepthThreshold = Parameters.DepthThreshold; + pOut->Parameters.Blur = Parameters.Blur; + + return STATUS_OK; + } +}; + +} // namespace D3D11 +} // namespace SSAO +} // namespace GFSDK -- cgit v1.2.3