runtime.cpp

//----------------------------------------------------------------------------------
// File:        FaceWorks/src/runtime.cpp
// SDK Version: v1.0
// Email:       gameworks@nvidia.com
// Site:        http://developer.nvidia.com/
//
// Copyright (c) 2014-2016, NVIDIA CORPORATION. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//----------------------------------------------------------------------------------

#include "internal.h"

#include <cassert>

// ======================================================================================
//     Runtime API for SSS
// ======================================================================================

GFSDK_FaceWorks_Result ValidateSSSConfig(
	const GFSDK_FaceWorks_SSSConfig * pConfig,
	GFSDK_FaceWorks_ErrorBlob * pErrorBlobOut)
{
	if (!pConfig)
	{
		ErrPrintf("pConfig is null\n");
		return GFSDK_FaceWorks_InvalidArgument;
	}

	if (pConfig->m_diffusionRadius <= 0.0f)
	{
		WarnPrintf(
			"pConfig->m_diffusionRadius is %g; should be greater than 0.0\n",
			pConfig->m_diffusionRadius);
	}
	if (pConfig->m_diffusionRadiusLUT <= 0.0f)
	{
		WarnPrintf(
			"pConfig->m_diffusionRadiusLUT is %g; should be greater than 0.0\n",
			pConfig->m_diffusionRadius);
	}
	if (pConfig->m_curvatureRadiusMinLUT <= 0.0f)
	{
		WarnPrintf(
			"pConfig->m_curvatureRadiusMinLUT is %g; should be greater than 0.0\n",
			pConfig->m_curvatureRadiusMinLUT);
	}
	if (pConfig->m_curvatureRadiusMaxLUT <= 0.0f)
	{
		WarnPrintf(
			"pConfig->m_curvatureRadiusMaxLUT is %g; should be greater than 0.0\n",
			pConfig->m_curvatureRadiusMaxLUT);
	}
	if (pConfig->m_curvatureRadiusMaxLUT < pConfig->m_curvatureRadiusMinLUT)
	{
		WarnPrintf(
			"pConfig->m_curvatureRadiusMaxLUT (%g) is less than pConfig->m_curvatureRadiusMinLUT (%g)\n",
			pConfig->m_curvatureRadiusMaxLUT, pConfig->m_curvatureRadiusMinLUT);
	}
	if (pConfig->m_shadowWidthMinLUT <= 0.0f)
	{
		WarnPrintf(
			"pConfig->m_shadowWidthMinLUT is %g; should be greater than 0.0\n",
			pConfig->m_shadowWidthMinLUT);
	}
	if (pConfig->m_shadowWidthMaxLUT <= 0.0f)
	{
		WarnPrintf(
			"pConfig->m_shadowWidthMaxLUT is %g; should be greater than 0.0\n",
			pConfig->m_shadowWidthMaxLUT);
	}
	if (pConfig->m_shadowWidthMaxLUT < pConfig->m_shadowWidthMinLUT)
	{
		WarnPrintf(
			"pConfig->m_shadowWidthMaxLUT (%g) is less than pConfig->m_shadowWidthMinLUT (%g)\n",
			pConfig->m_shadowWidthMaxLUT, pConfig->m_shadowWidthMinLUT);
	}
	if (pConfig->m_shadowFilterWidth <= 0.0f)
	{
		WarnPrintf(
			"pConfig->m_shadowFilterWidth is %g; should be greater than 0.0\n",
			pConfig->m_shadowFilterWidth);
	}
	if (pConfig->m_normalMapSize < 0)
	{
		WarnPrintf(
			"pConfig->m_normalMapSize is %d; should be at least 0\n",
			pConfig->m_normalMapSize);
	}
	if (pConfig->m_averageUVScale <= 0.0f)
	{
		WarnPrintf(
			"pConfig->m_averageUVScale is %g; should be greater than 0.0\n",
			pConfig->m_averageUVScale);
	}

	return GFSDK_FaceWorks_OK;
}

GFSDK_FACEWORKS_API GFSDK_FaceWorks_Result GFSDK_FACEWORKS_CALLCONV GFSDK_FaceWorks_WriteCBDataForSSS(
	const GFSDK_FaceWorks_SSSConfig * pConfig,
	GFSDK_FaceWorks_CBData * pCBDataOut,
	GFSDK_FaceWorks_ErrorBlob * pErrorBlobOut)
{
	// Validate params

	GFSDK_FaceWorks_Result res = ValidateSSSConfig(pConfig, pErrorBlobOut);
	if (res != GFSDK_FaceWorks_OK)
		return res;

	if (!pCBDataOut)
	{
		ErrPrintf("GFSDK_FaceWorks_WriteCBDataForSSS: pCBDataOut is null\n");
		return GFSDK_FaceWorks_InvalidArgument;
	}

	// The LUTs are built assuming a particular scattering radius, so the
	// curvatures and penumbra widths need to be scaled to match the
	// scattering radius set at runtime.
	float diffusionRadiusFactor = pConfig->m_diffusionRadiusLUT /
									pConfig->m_diffusionRadius;

	// Set up the constant buffer

	float curvatureMin = diffusionRadiusFactor / pConfig->m_curvatureRadiusMaxLUT;
	float curvatureMax = diffusionRadiusFactor / pConfig->m_curvatureRadiusMinLUT;
	float curvatureScale = 1.0f / (curvatureMax - curvatureMin);
	float curvatureBias = -curvatureMin * curvatureScale;

	float shadowRcpWidthMin = diffusionRadiusFactor / pConfig->m_shadowWidthMaxLUT;
	float shadowRcpWidthMax = diffusionRadiusFactor / pConfig->m_shadowWidthMinLUT;
	float shadowScale = 1.0f / (shadowRcpWidthMax - shadowRcpWidthMin);
	float shadowBias = -shadowRcpWidthMin * shadowScale;

	float minLevelForBlurredNormal = log2(max(
										pConfig->m_normalMapSize * pConfig->m_diffusionRadius,
										pConfig->m_averageUVScale)
										/ pConfig->m_averageUVScale);

	// Output to user buffer
	pCBDataOut->data[0].x = curvatureScale;
	pCBDataOut->data[0].y = curvatureBias;
	pCBDataOut->data[0].z = shadowScale / pConfig->m_shadowFilterWidth;
	pCBDataOut->data[0].w = shadowBias;
	pCBDataOut->data[1].x = minLevelForBlurredNormal;

	return GFSDK_FaceWorks_OK;
}



