void DBTexture::loadFromFile(const eastl::string& a_filePath, EFormat a_format, uint a_forcedNumComp)
{
int w, h, c;
byte* textureData = NULL;
switch (a_format)
{
case EFormat::BYTE: textureData = stbi_load(a_filePath.c_str(), &w, &h, &c, a_forcedNumComp); break;
case EFormat::FLOAT: textureData = rcast<byte*>(stbi_loadf(a_filePath.c_str(), &w, &h, &c, a_forcedNumComp)); break;
default: assert(false); break;
}
if (!textureData)
{
print("FAILED TO LOAD IMAGE: %s \n", a_filePath.c_str());
assert(false);
return;
}
m_format = a_format;
m_pixColSize = getPixColSize(m_format);
m_width = uint(w);
m_height = uint(h);
m_numComp = a_forcedNumComp ? a_forcedNumComp : uint(c); // If a number of components was forced, use that, otherwise use the number of components in the image.
const uint dataSize = m_width * m_height * m_numComp * m_pixColSize;
m_rawData.resize(dataSize);
memcpy(m_rawData.data(), textureData, dataSize);
stbi_image_free(textureData);
m_compressedDataUpToDate = false;
}
void WriteTime(int64_t timeNS, eastl::string& sTime)
{
if(timeNS > 1000000000)
sTime.sprintf(" %6.2f s", (double)timeNS / 1000000000);
else if(timeNS > 1000000)
sTime.sprintf("%6.1f ms", (double)timeNS / 1000000);
else if(timeNS > 1000)
sTime.sprintf("%6.1f us", (double)timeNS / 1000);
else
sTime.sprintf("%6.1f ns", (double)timeNS / 1);
}
void UProgramPermutor::PermuteProgram(const eastl::string& inProgramFilePath, ProgramPermutations_t& outProgramPermutations, bool inShouldGenPermutationFiles)
{
std::ifstream programInputStream(inProgramFilePath.c_str(), std::ios::in | std::ios::ate);
if (programInputStream.is_open())
{
std::string stdProgramStringBuffer;
eastl::vector<SShaderMetaFlagInstance> programMetaFlagInstances;
eastl::vector<SShaderUsageDescription> programUsageDescriptions;
eastl::vector<SShaderPermuteDescription> programPermutationDescriptions;
stdProgramStringBuffer.resize(programInputStream.tellg());
programInputStream.seekg(std::ios::beg);
stdProgramStringBuffer.assign(std::istream_iterator<char>(programInputStream), std::istream_iterator<char>());
eastl::string programStringBuffer(eastl::move(stdProgramStringBuffer.c_str()));
// Accumulate all of the meta flag instances in the program file
ParseProgramMetaFlags(programStringBuffer, programMetaFlagInstances);
// Go through all meta flags and retrieve the Usage and Permute meta flag instances
for (const auto& currentMetaFlagInst : programMetaFlagInstances)
{
switch (currentMetaFlagInst.MetaFlagType)
{
case EMetaFlagType::EMetaFlagType_Usage:
{
//LOG(LogProgramPermutor, Log, "Adding meta usage flag with values: %s - %s\n", currentMetaFlagInst.MetaFlagValues[0].c_str(), currentMetaFlagInst.MetaFlagValues[1].c_str());
programUsageDescriptions.push_back({ currentMetaFlagInst.MetaFlagValues[0], currentMetaFlagInst.MetaFlagValues[1] });
break;
}
case EMetaFlagType::EMetaFlagType_Permute:
{
EProgramIdMask permuteIdMask = UProgramPermutor::ConvertStringToPIDMask(currentMetaFlagInst.MetaFlagValues[0]);
if (permuteIdMask != EProgramIdMask::INVALID)
{
//LOG(LogProgramPermutor, Log, "Adding meta permute flag with define: %s\n", currentMetaFlagInst.MetaFlagValues[0].c_str());
programPermutationDescriptions.push_back({ permuteIdMask });
}
else
{
LOG(LogProgramPermutor, Error, "Error: Invalid permute flag: %s\n", currentMetaFlagInst.MetaFlagValues[0].c_str());
}
break;
}
}
}
// The usage descriptions tell us which parts of the program to include in the shader permutation sets
GeneratePermutations(inProgramFilePath, programUsageDescriptions, programPermutationDescriptions, outProgramPermutations, inShouldGenPermutationFiles);
}
}
String::String(const eastl::string &s, Type t)
{
d = new StringPrivate;
if(t == UTF16 || t == UTF16BE || t == UTF16LE) {
debug("String::String() -- A eastl::string should not contain UTF16.");
return;
}
int length = s.length();
d->data.resize(length);
wstring::iterator targetIt = d->data.begin();
for(eastl::string::const_iterator it = s.begin(); it != s.end(); it++) {
*targetIt = uchar(*it);
++targetIt;
}
prepare(t);
}
bool _VariableModifier_Type( eastl::string& str, const eastl::string& vname, const char* modifier, eastl::string& type )//是否为某种修饰类型的变量
{
size_t start_pos = 0;
do
{
start_pos = str.find( vname, start_pos );
if ( start_pos != eastl::string::npos )
{
size_t trunk = str.find_last_of( ';', start_pos );
trunk = trunk != eastl::string::npos ? trunk : 0;
string substr = str.substr( trunk, start_pos - trunk );
size_t istype = substr.find( modifier );
if ( istype != eastl::string::npos )
{
type = substr.substr( substr.find_first_of(' ') );
return true;
}
start_pos += vname.size();
}
} while ( start_pos != eastl::string::npos );
return false;
}
// Utility functions to convert between meta flag type and string
EProgramIdMask UProgramPermutor::ConvertStringToPIDMask(const eastl::string& inMaskString)
{
auto pidMaskStringFindIter = UProgramPermutor::s_programIdMaskToStringMap.find(inMaskString.c_str());
if (pidMaskStringFindIter != UProgramPermutor::s_programIdMaskToStringMap.cend())
{
return pidMaskStringFindIter->second;
}
else
{
return EProgramIdMask::INVALID;
}
}
void OpenGLGraphicSystem::ProcessShader( BohgeEngine::ShaderProperty::ShaderCode sc, eastl::string& code )
{
Utility::RemoveTargetString( code, "precision highp float;" );
Utility::RemoveTargetString( code, "precision mediump float;" );
Utility::RemoveTargetString( code, "precision lowp float;" );
Utility::RemoveTargetString( code, "highp " );
Utility::RemoveTargetString( code, "mediump " );
Utility::RemoveTargetString( code, "lowp " );
code.insert(0, "#define MAXJOINTS 128\n" );
code.insert(0, "#define MAXARRAYSIZE 256\n" );
code.insert(0, "#define _WINDOWS_\n" );
glslopt_shader_type type;
switch( sc )
{
case ShaderProperty::SC_VERTEX: type = kGlslOptShaderVertex; break;
case ShaderProperty::SC_FRAGMENT: type = kGlslOptShaderFragment; break;
default:ASSERT(false);
}
glslopt_shader* shader = glslopt_optimize( m_pGlslopt_ctx, type, code.c_str(), 0 );
if ( glslopt_get_status(shader) )
{
code = glslopt_get_output( shader );
}
else
{
const char* log = glslopt_get_log( shader );
DEBUGLOG("Can't optimize shader, caz %s\n", log );
}
if ( ShaderProperty::SC_VERTEX == sc )
{
size_t mainbegin = _FindMainFunction(code);
_FixAttributeIndexingType( code, mainbegin );
}
glslopt_shader_delete( shader );
}
size_t _FindMainFunction( eastl::string& str )//找到主函数段
{
size_t start_pos = 0;
do
{
start_pos = str.find("main", start_pos);
if( start_pos != eastl::string::npos )
{
size_t i = -1;
bool istype = false;
do
{
istype = ! Utility::NotVariablePart( str[ start_pos + i-- ] );
} while ( !istype );
if ( 'd' == str[start_pos + ++i] )
{
start_pos = str.find("{", start_pos);
return start_pos + 1;
}
}
start_pos++;
} while ( start_pos != eastl::string::npos );
return eastl::string::npos;
}
//---------------------------------------------------------------------------------------------------------
eastl::string _GetVariableName( const eastl::string& str, std::size_t begin, std::size_t dir )//得到变量全名
{
size_t spb = begin;
size_t spe;
while(true)
{
spb += dir;
if ( !Utility::NotVariablePart( str[spb] ) )
{
spe = spb + dir;
break;
}
}
while(true)
{
spe += dir;
if ( Utility::NotVariablePart( str[spe] ) )
{
break;
}
}
return str.substr( (spb < spe ? spb : spe)+1, spb < spe ? spe - spb : spb - spe );
}
//-------------------------------------------------------------------------------------------------------
PipelineProperty::ActivePassTypeArray MaterialSystem::ParseMaterial( const eastl::string& path, eastl::string& matstr )
{
string luaSource;
vector<string> funcs;
PipelineProperty::ActivePassTypeArray apta;
Utility::SeparateAllString( MATERIAL_DEFINE, END_DEFINE, funcs, matstr );//将材质分拆开来
for( int i = 0; i < funcs.size() ; ++ i )
{
Utility::MakeLuaFunction( MATERIAL_DEFINE, END_DEFINE, funcs[i] );//每个材质做成函数
luaSource += "\r\n" + funcs[i];
}
m_pScriptParser->DoScript( luaSource );//加载lua脚本
m_CurrentPassType = static_cast<BohgeEngine::PipelineProperty::PassType>(-1);
const int passCount = IMaterialSystem::Instance()->GetActivePassTypeCount();
for ( int i = 0 ; i < passCount ; ++ i )
{
PipelineProperty::PassType pt = IMaterialSystem::Instance()->GetPassType( i );
if( Utility::MacroName( m_pPassTypeNameArray[pt], matstr, m_pPassFunctionName[pt] ) )
{
apta.push_back( pt );
}
else
{
m_pPassFunctionName[pt].clear();
DEBUGLOG("empty %s pass function in file %s!\n", m_pPassTypeNameArray[pt].c_str(), path.c_str() );
}
}
return apta;
}
FileHandle::FileHandle(const eastl::string& a_filePath, EFileMode a_fileMode) : m_rwops(0), m_size(0), m_fileMode(a_fileMode)
{
initialize(a_filePath.c_str(), a_fileMode);
}
time_t GetFileModTime( const eastl::string &filename ) {
struct _stat statInfo;
_stat( filename.c_str(), &statInfo );
return statInfo.st_mtime;
}
// Parses the entire shader string buffer to match instances of the program meta flag
// Format of the shader usage flags: "!!>:(Flag Type, <Values, sep. by comma>)"
// Flag Type can be either Usage or Permute
void UProgramPermutor::ParseProgramMetaFlags(const eastl::string& inShaderBufferString, eastl::vector<SShaderMetaFlagInstance>& outMetaFlagInstances)
{
// Find all occurrences of shader meta flag string
size_t currentFindIndex = inShaderBufferString.find(s_shaderMetaFlagString, 0);
outMetaFlagInstances.clear();
while (currentFindIndex != eastl::string::npos)
{
eastl::string metaFlagInstanceString;
currentFindIndex += UProgramPermutor::s_shaderMetaFlagString.length();
while (inShaderBufferString[currentFindIndex] != ')')
{
metaFlagInstanceString += inShaderBufferString[currentFindIndex];
++currentFindIndex;
}
++currentFindIndex; // Skip past the ending parentheses
if (metaFlagInstanceString.empty())
{
LOG(LogProgramPermutor, Warning, "Warning: Shader usage instance #%d has an empty description pair!", outMetaFlagInstances.size());
return;
}
eastl::vector<eastl::string> metaFlagSubstrings;
SShaderMetaFlagInstance currentMetaFlagInstance;
// Split the meta flag string by coma
size_t currentCommaIndex = 0;
size_t nextCommaIndex = metaFlagInstanceString.find(',', currentCommaIndex);
while (nextCommaIndex != eastl::string::npos)
{
eastl::string flagValueString = metaFlagInstanceString.substr(currentCommaIndex, (nextCommaIndex - currentCommaIndex));
metaFlagSubstrings.emplace_back(flagValueString);
currentCommaIndex = nextCommaIndex + 1;
nextCommaIndex = metaFlagInstanceString.find(',', currentCommaIndex);
if (nextCommaIndex == eastl::string::npos)
{
eastl::string lastFlagValueString = metaFlagInstanceString.substr(currentCommaIndex, (nextCommaIndex - currentCommaIndex));
// On the last iteration, we need to add the last string
metaFlagSubstrings.emplace_back(lastFlagValueString);
}
}
// Flag string count sanity check
if (metaFlagSubstrings.size() == 0)
{
LOG(LogProgramPermutor, Warning, "Warning: Shader usage instance #%d has more than one separation commas!", outMetaFlagInstances.size());
return;
}
// First substring is the flag type
currentMetaFlagInstance.MetaFlagType = ConvertStringToFlagType(metaFlagSubstrings.front());
if (currentMetaFlagInstance.MetaFlagType == EMetaFlagType::EMetaFlagType_Invalid)
{
LOG(LogProgramPermutor, Warning, "Warning: Shader usage instance #%d has an invalid meta flag type!", outMetaFlagInstances.size());
return;
}
// Rest of the substrings are the parameter values (if applicable)
for (size_t i = 1; i < metaFlagSubstrings.size(); ++i)
{
currentMetaFlagInstance.MetaFlagValues.emplace_back(metaFlagSubstrings[i]);
}
outMetaFlagInstances.emplace_back(currentMetaFlagInstance);
currentFindIndex = inShaderBufferString.find(UProgramPermutor::s_shaderMetaFlagString, currentFindIndex);
}
}
//---------------------------------------------------------------------------------------------------------
void BTextSystem::_OnSetLanguage( const eastl::string& lan )
{
Text_1::SetLanguage( lan.c_str() );
}