Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 288 insertions, 0 deletions

diff --git a/APEX_1.4/samples_v2/SampleBase/ApexRenderMaterial.cpp b/APEX_1.4/samples_v2/SampleBase/ApexRenderMaterial.cpp
new file mode 100644
index 00000000..9e6eaa2d
--- /dev/null
+++ b/APEX_1.4/samples_v2/SampleBase/ApexRenderMaterial.cpp
@@ -0,0 +1,288 @@
+/*
+* Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+*
+* NVIDIA CORPORATION and its licensors retain all intellectual property
+* and proprietary rights in and to this software, 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.
+*/
+
+#include "ApexRenderMaterial.h"
+#include <DirectXMath.h>
+#include "ApexResourceCallback.h"
+#include "Utils.h"
+#include "PsFastXml.h"
+
+#include "PsFileBuffer.h"
+#include "PxInputDataFromPxFileBuf.h"
+#include "nvparameterized/NvParamUtils.h"
+
+
+const char* DEFAULT_SPRITE_PARTICLE_SHADER = "pointsprite.hlsl";
+const char* DEFAULT_MESH_PARTICLE_SHADER = "pointsprite.hlsl";
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//											Material .xml files parser
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+class MaterialXmlParser : public nvidia::shdfnd::FastXml::Callback
+{
+public:
+	MaterialXmlParser() :
+		blendMode(ApexRenderMaterial::BLEND_NONE)
+	{
+	}
+	virtual ~MaterialXmlParser()
+	{
+	}
+
+	string textureFile;
+	vector<string> shaderFiles;
+	ApexRenderMaterial::BlendMode blendMode;
+
+protected:
+	// encountered a comment in the XML
+	virtual bool processComment(const char* /*comment*/)
+	{
+		return true;
+	}
+
+	virtual bool processClose(const char* /*element*/, unsigned int /*depth*/, bool& /*isError*/)
+	{
+		return true;
+	}
+
+	// return true to continue processing the XML document, false to skip.
+	virtual bool processElement(const char* elementName, // name of the element
+		const char* elementData, // element data, null if none
+		const nvidia::shdfnd::FastXml::AttributePairs& attr,
+		int /*lineno*/) // line number in the source XML file
+	{
+		PX_UNUSED(attr);
+		if (::strcmp(elementName, "texture") == 0)
+		{
+			textureFile = elementData;
+		}
+		else if (::strcmp(elementName, "shader") == 0)
+		{
+			shaderFiles.push_back(elementData);
+		}
+		else if (::strcmp(elementName, "blending") == 0)
+		{
+			blendMode = (::stricmp(elementData, "additive") == 0) ? ApexRenderMaterial::BLEND_ADDITIVE :
+				ApexRenderMaterial::BLEND_ALPHA_BLENDING;
+		}
+
+		return true;
+	}
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//												ApexRenderMaterial
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ApexRenderMaterial::ApexRenderMaterial(ApexResourceCallback* resourceProvider, const char* xmlFilePath)
+{
+	PsFileBuffer theBuffer(xmlFilePath, nvidia::general_PxIOStream2::PxFileBuf::OPEN_READ_ONLY);
+	PxInputDataFromPxFileBuf id(theBuffer);
+	MaterialXmlParser parser;
+	nvidia::shdfnd::FastXml* xml = nvidia::shdfnd::createFastXml(&parser);
+	xml->processXml(id, false);
+
+	this->initialize(resourceProvider, parser.shaderFiles, parser.textureFile.c_str(), parser.blendMode);
+
+	xml->release();
+}
+
+ApexRenderMaterial::ApexRenderMaterial(ApexResourceCallback* resourceCallback, const NvParameterized::Interface *graphicMaterialData)
+{
+	const char* textureFileName = NULL;
+	NvParameterized::getParamString(*graphicMaterialData, "DiffuseTexture", textureFileName);
+
+	BlendMode blendMode = BLEND_NONE;
+
+	const char *technique = "SPRITE_ONE";
+	NvParameterized::getParamEnum(*graphicMaterialData, "RenderTechnique", technique);
+	if (technique)
+	{
+		if (::strcmp(technique, "SPRITE_ONE") == 0)
+		{
+			blendMode = BLEND_ADDITIVE;
+		}
+		else if (::strcmp(technique, "SPRITE_ALPHA") == 0)
+		{
+			blendMode = BLEND_ALPHA_BLENDING;
+		}
+	}
+
+	this->initialize(resourceCallback, blendMode == BLEND_NONE ? DEFAULT_MESH_PARTICLE_SHADER : DEFAULT_SPRITE_PARTICLE_SHADER, textureFileName, blendMode);
+}
+
+ApexRenderMaterial::ApexRenderMaterial(ApexResourceCallback* resourceCallback, const char* shaderFileName,
+	const char* textureFileName, BlendMode blendMode)
+{
+	this->initialize(resourceCallback, shaderFileName, textureFileName, blendMode);
+}
+
+void ApexRenderMaterial::initialize(ApexResourceCallback* resourceCallback, const char* shaderFileName, const char* textureFileName, BlendMode blendMode)
+{
+	vector<string> v;
+	v.push_back(shaderFileName);
+	initialize(resourceCallback, v, textureFileName, blendMode);
+}
+
+void ApexRenderMaterial::initialize(ApexResourceCallback* resourceCallback, vector<string> shaderFileNames, const char* textureFileName, BlendMode blendMode)
+{
+	mTextureSRV = nullptr;
+	mTexture = nullptr;
+	mBlendState = nullptr;
+	mTextureFileName = textureFileName;
+
+	for (uint32_t i = 0; i < shaderFileNames.size(); i++)
+	{
+		string shaderFilePath = ((char*)resourceCallback->requestResourceCustom(ApexResourceCallback::eSHADER_FILE_PATH, shaderFileNames[i].c_str()));
+		mShaderFilePathes.push_back(shaderFilePath);
+	}
+	mShaderGroups.reserve(mShaderFilePathes.size());
+
+	if (!mTextureFileName.empty())
+	{
+		mTexture =
+			(TextureResource*)resourceCallback->requestResourceCustom(ApexResourceCallback::eTEXTURE_RESOURCE, mTextureFileName.c_str());
+	}
+
+	setBlending(blendMode);
+
+	reload();
+}
+
+void ApexRenderMaterial::releaseReloadableResources()
+{
+	for (vector<ShaderGroup*>::iterator it = mShaderGroups.begin(); it != mShaderGroups.end(); it++)
+	{
+		delete *it;
+	}
+	mShaderGroups.clear();
+
+	SAFE_RELEASE(mTextureSRV);
+}
+
+ApexRenderMaterial::~ApexRenderMaterial()
+{
+	releaseReloadableResources();
+	SAFE_RELEASE(mBlendState);
+
+	for (list<Instance*>::iterator it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		delete *it;
+	}
+	mInstances.clear();
+}
+
+void ApexRenderMaterial::setBlending(BlendMode blendMode)
+{
+	SAFE_RELEASE(mBlendState);
+
+	D3D11_BLEND_DESC desc;
+	ZeroMemory(&desc, sizeof(desc));
+
+	switch (blendMode)
+	{
+	case BLEND_NONE:
+		desc.RenderTarget[0].BlendEnable = FALSE;
+		desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
+		break;
+	case BLEND_ALPHA_BLENDING:
+		desc.AlphaToCoverageEnable = FALSE;
+		desc.IndependentBlendEnable = TRUE;
+		desc.RenderTarget[0].BlendEnable = TRUE;
+		desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
+		desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
+		desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
+		desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
+		desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
+		desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
+		desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
+		break;
+	case BLEND_ADDITIVE: // actually, is's additive by alpha
+		desc.AlphaToCoverageEnable = FALSE;
+		desc.IndependentBlendEnable = TRUE;
+		desc.RenderTarget[0].BlendEnable = TRUE;
+		desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
+		desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
+		desc.RenderTarget[0].DestBlend = D3D11_BLEND_ONE;
+		desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ONE;
+		desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
+		desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
+		desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
+		break;
+	default:
+		PX_ALWAYS_ASSERT_MESSAGE("Unknown blend mode");
+	}
+
+	ID3D11Device* device = GetDeviceManager()->GetDevice();
+	V(device->CreateBlendState(&desc, &mBlendState));
+}
+
+void ApexRenderMaterial::reload()
+{
+	releaseReloadableResources();
+
+	// load shaders
+	ID3D11Device* device = GetDeviceManager()->GetDevice();
+
+	for (vector<string>::iterator it = mShaderFilePathes.begin(); it != mShaderFilePathes.end(); it++)
+	{
+		const char* shaderFilePath = (*it).c_str();
+		ShaderGroup* shaderGroup = new ShaderGroup();
+		V(createShaderFromFile(device, shaderFilePath, "VS", &(shaderGroup->vs), shaderGroup->buffer));
+		V(createShaderFromFile(device, shaderFilePath, "PS", &shaderGroup->ps));
+		createShaderFromFile(device, shaderFilePath, "GS", &shaderGroup->gs);
+		mShaderGroups.push_back(shaderGroup);
+	}
+
+	// load texture
+	if (mTexture)
+	{
+		V(DirectX::CreateShaderResourceView(device, mTexture->image.GetImages(), mTexture->image.GetImageCount(),
+		                                    mTexture->metaData, &mTextureSRV));
+	}
+}
+
+ApexRenderMaterial::Instance* ApexRenderMaterial::getMaterialInstance(const D3D11_INPUT_ELEMENT_DESC* elementDescs, uint32_t numElements)
+{
+	ID3D11InputLayout* inputLayout = NULL;
+	ID3D11Device* device = GetDeviceManager()->GetDevice();
+
+	for (uint32_t i = 0; i < mShaderGroups.size(); i++)
+	{
+		if (mShaderGroups[i]->buffer == NULL)
+			continue;
+
+		device->CreateInputLayout(elementDescs, numElements, mShaderGroups[i]->buffer->GetBufferPointer(), mShaderGroups[i]->buffer->GetBufferSize(), &inputLayout);
+
+		if (inputLayout)
+		{
+			Instance* materialInstance = new Instance(*this, inputLayout, i);
+			mInstances.push_back(materialInstance);
+			return materialInstance;
+		}
+	}
+	PX_ALWAYS_ASSERT();
+	return NULL;
+}
+
+void ApexRenderMaterial::Instance::bind(ID3D11DeviceContext& context, uint32_t slot)
+{
+	mMaterial.mShaderGroups[mShaderNum]->Set(&context);
+
+	context.OMSetBlendState(mMaterial.mBlendState, nullptr, 0xFFFFFFFF);
+	context.PSSetShaderResources(slot, 1, &(mMaterial.mTextureSRV));
+	context.IASetInputLayout(mInputLayout);
+}
+
+bool ApexRenderMaterial::Instance::isValid()
+{
+	return mMaterial.mShaderGroups.size() > 0 && mMaterial.mShaderGroups[mShaderNum]->IsValid();
+}