TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-10 22:24:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Initial implementation of Custom Shader Features

Browse source
This commit is contained in:
Areloch 2019-05-17 01:20:19 -05:00
parent 54b4d2eaaf
commit 9a63761627
31 changed files with 1772 additions and 17 deletions
Download patch file Download diff file Expand all files Collapse all files

10
Engine/source/materials/baseMatInstance.h
View file

@ -49,6 +49,13 @@
#ifndef _MATSTATEHINT_H_
#include "materials/matStateHint.h"
#endif
#ifndef _GFXDEVICE_H_
#include "gfx/gfxDevice.h"
#endif
#ifndef CUSTOMSHADERBINDINGDATA_H
#include "materials/customShaderBindingData.h"
#endif
struct RenderPassData;
class GFXVertexBufferHandleBase;
@ -155,6 +162,9 @@ public:
/// Sets node transforms for the current stage. Used for hardware skinning.
virtual void setNodeTransforms( const MatrixF *address, const U32 numTransforms ) = 0;
/// Sets custom shader data
virtual void setCustomShaderData(Vector<CustomShaderBindingData> &shaderData) = 0;
/// This initializes various material scene state settings and
/// should be called after setupPass() within the pass loop.
/// @see setupPass

97
Engine/source/materials/customShaderBindingData.h Normal file
View file

@ -0,0 +1,97 @@
#pragma once
#ifndef CUSTOMSHADERBINDINGDATA_H
#define CUSTOMSHADERBINDINGDATA_H
#ifndef _GFXDEVICE_H_
#include "gfx/gfxDevice.h"
#endif
struct CustomShaderBindingData
{
public:
enum UniformType
{
Float = 0,
Float2,
Float3,
Float4,
Texture2D,
Texture3D,
Cubemap,
Matrix2x2,
Matrix2x3,
Matrix2x4,
Matrix3x2,
Matrix3x3,
Matrix3x4,
Matrix4x2,
Matrix4x3,
Matrix4x4
};
private:
StringTableEntry targetedUniformName;
//ShaderConstHandles shaderConstHandle;
UniformType type;
F32 mFloat;
Point2F mFloat2;
Point3F mFloat3;
Point4F mFloat4;
//Image stuff
GFXTexHandle texture;
GFXSamplerStateDesc samplerState;
public:
void setFloat(StringTableEntry shaderConstName, F32 f)
{
targetedUniformName = shaderConstName;
mFloat = f;
type = Float;
}
F32 getFloat() { return mFloat; }
void setFloat2(StringTableEntry shaderConstName, Point2F f)
{
targetedUniformName = shaderConstName;
mFloat2 = f;
type = Float2;
}
Point2F getFloat2() { return mFloat2; }
void setFloat3(StringTableEntry shaderConstName, Point3F f)
{
targetedUniformName = shaderConstName;
mFloat3 = f;
type = Float3;
}
Point3F getFloat3() { return mFloat3; }
void setFloat4(StringTableEntry shaderConstName, Point4F f)
{
targetedUniformName = shaderConstName;
mFloat4 = f;
type = Float4;
}
Point4F getFloat4() { return mFloat4; }
void setTexture2D(StringTableEntry shaderConstName, GFXTexHandle f)
{
targetedUniformName = shaderConstName;
texture = f;
type = Texture2D;
}
GFXTexHandle getTexture2D() { return texture; }
StringTableEntry getHandleName() {
return targetedUniformName;
}
UniformType getType() {
return type;
}
};
#endif

6
Engine/source/materials/matInstance.cpp
View file

