//-----------------------------------------------------------------------
void D3D10HLSLProgram::createLowLevelImpl(void)
{
// Create a low-level program, give it the same name as us
mAssemblerProgram =GpuProgramPtr(dynamic_cast<GpuProgram*>(this));
/*
GpuProgramManager::getSingleton().createProgramFromString(
mName,
mGroup,
"",// dummy source, since we'll be using microcode
mType,
mTarget);
// static_cast<D3D10GpuProgram*>(mAssemblerProgram.get())->setExternalMicrocode(mpMicroCode);*/
}
//-----------------------------------------------------------------------------------
GpuProgramPtr ShaderManager::createGpuProgram(const String& name, const String& code, HlmsDatablock* dataBlock)
{
HighLevelGpuProgramPtr gpuProgram = HighLevelGpuProgramManager::getSingleton().createProgram(name,
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, dataBlock->getLanguage(), dataBlock->getShaderType());
gpuProgram->setParameter("entry_point", "main");
gpuProgram->setSource(code);
if (dataBlock->getLanguage() == "hlsl")
{
// HLSL program requires specific target profile settings - we have to split the profile string.
const StringVector& profilesList = dataBlock->getProfileList();
StringVector::const_iterator it = profilesList.begin();
StringVector::const_iterator itEnd = profilesList.end();
for (; it != itEnd; ++it)
{
if (GpuProgramManager::getSingleton().isSyntaxSupported(*it))
{
gpuProgram->setParameter("target", *it);
break;
}
}
}
gpuProgram->load();
// Case an error occurred.
if (gpuProgram->hasCompileError())
{
gpuProgram.setNull();
return GpuProgramPtr(gpuProgram);
}
return gpuProgram;
}
//-----------------------------------------------------------------------------
GpuProgramPtr ProgramManager::createGpuProgram(Program* shaderProgram,
ProgramWriter* programWriter,
const String& language,
const String& profiles,
const StringVector& profilesList,
const String& cachePath)
{
#if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
Ogre::StringSerialiser sourceCodeStringStream;
#else
std::stringstream sourceCodeStringStream;
#endif
_StringHash stringHash;
uint32 programHashCode;
String programName;
// Generate source code.
programWriter->writeSourceCode(sourceCodeStringStream, shaderProgram);
// Generate program hash code.
programHashCode = static_cast<uint32>(stringHash(sourceCodeStringStream.str()));
// Generate program name.
programName = StringConverter::toString(programHashCode);
if (shaderProgram->getType() == GPT_VERTEX_PROGRAM)
{
programName += "_VS";
}
else if (shaderProgram->getType() == GPT_FRAGMENT_PROGRAM)
{
programName += "_FS";
}
HighLevelGpuProgramPtr pGpuProgram;
// Try to get program by name.
pGpuProgram = HighLevelGpuProgramManager::getSingleton().getByName(programName);
// Case the program doesn't exist yet.
if (pGpuProgram.isNull())
{
// Create new GPU program.
pGpuProgram = HighLevelGpuProgramManager::getSingleton().createProgram(programName,
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, language, shaderProgram->getType());
// Case cache directory specified -> create program from file.
if (cachePath.empty() == false)
{
const String programFullName = programName + "." + language;
const String programFileName = cachePath + programFullName;
std::ifstream programFile;
bool writeFile = true;
// Check if program file already exist.
programFile.open(programFileName.c_str());
// Case no matching file found -> we have to write it.
if (!programFile)
{
writeFile = true;
}
else
{
writeFile = false;
programFile.close();
}
// Case we have to write the program to a file.
if (writeFile)
{
std::ofstream outFile(programFileName.c_str());
if (!outFile)
return GpuProgramPtr();
outFile << sourceCodeStringStream.str();
outFile.close();
}
pGpuProgram->setSourceFile(programFullName);
}
// No cache directory specified -> create program from system memory.
else
{
pGpuProgram->setSource(sourceCodeStringStream.str());
}
pGpuProgram->setParameter("entry_point", shaderProgram->getEntryPointFunction()->getName());
// HLSL program requires specific target profile settings - we have to split the profile string.
if (language == "hlsl")
{
StringVector::const_iterator it = profilesList.begin();
StringVector::const_iterator itEnd = profilesList.end();
for (; it != itEnd; ++it)
{
if (GpuProgramManager::getSingleton().isSyntaxSupported(*it))
{
pGpuProgram->setParameter("target", *it);
break;
}
}
}
pGpuProgram->setParameter("profiles", profiles);
pGpuProgram->load();
// Case an error occurred.
if (pGpuProgram->hasCompileError())
{
pGpuProgram.setNull();
return GpuProgramPtr(pGpuProgram);
}
// Add the created GPU program to local cache.
if (pGpuProgram->getType() == GPT_VERTEX_PROGRAM)
{
mVertexShaderMap[programName] = pGpuProgram;
}
else if (pGpuProgram->getType() == GPT_FRAGMENT_PROGRAM)
{
mFragmentShaderMap[programName] = pGpuProgram;
}
}
return GpuProgramPtr(pGpuProgram);
}
//-----------------------------------------------------------------------------
GpuProgramPtr ProgramManager::createGpuProgram(Program* shaderProgram,
ProgramWriter* programWriter,
const String& language,
const String& profiles,
const StringVector& profilesList,
const String& cachePath)
{
stringstream sourceCodeStringStream;
// Generate source code.
programWriter->writeSourceCode(sourceCodeStringStream, shaderProgram);
String source = sourceCodeStringStream.str();
// Generate program name.
String programName = generateHash(source);
if (shaderProgram->getType() == GPT_VERTEX_PROGRAM)
{
programName += "_VS";
}
else if (shaderProgram->getType() == GPT_FRAGMENT_PROGRAM)
{
programName += "_FS";
}
// Try to get program by name.
HighLevelGpuProgramPtr pGpuProgram =
HighLevelGpuProgramManager::getSingleton().getByName(
programName, ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
if(pGpuProgram) {
return static_pointer_cast<GpuProgram>(pGpuProgram);
}
// Case the program doesn't exist yet.
// Create new GPU program.
pGpuProgram = HighLevelGpuProgramManager::getSingleton().createProgram(programName,
ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME, language, shaderProgram->getType());
// Case cache directory specified -> create program from file.
if (!cachePath.empty())
{
const String programFullName = programName + "." + language;
const String programFileName = cachePath + programFullName;
std::ifstream programFile;
// Check if program file already exist.
programFile.open(programFileName.c_str());
// Case we have to write the program to a file.
if (!programFile)
{
std::ofstream outFile(programFileName.c_str());
if (!outFile)
return GpuProgramPtr();
outFile << source;
outFile.close();
}
else
{
// use program file version
StringStream buffer;
programFile >> buffer.rdbuf();
source = buffer.str();
}
}
pGpuProgram->setSource(source);
pGpuProgram->setParameter("entry_point", shaderProgram->getEntryPointFunction()->getName());
if (language == "hlsl")
{
// HLSL program requires specific target profile settings - we have to split the profile string.
StringVector::const_iterator it = profilesList.begin();
StringVector::const_iterator itEnd = profilesList.end();
for (; it != itEnd; ++it)
{
if (GpuProgramManager::getSingleton().isSyntaxSupported(*it))
{
pGpuProgram->setParameter("target", *it);
break;
}
}
pGpuProgram->setParameter("enable_backwards_compatibility", "true");
pGpuProgram->setParameter("column_major_matrices", StringConverter::toString(shaderProgram->getUseColumnMajorMatrices()));
}
pGpuProgram->setParameter("profiles", profiles);
pGpuProgram->load();
// Case an error occurred.
if (pGpuProgram->hasCompileError())
{
//! [debug_break]
pGpuProgram.reset();
//! [debug_break]
return GpuProgramPtr(pGpuProgram);
}
// Add the created GPU program to local cache.
if (pGpuProgram->getType() == GPT_VERTEX_PROGRAM)
{
mVertexShaderMap[programName] = pGpuProgram;
}
else if (pGpuProgram->getType() == GPT_FRAGMENT_PROGRAM)
{
mFragmentShaderMap[programName] = pGpuProgram;
}
return static_pointer_cast<GpuProgram>(pGpuProgram);
}
//-----------------------------------------------------------------------
void GLSLESProgram::createLowLevelImpl(void)
{
mAssemblerProgram = GpuProgramPtr(OGRE_NEW GLSLESGpuProgram( this ));
}
//-----------------------------------------------------------------------
void GLSLProgram::createLowLevelImpl(void)
{
mAssemblerProgram = GpuProgramPtr(new GLSLGpuProgram( this ));
}
//-----------------------------------------------------------------------
void GLSLProgram::createLowLevelImpl(void)
{
mAssemblerProgram = GpuProgramPtr(OGRE_NEW GLSLGpuProgram( this ));
// Shader params need to be forwarded to low level implementation
mAssemblerProgram->setAdjacencyInfoRequired(isAdjacencyInfoRequired());
}
//---------------------------------------------------------------------
FixedFuncPrograms * FixedFuncEmuShaderManager::_createShaderPrograms( const String & generatorName,
const VertexBufferDeclaration & vertexBufferDeclaration, FixedFuncState & fixedFuncState )
{
const String vertexProgramName = "VS";
const String fragmentProgramName = "FP";
FixedFuncEmuShaderGenerator * fixedFuncEmuShaderGenerator = mFixedFuncEmuShaderGeneratorMap[generatorName];
String shaderSource = fixedFuncEmuShaderGenerator->getShaderSource(
vertexProgramName,
fragmentProgramName,
vertexBufferDeclaration,
fixedFuncState
);
// Vertex program details
GpuProgramUsage * vertexProgramUsage = new GpuProgramUsage(GPT_VERTEX_PROGRAM);
// Fragment program details
GpuProgramUsage * fragmentProgramUsage = new GpuProgramUsage(GPT_FRAGMENT_PROGRAM);
HighLevelGpuProgramPtr vs;
HighLevelGpuProgramPtr fs;
class LoadFromSourceGpuProgram : public HighLevelGpuProgram
{
public:
void doLoadFromSource(void)
{
loadFromSource();
};
};
static size_t shaderCount = 0;
shaderCount++;
vs = HighLevelGpuProgramManager::getSingleton().
createProgram("VS_" + StringConverter::toString(shaderCount), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
fixedFuncEmuShaderGenerator->getLanguageName(), GPT_VERTEX_PROGRAM);
vs->setSource(shaderSource);
vs->setParameter("entry_point",vertexProgramName);
vs->setParameter("target",fixedFuncEmuShaderGenerator->getVpTarget());
static_cast<LoadFromSourceGpuProgram *>(vs.get())->doLoadFromSource();
vertexProgramUsage->setProgram(GpuProgramPtr(vs));
vertexProgramUsage->setParameters(vs->createParameters());
fs = HighLevelGpuProgramManager::getSingleton().
createProgram("FS_" + StringConverter::toString(shaderCount), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
fixedFuncEmuShaderGenerator->getLanguageName(), GPT_FRAGMENT_PROGRAM);
fs->setSource(shaderSource);
fs->setParameter("entry_point",fragmentProgramName);
fs->setParameter("target",fixedFuncEmuShaderGenerator->getFpTarget());
static_cast<LoadFromSourceGpuProgram *>(fs.get())->doLoadFromSource();
fragmentProgramUsage->setProgram(GpuProgramPtr(fs));
fragmentProgramUsage->setParameters(fs->createParameters());
FixedFuncPrograms * newPrograms = fixedFuncEmuShaderGenerator->createFixedFuncPrograms();
mLanguage2State2Declaration2ProgramsMap[generatorName][fixedFuncState][vertexBufferDeclaration] = newPrograms;
newPrograms->setVertexProgramUsage(vertexProgramUsage);
newPrograms->setFragmentProgramUsage(fragmentProgramUsage);
newPrograms->setFixedFuncState(fixedFuncState);
mProgramsToDeleteAtTheEnd.push_back(newPrograms);
return newPrograms;
}