//-----------------------------------------------------------------------
void EntityRenderer::_rotateTexture(VisualParticle* particle, Ogre::Entity* entity)
{
Ogre::TextureUnitState::EffectMap::const_iterator it;
// Get the material and rotate it
unsigned int numberOfSubEntities = entity->getNumSubEntities();
for (unsigned short u = 0; u < numberOfSubEntities; ++u)
{
Ogre::MaterialPtr material = entity->getSubEntity(u)->getMaterial();
unsigned short numberOfTechniques = material->getNumTechniques();
for (unsigned short v = 0; v < numberOfTechniques; ++v)
{
Ogre::Technique* technique = material->getTechnique(v);
unsigned short numberOfPasses = technique->getNumPasses();
for (unsigned short w = 0; w < numberOfPasses; ++w)
{
Ogre::Pass* pass = technique->getPass(w);
unsigned short numberOfTextureUnitStates = pass->getNumTextureUnitStates();
for (unsigned short x = 0; x < numberOfTextureUnitStates; ++x)
{
// Set the rotation if not already available.
// This can only be done once! Changing the rotationspeed or removing the rotation
// and resetting it doesn´t seem to work.
Ogre::TextureUnitState* textureUnitState = pass->getTextureUnitState(x);
it = textureUnitState->getEffects().find(Ogre::TextureUnitState::ET_ROTATE);
if (it == textureUnitState->getEffects().end())
{
textureUnitState->setRotateAnimation((particle->zRotationSpeed.valueRadians()));
}
}
}
}
}
}
void MeshResourceMarker::reset()
{
//destroy entity
if (entity_)
{
context_->getSceneManager()->destroyEntity( entity_ );
entity_ = 0;
}
// destroy all the materials we've created
S_MaterialPtr::iterator it;
for ( it = materials_.begin(); it!=materials_.end(); it++ )
{
Ogre::MaterialPtr material = *it;
if (!material.isNull())
{
for (size_t i = 0; i < material->getNumTechniques(); ++i)
{
Ogre::Technique* t = material->getTechnique(i);
// hack hack hack, really need to do a shader-based way of picking, rather than
// creating a texture for each object
if (t->getSchemeName() == "Pick")
{
Ogre::TextureManager::getSingleton().remove(t->getPass(0)->getTextureUnitState(0)->getTextureName());
}
}
material->unload();
Ogre::MaterialManager::getSingleton().remove(material->getName());
}
}
materials_.clear();
}
//-----------------------------------------------------------------------
void PrimitiveShapeSet::rotateTexture(Ogre::Real speed)
{
// Get the material and rotate it, assume the material is loaded already, otherwise skip.
Ogre::MaterialPtr material = getMaterial();
if (material.isNull())
return;
Ogre::TextureUnitState::EffectMap::const_iterator it;
unsigned short numberOfTechniques = material->getNumTechniques();
for (unsigned short u = 0; u < numberOfTechniques; ++u)
{
Ogre::Technique* technique = material->getTechnique(u);
unsigned short numberOfPasses = technique->getNumPasses();
for (unsigned short v = 0; v < numberOfPasses; ++v)
{
Ogre::Pass* pass = technique->getPass(v);
unsigned short numberOfTextureUnitStates = pass->getNumTextureUnitStates();
for (unsigned short w = 0; w < numberOfTextureUnitStates; ++w)
{
// Set the rotation if not already available.
// This can only be done once! Changing the rotationspeed or removing the rotation
// and resetting it doesn´t seem to work.
Ogre::TextureUnitState* textureUnitState = pass->getTextureUnitState(w);
it = textureUnitState->getEffects().find(Ogre::TextureUnitState::ET_ROTATE);
if (it == textureUnitState->getEffects().end())
{
textureUnitState->setRotateAnimation(speed);
}
}
}
}
}
void EC_HoveringText::SetOverlayAlpha(float alpha)
{
Ogre::MaterialManager &mgr = Ogre::MaterialManager::getSingleton();
Ogre::MaterialPtr material = mgr.getByName(materialName_);
if (!material.get() || material->getNumTechniques() < 1 || material->getTechnique(0)->getNumPasses() < 1 || material->getTechnique(0)->getPass(0)->getNumTextureUnitStates() < 1)
return;
material->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setAlphaOperation(
Ogre::LBX_BLEND_MANUAL, Ogre::LBS_TEXTURE, Ogre::LBS_MANUAL, 1.0, 0.0, alpha);
}
//------------------------------------------------------
void MaterialService::addWorldMaterialTemplate(unsigned int idx, const Ogre::MaterialPtr& material) {
assert(!material.isNull());
mTemplateMaterials.insert(make_pair(idx, material));
TextureDimensions2D dimensions;
dimensions.first = 64;
dimensions.second = 64;
if (material->getNumTechniques() > 0) {
Pass *shadPass = material->getTechnique(0)->getPass(0);
if (shadPass->getNumTextureUnitStates() > 0) {
TextureUnitState* tus = shadPass->getTextureUnitState(0);
try {
// ensure the material is loaded before getting the dimensions
material->escalateLoading();
// This is stupid, but can happen - the getTextureDimensions seems buggy in this regard
if (tus->getNumFrames() <= 0) {
LOG_ERROR("MaterialService: Error getting texture dimensions (Mat. %s) : Zero frame count!", material->getName().c_str());
} else {
dimensions = tus->getTextureDimensions();
// register the scale
std::pair<float, float> tscale;
tscale.first = tus->getTextureUScale();
tscale.second = tus->getTextureVScale();
// register the texture scale...
setWRTextureScale(idx, tscale);
// reset the scale back, it is canceled out by the fact we UV map with different txt dimensions
tus->setTextureUScale(1.0f);
tus->setTextureVScale(1.0f);
dimensions.first = static_cast<unsigned int> (tscale.first * dimensions.first);
dimensions.second = static_cast<unsigned int> (tscale.second * dimensions.second);
}
} catch (Ogre::Exception &e) {
// Nothing, just log it could not be done
LOG_ERROR("MaterialService: Error getting texture dimensions : %s", e.getFullDescription().c_str());
}
}
}
LOG_INFO("MaterialService: Registered a WR template material %u - %s", idx, material->getName().c_str());
// insert
mTextureDimensionMap.insert(make_pair(idx, dimensions));
}
void BillboardObject::setColour(const ColourValue& pColour)
{
mColour = pColour;
Ogre::MaterialPtr m = static_cast<sh::OgreMaterial*>(mMaterial->getMaterial ())->getOgreMaterial ();
for (int i=0; i<m->getNumTechniques(); ++i)
{
Ogre::Technique* t = m->getTechnique(i);
if (t->getNumPasses ())
t->getPass(0)->setSelfIllumination (pColour);
}
}
void BillboardObject::setVisibility(const float visibility)
{
mVisibility = visibility;
Ogre::MaterialPtr m = static_cast<sh::OgreMaterial*>(mMaterial->getMaterial ())->getOgreMaterial ();
for (int i=0; i<m->getNumTechniques(); ++i)
{
Ogre::Technique* t = m->getTechnique(i);
if (t->getNumPasses ())
t->getPass(0)->setDiffuse (0,0,0, visibility);
}
}
void EffectManager::addEffect(const std::string &model, std::string textureOverride, const Ogre::Vector3 &worldPosition, float scale)
{
Ogre::SceneNode* sceneNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(worldPosition);
sceneNode->setScale(scale,scale,scale);
// fix texture extension to .dds
if (textureOverride.size() > 4)
{
textureOverride[textureOverride.size()-3] = 'd';
textureOverride[textureOverride.size()-2] = 'd';
textureOverride[textureOverride.size()-1] = 's';
}
NifOgre::ObjectScenePtr scene = NifOgre::Loader::createObjects(sceneNode, model);
// TODO: turn off shadow casting
MWRender::Animation::setRenderProperties(scene, RV_Misc,
RQG_Main, RQG_Alpha, 0.f, false, NULL);
for(size_t i = 0;i < scene->mControllers.size();i++)
{
if(scene->mControllers[i].getSource().isNull())
scene->mControllers[i].setSource(Ogre::SharedPtr<EffectAnimationTime> (new EffectAnimationTime()));
}
if (!textureOverride.empty())
{
for(size_t i = 0;i < scene->mParticles.size(); ++i)
{
Ogre::ParticleSystem* partSys = scene->mParticles[i];
Ogre::MaterialPtr mat = scene->mMaterialControllerMgr.getWritableMaterial(partSys);
for (int t=0; t<mat->getNumTechniques(); ++t)
{
Ogre::Technique* tech = mat->getTechnique(t);
for (int p=0; p<tech->getNumPasses(); ++p)
{
Ogre::Pass* pass = tech->getPass(p);
for (int tex=0; tex<pass->getNumTextureUnitStates(); ++tex)
{
Ogre::TextureUnitState* tus = pass->getTextureUnitState(tex);
tus->setTextureName("textures\\" + textureOverride);
}
}
}
}
}
mEffects.push_back(std::make_pair(sceneNode, scene));
}
//-----------------------------------------------------------------------
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
}
void EC_Sky::OnTextureAssetLoaded(AssetPtr tex)
{
std::vector<std::string> texture_names;
texture_names.reserve(cSkyBoxTextureCount);
AssetReferenceList textureList = textureRefs.Get();
const char * const defaultSkyTextures[cSkyBoxTextureCount] =
{ "rex_sky_front.dds",
"rex_sky_back.dds",
"rex_sky_left.dds",
"rex_sky_right.dds",
"rex_sky_top.dds",
"rex_sky_bot.dds"
};
for(size_t i = 0; i < textureAssets.size() || i < cSkyBoxTextureCount; ++i)
if (i < textureAssets.size() && textureAssets[i])
{
AssetPtr asset = textureAssets[i]->Asset();
TextureAsset *textureAsset = dynamic_cast<TextureAsset*>(asset.get());
if (textureAsset)
texture_names.push_back(textureAsset->ogreAssetName.toStdString());
else
texture_names.push_back(defaultSkyTextures[i]);
}
else
texture_names.push_back(defaultSkyTextures[i]);
assert(texture_names.size() == cSkyBoxTextureCount);
///\todo Use AssetAPI for the material.
Ogre::MaterialPtr materialPtr = Ogre::MaterialManager::getSingleton().getByName(materialRef.Get().ref.toStdString().c_str());
if (materialPtr.isNull())
{
LogError("EC_Sky::OnTextureAssetLoaded: Cannot find Ogre material \"" + materialRef.Get().ref.toStdString() + "\"!");
return;
}
if (materialPtr->getNumTechniques() == 0 || materialPtr->getTechnique(0) == 0 ||
materialPtr->getTechnique(0)->getNumPasses() == 0 || materialPtr->getTechnique(0)->getPass(0) == 0 ||
materialPtr->getTechnique(0)->getPass(0)->getNumTextureUnitStates() == 0 ||
materialPtr->getTechnique(0)->getPass(0)->getTextureUnitState(0) == 0)
{
LogError("EC_Sky::OnTextureAssetLoaded: Cannot use material \"" + materialRef.Get().ref.toStdString() + "\" as Skybox material: It has 0 techniques, passes or texture unit states!");
return;
}
materialPtr->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setCubicTextureName(&texture_names[0], false);
CreateSky();
}
//-----------------------------------------------------------------------
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;
}
EC_WidgetCanvas::EC_WidgetCanvas(Scene *scene) :
IComponent(scene),
widget_(0),
update_internals_(false),
mesh_hooked_(false),
refresh_timer_(0),
update_interval_msec_(0),
material_name_(""),
texture_name_("")
{
if (framework->IsHeadless())
return;
if (framework->Renderer())
{
// Create texture
texture_name_ = framework->Renderer()->GetUniqueObjectName("EC_3DCanvas_tex");
Ogre::TexturePtr texture = Ogre::TextureManager::getSingleton().createManual(
texture_name_, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Ogre::TEX_TYPE_2D, 1, 1, 0, Ogre::PF_A8R8G8B8,
Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
if (texture.isNull())
{
LogError("EC_WidgetCanvas: Could not create texture for usage!");
return;
}
// Create material: Make sure we have one tech with one pass with one texture unit.
// Don't use our lit textured templates here as emissive will not work there as it has vertex etc programs in it.
material_name_ = framework->Renderer()->GetUniqueObjectName("EC_3DCanvas_mat");
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create(material_name_, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
if (material->getNumTechniques() == 0)
material->createTechnique();
if (material->getTechnique(0) &&
material->getTechnique(0)->getNumPasses() == 0)
material->getTechnique(0)->createPass();
if (material->getTechnique(0)->getPass(0) &&
material->getTechnique(0)->getPass(0)->getNumTextureUnitStates() == 0)
material->getTechnique(0)->getPass(0)->createTextureUnitState(texture_name_);
}
connect(this, SIGNAL(ParentEntitySet()), SLOT(ParentEntitySet()), Qt::UniqueConnection);
}
void RoR::SkinManager::ReplaceMaterialTextures(SkinDef* skin_def, std::string materialName) // Static
{
const auto not_found = skin_def->replace_textures.end();
Ogre::MaterialPtr mat = RoR::OgreSubsystem::GetMaterialByName(materialName);
if (!mat.isNull())
{
for (int t = 0; t < mat->getNumTechniques(); t++)
{
Ogre::Technique* tech = mat->getTechnique(0);
if (!tech)
continue;
for (int p = 0; p < tech->getNumPasses(); p++)
{
Ogre::Pass* pass = tech->getPass(p);
if (!pass)
continue;
for (int tu = 0; tu < pass->getNumTextureUnitStates(); tu++)
{
Ogre::TextureUnitState* tus = pass->getTextureUnitState(tu);
if (!tus)
continue;
//if (tus->getTextureType() != TEX_TYPE_2D) continue; // only replace 2d images
// walk the frames, usually there is only one
for (unsigned int fr = 0; fr < tus->getNumFrames(); fr++)
{
Ogre::String textureName = tus->getFrameTextureName(fr);
std::map<Ogre::String, Ogre::String>::iterator it = skin_def->replace_textures.find(textureName);
if (it != not_found)
{
textureName = it->second; //getReplacementForTexture(textureName);
tus->setFrameTextureName(textureName, fr);
}
}
}
}
}
}
}
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);
}
}
}
}
}
}
}
Ogre::MaterialPtr gkMaterialLoader::createRTSSMaterial(const gkString& matName, bool enableLight)
{
#ifdef OGREKIT_USE_RTSHADER_SYSTEM
Ogre::RTShader::ShaderGenerator* shaderGenerator = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
GK_ASSERT(shaderGenerator);
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().getByName(matName,
Ogre::ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
if (material.isNull())
{
material = Ogre::MaterialManager::getSingleton().create(matName,
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
}
material->setLightingEnabled(enableLight);
shaderGenerator->createShaderBasedTechnique(matName,
Ogre::MaterialManager::DEFAULT_SCHEME_NAME, Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME);
shaderGenerator->validateMaterial(Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME, matName);
if (material->getNumTechniques() > 1)
{
material->getTechnique(0)->getPass(0)->setVertexProgram(
material->getTechnique(1)->getPass(0)->getVertexProgram()->getName());
material->getTechnique(0)->getPass(0)->setFragmentProgram(
material->getTechnique(1)->getPass(0)->getFragmentProgram()->getName());
}
GK_ASSERT(!material->getTechnique(0)->getPass(0)->getVertexProgram().isNull());
GK_ASSERT(!material->getTechnique(0)->getPass(0)->getFragmentProgram().isNull());
return material;
#else
return Ogre::MaterialPtr();
#endif
}
void Animation::addEffect(const std::string &model, int effectId, bool loop, const std::string &bonename, std::string texture)
{
// Early out if we already have this effect
for (std::vector<EffectParams>::iterator it = mEffects.begin(); it != mEffects.end(); ++it)
if (it->mLoop && loop && it->mEffectId == effectId && it->mBoneName == bonename)
return;
// fix texture extension to .dds
if (texture.size() > 4)
{
texture[texture.size()-3] = 'd';
texture[texture.size()-2] = 'd';
texture[texture.size()-1] = 's';
}
EffectParams params;
params.mModelName = model;
if (bonename.empty())
params.mObjects = NifOgre::Loader::createObjects(mInsert, model);
else
params.mObjects = NifOgre::Loader::createObjects(mSkelBase, bonename, mInsert, model);
// TODO: turn off shadow casting
setRenderProperties(params.mObjects, RV_Misc,
RQG_Main, RQG_Alpha, 0.f, false, NULL);
params.mLoop = loop;
params.mEffectId = effectId;
params.mBoneName = bonename;
for(size_t i = 0;i < params.mObjects->mControllers.size();i++)
{
if(params.mObjects->mControllers[i].getSource().isNull())
params.mObjects->mControllers[i].setSource(Ogre::SharedPtr<EffectAnimationTime> (new EffectAnimationTime()));
}
if (!texture.empty())
{
for(size_t i = 0;i < params.mObjects->mParticles.size(); ++i)
{
Ogre::ParticleSystem* partSys = params.mObjects->mParticles[i];
Ogre::MaterialPtr mat = params.mObjects->mMaterialControllerMgr.getWritableMaterial(partSys);
for (int t=0; t<mat->getNumTechniques(); ++t)
{
Ogre::Technique* tech = mat->getTechnique(t);
for (int p=0; p<tech->getNumPasses(); ++p)
{
Ogre::Pass* pass = tech->getPass(p);
for (int tex=0; tex<pass->getNumTextureUnitStates(); ++tex)
{
Ogre::TextureUnitState* tus = pass->getTextureUnitState(tex);
tus->setTextureName("textures\\" + texture);
}
}
}
}
}
mEffects.push_back(params);
}
bool ShaderManager::checkMaterial(const std::string& materialName, const std::string& schemeName)
{
// OGRE scheme is switched in caller
Ogre::MaterialPtr material = static_cast<Ogre::MaterialPtr>(Ogre::MaterialManager::getSingleton().load(materialName, "General"));
if (material->getNumSupportedTechniques() == 0) {
S_LOG_INFO("The material '" << material->getName() << "' has no supported techniques with scheme " << schemeName << ". The reason for this is: \n" << material->getUnsupportedTechniquesExplanation());
return false;
}
S_LOG_INFO("The material '" << material->getName() << "' has " << material->getNumSupportedTechniques() << " supported techniques out of " << material->getNumTechniques());
// Check that we use desired scheme, but not fallbacked to default
if (material->getBestTechnique()->getSchemeName() != schemeName) {
S_LOG_INFO("The material '" << material->getName() << "' has best supported scheme " << material->getBestTechnique()->getSchemeName() << ". Was looking for " << schemeName);
return false;
}
S_LOG_INFO("The material '" << material->getName() << "' supported with scheme " << schemeName);
return true;
}
/****************************************************************************
**
** 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 MeshObject::loadMesh()
{
try
{
Ogre::String resourceGroup = Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME;
mesh = static_cast<Ogre::MeshPtr>(Ogre::MeshManager::getSingleton().create(meshName, resourceGroup));
if(backgroundLoading)
{
mesh->setBackgroundLoaded(true);
mesh->addListener(this);
ticket = Ogre::ResourceBackgroundQueue::getSingleton().load(
Ogre::MeshManager::getSingletonPtr()->getResourceType(),
mesh->getName(),
resourceGroup,
false,
0,
0,
0);
// try to load its textures in the background
for(int i=0; i<mesh->getNumSubMeshes(); i++)
{
SubMesh *sm = mesh->getSubMesh(i);
String materialName = sm->getMaterialName();
Ogre::MaterialPtr mat = static_cast<Ogre::MaterialPtr>(Ogre::MaterialManager::getSingleton().getByName(materialName)); //, resourceGroup));
if(mat.isNull()) continue;
for(int tn=0; tn<mat->getNumTechniques(); tn++)
{
Technique *t = mat->getTechnique(tn);
for(int pn=0; pn<t->getNumPasses(); pn++)
{
Pass *p = t->getPass(pn);
for(int tun=0; tun<p->getNumTextureUnitStates(); tun++)
{
TextureUnitState *tu = p->getTextureUnitState(tun);
String textureName = tu->getTextureName();
// now add this texture to the background loading queue
Ogre::TexturePtr tex = static_cast<Ogre::TexturePtr>(Ogre::TextureManager::getSingleton().create(textureName, resourceGroup));
tex->setBackgroundLoaded(true);
tex->addListener(this);
ticket = Ogre::ResourceBackgroundQueue::getSingleton().load(
Ogre::TextureManager::getSingletonPtr()->getResourceType(),
tex->getName(),
resourceGroup,
false,
0,
0,
0);
}
}
}
}
}
if(!backgroundLoading)
postProcess();
}
catch (Ogre::Exception* e)
{
LOG("exception while loading mesh: " + e->getFullDescription());
}
}
CFakeObjectEntityManager::FakeObjectMap::iterator CFakeObjectEntityManager::_GetFakeNode(LPCTSTR szNodeName, tEntityNode* pNode, LPCTSTR szCameraName, int nTexWidth, int nTexHeight, LPCTSTR szBackgroundName)
{
//缺省摄像机的位置
static const float s_fHeight = 0.8f;
static const float s_fDistance = 3.2f;
static const float s_fPitch = 0.21f;
FakeObjectMap::iterator it = m_mapObject.find(szNodeName);
if(it != m_mapObject.end()) return it;
//不存在，创建
FakeObject newNode;
newNode.strName = szNodeName;
//--------------------------------------------------
//创建RenderTarget
Ogre::TexturePtr ptrTex =
Ogre::TextureManager::getSingleton().createManual(
Ogre::String(szNodeName) + "_RenderTexture",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Ogre::TEX_TYPE_2D,
nTexWidth, nTexHeight, 1, 0,
Ogre::PF_R8G8B8A8,
Ogre::TU_RENDERTARGET,
0);
//ptrTex->load();
newNode.ptrRenderTexture = ptrTex;
Ogre::RenderTexture* pTexture = ptrTex->getBuffer()->getRenderTarget();
//缺省不刷新
pTexture->setAutoUpdated(false);
pTexture->addListener(&g_theListener);
//--------------------------------------------------
//放置摄像机
Ogre::SceneManager* pScnManager = CEngineInterface::GetMe()->GetFairySystem()->getSceneManager();
newNode.pCamera = pScnManager->createCamera(Ogre::String(szNodeName) + "_Camera");
//放缩系数
fVector3 fvScale = CEngineInterface::GetMe()->GetSacle();
newNode.fCameraHeight=s_fHeight;
newNode.fCameraDistance=s_fDistance;
newNode.fCameraPitch=s_fPitch;
STRING szUserCameraValue;
pNode->Actor_GetObjectProperty(szCameraName, szUserCameraValue);
// if(szUserCameraValue.size() > 2 && szUserCameraValue.find(';') != STRING::npos)
// {
// sscanf(szUserCameraValue.c_str(), "%f;%f", &(newNode.fCameraHeight), &(newNode.fCameraDistance));
// }
int Row_Index;
Row_Index = atoi(szUserCameraValue.c_str());
const tDataBase* pDBC = g_pDataBase->GetDataBase(DBC_MODEL_PARAMETER);
KLAssert(pDBC);
const _DBC_MODEL_PARAMETER* pParameter = NULL;
pParameter = (const _DBC_MODEL_PARAMETER*)((tDataBase*)pDBC)->Search_Index_EQU(Row_Index);
if(pParameter)
{
newNode.fCameraHeight = pParameter->nHeight;
newNode.fCameraDistance = pParameter->nDistance;
}
//设置摄像机
_UpdateCamera(newNode);
newNode.pCamera->setNearClipDistance(10.f);
newNode.pCamera->setAspectRatio((float)nTexWidth/nTexHeight);
newNode.pCamera->setFOVy(Ogre::Degree(45.0f)); // 经验值
newNode.pCamera->setProjectionType(Ogre::PT_PERSPECTIVE); //透视投影 (平行投影 Ogre::PT_ORTHOGRAPHIC)
//--------------------------------------------------
//创建ViewPort
newNode.pViewPort = pTexture->addViewport(newNode.pCamera, 1);
newNode.pViewPort->setClearEveryFrame(true);
newNode.pViewPort->setBackgroundColour(Ogre::ColourValue(0,0,0,0));
newNode.pViewPort->setOverlaysEnabled(false);
newNode.pViewPort->setSkiesEnabled(false);
newNode.pViewPort->setShadowsEnabled(false);
//--------------------------------------------------
//创建rectangle(如果纹理名称不为空并且所需的material template存在)
Ogre::String backgroundTexName(szBackgroundName);
Ogre::MaterialPtr originMat = Ogre::MaterialManager::getSingleton().getByName("UIModelBackground");
if (false == backgroundTexName.empty() && false == originMat.isNull())
{
newNode.pRectange = new Ogre::Rectangle2D(true);
newNode.pRectange->setCorners(-1.0f, 1.0f, 1.0f, -1.0f);
Ogre::String cloneMatName = Ogre::String(szNodeName) + "_Rectangle";
Ogre::MaterialPtr cloneMat = Ogre::MaterialManager::getSingleton().getByName(cloneMatName);
if (cloneMat.isNull())
{
cloneMat = originMat->clone(cloneMatName);
if (cloneMat->getNumTechniques())
{
Ogre::Technique* tech = cloneMat->getTechnique(0);
if (tech->getNumPasses())
{
Ogre::Pass* pass = tech->getPass(0);
if (pass->getNumTextureUnitStates())
{
Ogre::TextureUnitState* tex = pass->getTextureUnitState(0);
tex->setTextureName(szBackgroundName);
}
}
}
}
newNode.pRectange->setMaterial(cloneMat->getName());
newNode.pRectange->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND);
newNode.pRectange->setVisibilityFlags(Fairy::OVF_GUI_ELEMENTS);
// 设置boundingbox为无限大，以防被camera剔除掉（默认的包围盒大小为-1，1）
newNode.pRectange->setBoundingBox(
Ogre::AxisAlignedBox(
Ogre::Vector3(Ogre::Math::NEG_INFINITY, Ogre::Math::NEG_INFINITY, Ogre::Math::NEG_INFINITY),
Ogre::Vector3(Ogre::Math::POS_INFINITY, Ogre::Math::POS_INFINITY, Ogre::Math::POS_INFINITY)
) );
Ogre::SceneNode* parentNode =
CEngineInterface::GetMe()->GetFairySystem()->getBaseSceneNode()->createChildSceneNode();
parentNode->attachObject(newNode.pRectange);
}
//--------------------------------------------------
//加入Map
m_mapObject.insert(std::make_pair(newNode.strName, newNode));
it = m_mapObject.find(newNode.strName);
KLAssert(it != m_mapObject.end());
//加入索引Map
m_mapIndexOfViewPort.insert(std::make_pair(newNode.pViewPort, &(it->second)));
return it;
}
bool OgreMaterialResource::SetData(Foundation::AssetPtr source)
{
// Remove old material if any
RemoveMaterial();
references_.clear();
original_textures_.clear();
Ogre::MaterialManager& matmgr = Ogre::MaterialManager::getSingleton();
OgreRenderingModule::LogDebug("Parsing material " + source->GetId());
if (!source)
{
OgreRenderingModule::LogError("Null source asset data pointer");
return false;
}
if (!source->GetSize())
{
OgreRenderingModule::LogError("Zero sized material asset");
return false;
}
Ogre::DataStreamPtr data = Ogre::DataStreamPtr(new Ogre::MemoryDataStream(const_cast<u8 *>(source->GetData()), source->GetSize()));
static int tempname_count = 0;
tempname_count++;
std::string tempname = "TempMat" + ToString<int>(tempname_count);
try
{
int num_materials = 0;
int brace_level = 0;
bool skip_until_next = false;
int skip_brace_level = 0;
// Parsed/modified material script
std::ostringstream output;
while (!data->eof())
{
Ogre::String line = data->getLine();
// Skip empty lines & comments
if ((line.length()) && (line.substr(0, 2) != "//"))
{
// Process opening/closing braces
if (!ResourceHandler::ProcessBraces(line, brace_level))
{
// If not a brace and on level 0, it should be a new material; replace name
if ((brace_level == 0) && (line.substr(0, 8) == "material"))
{
if (num_materials == 0)
{
line = "material " + tempname;
++num_materials;
}
else
{
OgreRenderingModule::LogWarning("More than one material defined in material asset " + source->GetId() + " - only first one supported");
break;
}
}
else
{
// Check for textures
if ((line.substr(0, 8) == "texture ") && (line.length() > 8))
{
std::string tex_name = line.substr(8);
// Note: we assume all texture references are asset based. ResourceHandler checks later whether this is true,
// before requesting the reference
references_.push_back(Foundation::ResourceReference(tex_name, OgreTextureResource::GetTypeStatic()));
original_textures_.push_back(tex_name);
// Replace any / with \ in the material, then change the texture names back later, so that Ogre does not go nuts
ReplaceCharInplace(line, '/', '\\');
ReplaceCharInplace(line, ':', '@');
}
}
// Write line to the modified copy
if (!skip_until_next)
output << line << std::endl;
}
else
{
// Write line to the modified copy
if (!skip_until_next)
output << line << std::endl;
if (brace_level <= skip_brace_level)
skip_until_next = false;
}
}
}
std::string output_str = output.str();
Ogre::DataStreamPtr modified_data = Ogre::DataStreamPtr(new Ogre::MemoryDataStream((u8 *)(&output_str[0]), output_str.size()));
matmgr.parseScript(modified_data, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Ogre::MaterialPtr tempmat;
tempmat = matmgr.getByName(tempname);
if (tempmat.isNull())
{
OgreRenderingModule::LogWarning(std::string("Failed to create an Ogre material from material asset ") +
source->GetId());
return false;
}
if(!tempmat->getNumTechniques())
{
OgreRenderingModule::LogWarning("Failed to create an Ogre material from material asset " +
source->GetId());
return false;
}
ogre_material_ = tempmat->clone(id_);
tempmat.setNull();
matmgr.remove(tempname);
if (ogre_material_.isNull())
{
OgreRenderingModule::LogWarning("Failed to create an Ogre material from material asset " +
source->GetId());
return false;
}
// Now go through all the texturenames and restore \ back to / and @ to :
Ogre::Material::TechniqueIterator iter = ogre_material_->getTechniqueIterator();
while (iter.hasMoreElements())
{
Ogre::Technique *tech = iter.getNext();
Ogre::Technique::PassIterator passIter = tech->getPassIterator();
while (passIter.hasMoreElements())
{
Ogre::Pass *pass = passIter.getNext();
Ogre::Pass::TextureUnitStateIterator texIter = pass->getTextureUnitStateIterator();
while (texIter.hasMoreElements())
{
Ogre::TextureUnitState *texUnit = texIter.getNext();
std::string texname = texUnit->getTextureName();
if (texname.find('\\') != std::string::npos)
{
ReplaceCharInplace(texname, '\\', '/');
ReplaceCharInplace(texname, '@', ':');
texUnit->setTextureName(texname);
}
}
}
}
//workaround: if receives shadows, check the amount of shadowmaps. If only 1 specified, add 2 more to support 3 shadowmaps
if(ogre_material_->getReceiveShadows() && shadowquality_ == Shadows_High && ogre_material_->getNumTechniques() > 0)
{
Ogre::Technique *tech = ogre_material_->getTechnique(0);
if(tech)
{
Ogre::Technique::PassIterator passiterator = tech->getPassIterator();
while(passiterator.hasMoreElements())
{
Ogre::Pass* pass = passiterator.getNext();
Ogre::Pass::TextureUnitStateIterator texiterator = pass->getTextureUnitStateIterator();
int shadowmaps = 0;
while(texiterator.hasMoreElements())
{
Ogre::TextureUnitState* state = texiterator.getNext();
if(state->getContentType() == Ogre::TextureUnitState::CONTENT_SHADOW)
{
shadowmaps++;
}
}
if(shadowmaps>0 && shadowmaps<3)
{
Ogre::TextureUnitState* sm2 = pass->createTextureUnitState();
sm2->setContentType(Ogre::TextureUnitState::CONTENT_SHADOW);
Ogre::TextureUnitState* sm3 = pass->createTextureUnitState();
sm3->setContentType(Ogre::TextureUnitState::CONTENT_SHADOW);
}
}
}
}
} catch (Ogre::Exception &e)
{
OgreRenderingModule::LogWarning(e.what());
OgreRenderingModule::LogWarning("Failed to parse Ogre material " + source->GetId() + ".");
try
{
if (!matmgr.getByName(tempname).isNull())
Ogre::MaterialManager::getSingleton().remove(tempname);
}
catch (...) {}
return false;
}
return true;
}