//---------------------------------------------------------------------
bool SubMesh::updateMaterialUsingTextureAliases(void)
{
bool newMaterialCreated = false;
// if submesh has texture aliases
// ask the material manager if the current summesh material exists
if (hasTextureAliases() && MaterialManager::getSingleton().resourceExists(mMaterialName))
{
// get the current submesh material
MaterialPtr material = MaterialManager::getSingleton().getByName( mMaterialName );
// get test result for if change will occur when the texture aliases are applied
if (material->applyTextureAliases(mTextureAliases, false))
{
Ogre::String newMaterialName;
// If this material was already derived from another material
// due to aliasing, let's strip off the aliasing suffix and
// generate a new one using our current aliasing table.
Ogre::String::size_type pos = mMaterialName.find("?TexAlias(", 0);
if( pos != Ogre::String::npos )
newMaterialName = mMaterialName.substr(0, pos);
else
newMaterialName = mMaterialName;
newMaterialName += "?TexAlias(";
// Iterate deterministically over the aliases (always in the same
// order via std::map's sorted iteration nature).
AliasTextureIterator aliasIter = getAliasTextureIterator();
while( aliasIter.hasMoreElements() )
{
newMaterialName += aliasIter.peekNextKey();
newMaterialName += "=";
newMaterialName += aliasIter.getNext();
newMaterialName += " ";
}
newMaterialName += ")";
// Reuse the material if it's already been created. This decreases batch
// count and keeps material explosion under control.
if(!MaterialManager::getSingleton().resourceExists(newMaterialName))
{
Ogre::MaterialPtr newMaterial = Ogre::MaterialManager::getSingleton().create(
newMaterialName, material->getGroup());
// copy parent material details to new material
material->copyDetailsTo(newMaterial);
// apply texture aliases to new material
newMaterial->applyTextureAliases(mTextureAliases);
}
// place new material name in submesh
setMaterialName(newMaterialName);
newMaterialCreated = true;
}
}
return newMaterialCreated;
}
//-----------------------------------------------------------------------
PrimitiveShapeSet::PrimitiveShapeSet(void) :
mBoundingRadius(0.0f),
mWorldSpace(false),
mCullIndividual(false),
mZRotated(false),
mAllDefaultSize(true)
{
setMaterialName("BaseWhite");
mCastShadows = false;
}
//-----------------------------------------------------------------------
PrimitiveShapeSet::PrimitiveShapeSet(const Ogre::String& name, unsigned int poolSize, bool externalData) :
MovableObject(name),
mBoundingRadius(0.0f),
mWorldSpace(false),
mCullIndividual(false),
mZRotated(false),
mAllDefaultSize(true)
{
setMaterialName("BaseWhite");
mCastShadows = false;
}
void Main::onInitialize() {
auto scene = addScene(new dt::Scene("testscene"));
dt::ResourceManager::get()->addResourceLocation("sinbad.zip","Zip", true);
dt::ResourceManager::get()->addResourceLocation("particle/","FileSystem", true);
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// make a scene
auto camnode = scene->addChildNode(new dt::Node("camnode"));
camnode->setPosition(Ogre::Vector3(0, 2, 10));
camnode->addComponent(new dt::CameraComponent("cam"))->lookAt(Ogre::Vector3(0, 2, 0));;
auto p = scene->addChildNode(new dt::Node("p"));
p->setScale(0.2);
auto mesh = p->addComponent(new dt::MeshComponent("Sinbad.mesh"));
mesh->setAnimation("RunBase");
mesh->setLoopAnimation(true);
mesh->playAnimation();
auto path =
p->addComponent(new dt::FollowPathComponent(dt::FollowPathComponent::LOOP));
path->addPoint(Ogre::Vector3(-10, 0, 0));
path->addPoint(Ogre::Vector3(10, 0, 0));
path->setDuration(2.f);
path->setFollowRotation(true);
// create the particle system
auto p_sys = p->addComponent(new dt::ParticleSystemComponent("p_sys"));
p_sys->setMaterialName("Test/Particle");
p_sys->setParticleCountLimit(1000);
p_sys->getOgreParticleSystem()->setDefaultDimensions(0.03, 0.03);
Ogre::ParticleEmitter* e = p_sys->addEmitter("emit1", "Point");
e->setAngle(Ogre::Degree(10));
e->setColour(Ogre::ColourValue(1.f, 0.6f, 0.f), Ogre::ColourValue(0.2f, 0.8f, 0.2f));
e->setEmissionRate(100);
e->setParticleVelocity(3.f, 4.f);
e->setTimeToLive(1.f, 2.f);
p_sys->addScalerAffector("scaler", 1.05);
p_sys->addLinearForceAffector("force", Ogre::Vector3(0, 5, 0));
Ogre::ParticleAffector* a = p_sys->addAffector("colour_interpolator", "ColourInterpolator");
a->setParameter("time0", "0");
a->setParameter("colour0", "1 1 0 1");
a->setParameter("time1", "0.5");
a->setParameter("colour1", "1 0.3 0 1");
a->setParameter("time2", "1");
a->setParameter("colour2", "1 0 0 0");
}
void TrussMaterial::loadFromXML ( const QDomElement& materialElem )
/*throw (LoadException)*/
{
XMLSerializableObject::loadFromXML( materialElem );
/**
* Set name
**************/
if ( ! materialElem.hasAttribute( "name" ) )
throw LoadException();
QString name = materialElem.attribute( "name" );
setMaterialName( name );
/**
* Set working stress
***************************/
if ( ! materialElem.hasAttribute( "workingStress" ) )
throw LoadException();
bool ok;
double stress = materialElem.attribute( "workingStress" ).toDouble( &ok );
if ( !ok ) throw LoadException();
setWorkingStress( stress );
/**
* Set elasticity module
***************************/
if ( ! materialElem.hasAttribute( "elasticityModule" ) )
throw LoadException();
double elast =
materialElem.attribute( "elasticityModule" ).toDouble( &ok );
if ( !ok ) throw LoadException();
setElasticityModule( elast );
/**
* Set density
******************/
if ( ! materialElem.hasAttribute( "density" ) )
throw LoadException();
double dens = materialElem.attribute( "density" ).toDouble( &ok );
if ( !ok ) throw LoadException();
setDensity( dens );
}
MovableTextOverlayAttributes::MovableTextOverlayAttributes(const Ogre::String & name, const Ogre::Camera *cam,
const Ogre::String & fontName, int charHeight, const Ogre::ColourValue & color, const Ogre::String & materialName)
: mpCam(cam)
, mpFont(NULL)
, mName(name)
, mFontName("")
, mMaterialName("")
, mCharHeight(charHeight)
, mColor(ColourValue::ZERO)
{
if (fontName.length() == 0)
Ogre::Exception(Ogre::Exception::ERR_INVALIDPARAMS, "Invalid font name", "MovableTextOverlayAttributes::MovableTextOverlayAttributes");
setFontName(fontName);
setMaterialName(materialName);
setColor(color);
}
//-----------------------------------------------------------------------
SubEntity::SubEntity (Entity* parent, SubMesh* subMeshBasis)
: Renderable(), mParentEntity(parent),
mSubMesh(subMeshBasis), mMaterialLodIndex(0), mCachedCamera(0)
{
mVisible = true;
mRenderQueueID = 0;
mRenderQueueIDSet = false;
mRenderQueuePrioritySet = false;
mSkelAnimVertexData = 0;
mVertexAnimationAppliedThisFrame = false;
mSoftwareVertexAnimVertexData = 0;
mHardwareVertexAnimVertexData = 0;
mHardwarePoseCount = 0;
mIndexStart = 0;
mIndexEnd = 0;
setMaterialName("BaseWhite");
}
void edTerrainNode::load(std::istream &stream, int version, CollectNodes *cn)
{
edPoint *p1;
edPoint *p2;
edPoint *p3;
edNode::load(stream, version, cn);
unsigned int n= 0;
stream.read((char*)&n,sizeof(n));
unsigned int ptUID, UID;
triangles.resize(n);
for (unsigned int i=0; i<n; i++)
{
stream.read((char*)&ptUID,sizeof(ptUID));
p1= cn->ptsList[ptUID];
stream.read((char*)&ptUID,sizeof(ptUID));
p2= cn->ptsList[ptUID];
stream.read((char*)&ptUID,sizeof(ptUID));
p3= cn->ptsList[ptUID];
triangles[i].set(p1,p2,p3);
p1->addTerrainOwner(this);
p2->addTerrainOwner(this);
p3->addTerrainOwner(this);
}
if(version<6)
{
stream.read((char*)&UID,sizeof(UID));
_materialName = v5materials[UID];
} else {
_materialName = readS(stream);
};
setMaterialName(_materialName.c_str());
if (version<2)
{
osg::Matrixd texMat;
stream.read((char*)texMat.ptr(),sizeof(osg::Matrixd::value_type)*16);
}
}
void ParticleTracer::parseAttrList(AttributeList *att)
{
AttributeList *tempAtt = mpAttrs;
mpAttrs = att;
mNumInitialParts = mpAttrs->readInt("particles",mNumInitialParts, "ParticleTracer","mNumInitialParts", false);
//errMsg(" NUMP"," "<<mNumInitialParts);
mPartScale = mpAttrs->readFloat("part_scale",mPartScale, "ParticleTracer","mPartScale", false);
mPartHeadDist = mpAttrs->readFloat("part_headdist",mPartHeadDist, "ParticleTracer","mPartHeadDist", false);
mPartTailDist = mpAttrs->readFloat("part_taildist",mPartTailDist, "ParticleTracer","mPartTailDist", false);
mPartSegments = mpAttrs->readInt ("part_segments",mPartSegments, "ParticleTracer","mPartSegments", false);
mValueScale = mpAttrs->readInt ("part_valscale",mValueScale, "ParticleTracer","mValueScale", false);
mValueCutoffTop = mpAttrs->readFloat("part_valcutofftop",mValueCutoffTop, "ParticleTracer","mValueCutoffTop", false);
mValueCutoffBottom = mpAttrs->readFloat("part_valcutoffbottom",mValueCutoffBottom, "ParticleTracer","mValueCutoffBottom", false);
mDumpParts = mpAttrs->readInt ("part_dump",mDumpParts, "ParticleTracer","mDumpParts", false);
// mDumpText deprecatd, use mDumpTextInterval>0. instead
mShowOnly = mpAttrs->readInt ("part_showonly",mShowOnly, "ParticleTracer","mShowOnly", false);
mDumpTextFile= mpAttrs->readString("part_textdumpfile",mDumpTextFile, "ParticleTracer","mDumpTextFile", false);
mDumpTextInterval= mpAttrs->readFloat("part_textdumpinterval",mDumpTextInterval, "ParticleTracer","mDumpTextInterval", false);
string matPart;
matPart = mpAttrs->readString("material_part", "default", "ParticleTracer","material", false);
setMaterialName( matPart );
mInitStart = mpAttrs->readFloat("part_initstart",mInitStart, "ParticleTracer","mInitStart", false);
mInitEnd = mpAttrs->readFloat("part_initend", mInitEnd, "ParticleTracer","mInitEnd", false);
// unused...
//int mTrailLength = 0; // UNUSED
//int mTrailInterval= 0; // UNUSED
mTrailLength = mpAttrs->readInt("traillength",mTrailLength, "ParticleTracer","mTrailLength", false);
mTrailInterval= mpAttrs->readFloat("trailinterval",mTrailInterval, "ParticleTracer","mTrailInterval", false);
// restore old list
mpAttrs = tempAtt;
}
//---------------------------------------------------------------------
bool SubMesh::updateMaterialUsingTextureAliases(void)
{
bool newMaterialCreated = false;
// if submesh has texture aliases
// ask the material manager if the current summesh material exists
if (hasTextureAliases() && MaterialManager::getSingleton().resourceExists(mMaterialName))
{
// get the current submesh material
MaterialPtr material = MaterialManager::getSingleton().getByName( mMaterialName );
// get test result for if change will occur when the texture aliases are applied
if (material->applyTextureAliases(mTextureAliases, false))
{
// material textures will be changed so copy material,
// new material name is old material name + index
// check with material manager and find a unique name
size_t index = 0;
String newMaterialName = mMaterialName + "_" + StringConverter::toString(index);
while (MaterialManager::getSingleton().resourceExists(newMaterialName))
{
// increment index for next name
newMaterialName = mMaterialName + "_" + StringConverter::toString(++index);
}
Ogre::MaterialPtr newMaterial = Ogre::MaterialManager::getSingleton().create(
newMaterialName, material->getGroup());
// copy parent material details to new material
material->copyDetailsTo(newMaterial);
// apply texture aliases to new material
newMaterial->applyTextureAliases(mTextureAliases);
// place new material name in submesh
setMaterialName(newMaterialName);
newMaterialCreated = true;
}
}
return newMaterialCreated;
}
//-----------------------------------------------------------------------
void MeshParticleRenderer::_setMaterial(MaterialPtr& mat)
{
setMaterialName(mat->getName());
}
MovableTextOverlayAttributes::~MovableTextOverlayAttributes()
{
setFontName("");
setMaterialName("");
}
void App::createScene()
{
#pragma region Plane
// Define the mathematical plane
Ogre::Plane plane(Vector3::UNIT_Y, 0);
// Create the plane into memory
Ogre::MeshManager::getSingleton().createPlane(
"plane",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
plane,
500, 500, // size
25, 25, // how many quads are used to make the plane
true,
1, 5, 5, Vector3::UNIT_Z);
// Create an instance of the plane
auto planeEnt = mSceneMgr->createEntity("PlaneEntity", "plane");
planeEnt->setMaterialName("Examples/BeachStones");
// Create a node for the plane and attach he plane to it
mSceneMgr->getRootSceneNode()->createChildSceneNode("planeNode")->attachObject(planeEnt);
#pragma endregion
#pragma region Lights
// Directional
auto sunlight = mSceneMgr->createLight("sun");
sunlight->setType(Ogre::Light::LT_DIRECTIONAL);
sunlight->setDirection(Ogre::Vector3(0, -1, -1));
sunlight->setDiffuseColour(Ogre::ColourValue(.30, .30, 0));
sunlight->setSpecularColour(Ogre::ColourValue(.30, .30, 0));
// Spotlight
auto spotlight = mSceneMgr->createLight("spotlight");
spotlight->setType(Ogre::Light::LT_SPOTLIGHT);
spotlight->setSpotlightRange(
Ogre::Degree(5.0f), // inner angle
Ogre::Degree(15.0f), // outer angle
0.0f); // falloff
spotlight->setDiffuseColour(Ogre::ColourValue(1.0f, 0.0f, 0.0f));
// Sphere to visualize the spotlights source
auto sphereEnt = mSceneMgr->createEntity("sphere", "sphere.mesh");
sphereEnt->setMaterialName("Examples/checker");
auto sphereNode = mSceneMgr->getSceneNode("planeNode")->createChildSceneNode("spotlightNode");
sphereNode->attachObject(sphereEnt);
sphereNode->attachObject(spotlight);
sphereNode->scale(0.02f, 0.02f, 0.02f);
sphereNode->translate(0.0f, 15.0f, 0.0f);
sphereNode->lookAt(Ogre::Vector3(0, 0, 0), Ogre::Node::TS_PARENT);
#pragma endregion
#pragma region Entities
std::array<Ogre::Entity*, 6> entities;
auto entParentNode = mSceneMgr->getSceneNode("planeNode")->createChildSceneNode("entParentNode");
float angleOffset = 360.0f / 6.0f;
float radius = 30.0f;
for (int i = 0; i < entities.size(); ++i)
{
auto e = mSceneMgr->createEntity("Sinbad.mesh");
entParentNode->createChildSceneNode(Ogre::Vector3(
radius * Math::Cos(Math::DegreesToRadians(angleOffset * i)), // x = r cos(t)
6.75f, // y = height
radius * Math::Sin(Math::DegreesToRadians(angleOffset * i)))) // z = r sin(t)
->attachObject(e);
}
// Barrel
auto barrel = mSceneMgr->createEntity("barrel.mesh");
mSceneMgr->getSceneNode("planeNode")->createChildSceneNode("barrel", Ogre::Vector3(0, 2.5f, 0))->attachObject(barrel);
#pragma endregion
// Skybox
mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox", 5000, false);
}
