virtual GpuProgramPtr generateFragmentShader(Perm permutation)
{
/// Create shader
if (mMasterSource.empty())
{
DataStreamPtr ptrMasterSource = ResourceGroupManager::getSingleton().openResource(
"DeferredShading/post/LightMaterial_ps.cg"
, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
assert(ptrMasterSource.isNull()==false);
mMasterSource = ptrMasterSource->getAsString();
}
assert(mMasterSource.empty()==false);
// Create name
String name = mBaseName+StringConverter::toString(permutation)+"_ps";
// Create shader object
HighLevelGpuProgramPtr ptrProgram = HighLevelGpuProgramManager::getSingleton().createProgram(
name, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"cg", GPT_FRAGMENT_PROGRAM);
ptrProgram->setSource(mMasterSource);
ptrProgram->setParameter("entry_point","main");
ptrProgram->setParameter("profiles","ps_2_x arbfp1");
// set up the preprocessor defines
// Important to do this before any call to get parameters, i.e. before the program gets loaded
ptrProgram->setParameter("compile_arguments", getPPDefines(permutation));
setUpBaseParameters(ptrProgram->getDefaultParameters());
return GpuProgramPtr(ptrProgram);
}
Ogre::DataStreamPtr TerrainGeometryManager::getPageConfig(int x, int z)
{
String cfg = getPageConfigFilename(x, z);
try
{
LOG("loading page config for page " + XZSTR(x,z) + " : " + cfg);
DataStreamPtr ds = ResourceGroupManager::getSingleton().openResource(cfg, Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME);
if (!ds.isNull() && ds->isReadable())
{
return ds;
}
} catch (...)
{
}
LOG("error loading page config for page " + XZSTR(x,z) + " : " + cfg);
if (x != 0 || z != 0)
{
LOG("loading default page config: " + cfg + " instead");
return getPageConfig(0, 0);
}
return DataStreamPtr();
}
//---------------------------------------------------------------------
String Texture::getSourceFileType() const
{
if (mName.empty())
return StringUtil::BLANK;
String::size_type pos = mName.find_last_of(".");
if (pos != String::npos && pos < (mName.length() - 1))
{
String ext = mName.substr(pos+1);
StringUtil::toLowerCase(ext);
return ext;
}
else
{
// No extension
DataStreamPtr dstream;
try
{
dstream = ResourceGroupManager::getSingleton().openResource(
mName, mGroup, true, 0);
}
catch (Exception&)
{
}
if (dstream.isNull() && getTextureType() == TEX_TYPE_CUBE_MAP)
{
// try again with one of the faces (non-dds)
try
{
dstream = ResourceGroupManager::getSingleton().openResource(
mName + "_rt", mGroup, true, 0);
}
catch (Exception&)
{
}
}
if (!dstream.isNull())
{
return Image::getFileExtFromMagic(dstream);
}
}
return StringUtil::BLANK;
}
Rocket::Core::FileHandle FileInterfaceOgre3D::Open(const Rocket::Core::String& path)
{
DataStreamPtr stream = ResourceGroupManager::getSingleton().openResource(path.CString());
if (stream.isNull())
return 0;
return (Rocket::Core::FileHandle)(new DataStreamPtr(stream));
}
Ogre::String TerrainGeometryManager::getPageHeightmap(int x, int z)
{
DataStreamPtr ds = getPageConfig(x, z);
if (ds.isNull())
return "";
char buf[4096];
ds->readLine(buf, 4096);
return String(buf);
}
virtual GpuProgramPtr generateFragmentShader(Perm permutation)
{
/// Create shader
if (mMasterSource.empty())
{
DataStreamPtr ptrMasterSource;
if(GpuProgramManager::getSingleton().isSyntaxSupported("glsles"))
ptrMasterSource = ResourceGroupManager::getSingleton().openResource("DeferredShading/post/LightMaterial_ps.glsles",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
else
ptrMasterSource = ResourceGroupManager::getSingleton().openResource("DeferredShading/post/LightMaterial_ps.glsl",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
assert(ptrMasterSource.isNull()==false);
mMasterSource = ptrMasterSource->getAsString();
}
assert(mMasterSource.empty()==false);
// Create name
String name = mBaseName+StringConverter::toString(permutation)+"_ps";
// Create shader object
HighLevelGpuProgramPtr ptrProgram;
if(GpuProgramManager::getSingleton().isSyntaxSupported("glsles"))
{
ptrProgram = HighLevelGpuProgramManager::getSingleton().createProgram(name, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"glsles", GPT_FRAGMENT_PROGRAM);
ptrProgram->setParameter("profiles", "glsles");
}
else
{
ptrProgram = HighLevelGpuProgramManager::getSingleton().createProgram(name, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"glsl", GPT_FRAGMENT_PROGRAM);
ptrProgram->setParameter("profiles", "glsl150");
}
ptrProgram->setSource(mMasterSource);
// set up the preprocessor defines
// Important to do this before any call to get parameters, i.e. before the program gets loaded
ptrProgram->setParameter("preprocessor_defines", getPPDefines(permutation));
setUpBaseParameters(ptrProgram->getDefaultParameters());
// Bind samplers
GpuProgramParametersSharedPtr params = ptrProgram->getDefaultParameters();
int numSamplers = 0;
params->setNamedConstant("Tex0", (int)numSamplers++);
params->setNamedConstant("Tex1", (int)numSamplers++);
if(permutation & LightMaterialGenerator::MI_SHADOW_CASTER)
params->setNamedConstant("ShadowTex", (int)numSamplers++);
return GpuProgramPtr(ptrProgram);
}
bool TestArchive()
{
//root->addResourceLocation("d:\\a.zip", "Zip");
root->addResourceLocation("../../media/packs/dragon.zip", "Zip");
// Pick a sample file
String tex = "legs.jpg";
//String tex = "a.h";
cout << "Opening file: " << tex << endl;
// Get it from the resource system
DataStreamPtr data = ResourceGroupManager::getSingleton().openResource(tex, "General");
if( !data.isNull() )
{
cout << "Size: " << data->size() << endl;
return true;
}else
{
return false;
}
}
bool LuaScript::LoadTextFile
(
const String& fileName,
String& text,
const String& resourceGroupName
)
{
//Open the file
try
{
DataStreamPtr stream = ResourceGroupManager::getSingleton().openResource(fileName, resourceGroupName);
if (stream.isNull())
return false;
//Get the text file contents
text = stream->getAsString();
return true;
}
catch (...)
{
return false;
}
}
//Implementation---------------------------------------------------------------
void OgreMaxUtilities::LoadXmlDocument(const String& fileName, TiXmlDocument& document, const String& resourceGroupName)
{
//Open the file
DataStreamPtr stream = ResourceGroupManager::getSingleton().openResource(fileName, resourceGroupName);
if (stream.isNull())
{
StringUtil::StrStreamType errorMessage;
errorMessage << "Could not open XML file: " << fileName;
OGRE_EXCEPT
(
Exception::ERR_FILE_NOT_FOUND,
errorMessage.str(),
"OgreMaxUtilities::LoadXmlDocument"
);
}
//Get the file contents
String data = stream->getAsString();
//Parse the XML document
document.Parse(data.c_str());
stream.setNull();
if (document.Error())
{
StringUtil::StrStreamType errorMessage;
errorMessage << "There was an error with the XML file: " << fileName;
OGRE_EXCEPT
(
Exception::ERR_INVALID_STATE,
errorMessage.str(),
"OgreMaxUtilities::LoadXmlDocument"
);
}
}
// if terrain is set, we operate on the already loaded terrain
void TerrainGeometryManager::loadLayers(int x, int z, Terrain *terrain)
{
if (pageConfigFormat.empty()) return;
DataStreamPtr ds = getPageConfig(x, z);
if (ds.isNull())
return;
char line[4096];
ds->readLine(line, 4096);
String heightmapImage = String(line);
ds->readLine(line, 4096);
terrainLayers = PARSEINT(String(line));
if (terrainLayers == 0)
return;
Ogre::Terrain::ImportData &defaultimp = mTerrainGroup->getDefaultImportSettings();
if (!terrain)
defaultimp.layerList.resize(terrainLayers);
blendInfo.clear();
blendInfo.resize(terrainLayers);
int layer = 0;
while (!ds->eof())
{
size_t ll = ds->readLine(line, 4096);
if (ll==0 || line[0]=='/' || line[0]==';') continue;
StringVector args = StringUtil::split(String(line), ",");
if (args.size() < 3)
{
LOG("invalid page config line: '" + String(line) + "'");
continue;
}
StringUtil::trim(args[1]);
StringUtil::trim(args[2]);
float worldSize = PARSEREAL(args[0]);
if (!terrain)
{
defaultimp.layerList[layer].worldSize = worldSize;
defaultimp.layerList[layer].textureNames.push_back(args[1]);
defaultimp.layerList[layer].textureNames.push_back(args[2]);
} else
{
terrain->setLayerWorldSize(layer, worldSize);
terrain->setLayerTextureName(layer, 0, args[1]);
terrain->setLayerTextureName(layer, 1, args[2]);
}
blendLayerInfo_t &bi = blendInfo[layer];
bi.blendMode = 'R';
bi.alpha = 'R';
if (args.size() > 3)
{
StringUtil::trim(args[3]);
bi.blendMapTextureFilename = args[3];
}
if (args.size() > 4)
{
StringUtil::trim(args[4]);
bi.blendMode = args[4][0];
}
if (args.size() > 5)
bi.alpha = PARSEREAL(args[5]);
layer++;
if (layer >= terrainLayers)
break;
}
LOG("done loading page: loaded " + TOSTRING(layer) + " layers");
}
