void AIManager::SetEnabled(bool state)
{
if (state)
{
LOG_F_MSG("ai", "AI Engine enabled");
}
else
{
LOG_F_MSG("ai", "AI Engine disabled");
}
mEnabled = state;
}
/**
* Load this object from a template
* @param objTemplate template to load from
* @return true if success
*/
bool SceneObject::LoadFromTemplate( ObjectTemplatePtr objTemplate, const SimEntityData& data )
{
if( !objTemplate )
return false;
Assert( objTemplate->mpSimFactory );
// cast to object template to the type we expect
mSceneObjectTemplate = static_pointer_cast< SceneObjectTemplate, ObjectTemplate>( objTemplate );
IrrFactory& irrFactory = mSceneObjectTemplate->mpSimFactory->getIrrFactory();
// are we an animated mesh?
if( mSceneObjectTemplate->mAniMesh )
{
mAniSceneNode = irrFactory.addAnimatedMeshSceneNode( mSceneObjectTemplate->mAniMesh.get() );
if (mSceneObjectTemplate->mCastsShadow)
{
mAniSceneNode->addShadowVolumeSceneNode();
}
mFPSCamera = mSceneObjectTemplate->mFPSCamera; // reminder to attach camera later
mAniSceneNode->setAnimationSpeed(0);
mStartFrame = mAniSceneNode->getStartFrame();
mEndFrame = mAniSceneNode->getEndFrame();
mAniSceneNode->setFrameLoop(0,0);
mAniSceneNode->setCurrentFrame(0);
mSceneNode = mAniSceneNode;
}
// are we a terrain?
else if( mSceneObjectTemplate->mHeightmap != "" )
{
mTerrSceneNode = irrFactory.addTerrainSceneNode( mSceneObjectTemplate->mHeightmap.c_str() );
mSceneNode = mTerrSceneNode;
mTerrSceneNode->scaleTexture( mSceneObjectTemplate->mScaleTexture.X, mSceneObjectTemplate->mScaleTexture.Y );
}
// are we a particle system?
else if( mSceneObjectTemplate->mParticleSystem != "" )
{
mParticleSystemNode = irrFactory.addParticleSystemNode( mSceneObjectTemplate->mParticleSystem );
mSceneNode = mParticleSystemNode;
// don't add a triangle selector for a particle node
}
if( mSceneNode )
{
// assign the textures
for( uint32_t i = 0; i < (uint32_t)mSceneObjectTemplate->mTextures.size(); ++i )
mSceneNode->setMaterialTexture( i, mSceneObjectTemplate->mTextures[i].get() );
// set the material flags
std::vector<IrrMaterialFlag>::const_iterator flagItr = mSceneObjectTemplate->mMaterialFlags.begin();
std::vector<IrrMaterialFlag>::const_iterator flagEnd = mSceneObjectTemplate->mMaterialFlags.end();
for( ; flagItr != flagEnd; ++flagItr )
mSceneNode->setMaterialFlag( flagItr->mFlag, flagItr->mValue );
// set the material type
mSceneNode->setMaterialType( mSceneObjectTemplate->mMaterialType );
// set the node scale
Vector3f scale = mSceneObjectTemplate->mScale;
/// we can optionally multiply by a custom scale
scale.X = scale.X * data.GetScale().X;
scale.Y = scale.Y * data.GetScale().Y;
scale.Z = scale.Z * data.GetScale().Z;
mSceneNode->setScale( ConvertNeroToIrrlichtPosition(scale) );
// make the id of the scene node the same as the SimId of our object
mSceneNode->setID(ConvertSimIdToSceneId(data.GetId(), data.GetType()));
// set the position of the object
SetPosition( data.GetPosition() );
// set the rotation of the object
SetRotation( data.GetRotation() );
// set up the triangle selector for this object
//if (data.GetType() > 0) {
{
ITriangleSelector_IPtr tri_selector = GetTriangleSelector();
if (!tri_selector) {
LOG_F_WARNING("collision", "could not create triangle selector for collisions with object " << GetId());
}
}
//}
// additionally, add a collision response animator
if (canCollide()) {
// the world will return the triangles that match the type mask
ITriangleSelector* world = new CollideByTypeTriangleSelector(mSceneObjectTemplate->mCollisionMask);
// get the axis-aligned bounding box for the node
BBoxf box = mSceneNode->getBoundingBox();
// use the aabbox to make the ellipsoid for the collision response animator
Vector3f ellipsoid_radius = box.MaxEdge - box.getCenter();
// TODO: might add gravity here
Vector3f gravity(0,0,0);
// ellipsoid translation relative to object coordinates
Vector3f ellipsoid_translation(0,0,0);
mCollider = GetSceneManager()->createCollisionResponseAnimator(
world, mSceneNode.get(), ellipsoid_radius, gravity, ellipsoid_translation);
if (!mCollider) {
LOG_F_ERROR("collision", "could not create Collision Response Animator for object id: " << data.GetId());
} else {
SafeIrrDrop(world); // we don't need the handle
mSceneNode->addAnimator(mCollider.get());
LOG_F_DEBUG("collision",
"added collision response animator for object id: "
<< data.GetId() << " of type: " << data.GetType()
<< " for collision with mask: " << mSceneObjectTemplate->mCollisionMask
<< " with bounding ellipsoid: " << ellipsoid_radius);
}
}
#if SCENEOBJECT_ENABLE_STATS
// debug information
if( mTerrSceneNode )
{
const aabbox3df& bbox = mTerrSceneNode->getBoundingBox();
vector3df dim = bbox.MaxEdge - bbox.MinEdge;
float32_t vol = dim.X * dim.Y * dim.Z;
vol = (vol<0) ? -vol : vol;
LOG_F_MSG( "render", "Added terrain with heightmap: " << mSceneObjectTemplate->mHeightmap );
LOG_F_MSG( "render", " Dim: (" << dim.X << ", " << dim.Y << ", " << dim.Z << ")" );
LOG_F_MSG( "render", " Volume: " << vol );
}
#endif // end SCENEOBJECT_ENABLE_STATS
}
return true;
}
/// constructor
SceneObjectTemplate::SceneObjectTemplate( SimFactoryPtr factory, const PropertyMap& propMap ) :
ObjectTemplate( factory, propMap ),
mScaleTexture(1,1),
mTextures(),
mMaterialFlags(),
mMaterialType( EMT_SOLID ),
mHeightmap(),
mParticleSystem(),
mAniMesh(NULL),
mCastsShadow(false),
mDrawBoundingBox(false),
mDrawLabel(false),
mFPSCamera(),
mAnimationSpeed(25.0f),
mCollisionMask(0)
{
AssertMsg( factory, "Invalid sim factory" );
std::string val, aniMeshFile;
IrrFactory& irrFac = factory->getIrrFactory();
// get the mesh (possibly)
if( propMap.getValue( aniMeshFile, "Template.Render.AniMesh" ) )
{
mAniMesh = irrFac.LoadAniMesh( aniMeshFile.c_str() );
}
if( propMap.hasSection( "Template.Render.CastsShadow" ) )
{
propMap.getValue( mCastsShadow, "Template.Render.CastsShadow" );
}
if( propMap.hasSection( "Template.Render.DrawBoundingBox" ) )
{
propMap.getValue( mDrawBoundingBox, "Template.Render.DrawBoundingBox" );
}
if( propMap.hasSection( "Template.Render.DrawLabel" ) )
{
propMap.getValue( mDrawLabel, "Template.Render.DrawLabel" );
}
if (propMap.hasSection( "Template.Render.FPSCamera" ) )
{
mFPSCamera.reset(new FPSCameraTemplate("Template.Render.FPSCamera", propMap));
LOG_F_DEBUG( "render", "object uses an FPS camera " << mFPSCamera );
}
if (propMap.hasSection( "Template.Render.AnimationSpeed" ) )
{
propMap.getValue( mAnimationSpeed, "Template.Render.AnimationSpeed" );
LOG_F_DEBUG( "render", "object animation speed: " << mAnimationSpeed );
}
if (propMap.hasSection( "Template.Render.Collision" ))
{
propMap.getValue( mCollisionMask, "Template.Render.Collision" );
}
// get the heightmap (possibly)
propMap.getValue( mHeightmap, "Template.Render.Terrain" );
// get the particle system (possibly)
propMap.getValue( mParticleSystem, "Template.Render.ParticleSystem" );
PropertyMap::ChildPropVector renderProps;
propMap.getPropChildren( renderProps, "Template.Render" );
PropertyMap::ChildPropVector::const_iterator itr = renderProps.begin();
PropertyMap::ChildPropVector::const_iterator end = renderProps.end();
// get all the properties of Render
for( ; itr != end; ++itr )
{
// if it starts with the word "Texture" in it (ex: Texture0, Texture1, ...)
if( itr->first.find("Texture") == 0 )
{
ITexture* tex = irrFac.LoadTexture( itr->second );
if( tex )
{
mTextures.push_back( ITexture_IPtr(tex) );
}
}
// if it contains the word "MaterialFlag" in it( ex: MaterialFlagLighting, ... )
if( itr->first.find("MaterialFlag") != std::string::npos )
{
IrrMaterialFlag flag;
IrrMaterialFlagConverter c( itr->first.substr(12) );
c( flag, itr->second );
if( flag.mFlag != (E_MATERIAL_FLAG)-1 )
mMaterialFlags.push_back( flag );
}
}
// get the material type
propMap.getValue( mMaterialType, "Template.Render.MaterialType", IrrMaterialTypeConverter(factory) );
// get the scale and texture scale
propMap.getValue( mScale, "Template.Render.Scale" );
propMap.getValue( mScaleTexture, "Template.Render.ScaleTexture" );
#if SCENEOBJECT_ENABLE_STATS
// display debug scene object info
if( mAniMesh )
{
const aabbox3df& bbox = mAniMesh->getBoundingBox();
vector3df dim = bbox.MaxEdge - bbox.MinEdge;
dim.X *= mScale.X;
dim.Y *= mScale.Y;
dim.Z *= mScale.Z;
float32_t vol = dim.X * dim.Y * dim.Z;
vol = (vol<0) ? -vol : vol;
LOG_F_MSG( "render", "Loaded animated mesh " << aniMeshFile << " with custom scale (" << mScale << ")" );
LOG_F_MSG( "render", " Dim: (" << dim.X << ", " << dim.Y << ", " << dim.Z << ")" );
LOG_F_MSG( "render", " Volume: " << vol );
}
#endif // SCENEOBJECT_ENABLE_STATS
}
