mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 04:34:48 +00:00
424 lines
15 KiB
C++
424 lines
15 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2012 GarageGames, LLC
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "platform/platform.h"
|
|
#include "materials/shaderData.h"
|
|
|
|
#include "console/consoleTypes.h"
|
|
#include "gfx/gfxDevice.h"
|
|
#include "core/strings/stringUnit.h"
|
|
#include "lighting/lightManager.h"
|
|
#include "console/engineAPI.h"
|
|
#include "console/typeValidators.h"
|
|
|
|
using namespace Torque;
|
|
|
|
|
|
Vector<ShaderData*> ShaderData::smAllShaderData;
|
|
|
|
|
|
IMPLEMENT_CONOBJECT( ShaderData );
|
|
|
|
ConsoleDocClass( ShaderData,
|
|
"@brief Special type of data block that stores information about a handwritten shader.\n\n"
|
|
|
|
"To use hand written shaders, a ShaderData datablock must be used. This datablock "
|
|
"refers only to the vertex and pixel shader filenames and a hardware target level. "
|
|
"Shaders are API specific, so DirectX and OpenGL shaders must be explicitly identified.\n\n "
|
|
|
|
"@tsexample\n"
|
|
"// Used for the procedural clould system\n"
|
|
"singleton ShaderData( CloudLayerShader )\n"
|
|
"{\n"
|
|
" DXVertexShaderFile = $Core::CommonShaderPath @ \"/cloudLayerV.hlsl\";\n"
|
|
" DXPixelShaderFile = $Core::CommonShaderPath @ \"/cloudLayerP.hlsl\";\n"
|
|
" DXGeometryShaderFile = $Core::CommonShaderPath @ \"/cloudLayerG.hlsl\";\n"
|
|
" OGLVertexShaderFile = $Core::CommonShaderPath @ \"/gl/cloudLayerV.glsl\";\n"
|
|
" OGLPixelShaderFile = $Core::CommonShaderPath @ \"/gl/cloudLayerP.glsl\";\n"
|
|
" OGLGeometryShaderFile = $Core::CommonShaderPath @ \"/gl/cloudLayerG.glsl\";\n"
|
|
" pixVersion = 2.0;\n"
|
|
"};\n"
|
|
"@endtsexample\n\n"
|
|
|
|
"@ingroup Shaders\n");
|
|
|
|
ShaderData::ShaderData()
|
|
{
|
|
VECTOR_SET_ASSOCIATION( mShaderMacros );
|
|
|
|
mUseDevicePixVersion = false;
|
|
mPixVersion = 1.0;
|
|
|
|
for( int i = 0; i < NumTextures; ++i)
|
|
mRTParams[i] = false;
|
|
|
|
mDXVertexShaderName = StringTable->EmptyString();
|
|
mDXPixelShaderName = StringTable->EmptyString();
|
|
mDXGeometryShaderName = StringTable->EmptyString();
|
|
|
|
mOGLVertexShaderName = StringTable->EmptyString();
|
|
mOGLPixelShaderName = StringTable->EmptyString();
|
|
mOGLGeometryShaderName = StringTable->EmptyString();
|
|
}
|
|
|
|
void ShaderData::initPersistFields()
|
|
{
|
|
docsURL;
|
|
addField("DXVertexShaderFile", TypeStringFilename, Offset(mDXVertexShaderName, ShaderData),
|
|
"@brief %Path to the DirectX vertex shader file to use for this ShaderData.\n\n"
|
|
"It must contain only one program and no pixel shader, just the vertex shader."
|
|
"It can be either an HLSL or assembly level shader. HLSL's must have a "
|
|
"filename extension of .hlsl, otherwise its assumed to be an assembly file.");
|
|
|
|
addField("DXPixelShaderFile", TypeStringFilename, Offset(mDXPixelShaderName, ShaderData),
|
|
"@brief %Path to the DirectX pixel shader file to use for this ShaderData.\n\n"
|
|
"It must contain only one program and no vertex shader, just the pixel "
|
|
"shader. It can be either an HLSL or assembly level shader. HLSL's "
|
|
"must have a filename extension of .hlsl, otherwise its assumed to be an assembly file.");
|
|
|
|
addField("DXGeometryShaderFile", TypeStringFilename, Offset(mDXGeometryShaderName, ShaderData),
|
|
"@brief %Path to the DirectX geometry shader file to use for this ShaderData.\n\n"
|
|
"It can be either an HLSL or assembly level shader. HLSL's must have a "
|
|
"filename extension of .hlsl, otherwise its assumed to be an assembly file.");
|
|
|
|
addField("OGLVertexShaderFile", TypeStringFilename, Offset(mOGLVertexShaderName, ShaderData),
|
|
"@brief %Path to an OpenGL vertex shader file to use for this ShaderData.\n\n"
|
|
"It must contain only one program and no pixel shader, just the vertex shader.");
|
|
|
|
addField("OGLPixelShaderFile", TypeStringFilename, Offset(mOGLPixelShaderName, ShaderData),
|
|
"@brief %Path to an OpenGL pixel shader file to use for this ShaderData.\n\n"
|
|
"It must contain only one program and no vertex shader, just the pixel "
|
|
"shader.");
|
|
|
|
addField("OGLGeometryShaderFile", TypeStringFilename, Offset(mOGLGeometryShaderName, ShaderData),
|
|
"@brief %Path to the OpenGL Geometry shader file to use for this ShaderData.\n\n");
|
|
|
|
addField("useDevicePixVersion", TypeBool, Offset(mUseDevicePixVersion, ShaderData),
|
|
"@brief If true, the maximum pixel shader version offered by the graphics card will be used.\n\n"
|
|
"Otherwise, the script-defined pixel shader version will be used.\n\n");
|
|
|
|
addFieldV("pixVersion", TypeRangedF32, Offset(mPixVersion, ShaderData), &CommonValidators::PositiveFloat,
|
|
"@brief Indicates target level the shader should be compiled.\n\n"
|
|
"Valid numbers at the time of this writing are 1.1, 1.4, 2.0, and 3.0. "
|
|
"The shader will not run properly if the hardware does not support the "
|
|
"level of shader compiled.");
|
|
|
|
addField("defines", TypeRealString, Offset(mDefines, ShaderData),
|
|
"@brief String of case-sensitive defines passed to the shader compiler.\n\n"
|
|
"The string should be delimited by a semicolon, tab, or newline character."
|
|
|
|
"@tsexample\n"
|
|
"singleton ShaderData( FlashShader )\n"
|
|
"{\n"
|
|
"DXVertexShaderFile = $shaderGen::cachePath @ \"/postFx/flashV.hlsl\";\n"
|
|
"DXPixelShaderFile = $shaderGen::cachePath @ \"/postFx/flashP.hlsl\";\n\n"
|
|
"DXGeometryShaderFile = $shaderGen::cachePath @ \"/postFx/flashG.hlsl\";\n\n"
|
|
" //Define setting the color of WHITE_COLOR.\n"
|
|
"defines = \"WHITE_COLOR=float4(1.0,1.0,1.0,0.0)\";\n\n"
|
|
"pixVersion = 2.0\n"
|
|
"}\n"
|
|
"@endtsexample\n\n"
|
|
);
|
|
|
|
addField("samplerNames", TypeRealString, Offset(mSamplerNames, ShaderData), NumTextures,
|
|
"@brief Indicates names of samplers present in shader. Order is important.\n\n"
|
|
"Order of sampler names are used to assert correct sampler register/location"
|
|
"Other objects (GFXStateBlockData, PostEffect...) use index number to link samplers."
|
|
);
|
|
|
|
addField("rtParams", TypeBool, Offset(mRTParams, ShaderData), NumTextures, "");
|
|
|
|
Parent::initPersistFields();
|
|
|
|
// Make sure we get activation signals.
|
|
LightManager::smActivateSignal.notify(&ShaderData::_onLMActivate);
|
|
}
|
|
|
|
bool ShaderData::onAdd()
|
|
{
|
|
if( !Parent::onAdd() )
|
|
return false;
|
|
|
|
mShaderMacros.clear();
|
|
|
|
// Keep track of it.
|
|
smAllShaderData.push_back( this );
|
|
|
|
// NOTE: We initialize the shader on request.
|
|
|
|
for(int i = 0; i < NumTextures; ++i)
|
|
{
|
|
if( mSamplerNames[i].isNotEmpty() && !mSamplerNames[i].startsWith("$") )
|
|
mSamplerNames[i].insert(0, "$");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void ShaderData::onRemove()
|
|
{
|
|
// Remove it from the all shaders list.
|
|
smAllShaderData.remove( this );
|
|
|
|
Parent::onRemove();
|
|
}
|
|
|
|
const Vector<GFXShaderMacro>& ShaderData::_getMacros()
|
|
{
|
|
// If they have already been processed then
|
|
// return the cached result.
|
|
if ( mShaderMacros.size() != 0 || mDefines.isEmpty() )
|
|
return mShaderMacros;
|
|
|
|
mShaderMacros.clear();
|
|
GFXShaderMacro macro;
|
|
const U32 defineCount = StringUnit::getUnitCount( mDefines, ";\n\t" );
|
|
for ( U32 i=0; i < defineCount; i++ )
|
|
{
|
|
String define = StringUnit::getUnit( mDefines, i, ";\n\t" );
|
|
|
|
macro.name = StringUnit::getUnit( define, 0, "=" );
|
|
macro.value = StringUnit::getUnit( define, 1, "=" );
|
|
mShaderMacros.push_back( macro );
|
|
}
|
|
|
|
return mShaderMacros;
|
|
}
|
|
|
|
GFXShader* ShaderData::getShader( const Vector<GFXShaderMacro> ¯os )
|
|
{
|
|
PROFILE_SCOPE( ShaderData_GetShader );
|
|
|
|
// Combine the dynamic macros with our script defined macros.
|
|
Vector<GFXShaderMacro> finalMacros;
|
|
finalMacros.merge( _getMacros() );
|
|
finalMacros.merge( macros );
|
|
|
|
// Convert the final macro list to a string.
|
|
String cacheKey;
|
|
GFXShaderMacro::stringize( macros, &cacheKey );
|
|
|
|
// Lookup the shader for this instance.
|
|
ShaderCache::Iterator iter = mShaders.find( cacheKey );
|
|
if ( iter != mShaders.end() )
|
|
return iter->value;
|
|
|
|
// Create the shader instance... if it fails then
|
|
// bail out and return nothing to the caller.
|
|
GFXShader *shader = _createShader( finalMacros );
|
|
if ( !shader )
|
|
return NULL;
|
|
|
|
_checkDefinition(shader);
|
|
|
|
// Store the shader in the cache and return it.
|
|
mShaders.insertUnique( cacheKey, shader );
|
|
return shader;
|
|
}
|
|
|
|
GFXShader* ShaderData::_createShader( const Vector<GFXShaderMacro> ¯os )
|
|
{
|
|
F32 pixver = mPixVersion;
|
|
if ( mUseDevicePixVersion )
|
|
pixver = getMax( pixver, GFX->getPixelShaderVersion() );
|
|
|
|
// Enable shader error logging.
|
|
GFXShader::setLogging( true, true );
|
|
|
|
GFXShader *shader = GFX->createShader();
|
|
bool success = false;
|
|
|
|
Vector<String> samplers;
|
|
samplers.setSize(ShaderData::NumTextures);
|
|
for(int i = 0; i < ShaderData::NumTextures; ++i)
|
|
samplers[i] = mSamplerNames[i][0] == '$' ? mSamplerNames[i] : "$"+mSamplerNames[i];
|
|
|
|
// Initialize the right shader type.
|
|
switch( GFX->getAdapterType() )
|
|
{
|
|
case Direct3D11:
|
|
{
|
|
if (mDXVertexShaderName != String::EmptyString)
|
|
shader->setShaderStageFile(GFXShaderStage::VERTEX_SHADER, mDXVertexShaderName);
|
|
if (mDXPixelShaderName != String::EmptyString)
|
|
shader->setShaderStageFile(GFXShaderStage::PIXEL_SHADER, mDXPixelShaderName);
|
|
if (mDXGeometryShaderName != String::EmptyString)
|
|
shader->setShaderStageFile(GFXShaderStage::GEOMETRY_SHADER, mDXGeometryShaderName);
|
|
success = shader->init( pixver,
|
|
macros,
|
|
samplers);
|
|
break;
|
|
}
|
|
|
|
case OpenGL:
|
|
{
|
|
if(mOGLVertexShaderName != String::EmptyString)
|
|
shader->setShaderStageFile(GFXShaderStage::VERTEX_SHADER, mOGLVertexShaderName);
|
|
if (mOGLPixelShaderName != String::EmptyString)
|
|
shader->setShaderStageFile(GFXShaderStage::PIXEL_SHADER, mOGLPixelShaderName);
|
|
if (mOGLGeometryShaderName != String::EmptyString)
|
|
shader->setShaderStageFile(GFXShaderStage::GEOMETRY_SHADER, mOGLGeometryShaderName);
|
|
|
|
success = shader->init( pixver,
|
|
macros,
|
|
samplers);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
// Other device types are assumed to not support shaders.
|
|
success = false;
|
|
break;
|
|
}
|
|
|
|
#if defined(TORQUE_DEBUG)
|
|
//Assert Sampler registers
|
|
const Vector<GFXShaderConstDesc>& descs = shader->getShaderConstDesc();
|
|
for(int i = 0; i < descs.size(); ++i)
|
|
{
|
|
if(descs[i].constType != GFXSCT_Sampler && descs[i].constType != GFXSCT_SamplerCube)
|
|
continue;
|
|
|
|
GFXShaderConstHandle *handle = shader->findShaderConstHandle(descs[i].name);
|
|
if(!handle || !handle->isValid())
|
|
continue;
|
|
|
|
int reg = handle->getSamplerRegister();
|
|
if( descs[i].name != samplers[reg] )
|
|
{
|
|
const char *err = avar("ShaderData(%s): samplerNames[%d] = \"%s\" are diferent to sampler in shader: %s : register(S%d)"
|
|
,getName(), reg, samplers[reg].c_str(), handle->getName().c_str(), reg);
|
|
Con::printf(err);
|
|
GFXAssertFatal(0, err);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// If we failed to load the shader then
|
|
// cleanup and return NULL.
|
|
if ( !success )
|
|
SAFE_DELETE( shader );
|
|
|
|
return shader;
|
|
}
|
|
|
|
void ShaderData::reloadShaders()
|
|
{
|
|
ShaderCache::Iterator iter = mShaders.begin();
|
|
for ( ; iter != mShaders.end(); iter++ )
|
|
iter->value->reload();
|
|
}
|
|
|
|
void ShaderData::reloadAllShaders()
|
|
{
|
|
Vector<ShaderData*>::iterator iter = smAllShaderData.begin();
|
|
for ( ; iter != smAllShaderData.end(); iter++ )
|
|
(*iter)->reloadShaders();
|
|
}
|
|
|
|
void ShaderData::_onLMActivate( const char *lm, bool activate )
|
|
{
|
|
// Only on activations do we do anything.
|
|
if ( !activate )
|
|
return;
|
|
|
|
// Since the light manager usually swaps shadergen features
|
|
// and changes system wide shader defines we need to completely
|
|
// flush and rebuild all shaders.
|
|
|
|
reloadAllShaders();
|
|
}
|
|
|
|
bool ShaderData::hasSamplerDef(const String &_samplerName, int &pos) const
|
|
{
|
|
String samplerName = _samplerName.startsWith("$") ? _samplerName : "$"+_samplerName;
|
|
for(int i = 0; i < NumTextures; ++i)
|
|
{
|
|
if( mSamplerNames[i].equal(samplerName, String::NoCase ) )
|
|
{
|
|
pos = i;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
pos = -1;
|
|
return false;
|
|
}
|
|
|
|
bool ShaderData::_checkDefinition(GFXShader *shader)
|
|
{
|
|
bool error = false;
|
|
Vector<String> samplers;
|
|
samplers.reserve(NumTextures);
|
|
bool rtParams[NumTextures];
|
|
for(int i = 0; i < NumTextures; ++i)
|
|
rtParams[i] = false;
|
|
|
|
const Vector<GFXShaderConstDesc> &shaderConstDesc = shader->getShaderConstDesc();
|
|
|
|
for(int i = 0; i < shaderConstDesc.size(); ++i)
|
|
{
|
|
const GFXShaderConstDesc &desc = shaderConstDesc[i];
|
|
if(desc.constType == GFXSCT_Sampler)
|
|
{
|
|
samplers.push_back(desc.name );
|
|
}
|
|
}
|
|
|
|
for(int i = 0; i < samplers.size(); ++i)
|
|
{
|
|
int pos;
|
|
bool find = hasSamplerDef(samplers[i], pos);
|
|
|
|
if(find && pos >= 0 && mRTParams[pos])
|
|
{
|
|
if( !shader->findShaderConstHandle( String::ToString("$rtParams%d", pos)) )
|
|
{
|
|
String errStr = String::ToString("ShaderData(%s) sampler[%d] used but rtParams%d not used in shader compilation. Possible error", shader->getPixelShaderFile().c_str(), pos, pos);
|
|
Con::errorf(errStr);
|
|
error = true;
|
|
}
|
|
}
|
|
|
|
if(!find)
|
|
{
|
|
String errStr = String::ToString("ShaderData(%s) sampler %s not defined", shader->getPixelShaderFile().c_str(), samplers[i].c_str());
|
|
Con::errorf(errStr);
|
|
GFXAssertFatal(0, errStr);
|
|
error = true;
|
|
}
|
|
}
|
|
|
|
return !error;
|
|
}
|
|
|
|
DefineEngineMethod( ShaderData, reload, void, (),,
|
|
"@brief Rebuilds all the vertex and pixel shader instances created from this ShaderData.\n\n"
|
|
|
|
"@tsexample\n"
|
|
"// Rebuild the shader instances from ShaderData CloudLayerShader\n"
|
|
"CloudLayerShader.reload();\n"
|
|
"@endtsexample\n\n")
|
|
{
|
|
object->reloadShaders();
|
|
}
|