// ======================================================================================
//     Runtime API for deep scatter
// ======================================================================================

GFSDK_FaceWorks_Result ValidateDeepScatterConfig(
	const GFSDK_FaceWorks_DeepScatterConfig * pConfig,
	GFSDK_FaceWorks_ErrorBlob * pErrorBlobOut)
{
	if (!pConfig)
	{
		ErrPrintf("pConfig is null\n");
		return GFSDK_FaceWorks_InvalidArgument;
	}

	if (pConfig->m_radius <= 0.0f)
	{
		WarnPrintf(
			"pConfig->m_radius is %g; should be greater than 0.0\n",
			pConfig->m_radius);
	}
	if (pConfig->m_shadowProjType != GFSDK_FaceWorks_NoProjection &&
		pConfig->m_shadowProjType != GFSDK_FaceWorks_ParallelProjection &&
		pConfig->m_shadowProjType != GFSDK_FaceWorks_PerspectiveProjection)
	{
		ErrPrintf(
			"pConfig->m_shadowProjType is %d; not a valid GFSDK_FaceWorks_ProjectionType enum value\n",
			pConfig->m_shadowProjType);
		return GFSDK_FaceWorks_InvalidArgument;
	}
	if (pConfig->m_shadowProjType != GFSDK_FaceWorks_NoProjection)
	{
		// Error checking for shadow parameters is done only if enabled by the projection type
		if (pConfig->m_shadowFilterRadius < 0.0f)
		{
			WarnPrintf(
				"pConfig->m_shadowFilterRadius is %g; should be at least 0.0\n",
				pConfig->m_shadowFilterRadius);
		}

		// Should we check that m_shadowProjMatrix is of the expected form
		// (e.g. has zeros in the expected places)?
	}

	return GFSDK_FaceWorks_OK;
}

GFSDK_FACEWORKS_API GFSDK_FaceWorks_Result GFSDK_FACEWORKS_CALLCONV GFSDK_FaceWorks_WriteCBDataForDeepScatter(
	const GFSDK_FaceWorks_DeepScatterConfig * pConfig,
	GFSDK_FaceWorks_CBData * pCBDataOut,
	GFSDK_FaceWorks_ErrorBlob * pErrorBlobOut)
{
	// Validate params

	GFSDK_FaceWorks_Result res = ValidateDeepScatterConfig(pConfig, pErrorBlobOut);
	if (res != GFSDK_FaceWorks_OK)
		return res;

	if (!pCBDataOut)
	{
		ErrPrintf("pCBDataOut is null\n");
		return GFSDK_FaceWorks_InvalidArgument;
	}

	// Set up the constant buffer

	// -0.7213475f = -1 / (2 * ln(2)) - this conversion lets us write this in the shader:
	//     exp2(deepScatterFalloff * thickness^2)
	// instead of this:
	//     exp(-thickness^2 / (2 * radius^2))
	float deepScatterFalloff = -0.7213475f / (pConfig->m_radius * pConfig->m_radius);

	// Calculate depth-decoding parameters from the projection matrix
	float decodeDepthScale = 0.0f;
	float decodeDepthBias = 0.0f;
	switch (pConfig->m_shadowProjType)
	{
	case GFSDK_FaceWorks_NoProjection:
		break;	// Nothing to do

	case GFSDK_FaceWorks_ParallelProjection:
		decodeDepthScale = -1.0f / pConfig->m_shadowProjMatrix._33;
		break;

	case GFSDK_FaceWorks_PerspectiveProjection:
		decodeDepthScale = pConfig->m_shadowProjMatrix._34 / pConfig->m_shadowProjMatrix._43;
		decodeDepthBias = -pConfig->m_shadowProjMatrix._33 / pConfig->m_shadowProjMatrix._43;
		break;

	default:
		assert(false);
		return GFSDK_FaceWorks_InvalidArgument;
	}

	// Output to user buffer
	pCBDataOut->data[1].y = deepScatterFalloff;
	pCBDataOut->data[1].z = pConfig->m_shadowFilterRadius;
	pCBDataOut->data[1].w = decodeDepthScale;
	pCBDataOut->data[2].x = decodeDepthBias;

	return GFSDK_FaceWorks_OK;
}