@ -473,6 +473,12 @@ void MatInstance::setNodeTransforms(const MatrixF *address, const U32 numTransfo
mProcessedMaterial->setNodeTransforms(address, numTransforms, getCurPass());
}
void MatInstance::setCustomShaderData(Vector<CustomShaderBindingData> &shaderData)
{
PROFILE_SCOPE(MatInstance_setCustomShaderData);
mProcessedMaterial->setCustomShaderData(shaderData, getCurPass());
}
void MatInstance::setSceneInfo(SceneRenderState * state, const SceneData& sgData)
{
PROFILE_SCOPE(MatInstance_setSceneInfo);

1
Engine/source/materials/matInstance.h
View file

@ -66,6 +66,7 @@ public:
virtual bool setupPass(SceneRenderState *, const SceneData &sgData );
virtual void setTransforms(const MatrixSet &matrixSet, SceneRenderState *state);
virtual void setNodeTransforms(const MatrixF *address, const U32 numTransforms);
virtual void setCustomShaderData(Vector<CustomShaderBindingData> &shaderData);
virtual void setSceneInfo(SceneRenderState *, const SceneData& sgData);
virtual void setTextureStages(SceneRenderState * state, const SceneData &sgData );
virtual void setBuffers(GFXVertexBufferHandleBase* vertBuffer, GFXPrimitiveBufferHandle* primBuffer);

34
Engine/source/materials/materialDefinition.cpp
View file

@ -483,6 +483,11 @@ void Material::initPersistFields()
endGroup( "Behavioral" );
addProtectedField("customShaderFeature", TypeRealString, NULL, &protectedSetCustomShaderFeature, &defaultProtectedGetFn,
"Do not modify, for internal use.", AbstractClassRep::FIELD_HideInInspectors);
addProtectedField("CustomShaderFeatureUniforms", TypeRealString, NULL, &protectedSetCustomShaderFeatureUniforms, &defaultProtectedGetFn,
"Do not modify, for internal use.", AbstractClassRep::FIELD_HideInInspectors);
Parent::initPersistFields();
}
@ -500,6 +505,35 @@ bool Material::writeField( StringTableEntry fieldname, const char *value )
return Parent::writeField( fieldname, value );
}
bool Material::protectedSetCustomShaderFeature(void *object, const char *index, const char *data)
{
Material *material = static_cast< Material* >(object);
CustomShaderFeatureData* customFeature;
if (!Sim::findObject(data, customFeature))
return false;
material->mCustomShaderFeatures.push_back(customFeature);
return false;
}
bool Material::protectedSetCustomShaderFeatureUniforms(void *object, const char *index, const char *data)
{
Material *material = static_cast< Material* >(object);
if (index != NULL)
{
char featureName[256] = { 0 };
U32 id = 0;
dSscanf(index, "%s_%i", featureName, id);
String uniformName = data;
}
return false;
}
bool Material::onAdd()
{
if (Parent::onAdd() == false)

10
Engine/source/materials/materialDefinition.h
View file

@ -41,6 +41,9 @@
#include "console/dynamicTypes.h"
#endif
#ifndef CUSTOMSHADERFEATURE_H
#include "shaderGen/customShaderFeature.h"
#endif
class CubemapData;
class SFXTrack;
@ -49,7 +52,7 @@ class FeatureSet;
class FeatureType;
class MaterialSoundProfile;
class MaterialPhysicsProfile;
class CustomShaderFeatureData;
/// The basic material definition.
class Material : public BaseMaterialDefinition
@ -343,6 +346,8 @@ public:
F32 mDirectSoundOcclusion; ///< Amount of volume occlusion on direct sounds.
F32 mReverbSoundOcclusion; ///< Amount of volume occlusion on reverb sounds.
Vector<CustomShaderFeatureData*> mCustomShaderFeatures;
///@}
String mMapTo; // map Material to this texture name
@ -380,6 +385,9 @@ public:
virtual void inspectPostApply();
virtual bool writeField( StringTableEntry fieldname, const char *value );
static bool protectedSetCustomShaderFeature(void *object, const char *index, const char *data);
static bool protectedSetCustomShaderFeatureUniforms(void *object, const char *index, const char *data);
//
// ConsoleObject interface
//

2
Engine/source/materials/processedCustomMaterial.cpp
View file

@ -245,7 +245,7 @@ bool ProcessedCustomMaterial::init( const FeatureSet &features,
return false;
}
rpd->shaderHandles.init( rpd->shader, mCustomMaterial );
rpd->shaderHandles.init( rpd->shader, mCustomMaterial->mCustomShaderFeatures, mCustomMaterial );
_initMaterialParameters();
mDefaultParameters = allocMaterialParameters();
setMaterialParameters( mDefaultParameters, 0 );

1
Engine/source/materials/processedFFMaterial.h
View file

@ -54,6 +54,7 @@ public:
virtual void setTransforms(const MatrixSet &matrixSet, SceneRenderState *state, const U32 pass);
virtual void setNodeTransforms(const MatrixF *address, const U32 numTransforms, const U32 pass) {;}
virtual void setCustomShaderData(Vector<CustomShaderBindingData> &shaderData, const U32 pass) {;}
virtual void setSceneInfo(SceneRenderState *, const SceneData& sgData, U32 pass);

9
Engine/source/materials/processedMaterial.h
View file

@ -39,6 +39,10 @@
#include "materials/matStateHint.h"
#endif
#ifndef CUSTOMSHADERBINDINGDATA_H
#include "materials/customShaderBindingData.h"
#endif
class ShaderFeature;
class MaterialParameters;
class MaterialParameterHandle;
@ -81,6 +85,8 @@ public:
MaterialFeatureData mFeatureData;
Vector<CustomShaderFeatureData*> mCustomShaderFeatureData;
bool mGlow;
Material::BlendOp mBlendOp;
@ -144,6 +150,9 @@ public:
/// Sets the node transforms for HW Skinning
virtual void setNodeTransforms(const MatrixF *address, const U32 numTransforms, const U32 pass) = 0;
/// Sets any custom shader data
virtual void setCustomShaderData(Vector<CustomShaderBindingData> &shaderData, const U32 pass) = 0;
/// Sets the scene info like lights for the given pass.
virtual void setSceneInfo(SceneRenderState *, const SceneData& sgData, U32 pass) = 0;

59
Engine/source/materials/processedShaderMaterial.cpp
View file

@ -50,7 +50,7 @@
///
/// ShaderConstHandles
///
void ShaderConstHandles::init( GFXShader *shader, CustomMaterial* mat /*=NULL*/ )
void ShaderConstHandles::init( GFXShader *shader, Vector<CustomShaderFeatureData*> customFeatureData, CustomMaterial* mat /*=NULL*/)
{
mDiffuseColorSC = shader->getShaderConstHandle("$diffuseMaterialColor");
mTexMatSC = shader->getShaderConstHandle(ShaderGenVars::texMat);
@ -116,6 +116,19 @@ void ShaderConstHandles::init( GFXShader *shader, CustomMaterial* mat /*=NULL*/
// Deferred Shading
mMatInfoFlagsSC = shader->getShaderConstHandle(ShaderGenVars::matInfoFlags);
//custom features
for (U32 f = 0; f < customFeatureData.size(); ++f)
{
for (U32 i = 0; i < customFeatureData[f]->mAddedShaderConstants.size(); ++i)
{
customHandleData newSC;
newSC.handle = shader->getShaderConstHandle(String("$") + String(customFeatureData[f]->mAddedShaderConstants[i]));
newSC.handleName = customFeatureData[f]->mAddedShaderConstants[i];
mCustomHandles.push_back(newSC);
}
}
}
///
@ -654,10 +667,10 @@ bool ProcessedShaderMaterial::_addPass( ShaderRenderPassData &rpd,
// Generate shader
GFXShader::setLogging( true, true );
rpd.shader = SHADERGEN->getShader( rpd.mFeatureData, mVertexFormat, &mUserMacros, samplers );
rpd.shader = SHADERGEN->getShader( rpd.mFeatureData, mMaterial->mCustomShaderFeatures, mVertexFormat, &mUserMacros, samplers );
if( !rpd.shader )
return false;
rpd.shaderHandles.init( rpd.shader );
rpd.shaderHandles.init( rpd.shader, mMaterial->mCustomShaderFeatures);
// If a pass glows, we glow
if( rpd.mGlow )
@ -1260,6 +1273,46 @@ void ProcessedShaderMaterial::setNodeTransforms(const MatrixF *transforms, const
}
}
void ProcessedShaderMaterial::setCustomShaderData(Vector<CustomShaderBindingData> &shaderData, const U32 pass)
{
PROFILE_SCOPE(ProcessedShaderMaterial_setCustomShaderData);
GFXShaderConstBuffer* shaderConsts = _getShaderConstBuffer(pass);
ShaderConstHandles* handles = _getShaderConstHandles(pass);
for (U32 i = 0; i < shaderData.size(); i++)
{
for (U32 h = 0; h < handles->mCustomHandles.size(); ++h)
{
StringTableEntry handleName = shaderData[i].getHandleName();
bool tmp = true;
}
//roll through and try setting our data!
for (U32 h = 0; h < handles->mCustomHandles.size(); ++h)
{
StringTableEntry handleName = shaderData[i].getHandleName();
StringTableEntry rpdHandleName = handles->mCustomHandles[h].handleName;
if (handles->mCustomHandles[h].handleName == shaderData[i].getHandleName())
{
if (handles->mCustomHandles[h].handle->isValid())
{
CustomShaderBindingData::UniformType type = shaderData[i].getType();
if (type == CustomShaderBindingData::Float)
shaderConsts->setSafe(handles->mCustomHandles[h].handle, shaderData[i].getFloat());
else if (type == CustomShaderBindingData::Float2)
shaderConsts->setSafe(handles->mCustomHandles[h].handle, shaderData[i].getFloat2());
else if (type == CustomShaderBindingData::Float3)
shaderConsts->setSafe(handles->mCustomHandles[h].handle, shaderData[i].getFloat3());
else if (type == CustomShaderBindingData::Float4)
shaderConsts->setSafe(handles->mCustomHandles[h].handle, shaderData[i].getFloat4());
break;
}
}
}
}
}
void ProcessedShaderMaterial::setSceneInfo(SceneRenderState * state, const SceneData& sgData, U32 pass)
{
PROFILE_SCOPE( ProcessedShaderMaterial_setSceneInfo );

14
Engine/source/materials/processedShaderMaterial.h
View file

@ -29,6 +29,9 @@
#ifndef _GFXSHADER_H_
#include "gfx/gfxShader.h"
#endif
#ifndef CUSTOMSHADERBINDINGDATA_H
#include "materials/customShaderBindingData.h"
#endif
class GenericConstBufferLayout;
class ShaderData;
@ -96,7 +99,15 @@ public:
GFXShaderConstHandle* mNodeTransforms;
void init( GFXShader* shader, CustomMaterial* mat = NULL );
struct customHandleData
{
StringTableEntry handleName;
GFXShaderConstHandle* handle;
};
Vector<customHandleData> mCustomHandles;
void init( GFXShader* shader, Vector<CustomShaderFeatureData*> customFeatureData, CustomMaterial* mat = NULL);
};
class ShaderRenderPassData : public RenderPassData
@ -132,6 +143,7 @@ public:
virtual void setTextureStages(SceneRenderState *, const SceneData &sgData, U32 pass );
virtual void setTransforms(const MatrixSet &matrixSet, SceneRenderState *state, const U32 pass);
virtual void setNodeTransforms(const MatrixF *address, const U32 numTransforms, const U32 pass);
virtual void setCustomShaderData(Vector<CustomShaderBindingData> &shaderData, const U32 pass);
virtual void setSceneInfo(SceneRenderState *, const SceneData& sgData, U32 pass);
virtual void setBuffers(GFXVertexBufferHandleBase* vertBuffer, GFXPrimitiveBufferHandle* primBuffer);
virtual bool stepInstance();

4
Engine/source/materials/sceneData.h
View file

@ -34,7 +34,7 @@
class GFXTexHandle;
class GFXCubemap;
class CustomShaderBindingData;
struct SceneData
{
@ -95,6 +95,8 @@ struct SceneData
/// features.
void *materialHint;
Vector<CustomShaderBindingData*> customShaderData;
/// Constructor.
SceneData()
{