//---------------------------------------------------------------------------//
void GpuProgramPipelineDX12::UpdateShaderByteCodeHash()
{
myShaderByteCodeHash = 0u;
for (uint i = 0u; i < (uint)ShaderStage::NUM; ++i)
{
GpuProgram* shader = myGpuPrograms[i].get();
MathUtil::hash_combine(myShaderByteCodeHash, reinterpret_cast<uint64>(shader));
if (shader != nullptr)
MathUtil::hash_combine(myShaderByteCodeHash, reinterpret_cast<uint64>(shader->getNativeData().Get()));
}
}
void GpuProgram::CmdType::doSet(void* target, const String& val)
{
GpuProgram* t = static_cast<GpuProgram*>(target);
if (val == "vertex_program")
{
t->setType(GPT_VERTEX_PROGRAM);
}
else if (val == "geometry_program")
{
t->setType(GPT_GEOMETRY_PROGRAM);
}
else if (val == "domain_program")
{
t->setType(GPT_DOMAIN_PROGRAM);
}
else if (val == "hull_program")
{
t->setType(GPT_HULL_PROGRAM);
}
else if (val == "compute_program")
{
t->setType(GPT_COMPUTE_PROGRAM);
}
else
{
t->setType(GPT_FRAGMENT_PROGRAM);
}
}
Resource* GLSLShaderManager::createImpl(const String& name,
ResourceHandle handle,
const String& group, bool isManual,
ManualResourceLoader* loader,
GpuProgramType gptype,
const String& syntaxCode)
{
ShaderMap::const_iterator iter = mShaderMap.find(syntaxCode);
if (iter == mShaderMap.end())
{
// No factory, this is an unsupported syntax code, probably for another rendersystem
// Create a basic one, it doesn't matter what it is since it won't be used
// we have to forward the syntax code though
GpuProgram* ret = new GLSLShader(this, name, handle, group, isManual, loader);
ret->setSyntaxCode(syntaxCode);
return ret;
}
return (iter->second)(this, name, handle, group, isManual, loader, gptype, syntaxCode);
}
//-----------------------------------------------------------------------------
void GLRenderToVertexBuffer::bindVerticesOutput(Pass* pass)
{
VertexDeclaration* declaration = mVertexData->vertexDeclaration;
bool useVaryingAttributes = false;
//Check if we are FixedFunc/ASM shaders (Static attributes) or GLSL (Varying attributes)
//We assume that there isn't a mix of GLSL and ASM as this is illegal
GpuProgram* sampleProgram = 0;
if (pass->hasVertexProgram())
{
sampleProgram = pass->getVertexProgram().getPointer();
}
else if (pass->hasGeometryProgram())
{
sampleProgram = pass->getGeometryProgram().getPointer();
}
if ((sampleProgram != 0) && (sampleProgram->getLanguage() == "glsl"))
{
useVaryingAttributes = true;
}
if (useVaryingAttributes)
{
//Have GLSL shaders, using varying attributes
GLSLLinkProgram* linkProgram = GLSLLinkProgramManager::getSingleton().getActiveLinkProgram();
GLhandleARB linkProgramId = linkProgram->getGLHandle();
vector<GLint>::type locations;
for (unsigned short e=0; e < declaration->getElementCount(); e++)
{
const VertexElement* element =declaration->getElement(e);
String varyingName = getSemanticVaryingName(element->getSemantic(), element->getIndex());
GLint location = glGetVaryingLocationNV(linkProgramId, varyingName.c_str());
if (location < 0)
{
OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
"GLSL link program does not output " + varyingName +
" so it cannot fill the requested vertex buffer",
"OgreGLRenderToVertexBuffer::bindVerticesOutput");
}
locations.push_back(location);
}
glTransformFeedbackVaryingsNV(
linkProgramId, static_cast<GLsizei>(locations.size()),
&locations[0], GL_INTERLEAVED_ATTRIBS_NV);
}
else
{
//Either fixed function or assembly (CG = assembly) shaders
vector<GLint>::type attribs;
for (unsigned short e=0; e < declaration->getElementCount(); e++)
{
const VertexElement* element = declaration->getElement(e);
//Type
attribs.push_back(getGLSemanticType(element->getSemantic()));
//Number of components
attribs.push_back(VertexElement::getTypeCount(element->getType()));
//Index
attribs.push_back(element->getIndex());
}
glTransformFeedbackAttribsNV(
static_cast<GLuint>(declaration->getElementCount()),
&attribs[0], GL_INTERLEAVED_ATTRIBS_NV);
}
checkGLError(true, true, "GLRenderToVertexBuffer::bindVerticesOutput");
}
void GpuProgram::CmdComputeGroupDims::doSet(void* target, const String& val)
{
GpuProgram* t = static_cast<GpuProgram*>(target);
t->setComputeGroupDimensions(StringConverter::parseVector3(val));
}
void GpuProgram::CmdAdjacency::doSet(void* target, const String& val)
{
GpuProgram* t = static_cast<GpuProgram*>(target);
t->setAdjacencyInfoRequired(StringConverter::parseBool(val));
}
void GpuProgram::CmdManualNamedConstsFile::doSet(void* target, const String& val)
{
GpuProgram* t = static_cast<GpuProgram*>(target);
t->setManualNamedConstantsFile(val);
}
void GpuProgram::CmdVTF::doSet(void* target, const String& val)
{
GpuProgram* t = static_cast<GpuProgram*>(target);
t->setVertexTextureFetchRequired(StringConverter::parseBool(val));
}
void GpuProgram::CmdPose::doSet(void* target, const String& val)
{
GpuProgram* t = static_cast<GpuProgram*>(target);
t->setPoseAnimationIncluded((ushort)StringConverter::parseUnsignedInt(val));
}
void GpuProgram::CmdMorph::doSet(void* target, const String& val)
{
GpuProgram* t = static_cast<GpuProgram*>(target);
t->setMorphAnimationIncluded(StringConverter::parseBool(val));
}
void GpuProgram::CmdSyntax::doSet(void* target, const String& val)
{
GpuProgram* t = static_cast<GpuProgram*>(target);
t->setSyntaxCode(val);
}
Resource* GLSLShaderManager::createImpl(const String& name,
ResourceHandle handle,
const String& group, bool isManual,
ManualResourceLoader* loader,
const NameValuePairList* params)
{
NameValuePairList::const_iterator paramSyntax, paramType;
if (!params ||
(paramSyntax = params->find("syntax")) == params->end() ||
(paramType = params->find("type")) == params->end())
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"You must supply 'syntax' and 'type' parameters",
"GLSLShaderManager::createImpl");
}
ShaderMap::const_iterator iter = mShaderMap.find(paramSyntax->second);
if(iter == mShaderMap.end())
{
// No factory, this is an unsupported syntax code, probably for another rendersystem
// Create a basic one, it doesn't matter what it is since it won't be used
// we have to forward the syntax code though
GpuProgram* ret = new GLSLShader(this, name, handle, group, isManual, loader);
ret->setSyntaxCode(paramSyntax->second);
return ret;
}
GpuProgramType gpt;
if (paramType->second == "vertex_program")
{
gpt = GPT_VERTEX_PROGRAM;
}
else if (paramType->second == "tesselation_hull_program")
{
gpt = GPT_HULL_PROGRAM;
}
else if (paramType->second == "tesselation_domain_program")
{
gpt = GPT_DOMAIN_PROGRAM;
}
else if (paramType->second == "geometry_program")
{
gpt = GPT_GEOMETRY_PROGRAM;
}
else if (paramType->second == "fragment_program")
{
gpt = GPT_FRAGMENT_PROGRAM;
}
else if (paramType->second == "compute_program")
{
gpt = GPT_COMPUTE_PROGRAM;
}
else
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"Unknown or unimplemented program type " + paramType->second,
"GLSLShaderManager::createImpl");
}
return (iter->second)(this, name, handle, group, isManual,
loader, gpt, paramSyntax->second);
}