void GaussianListener::notifyMaterialSetup(Ogre::uint32 pass_id, Ogre::MaterialPtr &mat)
{
// Prepare the fragment params offsets
switch(pass_id)
{
case 701: // blur horz
{
// horizontal bloom
mat->load();
Ogre::GpuProgramParametersSharedPtr fparams =
mat->getBestTechnique()->getPass(0)->getFragmentProgramParameters();
const Ogre::String& progName = mat->getBestTechnique()->getPass(0)->getFragmentProgramName();
fparams->setNamedConstant("sampleOffsets", mBloomTexOffsetsHorz[0], 15);
fparams->setNamedConstant("sampleWeights", mBloomTexWeights[0], 15);
break;
}
case 700: // blur vert
{
// vertical bloom
mat->load();
Ogre::GpuProgramParametersSharedPtr fparams =
mat->getTechnique(0)->getPass(0)->getFragmentProgramParameters();
const Ogre::String& progName = mat->getBestTechnique()->getPass(0)->getFragmentProgramName();
fparams->setNamedConstant("sampleOffsets", mBloomTexOffsetsVert[0], 15);
fparams->setNamedConstant("sampleWeights", mBloomTexWeights[0], 15);
break;
}
}
}
//-------------------------------------------------------
Ogre::Material* Ground::CreateGroundMaterialTextured(const std::string & name, const Ogre::Image* texture)
{
Ogre::TexturePtr heightMapTexture = Ogre::TextureManager::getSingleton().loadImage("Texture/Terrain",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, *texture);
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create(name, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
{
Ogre::Technique* techniqueGL = material->getTechnique(0);
Ogre::Pass* pass = techniqueGL->getPass(0);
{
auto vprogram = Ogre::HighLevelGpuProgramManager::getSingleton().createProgram("Shader/" + CLASS_NAME + "/GL/Textured/V",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "glsl", Ogre::GPT_VERTEX_PROGRAM);
vprogram->setSource(Shader_GL_Simple_V);
//auto vparams = vprogram->createParameters();
//vparams->setNamedAutoConstant("modelviewproj", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
pass->setVertexProgram(vprogram->getName());
}
{
auto fprogram = Ogre::HighLevelGpuProgramManager::getSingleton().createProgram("Shader/" + CLASS_NAME + "/GL/Textured/F",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "glsl", Ogre::GPT_FRAGMENT_PROGRAM);
fprogram->setSource(Shader_GL_Simple_F);
auto unit0 = pass->createTextureUnitState(heightMapTexture->getName());
unit0->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
unit0->setTextureFiltering(Ogre::TFO_NONE);
pass->setFragmentProgram(fprogram->getName());
}
}
#if !NDEBUG
material->load();
#endif
return material.get();
}
bool Simple::compileMaterial(Ogre::MaterialPtr material)
{
material->removeAllTechniques();
Ogre::Technique* technique = material->createTechnique();
for (SurfaceLayerStore::const_iterator I = mTerrainPageSurfaces.begin(); I != mTerrainPageSurfaces.end(); ++I) {
const TerrainPageSurfaceLayer* surfaceLayer = I->second;
if (I == mTerrainPageSurfaces.begin()) {
Ogre::Pass* pass = technique->createPass();
pass->setLightingEnabled(false);
//add the first layer of the terrain, no alpha or anything
Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState();
textureUnitState->setTextureScale(1.0f / surfaceLayer->getScale(), 1.0f / surfaceLayer->getScale());
textureUnitState->setTextureName(surfaceLayer->getDiffuseTextureName());
textureUnitState->setTextureCoordSet(0);
} else {
if (surfaceLayer->intersects(*mGeometry)) {
addPassToTechnique(*mGeometry, technique, surfaceLayer);
}
}
}
if (mTerrainPageShadow) {
addShadow(technique, mTerrainPageShadow, material);
}
material->load();
if (material->getNumSupportedTechniques() == 0) {
S_LOG_WARNING("The material '" << material->getName() << "' has no supported techniques. The reason for this is: \n" << material->getUnsupportedTechniquesExplanation());
return false;
}
return true;
}
bool Simple::compileMaterial(Ogre::MaterialPtr material, std::set<std::string>& managedTextures) const
{
material->removeAllTechniques();
Ogre::Technique* technique = material->createTechnique();
if (!mTerrainPageSurfaces.empty()) {
//First add a base pass
auto surfaceLayer = mTerrainPageSurfaces.begin()->second;
Ogre::Pass* pass = technique->createPass();
pass->setLightingEnabled(false);
Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState();
textureUnitState->setTextureScale(1.0f / surfaceLayer->getScale(), 1.0f / surfaceLayer->getScale());
textureUnitState->setTextureName(surfaceLayer->getDiffuseTextureName());
textureUnitState->setTextureCoordSet(0);
for (auto& layer : mLayers) {
addPassToTechnique(*mGeometry, technique, layer, managedTextures);
}
}
if (mTerrainPageShadow) {
addShadow(technique, mTerrainPageShadow, material, managedTextures);
}
// addLightingPass(technique, managedTextures);
material->load();
if (material->getNumSupportedTechniques() == 0) {
S_LOG_WARNING("The material '" << material->getName() << "' has no supported techniques. The reason for this is: \n" << material->getUnsupportedTechniquesExplanation());
return false;
}
return true;
}
void Rect::Draw(Ogre::Vector3 pos)
{
Ogre::Vector3 quad[4];
quad[0] = Ogre::Vector3(pos.x - (length / 2.0), pos.y, pos.z - (height / 2.0)); // ll
quad[1] = Ogre::Vector3(pos.x - (length / 2.0), pos.y, pos.z + (height / 2.0)); // ul
quad[2] = Ogre::Vector3(pos.x + (length / 2.0), pos.y, pos.z + (height / 2.0)); // ur
quad[3] = Ogre::Vector3(pos.x + (length / 2.0), pos.y, pos.z - (height / 2.0)); // lr
Ogre::MaterialPtr matptr = Ogre::MaterialManager::getSingleton().create("BaseColoured", "General");
matptr->load();
matptr->getBestTechnique()->getPass(0)->setVertexColourTracking(Ogre::TVC_DIFFUSE);
matptr->getBestTechnique()->getPass(0)->setLightingEnabled(false);
mObj->begin("BaseColoured", Ogre::RenderOperation::OT_TRIANGLE_LIST);
mObj->position(quad[0]);
mObj->colour(colour);
//mObj->textureCoord(1,1);
mObj->position(quad[1]);
mObj->colour(colour);
//mObj->textureCoord(1,0);
mObj->position(quad[2]);
mObj->colour(colour);
//mObj->textureCoord(0,0);
mObj->position(quad[3]);
mObj->colour(colour);
//mObj->textureCoord(0,1);
mObj->quad(0,1,2,3);
mObj->end();
}
//---------------------------------------------------------------------------
void BlurListener::notifyMaterialSetup(Ogre::uint32 pass_id, Ogre::MaterialPtr &mat)
{
mat->load();
/*Ogre::GpuProgramParametersSharedPtr fparams = mat->getBestTechnique()->getPass(0)->getFragmentProgramParameters();
fparams->setNamedConstant("radius", 10);
fparams->setNamedConstant("intensity", 1);*/
}
void RenderedCompassImpl::_setCompass(Compass* compass)
{
Ogre::MaterialPtr originalMaterial = static_cast<Ogre::MaterialPtr>(Ogre::MaterialManager::getSingleton().getByName(mMaterialName));
if (originalMaterial) {
originalMaterial->load();
mCompassMaterial = originalMaterial->clone(OgreInfo::createUniqueResourceName(originalMaterial->getName()));
if (Ogre::Technique* tech = mCompassMaterial->getBestTechnique()) {
Ogre::Pass* pass = nullptr;
if (tech->getNumPasses() && (pass = tech->getPass(0))) {
mCompassMaterialMapTUS = pass->getTextureUnitState("Background");
if (mCompassMaterialMapTUS) {
//Make sure that the compass material is using the map texture for the base rendering
mCompassMaterialMapTUS->setTexture(mMap->getTexture());
mTexture = Ogre::TextureManager::getSingleton().createManual("RenderedCompass", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, 128, 128, 1, Ogre::PF_A8R8G8B8, Ogre::TU_RENDERTARGET);
mRenderTexture = mTexture->getBuffer()->getRenderTarget();
mRenderTexture->removeAllViewports();
mRenderTexture->setAutoUpdated(false);
mRenderTexture->setActive(true);
mCamera = mSceneManager->createCamera("RenderedCompassCamera");
mViewport = mRenderTexture->addViewport(mCamera);
mViewport->setOverlaysEnabled(false);
mViewport->setShadowsEnabled(false);
mViewport->setSkiesEnabled(false);
mViewport->setClearEveryFrame(true);
mViewport->setBackgroundColour(Ogre::ColourValue::ZERO);
mMapRectangle = OGRE_NEW Ogre::Rectangle2D(true);
auto mapMaterialPtr = Ogre::MaterialManager::getSingleton().getByName(mCompassMaterial->getName(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
if (mapMaterialPtr) {
mMapRectangle->setMaterial(mapMaterialPtr);
}
//We need to maximise the rendered texture to cover the whole screen
Ogre::RenderSystem* rs = Ogre::Root::getSingleton().getRenderSystem();
Ogre::Real hOffset = rs->getHorizontalTexelOffset() / (0.5 * mViewport->getActualWidth());
Ogre::Real vOffset = rs->getVerticalTexelOffset() / (0.5 * mViewport->getActualHeight());
mMapRectangle->setCorners(-1 + hOffset, 1 - vOffset, 1 + hOffset, -1 - vOffset);
//Since a Rectangle2D instance is a moveable object it won't be rendered unless it's in the frustrum. If we set the axis aligned box to be "infinite" it will always be rendered.
Ogre::AxisAlignedBox aabInf;
aabInf.setInfinite();
mMapRectangle->setBoundingBox(aabInf);
//We can't attach something to the root node, so we'll attach it to a newly created node. We won't keep a reference to this node since it will be destroyed along with the scene manager when we ourselves are destroyed.
mSceneManager->getRootSceneNode()->createChildSceneNode()->attachObject(mMapRectangle);
//Return early since everything is good.
return;
}
}
}
}
S_LOG_WARNING("Could not load material '" << mMaterialName << "' for the compass.");
}
void HDRListener::notifyMaterialSetup(Ogre::uint32 pass_id, Ogre::MaterialPtr &mat)
{
// Prepare the fragment params offsets
switch (pass_id)
{
//case 994: // rt_lum4
case 993: // rt_lum3
case 992: // rt_lum2
case 991: // rt_lum1
case 990: // rt_lum0
break;
case 800: // rt_brightpass
break;
case 701: // rt_bloom1
{
// horizontal bloom
try
{ mat->load();
Ogre::GpuProgramParametersSharedPtr fparams =
mat->getBestTechnique()->getPass(0)->getFragmentProgramParameters();
fparams->setNamedConstant("sampleOffsets", mBloomTexOffsetsHorz[0], 15);
fparams->setNamedConstant("sampleWeights", mBloomTexWeights[0], 15);
}catch(...)
{ }
break;
}
case 700: // rt_bloom0
{
// vertical bloom
try
{ mat->load();
Ogre::GpuProgramParametersSharedPtr fparams =
mat->getTechnique(0)->getPass(0)->getFragmentProgramParameters();
fparams->setNamedConstant("sampleOffsets", mBloomTexOffsetsVert[0], 15);
fparams->setNamedConstant("sampleWeights", mBloomTexWeights[0], 15);
}catch(...)
{ }
break;
}
}
}
void loadMaterialControlsFile(MaterialControlsContainer& controlsContainer, const Ogre::String& filename)
{
// Load material controls from config file
Ogre::ConfigFile cf;
try
{
cf.load(filename, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "\t;=", true);
// Go through all sections & controls in the file
Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
Ogre::String secName, typeName, materialName, dataString;
while (seci.hasMoreElements())
{
secName = seci.peekNextKey();
Ogre::ConfigFile::SettingsMultiMap* settings = seci.getNext();
if (!secName.empty() && settings)
{
materialName = cf.getSetting("material", secName);
Ogre::MaterialPtr curMat = Ogre::MaterialManager::getSingleton().getByName(materialName);
curMat->load();
Ogre::Technique * curTec = curMat->getBestTechnique();
if (!curTec || !curTec->isSupported())
{
continue;
}
MaterialControls newMaaterialControls(secName, materialName);
controlsContainer.push_back(newMaaterialControls);
size_t idx = controlsContainer.size() - 1;
Ogre::ConfigFile::SettingsMultiMap::iterator i;
for (i = settings->begin(); i != settings->end(); ++i)
{
typeName = i->first;
dataString = i->second;
if (typeName == "control")
controlsContainer[idx].addControl(dataString);
}
}
}
Ogre::LogManager::getSingleton().logMessage( "Material Controls setup" );
}
catch (Ogre::Exception e)
{
// Guess the file didn't exist
}
}
//-----------------------------------------------------------------------
void MaterialTab::selectMaterial(wxString& materialName)
{
Ogre::TextureUnitState* textureUnitState = 0;
mTxtMaterialName->SetValue(materialName);
if (isSelectedMaterialInUse())
{
mTxtMaterialName->Disable();
}
else
{
mTxtMaterialName->Enable();
}
mLastSelectedMaterial = materialName;
Ogre::String name = wx2ogre(materialName);
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().getByName(name);
if (!material.isNull() && material->getNumTechniques() > 0)
{
material->load();
mTxtTextureLoad->SetValue(wxT(""));
Ogre::Technique* technique = material->getBestTechnique(); // Get the best technique
if (technique && technique->getNumPasses() > 0)
{
Ogre::Pass* pass = technique->getPass(0); // Get the first
if (pass)
{
// Set pass properties
mCheckLighting->SetValue(pass->getLightingEnabled());
mCheckDepthCheck->SetValue(pass->getDepthCheckEnabled());
mCheckDepthWrite->SetValue(pass->getDepthWriteEnabled());
mSceneBlendList->SetValue(getSceneBlending(pass));
if (pass->getNumTextureUnitStates() > 0)
{
textureUnitState = pass->getTextureUnitState(0); // Get the first
if (textureUnitState)
{
// Set texture properties
if (textureUnitState->getNumFrames() > 0)
{
wxString name = ogre2wx(textureUnitState->getFrameTextureName(0));
mTxtTextureLoad->SetValue(name);
}
mAddressingModeList->SetValue(getTextureAddressingMode(textureUnitState));
}
}
}
}
}
// Display image
viewTexture(textureUnitState); // Clear the old texture if no TextureUnitState
}
//---------------------------------------------------------------------
std::list<Ogre::MaterialPtr> MapBlock::cloneMaterials(void) {
std::list<Ogre::MaterialPtr> clones;
for(unsigned int i=0; i < mEntity->getNumSubEntities(); i++) {
Ogre::MaterialPtr realMaterial = mEntity->getSubEntity(i)->getMaterial();
std::stringstream nameStream;
nameStream << realMaterial->getName() << " " << mStaticPosition[0] << ":" << mStaticPosition[1];
Ogre::MaterialPtr newMaterial = realMaterial->clone(nameStream.str());
newMaterial->load();
mEntity->getSubEntity(i)->setMaterial(newMaterial);
clones.push_back(newMaterial);
}
return clones;
}
void MotionBlurListener::notifyMaterialRender(Ogre::uint32 pass_id, Ogre::MaterialPtr &mat)
{
if (pass_id != 120) return;
//Ogre::LogManager::getSingleton().logMessage("notifyMaterialRender");
try
{ mat->load();
Ogre::GpuProgramParametersSharedPtr fparams =
mat->getBestTechnique()->getPass(0)->getFragmentProgramParameters();
fparams->setNamedConstant("blur", pApp->motionBlurIntensity);
}catch(Ogre::Exception& e)
{
Ogre::LogManager::getSingleton().logMessage("Error setting motion blur");
}
}
//-----------------------------------------------------------------------
Ogre::Pass* MaterialTab::getFirstPass(void)
{
wxString materialName = mMaterialListBox->GetStringSelection();
Ogre::String name = wx2ogre(materialName);
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().getByName(name);
if (!material.isNull() && material->getNumTechniques() > 0)
{
Ogre::Technique* technique = 0;
material->load();
technique = material->getBestTechnique(); // Get the best technique
if (technique && technique->getNumPasses() > 0)
{
return technique->getPass(0); // Get the first
}
}
return 0;
}
//-----------------------------------------------------------------------
Ogre::TextureUnitState* MaterialTab::forceCreateFirstTexture(const Ogre::String textureName)
{
// Ignore some materials because they result in a crash while unloading
wxString materialName = mMaterialListBox->GetStringSelection();
if (materialName == wxT("DefaultSettings"))
return 0;
Ogre::Technique* technique = 0;
Ogre::TextureUnitState* texture = 0;
Ogre::Pass* pass = getFirstPass();
if (pass)
{
// There is a pass, check for textures or create one
if (pass->getNumTextureUnitStates() > 0)
{
pass->removeAllTextureUnitStates();
}
texture = pass->createTextureUnitState(textureName);
}
else
{
// There is no pass
wxString materialName = mMaterialListBox->GetStringSelection();
Ogre::String name = wx2ogre(materialName);
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().getByName(name);
if (!material.isNull())
{
material->load();
if (material->getNumTechniques() > 0)
{
technique = material->getBestTechnique(); // Get the best technique
pass = technique->createPass();
texture = pass->createTextureUnitState(textureName);
}
else
{
// There is no technique, no pass and no textureunitstate
technique = material->createTechnique();
pass = technique->createPass();
texture = pass->createTextureUnitState(textureName);
}
}
}
return texture;
}
void DepthOfFieldListener::notifyMaterialSetup(Ogre::uint32 pass_id, Ogre::MaterialPtr &mat)
{
if(pass_id == 1)
{
float blurScale =.5f;
Ogre::Vector4 pixelSize(1.0f / (mViewportWidth * blurScale), 1.0f / (mViewportHeight * blurScale), 0.0f, 0.0f);
mat->load();
Ogre::Pass *pass = mat->getBestTechnique()->getPass(0);
Ogre::GpuProgramParametersSharedPtr params = pass->getFragmentProgramParameters();
if (params->_findNamedConstantDefinition("pixelSize"))
params->setNamedConstant("pixelSize", pixelSize);
}
else if(pass_id == 2)
{
float blurScale =.5f;
Ogre::Vector4 pixelSize(1.0f / mViewportWidth, 1.0f / mViewportHeight,1.0f / (mViewportWidth * blurScale), 1.0f / (mViewportHeight * blurScale) );
Ogre::Pass *pass = mat->getBestTechnique()->getPass(0);
Ogre::GpuProgramParametersSharedPtr params = pass->getFragmentProgramParameters();
if (params->_findNamedConstantDefinition("pixelSize"))
params->setNamedConstant("pixelSize", pixelSize);
// this is the camera you're using
#ifndef ROAD_EDITOR
Ogre::Camera *cam = mApp->mSplitMgr->mCameras.front();
#else
Ogre::Camera *cam = mApp->mCamera;
#endif
if (params->_findNamedConstantDefinition("far"))
params->setNamedConstant("far", cam->getFarClipDistance());
if (params->_findNamedConstantDefinition("dofparams"))
{
Ogre::Vector4 dofParams(0.0f,mApp->pSet->depthOfFieldFocus,mApp->pSet->depthOfFieldFar,1.0);
params->setNamedConstant("dofparams", dofParams);
}
}
}
void GPGPUDemo::launch()
{
// create rendertarget
Ogre::TexturePtr tex = Ogre::TextureManager::getSingleton().createManual("Ogre/GPGPU/RT", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, 512, 512, 0, Ogre::PF_R8G8B8A8, Ogre::TU_RENDERTARGET);
// load material
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().getByName("GPGPUDemo");
mat->load();
Ogre::GPGPU::Root* gpgpu = new Ogre::GPGPU::Root;
Ogre::GPGPU::Result* result = gpgpu->createResult(tex->getBuffer(0, 0));
Ogre::GPGPU::Operation* op = gpgpu->createOperation(mat->getTechnique(0)->getPass(0));
Chrono chrono(true);
for (unsigned int i=0; i<5000; ++i)
gpgpu->compute(result, op);
result->save("gpgpu_computing.png");
std::cout << chrono.getTimeElapsed() << "ms [rendering+saving]" << std::endl;
}
//-----------------------------------------------------------------------
void MaterialTab::OnChangeName(wxCommandEvent& event)
{
wxString newName = mTxtMaterialName->GetValue();
wxString oldName = mMaterialListBox->GetStringSelection();
Ogre::String newMaterialName = wx2ogre(newName);
Ogre::String oldMaterialName = wx2ogre(oldName);
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().getByName(oldMaterialName);
if (!material.isNull())
{
Ogre::MaterialPtr clonedMaterial = material->clone(newMaterialName);
if (!clonedMaterial.isNull())
{
// Load the new resource, unload the old one, remove it from the list and set the new material as the selected
clonedMaterial->load();
Ogre::MaterialManager* materialManager = Ogre::MaterialManager::getSingletonPtr();
materialManager->remove(oldMaterialName);
mMaterialListBox->Delete(mMaterialListBox->GetSelection());
mMaterialListBox->addMaterialName(newName);
selectMaterial(newName);
}
}
}
void CompositionHandler::SetMaterialParameters(const Ogre::MaterialPtr &material, const QList< std::pair<std::string, Ogre::Vector4> > &source) const
{
assert (material.get());
material->load();
for(ushort t=0 ; t<material->getNumTechniques() ; ++t)
{
Ogre::Technique *technique = material->getTechnique(t);
if (technique)
{
for(ushort p=0 ; p<technique->getNumPasses() ; ++p)
{
Ogre::Pass *pass = technique->getPass(p);
if (pass)
{
if (pass->hasVertexProgram())
{
Ogre::GpuProgramParametersSharedPtr destination = pass->getVertexProgramParameters();
for(int i=0 ; i<source.size() ; ++i)
{
if (destination->_findNamedConstantDefinition(source[i].first, false))
destination->setNamedConstant(source[i].first, source[i].second);
}
}
if (pass->hasFragmentProgram())
{
Ogre::GpuProgramParametersSharedPtr destination = pass->getFragmentProgramParameters();
for(int i=0 ; i<source.size() ; ++i)
{
if (destination->_findNamedConstantDefinition(source[i].first, false))
destination->setNamedConstant(source[i].first, source[i].second);
}
}
}
}
}
}
}
void ReloadMaterial(const std::string& materialName, const std::string& groupName, const std::string& filename, bool parseMaterialScript)
{
if (materialName.empty())
{
Ogre::LogManager::getSingleton().logMessage("Material name is empty.");
return;
}
if (groupName.empty())
{
Ogre::LogManager::getSingleton().logMessage("Group name is empty.");
return;
}
if (filename.empty())
{
Ogre::LogManager::getSingleton().logMessage("Filename is empty.");
return;
}
UnloadMaterials(filename);
UnloadVertexPrograms(filename);
UnloadFragmentPrograms(filename);
if (parseMaterialScript)
{
Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton().openResource(filename);
if(!stream.isNull())
{
try
{
Ogre::MaterialManager::getSingleton().parseScript(stream, groupName);
Ogre::MaterialPtr materialPtr = Ogre::MaterialManager::getSingleton().getByName(materialName);
if (!materialPtr.isNull())
{
materialPtr->compile();
materialPtr->load();
}
}
catch (Ogre::Exception &e)
{
StringUtil::StrStreamType msg;
msg << "Exception: FILE: " << __FILE__ << " LINE: " << __LINE__ << " DESC: " << e.getFullDescription() << std::endl;
Ogre::LogManager::getSingleton().logMessage(msg.str());
}
}
stream->close();
///
/// RELOAD MATERIAL SCRIPT CONTENTS
///
stream = Ogre::ResourceGroupManager::getSingleton().openResource(filename);
if(!stream.isNull())
{
try
{
///
/// RELOAD ALL MATERIAL CONTENTS IN FILE
///
while(!stream->eof())
{
std::string line = stream->getLine();
StringUtil::trim(line);
///
/// RELOAD MATERIALS
///
if (StringUtil::startsWith(line, "material"))
{
Ogre::vector<Ogre::String>::type vec = StringUtil::split(line," \t:");
bool skipFirst = true;
for (Ogre::vector<Ogre::String>::type::iterator it = vec.begin(); it < vec.end(); ++it)
{
if (skipFirst)
{
skipFirst = false;
continue;
}
std::string match = (*it);
StringUtil::trim(match);
if (!match.empty())
{
LoadResource(Ogre::MaterialManager::getSingletonPtr(), match, groupName);
break;
}
}
}
///
/// RELOAD VERTEX PROGRAMS
///
if (StringUtil::startsWith(line, "vertex_program") && !StringUtil::startsWith(line, "vertex_program_ref"))
{
Ogre::vector<Ogre::String>::type vec = StringUtil::split(line," \t");
bool skipFirst = true;
for (Ogre::vector<Ogre::String>::type::iterator it = vec.begin(); it < vec.end(); ++it)
{
if (skipFirst)
{
skipFirst = false;
continue;
}
std::string match = (*it);
StringUtil::trim(match);
if (!match.empty())
{
LoadResource(Ogre::HighLevelGpuProgramManager::getSingletonPtr(), match, groupName);
break;
}
}
}
///
/// RELOAD FRAGMENT PROGRAMS
///
if (StringUtil::startsWith(line, "fragment_program") && !StringUtil::startsWith(line, "fragment_program_ref"))
{
Ogre::vector<Ogre::String>::type vec = StringUtil::split(line," \t");
bool skipFirst = true;
for (Ogre::vector<Ogre::String>::type::iterator it = vec.begin(); it < vec.end(); ++it)
{
if (skipFirst)
{
skipFirst = false;
continue;
}
std::string match = (*it);
StringUtil::trim(match);
if (!match.empty())
{
LoadResource(Ogre::HighLevelGpuProgramManager::getSingletonPtr(), match, groupName);
break;
}
}
}
}
}
catch (Ogre::Exception &e)
{
StringUtil::StrStreamType msg;
msg << "Exception: FILE: " << __FILE__ << " LINE: " << __LINE__ << " DESC: " << e.getFullDescription() << std::endl;
Ogre::LogManager::getSingleton().logMessage(msg.str());
}
}
stream->close();
try
{
// Do a render test if it fails, leave materials unloaded
Ogre::Root::getSingleton().renderOneFrame();
return;
}
catch (Ogre::Exception &e)
{
UnloadVertexPrograms(filename);
StringUtil::StrStreamType msg;
msg << "Render test failed. Unloading vertex programs." << std::endl;
msg << "Exception: FILE: " << __FILE__ << " LINE: " << __LINE__ << " DESC: " << e.getFullDescription() << std::endl;
Ogre::LogManager::getSingleton().logMessage(msg.str());
}
try
{
// Do a render test if it fails, leave materials unloaded
Ogre::Root::getSingleton().renderOneFrame();
}
catch (Ogre::Exception &e)
{
// Don't load the script this time
ReloadMaterial(materialName, groupName, filename, false);
StringUtil::StrStreamType msg;
msg << "Render test failed. Unloading materials." << std::endl;
msg << "Exception: FILE: " << __FILE__ << " LINE: " << __LINE__ << " DESC: " << e.getFullDescription() << std::endl;
Ogre::LogManager::getSingleton().logMessage(msg.str());
}
}
}
void LIRenAttachmentEntity::update (float secs)
{
/* Check if background loading has finished. */
if (loaded)
return;
lisys_assert (entity == NULL);
/* Wait for the mesh to load. */
if (!mesh->isLoaded ())
{
if (loading_mesh)
return;
loading_mesh = true;
#ifdef LIREN_BACKGROUND_LOADING
Ogre::ResourceBackgroundQueue::getSingleton ().load (
"Mesh", mesh->getName (), mesh->getGroup ());
#else
mesh->load ();
#endif
return;
}
/* Start loading dependencies. */
if (!loading_deps)
{
loading_deps = true;
for (size_t i = 0 ; i < mesh->getNumSubMeshes () ; i++)
{
Ogre::SubMesh* sub = mesh->getSubMesh (i);
if (sub->isMatInitialised ())
{
Ogre::MaterialManager& mgr = Ogre::MaterialManager::getSingleton ();
Ogre::MaterialPtr material = mgr.getByName (sub->getMaterialName (), mesh->getGroup ());
if (!material.isNull ())
{
resources.push_back (material);
#ifdef LIREN_BACKGROUND_LOADING
Ogre::ResourceBackgroundQueue::getSingleton ().load (
"Material", material->getName (), material->getGroup ());
#else
material->load (true);
#endif
}
}
}
return;
}
// Wait for the dependencies to load.
for (size_t i = 0 ; i < resources.size () ; i++)
{
Ogre::ResourcePtr& resource = resources[i];
if (!resource->isLoaded ())
return;
}
// Create the entity.
Ogre::String e_name = render->id.next ();
entity = render->scene_manager->createEntity (e_name, mesh->getName (), LIREN_RESOURCES_TEMPORARY);
object->node->attachObject (entity);
// Create the skeleton and its pose buffer.
if (create_skeleton ())
{
LIRenModelData* model = get_model ();
lisys_assert (pose_buffer == NULL);
if (model != NULL)
{
pose_buffer = limdl_pose_buffer_new_copy (model->rest_pose_buffer);
lisys_assert (pose_buffer != NULL);
lisys_assert (pose_buffer->bones.count == entity->getSkeleton ()->getNumBones ());
}
}
// Set the entity flags.
entity->setCastShadows (object->get_shadow_casting ());
// Trigger queued texture replacements.
//
// This needs to be done before showing the entity in order to avoid
// the textures flickering for a few frames.
for (size_t i = 0 ; i < queued_texture_replaces.size () ; ++i)
{
LIRenTextureReplace& repl = queued_texture_replaces[i];
replace_texture_now (repl.name, repl.texture);
}
queued_texture_replaces.clear();
// Set entity visibility.
//
// If a visible entity is added to a hidden scene node, the entity is
// still rendered. Hence, newly added entities needs to be explicitly
// hidden or Ogre will render our invisible objects. */
entity->setVisible (object->get_visible ());
// Apply queued settings.
update_settings ();
// Clear the now useless dependency list.
resources.clear ();
loading_mesh = false;
loading_deps = false;
loaded = true;
}
void gkDebugScreen::initialize()
{
if (m_isInit)
return;
try
{
m_font = new gkBuiltinFont;
Ogre::FontPtr fp = Ogre::FontManager::getSingleton().create("<gkBuiltin/Font>", GK_BUILTIN_GROUP, true, m_font);
fp->load();
#define FONT_MATERIAL 1
#if FONT_MATERIAL
#ifndef OGREKIT_USE_OLD
gkString ShareMaterail = "Examples/BumpMapping/MultiLight";
static int Use_Init_Once = 0;
if(Use_Init_Once < 2)
{
Ogre::FileInfoListPtr fileInfoList =
Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(
"",
"*.material");
for (Ogre::FileInfoList::const_iterator cit=fileInfoList->begin();
cit != fileInfoList->end();
++cit) {
const Ogre::String& name = cit->filename;
const Ogre::String& basename = cit->basename;
Ogre::String sType = cit->archive->getType();
Ogre::String sPath = cit->archive->getName();
if (sType=="Zip" || sType=="FileSystem") {
Ogre::DataStreamPtr pData=
Ogre::ResourceGroupManager::getSingleton().openResource(
basename,"");
Ogre::MaterialManager::getSingleton().parseScript(
pData, "");
Ogre::MaterialManager::getSingleton().load(basename,"");
}
}
Use_Init_Once++;
}
#endif
Ogre::MaterialPtr ShareMaterailPtr = Ogre::MaterialManager::getSingleton().getByName(ShareMaterail, "");
if (!ShareMaterailPtr.isNull())
{
ShareMaterailPtr->load();
//ShareMaterailPtr->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("textureCount",1);
}
Ogre::MaterialPtr oma = Ogre::MaterialManager::getSingleton().getByName("Fonts/<gkBuiltin/Font>");
if (!oma.isNull())
{
Ogre::Pass* pass1 = oma->getTechnique(0)->getPass(0);
Ogre::GpuProgramPtr vsPtr = Ogre::HighLevelGpuProgramManager::getSingleton().getByName("FixVs");
if (vsPtr.isNull())
{
LogManager::getSingleton().logMessage("GpuProgramPtr NULL");
}
gkString VertexProgramName = "FixVs";
gkString FragmentProgramName ="FixPs";
if (pass1)
{
pass1->setVertexProgram(VertexProgramName);
pass1->setFragmentProgram(FragmentProgramName);
Ogre::GpuProgramParametersSharedPtr vsParams = pass1->getVertexProgramParameters();
vsParams->copyMatchingNamedConstantsFrom(*ShareMaterailPtr->getTechnique(0)->getPass(0)->getVertexProgramParameters().get());
Ogre::GpuProgramParametersSharedPtr psParams = pass1->getFragmentProgramParameters();
psParams->copyMatchingNamedConstantsFrom(*ShareMaterailPtr->getTechnique(0)->getPass(0)->getFragmentProgramParameters().get());
//psParams->setNamedConstant("textureCount",1);
//psParams->setNamedConstant("AlphaValue",0.0f);
//vsParams->setNamedConstant("lightOpen",0);
LogManager::getSingleton().logMessage("set font es2.0");
}
}
#endif
Ogre::OverlayManager& mgr = Ogre::OverlayManager::getSingleton();
m_over = mgr.create("<gkBuiltin/gkDebugScreen>");
m_ele = mgr.createOverlayElement("TextArea", "<gkBuiltin/gkDebugScreen/TextArea>");
Ogre::OverlayContainer* cont = (Ogre::OverlayContainer*)mgr.createOverlayElement("BorderPanel", "<gkBuiltin/gkDebugScreen/Containter>");
cont->setMetricsMode(Ogre::GMM_PIXELS);
cont->setVerticalAlignment(Ogre::GVA_TOP);
const gkVector2& dims = gkWindowSystem::getSingleton().getMouse()->winsize;
m_ele->setMetricsMode(Ogre::GMM_PIXELS);
m_ele->setVerticalAlignment(Ogre::GVA_TOP);
m_ele->setPosition(0, 0);
m_ele->setDimensions(dims.x, dims.y);
Ogre::TextAreaOverlayElement* textArea = static_cast<Ogre::TextAreaOverlayElement*>(m_ele);
textArea->setFontName("<gkBuiltin/Font>");
textArea->setCharHeight(SCREEN_SIZE);
textArea->setColour(Ogre::ColourValue::White);
m_over->setZOrder(500);
cont->addChild(m_ele);
m_over->add2D(cont);
}
catch (Ogre::Exception& e)
{
gkPrintf("%s", e.getDescription().c_str());
return;
}
m_isInit = true;
gConsole = this;
}
/****************************************************************************
**
** Copyright (C) 2014
**
** This file is generated by the Magus toolkit
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
****************************************************************************/
// Include
#include "mainwindow.h"
#include "Editor_dockwidget.h"
#include "constants.h"
#include "sme_asset_material.h"
#include "sme_node_material.h"
#include "sme_asset_technique.h"
#include "sme_node_technique.h"
#include "sme_asset_pass.h"
#include "sme_node_pass.h"
#include "sme_asset_texture_unit.h"
#include "sme_node_texture_unit.h"
//****************************************************************************/
EditorDockWidget::EditorDockWidget(QString title, MainWindow* parent, Qt::WindowFlags flags) :
QDockWidget (title, parent, flags),
mParent(parent)
{
mInnerMain = new QMainWindow();
setWidget(mInnerMain);
// Perform standard functions
createActions();
createMenus();
createToolBars();
// Create the node editor widget.
mNodeEditor = new Magus::QtNodeEditor(this);
mNodeEditor->setMenuSelectionToCompoundEnabled(false); // Enabling this makes it a bit more complicated
mNodeEditor->setMenuExpandCompoundsEnabled(false); // No compounds are used
connect(mNodeEditor, SIGNAL(nodeRemoved(QtNode*)), this, SLOT(nodeDeleted()));
connect(mNodeEditor, SIGNAL(nodeSelected(QtNode*)), this, SLOT(nodeSelected(QtNode*)));
mInnerMain->setCentralWidget(mNodeEditor);
mMaterialNode = 0;
}
//****************************************************************************/
EditorDockWidget::~EditorDockWidget(void)
{
}
//****************************************************************************/
void EditorDockWidget::createActions(void)
{
mMaterialHToolbarAction = new QAction(QIcon(ICON_MATERIAL), QString("Add a material node to the editor"), this);
connect(mMaterialHToolbarAction, SIGNAL(triggered()), this, SLOT(doMaterialHToolbarAction()));
mTechniqueHToolbarAction = new QAction(QIcon(ICON_TECHNIQUE), QString("Add a technique node to the editor"), this);
connect(mTechniqueHToolbarAction, SIGNAL(triggered()), this, SLOT(doTechniqueHToolbarAction()));
mPassHToolbarAction = new QAction(QIcon(ICON_PASS), QString("Add a pass node to the editor"), this);
connect(mPassHToolbarAction, SIGNAL(triggered()), this, SLOT(doPassHToolbarAction()));
mTextureHToolbarAction = new QAction(QIcon(ICON_TEXTURE), QString("Add a texture unit node to the editor"), this);
connect(mTextureHToolbarAction, SIGNAL(triggered()), this, SLOT(doTextureHToolbarAction()));
mCogHToolbarAction = new QAction(QIcon(ICON_COG), QString("Generate material"), this);
connect(mCogHToolbarAction, SIGNAL(triggered()), this, SLOT(doCogHToolbarAction()));
}
//****************************************************************************/
void EditorDockWidget::createMenus(void)
{
}
//****************************************************************************/
void EditorDockWidget::createToolBars(void)
{
mHToolBar = new QToolBar();
mInnerMain->addToolBar(Qt::TopToolBarArea, mHToolBar);
mHToolBar->setMinimumHeight(TB_ICON_AND_SPACING);
mHToolBar->setMinimumWidth(1200);
mHToolBar->addAction(mMaterialHToolbarAction);
mHToolBar->addAction(mTechniqueHToolbarAction);
mHToolBar->addAction(mPassHToolbarAction);
mHToolBar->addAction(mTextureHToolbarAction);
mHToolBar->addAction(mCogHToolbarAction);
}
//****************************************************************************/
void EditorDockWidget::doMaterialHToolbarAction(void)
{
// Add a material node; only 1 is allowed
if (!mMaterialNode)
{
mMaterialNode = new Magus::QtNodeMaterial(NODE_TITLE_MATERIAL);
mNodeEditor->addNode(mMaterialNode);
}
}
//****************************************************************************/
void EditorDockWidget::doTechniqueHToolbarAction(void)
{
// Add a technique node
Magus::QtNodeTechnique* techniqueNode = new Magus::QtNodeTechnique(NODE_TITLE_TECHNIQUE);
mNodeEditor->addNode(techniqueNode);
}
//****************************************************************************/
void EditorDockWidget::doPassHToolbarAction(void)
{
// Add a pass node
Magus::QtNodePass* passNode = new Magus::QtNodePass(NODE_TITLE_PASS);
mNodeEditor->addNode(passNode);
}
//****************************************************************************/
void EditorDockWidget::doTextureHToolbarAction(void)
{
// Add a texture unit node
Magus::QtNodeTextureUnit* textureUnitNode = new Magus::QtNodeTextureUnit(NODE_TITLE_TEXTURE_UNIT);
mNodeEditor->addNode(textureUnitNode);
}
//****************************************************************************/
void EditorDockWidget::doCogHToolbarAction(void)
{
if (!mMaterialNode)
return;
if (mMaterialNode->getMaterialName().isEmpty())
return;
// ---------------------------------------- Create a material ----------------------------------------
Ogre::LogManager* logManager = Ogre::LogManager::getSingletonPtr();
Ogre::MaterialManager* materialManager = Ogre::MaterialManager::getSingletonPtr();
Ogre::String materialName = mMaterialNode->getMaterialName().toStdString(); // Convert to std format
logManager->logMessage("SME: create Ogre material: " + materialName);
Ogre::MaterialPtr material = materialManager->create(materialName, "General");
// Remark: Sceneblending is done for each pass individually, although it is defined on material level
// ---------------------------------------- Add the technique ----------------------------------------
Magus::QtNode* node = mMaterialNode->getNodeConnectedToPort(PORT_TECHNIQUE_OUT);
if (!node)
{
logManager->logMessage("SME: No technique node available");
return;
}
Magus::QtNodeTechnique* techniqueNode = static_cast<Magus::QtNodeTechnique*>(node);
material->removeAllTechniques();
Ogre::Technique* technique = material->createTechnique();
technique->removeAllPasses();
logManager->logMessage("SME: Technique created" + Ogre::StringConverter::toString(material->getNumTechniques()));
// ---------------------------------------- Add the passes ----------------------------------------
Magus::QtNodePass* passNode;
Magus::QtNodeTextureUnit* textureUnitNode;
Ogre::Pass* pass;
Ogre::TextureUnitState* textureUnit;
for (unsigned int i = 1; i < 5; ++i)
{
node = techniqueNode->getNodeConnectedToPort(PORT_PASS_OUT, i); // node with the same name
if (node)
{
passNode = static_cast<Magus::QtNodePass*>(node);
pass = technique->createPass();
pass->removeAllTextureUnitStates();
logManager->logMessage("SME: Pass on port nr. " + Ogre::StringConverter::toString(i) + " created");
propagatePassNodeData(passNode, pass);
// ---------------------------------------- Add the texture units ----------------------------------------
for (unsigned int j = 1; j < 9; ++j)
{
node = passNode->getNodeConnectedToPort(PORT_TEXTURE_OUT, j);
if (node)
{
logManager->logMessage("SME: Texture unit on port nr. " +
Ogre::StringConverter::toString(j) +
" of Pass port nr. " +
Ogre::StringConverter::toString(i) +
" created");
textureUnitNode = static_cast<Magus::QtNodeTextureUnit*>(node);
textureUnit = pass->createTextureUnitState();
propagateTextureUnitNodeData(textureUnitNode, textureUnit);
}
}
}
}
// Assign the material to the ogrehead
material->compile();
material->load();
mParent->getOgreManager()->getOgreWidget(1)->mEntity->setMaterial(material);
}
void GPUSurfFeatureDetector::allocOgreResource()
{
int hwidth = (int)mWidth / 2;
int hheight = (int)mHeight / 2;
//create ogre tex
mGrayTexture = Ogre::TextureManager::getSingleton().createManual("GPGPU/Gray", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, mWidth, mHeight, mNbOctave-1, Ogre::PF_A8R8G8B8, Ogre::TU_RENDERTARGET);
mGxTexture = Ogre::TextureManager::getSingleton().createManual("GPGPU/Gx", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, mWidth, mHeight, mNbOctave-1, Ogre::PF_A8R8G8B8, Ogre::TU_RENDERTARGET);
mGyTexture = Ogre::TextureManager::getSingleton().createManual("GPGPU/Gy", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, mWidth, mHeight, mNbOctave-1, Ogre::PF_A8R8G8B8, Ogre::TU_RENDERTARGET);
mHTexture = Ogre::TextureManager::getSingleton().createManual("GPGPU/H", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, mWidth, mHeight, mNbOctave-1, Ogre::PF_A8R8G8B8, Ogre::TU_RENDERTARGET);
mNMSTexture = Ogre::TextureManager::getSingleton().createManual("GPGPU/NMS", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, hwidth, hheight, mNbOctave-1, Ogre::PF_A8R8G8B8, Ogre::TU_RENDERTARGET);
//mFeatureCudaTexture = Ogre::TextureManager::getSingleton().createManual("GPGPU/Feature/Cuda", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_1D, mNbFeatureMax, 1, 0, Ogre::PF_FLOAT32_RGBA, Ogre::TU_RENDERTARGET);
//mFeatureTexture = Ogre::TextureManager::getSingleton().createManual("GPGPU/Feature", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_1D, mNbFeatureMax, 1, 0, Ogre::PF_FLOAT32_RGBA, Ogre::TU_RENDERTARGET);
//create operation
for (int i=0; i<mNbOctave; ++i)
{
mGrayResults.push_back(mGPGPURoot->createResult(mGrayTexture->getBuffer(0, i)));
mGxResults.push_back(mGPGPURoot->createResult(mGxTexture->getBuffer(0, i)));
mGyResults.push_back(mGPGPURoot->createResult(mGyTexture->getBuffer(0, i)));
mHResults.push_back(mGPGPURoot->createResult(mHTexture->getBuffer(0, i)));
mNMSResults.push_back(mGPGPURoot->createResult(mNMSTexture->getBuffer(0, i)));
std::stringstream materialName;
{
if (i == 0)
materialName << "GPGPU/RGB2Gray/Mipmap0";
else
materialName << "GPGPU/DownSampling/Mipmap" << i;
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().getByName(materialName.str());
mat->load();
materialName.str("");
mGrayOperations.push_back(mGPGPURoot->createOperation(mat->getBestTechnique()->getPass(0)));
}
{
materialName << "GPGPU/GaussianX/Mipmap" << i;
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().getByName(materialName.str());
mat->load();
materialName.str("");
mGxOperations.push_back(mGPGPURoot->createOperation(mat->getBestTechnique()->getPass(0)));
}
{
materialName << "GPGPU/GaussianY/Mipmap" << i;
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().getByName(materialName.str());
mat->load();
materialName.str("");
mGyOperations.push_back(mGPGPURoot->createOperation(mat->getBestTechnique()->getPass(0)));
}
{
materialName << "GPGPU/Hessian/Mipmap" << i;
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().getByName(materialName.str());
mat->load();
materialName.str("");
mHOperations.push_back(mGPGPURoot->createOperation(mat->getBestTechnique()->getPass(0)));
}
{
materialName << "GPGPU/NMS/Mipmap" << i;
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().getByName(materialName.str());
mat->load();
materialName.str("");
mNMSOperations.push_back(mGPGPURoot->createOperation(mat->getBestTechnique()->getPass(0)));
}
}
mOgreIsAllocated = true;
}
bool ModelBackgroundLoader::poll(const TimeFrame& timeFrame)
{
#if OGRE_THREAD_SUPPORT
if (mState == LS_UNINITIALIZED) {
//Start to load the meshes
for (SubModelDefinitionsStore::const_iterator I_subModels = mModel.getDefinition()->getSubModelDefinitions().begin(); I_subModels != mModel.getDefinition()->getSubModelDefinitions().end(); ++I_subModels) {
Ogre::MeshPtr meshPtr = static_cast<Ogre::MeshPtr> (Ogre::MeshManager::getSingleton().getByName((*I_subModels)->getMeshName()));
if (meshPtr.isNull() || !meshPtr->isPrepared()) {
try {
Ogre::BackgroundProcessTicket ticket = Ogre::ResourceBackgroundQueue::getSingleton().prepare(Ogre::MeshManager::getSingleton().getResourceType(), (*I_subModels)->getMeshName(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, false, 0, 0, createListener());
if (ticket) {
addTicket(ticket);
}
} catch (const std::exception& ex) {
S_LOG_FAILURE("Could not load the mesh " << (*I_subModels)->getMeshName() << " when loading model " << mModel.getName() << "." << ex);
continue;
}
}
}
mState = LS_MESH_PREPARING;
return poll(timeFrame);
} else if (mState == LS_MESH_PREPARING) {
if (areAllTicketsProcessed()) {
mState = LS_MESH_PREPARED;
return poll(timeFrame);
}
} else if (mState == LS_MESH_PREPARED) {
for (SubModelDefinitionsStore::const_iterator I_subModels = mModel.getDefinition()->getSubModelDefinitions().begin(); I_subModels != mModel.getDefinition()->getSubModelDefinitions().end(); ++I_subModels) {
Ogre::MeshPtr meshPtr = static_cast<Ogre::MeshPtr> (Ogre::MeshManager::getSingleton().getByName((*I_subModels)->getMeshName()));
if (!meshPtr.isNull()) {
if (!meshPtr->isLoaded()) {
#if OGRE_THREAD_SUPPORT == 1
Ogre::BackgroundProcessTicket ticket = Ogre::ResourceBackgroundQueue::getSingleton().load(Ogre::MeshManager::getSingleton().getResourceType(), meshPtr->getName(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, false, 0, 0, createListener());
if (ticket) {
// meshPtr->setBackgroundLoaded(true);
addTicket(ticket);
}
#else
if (!timeFrame.isTimeLeft()) {
return false;
}
try {
meshPtr->load();
} catch (const std::exception& ex) {
S_LOG_FAILURE("Could not load the mesh " << meshPtr->getName() << " when loading model " << mModel.getName() << "." << ex);
continue;
}
#endif
}
}
}
mState = LS_MESH_LOADING;
return poll(timeFrame);
} else if (mState == LS_MESH_LOADING) {
if (areAllTicketsProcessed()) {
mState = LS_MESH_LOADED;
return poll(timeFrame);
}
} else if (mState == LS_MESH_LOADED) {
for (SubModelDefinitionsStore::const_iterator I_subModels = mModel.getDefinition()->getSubModelDefinitions().begin(); I_subModels != mModel.getDefinition()->getSubModelDefinitions().end(); ++I_subModels) {
Ogre::MeshPtr meshPtr = static_cast<Ogre::MeshPtr> (Ogre::MeshManager::getSingleton().getByName((*I_subModels)->getMeshName()));
if (!meshPtr.isNull()) {
if (meshPtr->isLoaded()) {
Ogre::Mesh::SubMeshIterator subMeshI = meshPtr->getSubMeshIterator();
while (subMeshI.hasMoreElements()) {
Ogre::SubMesh* submesh(subMeshI.getNext());
Ogre::MaterialPtr materialPtr = static_cast<Ogre::MaterialPtr> (Ogre::MaterialManager::getSingleton().getByName(submesh->getMaterialName()));
if (materialPtr.isNull() || !materialPtr->isPrepared()) {
// S_LOG_VERBOSE("Preparing material " << materialPtr->getName());
Ogre::BackgroundProcessTicket ticket = Ogre::ResourceBackgroundQueue::getSingleton().prepare(Ogre::MaterialManager::getSingleton().getResourceType(),submesh->getMaterialName(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, false, 0, 0, createListener());
if (ticket) {
addTicket(ticket);
}
}
}
}
}
for (PartDefinitionsStore::const_iterator I_parts = (*I_subModels)->getPartDefinitions().begin(); I_parts != (*I_subModels)->getPartDefinitions().end(); ++I_parts) {
if ((*I_parts)->getSubEntityDefinitions().size() > 0) {
for (SubEntityDefinitionsStore::const_iterator I_subEntities = (*I_parts)->getSubEntityDefinitions().begin(); I_subEntities != (*I_parts)->getSubEntityDefinitions().end(); ++I_subEntities) {
const std::string& materialName = (*I_subEntities)->getMaterialName();
if (materialName != "") {
Ogre::MaterialPtr materialPtr = static_cast<Ogre::MaterialPtr> (Ogre::MaterialManager::getSingleton().getByName(materialName));
if (materialPtr.isNull() || !materialPtr->isPrepared()) {
// S_LOG_VERBOSE("Preparing material " << materialName);
Ogre::BackgroundProcessTicket ticket = Ogre::ResourceBackgroundQueue::getSingleton().prepare(Ogre::MaterialManager::getSingleton().getResourceType(), materialName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, false, 0, 0, createListener());
if (ticket) {
addTicket(ticket);
}
}
}
}
}
}
}
mState = LS_MATERIAL_PREPARING;
return poll(timeFrame);
} else if (mState == LS_MATERIAL_PREPARING) {
if (areAllTicketsProcessed()) {
mState = LS_MATERIAL_PREPARED;
return poll(timeFrame);
}
} else if (mState == LS_MATERIAL_PREPARED) {
for (SubModelDefinitionsStore::const_iterator I_subModels = mModel.getDefinition()->getSubModelDefinitions().begin(); I_subModels != mModel.getDefinition()->getSubModelDefinitions().end(); ++I_subModels) {
Ogre::MeshPtr meshPtr = static_cast<Ogre::MeshPtr> (Ogre::MeshManager::getSingleton().getByName((*I_subModels)->getMeshName()));
Ogre::Mesh::SubMeshIterator subMeshI = meshPtr->getSubMeshIterator();
while (subMeshI.hasMoreElements()) {
Ogre::SubMesh* submesh(subMeshI.getNext());
Ogre::MaterialPtr materialPtr = static_cast<Ogre::MaterialPtr> (Ogre::MaterialManager::getSingleton().getByName(submesh->getMaterialName()));
if (!materialPtr.isNull() && !materialPtr->isLoaded()) {
#if OGRE_THREAD_SUPPORT == 1
Ogre::BackgroundProcessTicket ticket = Ogre::ResourceBackgroundQueue::getSingleton().load(Ogre::MaterialManager::getSingleton().getResourceType(), materialPtr->getName(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, false, 0, 0, createListener());
if (ticket) {
// materialPtr->setBackgroundLoaded(true);
addTicket(ticket);
}
#else
Ogre::Material::TechniqueIterator techIter = materialPtr->getSupportedTechniqueIterator();
while (techIter.hasMoreElements()) {
Ogre::Technique* tech = techIter.getNext();
Ogre::Technique::PassIterator passIter = tech->getPassIterator();
while (passIter.hasMoreElements()) {
Ogre::Pass* pass = passIter.getNext();
Ogre::Pass::TextureUnitStateIterator tusIter = pass->getTextureUnitStateIterator();
while (tusIter.hasMoreElements()) {
Ogre::TextureUnitState* tus = tusIter.getNext();
unsigned int frames = tus->getNumFrames();
for (unsigned int i = 0; i < frames; ++i) {
if (!timeFrame.isTimeLeft()) {
return false;
}
//This will automatically load the texture.
// S_LOG_VERBOSE("Loading texture " << tus->getTextureName());
Ogre::TexturePtr texturePtr = tus->_getTexturePtr(i);
}
}
}
}
if (!timeFrame.isTimeLeft()) {
return false;
}
// S_LOG_VERBOSE("Loading material " << materialPtr->getName());
materialPtr->load();
#endif
}
}
for (PartDefinitionsStore::const_iterator I_parts = (*I_subModels)->getPartDefinitions().begin(); I_parts != (*I_subModels)->getPartDefinitions().end(); ++I_parts) {
if ((*I_parts)->getSubEntityDefinitions().size() > 0) {
for (SubEntityDefinitionsStore::const_iterator I_subEntities = (*I_parts)->getSubEntityDefinitions().begin(); I_subEntities != (*I_parts)->getSubEntityDefinitions().end(); ++I_subEntities) {
const std::string& materialName = (*I_subEntities)->getMaterialName();
if (materialName != "") {
Ogre::MaterialPtr materialPtr = static_cast<Ogre::MaterialPtr> (Ogre::MaterialManager::getSingleton().getByName(materialName));
if (!materialPtr.isNull() && !materialPtr->isLoaded()) {
#if OGRE_THREAD_SUPPORT == 1
Ogre::BackgroundProcessTicket ticket = Ogre::ResourceBackgroundQueue::getSingleton().load(Ogre::MaterialManager::getSingleton().getResourceType(), materialPtr->getName(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, false, 0, 0, createListener());
if (ticket) {
addTicket(ticket);
}
#else
Ogre::Material::TechniqueIterator techIter = materialPtr->getSupportedTechniqueIterator();
while (techIter.hasMoreElements()) {
Ogre::Technique* tech = techIter.getNext();
Ogre::Technique::PassIterator passIter = tech->getPassIterator();
while (passIter.hasMoreElements()) {
Ogre::Pass* pass = passIter.getNext();
Ogre::Pass::TextureUnitStateIterator tusIter = pass->getTextureUnitStateIterator();
while (tusIter.hasMoreElements()) {
Ogre::TextureUnitState* tus = tusIter.getNext();
unsigned int frames = tus->getNumFrames();
for (unsigned int i = 0; i < frames; ++i) {
if (!timeFrame.isTimeLeft()) {
return false;
}
//This will automatically load the texture.
// S_LOG_VERBOSE("Loading texture " << tus->getTextureName());
Ogre::TexturePtr texturePtr = tus->_getTexturePtr(i);
}
}
}
}
if (!timeFrame.isTimeLeft()) {
return false;
}
// S_LOG_VERBOSE("Loading material " << materialPtr->getName());
materialPtr->load();
#endif
}
}
}
}
}
}
mState = LS_MATERIAL_LOADING;
return poll(timeFrame);
} else if (mState == LS_MATERIAL_LOADING) {
if (areAllTicketsProcessed()) {
mState = LS_DONE;
return true;
}
} else {
return true;
}
return false;
#else
//If there's no threading support, just return here.
return true;
#endif
}