//------------------------------------------------------------------------
BackgroundProcessTicket ResourceBackgroundQueue::load(
const String& resType, const String& name,
const String& group, bool isManual,
ManualResourceLoader* loader,
const NameValuePairList* loadParams,
ResourceBackgroundQueue::Listener* listener)
{
#if OGRE_THREAD_SUPPORT
if (!mThread && mStartThread)
{
OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
"Thread not initialised",
"ResourceBackgroundQueue::load");
}
// queue a request
Request req;
req.type = RT_LOAD_RESOURCE;
req.resourceType = resType;
req.resourceName = name;
req.groupName = group;
req.isManual = isManual;
req.loader = loader;
req.loadParams = loadParams;
req.listener = listener;
return addRequest(req);
#else
// synchronous
ResourceManager* rm =
ResourceGroupManager::getSingleton()._getResourceManager(resType);
rm->load(name, group, isManual, loader, loadParams);
return 0;
#endif
}
//------------------------------------------------------------------------
BackgroundProcessTicket ResourceBackgroundQueue::load(
const String& resType, const String& name,
const String& group, bool isManual,
ManualResourceLoader* loader,
const NameValuePairList* loadParams,
ResourceBackgroundQueue::Listener* listener)
{
#if OGRE_THREAD_SUPPORT
// queue a request
ResourceRequest req;
req.type = RT_LOAD_RESOURCE;
req.resourceType = resType;
req.resourceName = name;
req.groupName = group;
req.isManual = isManual;
req.loader = loader;
// Make instance copy of loadParams for thread independence
req.loadParams = ( loadParams ? OGRE_NEW_T(NameValuePairList, MEMCATEGORY_GENERAL)( *loadParams ) : 0 );
req.listener = listener;
return addRequest(req);
#else
// synchronous
ResourceManager* rm =
ResourceGroupManager::getSingleton()._getResourceManager(resType);
rm->load(name, group, isManual, loader, loadParams);
return 0;
#endif
}
void SimFire::getShape(int shapeTag,
TSShapeInstance **ppShape,
TSShapeInstance::Thread **ppThread)
{
// Read shape, initialize thread
ResourceManager *rm = SimResource::get(manager);
const char* shapeName = SimTagDictionary::getString(manager,shapeTag);
hShape = rm->load(shapeName);
AssertFatal((bool)hShape,"Unable to load fire shape");
(*ppShape) = new TS::ShapeInstance(hShape, *rm);
AssertFatal((bool)(*ppShape),"Could not create fire shape instance");
(*ppThread) = (*ppShape)->CreateThread(); // pos 0, seq 0 by default
AssertFatal(*ppThread,"Could not create fire animation thread");
(*ppShape)->animateRoot(); // never have to do this again
(*ppThread)->SetPosition(fireRand.getFloat(0.0f,1.0f)); // start at random position
// set-up shape space bounding box -- real size
bbox.fMin = (*ppShape)->getShape().fCenter;
bbox.fMin += (*ppShape)->fRootDeltaTransform.p; // could be trouble if root has rot.
bbox.fMax = bbox.fMin;
bbox.fMin -= (*ppShape)->getShape().fRadius;
bbox.fMax += (*ppShape)->getShape().fRadius;
// get fire height
Box3F bounds;
TS::ObjectInstance * obj = (*ppShape)->getNode(0)->fObjectList[0];
obj->getBox(*ppShape,bounds);
fireHeight = bounds.fMax.z - bounds.fMin.z;
}
void SimSmoke::getShape(int shapeTag,
TSShapeInstance **ppShape,
TSShapeInstance::Thread **ppThread)
{
// Read shape, initialize thread
ResourceManager *rm = SimResource::get(manager);
const char* shapeName = SimTagDictionary::getString(manager,shapeTag);
hShape = rm->load(shapeName);
AssertFatal((bool)hShape,"Unable to load smoke shape");
(*ppShape) = new TS::ShapeInstance(hShape, *rm);
AssertFatal((bool)(*ppShape),"Could not create smoke shape instance");
(*ppThread) = (*ppShape)->CreateThread(); // pos 0, seq 0 by default
AssertFatal(*ppThread,"Could not create smoke animation thread");
(*ppThread)->setTimeScale((*ppThread)->getSequence().fDuration/smokeDuration);
(*ppShape)->animateRoot(); // never have to do this again
// set-up shape space bounding box -- real size
bbox.fMin = (*ppShape)->getShape().fCenter;
bbox.fMin += (*ppShape)->fRootDeltaTransform.p; // could be trouble if root has rot.
bbox.fMax = bbox.fMin;
bbox.fMin -= (*ppShape)->getShape().fRadius;
bbox.fMax += (*ppShape)->getShape().fRadius;
}
void ShapeView::loadShape(const char *lpszName)
{
int iMin;
if (instance)
{
if (! stricmp(lpszName, szShape)) return;
delete instance;
instance = NULL;
szShape[0] = '\0';
}
if (lpszName == NULL || *lpszName == '\0')
{
lpszName = gDefaultShapeFile;
}
ResourceManager *rm = SimResource::get(manager);
rsShape = rm->load(lpszName);
if (bool(rsShape))
{
strcpy(szShape, lpszName);
instance = new TSShapeInstance(rsShape, *rm);
rotation.x = -0.25f;
rotation.z = M_PI - 0.78f;
last.set(0, 0);
center = instance->getShape().fCenter;
camera->lock();
iMin = min(extent.x, extent.y);
rMinDist = camera->
projectionDistance(iMin, instance->getShape().fRadius * 2.5f);
rDefDist = camera->projectionDistance(iMin, 2.0f);
rMaxDist = camera->projectionDistance(iMin, 4.0f);
if (rDist == 0)
{
rDist = rDefDist;
}
else if (rDist < rMinDist)
{
rDist = rMinDist;
}
else if (rDist > rMaxDist)
{
rDist = rMaxDist;
}
camera->unlock();
}
}
//------------------------------------------------------------------------
void ResourceBackgroundQueue::handleResponse(const WorkQueue::Response* res, const WorkQueue* srcQ)
{
if( res->getRequest()->getAborted() )
{
mOutstandingRequestSet.erase(res->getRequest()->getID());
return ;
}
if (res->succeeded())
{
ResourceResponse resresp = any_cast<ResourceResponse>(res->getData());
// Complete full loading in main thread if semithreading
const ResourceRequest& req = resresp.request;
#if OGRE_THREAD_SUPPORT == 2
// These load commands would have been downgraded to prepare() for the background
if (req.type == RT_LOAD_RESOURCE)
{
ResourceManager *rm = ResourceGroupManager::getSingleton()
._getResourceManager(req.resourceType);
rm->load(req.resourceName, req.groupName, req.isManual, req.loader, req.loadParams, true);
}
else if (req.type == RT_LOAD_GROUP)
{
ResourceGroupManager::getSingleton().loadResourceGroup(req.groupName);
}
#endif
mOutstandingRequestSet.erase(res->getRequest()->getID());
// Call resource listener
if (!resresp.resource.isNull())
{
if (req.type == RT_LOAD_RESOURCE)
{
resresp.resource->_fireLoadingComplete( true );
}
else
{
resresp.resource->_firePreparingComplete( true );
}
}
// Call queue listener
if (req.listener)
req.listener->operationCompleted(res->getRequest()->getID(), req.result);
}
}
//-----------------------------------------------------------------------
WorkQueue::Response* ResourceBackgroundQueue::handleRequest(const WorkQueue::Request* req, const WorkQueue* srcQ)
{
ResourceRequest resreq = any_cast<ResourceRequest>(req->getData());
if( req->getAborted() )
{
if( resreq.type == RT_PREPARE_RESOURCE || resreq.type == RT_LOAD_RESOURCE )
{
OGRE_DELETE_T(resreq.loadParams, NameValuePairList, MEMCATEGORY_GENERAL);
resreq.loadParams = 0;
}
resreq.result.error = false;
ResourceResponse resresp(ResourcePtr(), resreq);
return OGRE_NEW WorkQueue::Response(req, true, Any(resresp));
}
ResourceManager* rm = 0;
ResourcePtr resource;
try
{
switch (resreq.type)
{
case RT_INITIALISE_GROUP:
ResourceGroupManager::getSingleton().initialiseResourceGroup(
resreq.groupName);
break;
case RT_INITIALISE_ALL_GROUPS:
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
break;
case RT_PREPARE_GROUP:
ResourceGroupManager::getSingleton().prepareResourceGroup(
resreq.groupName);
break;
case RT_LOAD_GROUP:
#if OGRE_THREAD_SUPPORT == 2
ResourceGroupManager::getSingleton().prepareResourceGroup(
resreq.groupName);
#else
ResourceGroupManager::getSingleton().loadResourceGroup(
resreq.groupName);
#endif
break;
case RT_UNLOAD_GROUP:
ResourceGroupManager::getSingleton().unloadResourceGroup(
resreq.groupName);
break;
case RT_PREPARE_RESOURCE:
rm = ResourceGroupManager::getSingleton()._getResourceManager(
resreq.resourceType);
resource = rm->prepare(resreq.resourceName, resreq.groupName, resreq.isManual,
resreq.loader, resreq.loadParams, true);
break;
case RT_LOAD_RESOURCE:
rm = ResourceGroupManager::getSingleton()._getResourceManager(
resreq.resourceType);
#if OGRE_THREAD_SUPPORT == 2
resource = rm->prepare(resreq.resourceName, resreq.groupName, resreq.isManual,
resreq.loader, resreq.loadParams, true);
#else
resource = rm->load(resreq.resourceName, resreq.groupName, resreq.isManual,
resreq.loader, resreq.loadParams, true);
#endif
break;
case RT_UNLOAD_RESOURCE:
rm = ResourceGroupManager::getSingleton()._getResourceManager(
resreq.resourceType);
if (resreq.resourceName.empty())
rm->unload(resreq.resourceHandle);
else
rm->unload(resreq.resourceName);
break;
};
}
catch (Exception& e)
{
if( resreq.type == RT_PREPARE_RESOURCE || resreq.type == RT_LOAD_RESOURCE )
{
OGRE_DELETE_T(resreq.loadParams, NameValuePairList, MEMCATEGORY_GENERAL);
resreq.loadParams = 0;
}
resreq.result.error = true;
resreq.result.message = e.getFullDescription();
// return error response
ResourceResponse resresp(resource, resreq);
return OGRE_NEW WorkQueue::Response(req, false, Any(resresp), e.getFullDescription());
}
// success
if( resreq.type == RT_PREPARE_RESOURCE || resreq.type == RT_LOAD_RESOURCE )
{
OGRE_DELETE_T(resreq.loadParams, NameValuePairList, MEMCATEGORY_GENERAL);
resreq.loadParams = 0;
}
resreq.result.error = false;
ResourceResponse resresp(resource, resreq);
return OGRE_NEW WorkQueue::Response(req, true, Any(resresp));
}
int main()
{
initCrashSystem();
initMemorySystem();
SDL_Init(SDL_INIT_EVERYTHING);
SDL_Window *window = SDL_CreateWindow("",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
640,
640,
SDL_WINDOW_OPENGL
|SDL_WINDOW_RESIZABLE
|SDL_WINDOW_SHOWN);
SDL_GLContext context = createContext(window);
SDL_GL_SetSwapInterval(1);
bool running = true;
float frametime = 0.0f;
Renderer *renderer = NEW(Renderer, NEW(GLBackend));
ResourceManager *resMgr = renderer->getResourceManager();
Scene *scene = NEW(Scene, renderer);
Scene *quadScene = NEW(Scene, renderer);
RenderTarget *target = NEW(RenderTarget, renderer);
RenderTarget *textureTarget = NEW(RenderTarget, renderer);
Framebuffer *framebuffer = textureTarget->addFramebuffer();
framebuffer->addColor(resMgr->createTexture(Texture::Texture2D), Texture::RGBAU8_Norm_InternalFormat);
framebuffer->addColor(resMgr->createTexture(Texture::Texture2D), Texture::Red32F_InternalFormat);
framebuffer->addColor(resMgr->createTexture(Texture::Texture2D), Texture::RGBU8_Norm_InternalFormat);
framebuffer->addColor(resMgr->createTexture(Texture::Texture2D), Texture::RGBAU8_Norm_InternalFormat);
framebuffer->addColor(resMgr->createTexture(Texture::Texture2D), Texture::RGBU8_Norm_InternalFormat);
framebuffer->addColor(resMgr->createTexture(Texture::Texture2D), Texture::RGBU8_Norm_InternalFormat);
framebuffer->finish();
ResPtr<Model> model = resMgr->load("res/models/dragon.json").cast<Model>();
ResPtr<Mesh> quadMesh = resMgr->createMesh(resMgr->load("res/shaders/quad vertex.json").cast<Shader>(), Mesh::Triangles, 6);
VertexBuffer *quadVB = quadMesh->addPositions(renderer, MeshComponent(2, MeshComponent::Float32))->getVertexBuffer();
quadVB->alloc(sizeof(glm::vec2)*6);
glm::vec2 *quadPositions = (glm::vec2 *)quadVB->map(false, true);
quadPositions[0] = glm::vec2(-1.0f, -1.0f);
quadPositions[1] = glm::vec2( 1.0f, -1.0f);
quadPositions[2] = glm::vec2(-1.0f, 1.0f);
quadPositions[3] = glm::vec2(-1.0f, 1.0f);
quadPositions[4] = glm::vec2( 1.0f, -1.0f);
quadPositions[5] = glm::vec2( 1.0f, 1.0f);
quadVB->unmap();
ResPtr<Material> quadMaterial = resMgr->createMaterial(
resMgr->load("res/shaders/quad fragment.json").cast<Shader>());
quadMaterial->mUniforms["colorTexture"] = framebuffer->getColorTexture(0);
quadMaterial->mUniforms["depthTexture"] = framebuffer->getColorTexture(1);
quadMaterial->mUniforms["normalTexture"] = framebuffer->getColorTexture(2);
quadMaterial->mUniforms["materialTexture"] = framebuffer->getColorTexture(3);
quadMaterial->mUniforms["ambientTexture"] = framebuffer->getColorTexture(4);
quadMaterial->mUniforms["specularTexture"] = framebuffer->getColorTexture(5);
quadMaterial->mUniforms["lightDirection"] = glm::vec3(0.0f);
ResPtr<Model> quadModel = resMgr->createModel();
quadModel->mLODs.push_back(LOD(quadMesh, quadMaterial, 0.0f));
quadModel->sortLODs();
quadScene->createEntity(quadModel);
scene->mSkyboxTexture = resMgr->load("res/textures/enviroment texture.json").cast<Texture>();
Entity *entity = scene->createEntity(model);
float t = 0.0f;
bool fullscreen = false;
glm::vec3 cameraPosition(0.0f, 0.0f, 5.0f);
glm::vec2 cameraAngle(3.1415f, 0.0f);
float cameraSpeed = 3.0f;
float cameraRotateSpeed = 1.0f;
while (running)
{
Uint64 start = SDL_GetPerformanceCounter();
SDL_Event event;
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_QUIT:
{
running = false;
break;
}
case SDL_KEYDOWN:
{
switch (event.key.keysym.scancode)
{
case SDL_SCANCODE_ESCAPE:
{
running = false;
break;
}
case SDL_SCANCODE_F1:
{
fullscreen = not fullscreen;
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP*fullscreen);
}
default: {}
}
}
}
}
const Uint8 *pressed = SDL_GetKeyboardState(NULL);
glm::vec3 direction(std::cos(cameraAngle.y) * std::sin(cameraAngle.x),
std::sin(cameraAngle.y),
std::cos(cameraAngle.y) * std::cos(cameraAngle.x));
glm::vec3 right(std::sin(cameraAngle.x - 3.1415f / 2.0f),
0.0f,
std::cos(cameraAngle.x - 3.1415f / 2.0f));
glm::vec3 up = glm::cross(right, direction);
if (pressed[SDL_SCANCODE_LEFT])
{
cameraAngle.x += cameraRotateSpeed * frametime;
} else if (pressed[SDL_SCANCODE_RIGHT])
{
cameraAngle.x -= cameraRotateSpeed * frametime;
} else if (pressed[SDL_SCANCODE_UP])
{
cameraAngle.y += cameraRotateSpeed * frametime;
} else if (pressed[SDL_SCANCODE_DOWN])
{
cameraAngle.y -= cameraRotateSpeed * frametime;
} else if (pressed[SDL_SCANCODE_A])
{
cameraPosition -= right * frametime * cameraSpeed;
} else if (pressed[SDL_SCANCODE_D])
{
cameraPosition += right * frametime * cameraSpeed;
} else if (pressed[SDL_SCANCODE_W])
{
cameraPosition += direction * frametime * cameraSpeed;
} else if (pressed[SDL_SCANCODE_S])
{
cameraPosition -= direction * frametime * cameraSpeed;
}
scene->mProjectionTransform.reset();
int windowWidth;
int windowHeight;
SDL_GetWindowSize(window, &windowWidth, &windowHeight);
target->setWidthAndHeight(windowWidth, windowHeight);
textureTarget->setWidthAndHeight(windowWidth, windowHeight);
scene->mProjectionTransform.perspective(45.0f, float(windowWidth)/float(windowHeight), 0.1f, 100.0f);
scene->mViewTransform.reset();
scene->mViewTransform.lookAt(cameraPosition,
cameraPosition+direction,
up);
t += frametime;
entity->mTransform.reset();
entity->mTransform.scale(glm::vec3(0.5f));
entity->mTransform.rotate(45.0f*t, glm::vec3(0.0f, 1.0f, 0.0f));
renderer->render(textureTarget, scene);
quadMaterial->mUniforms["lightDirection"]
= glm::mat3(scene->mViewTransform.getMatrix()) * glm::vec3(-1.0f, 1.0f, -1.0f);
renderer->render(target, quadScene);
SDL_GL_SwapWindow(window);
resMgr->deleteUnusedResources();
Uint64 end = SDL_GetPerformanceCounter();
frametime = float(end - start) / float(SDL_GetPerformanceFrequency());
char title[256];
std::memset(title, 0, 256);
std::snprintf(title, 256, "Frametime: %.4f, Framerate: %.0f", frametime, 1.0f/frametime);
SDL_SetWindowTitle(window, title);
}
model = nullRes<Model>();
quadMesh = nullRes<Mesh>();
quadMaterial = nullRes<Material>();
quadModel = nullRes<Model>();
DELETE(RenderTarget, textureTarget);
DELETE(RenderTarget, target);
DELETE(Scene, quadScene);
DELETE(Scene, scene);
DELETE(Renderer, renderer);
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(window);
SDL_Quit();
deinitMemorySystem();
return 0;
}
bool Resource::load(bool async)
{
ResourceManager* mgr = ResourceManager::thisManager();
return mgr->load(this,async);
}
bool Player::initResources(GameBase::GameBaseData *in_data)
{
data = dynamic_cast<PlayerData *>(in_data);
if(!Parent::initResources(in_data))
return false;
updateImageMass();
setDrag(data->drag);
setDensity(data->density);
int rnode = image.shape->getShape().findNode("dummyalways root");
const TMat3F& rmat = image.shape->getTransform(rnode);
image.shape->insertOverride("lowerback",0,&PlayerViewOverride);
image.shape->insertOverride("lowerback",1,const_cast<TMat3F*>(&rmat));
image.shape->setOverride(2);
//
myThread = createThread (0);
viewThread = Parent::createThread(0);
viewThread->setPriority(-1);
looksSequence = viewThread->GetSequenceIndex("looks");
crouchLooksSequence = viewThread->GetSequenceIndex("crouch looks");
if(crouchLooksSequence == -1)
crouchLooksSequence = looksSequence;
AssertFatal(looksSequence != -1, "DOH!");
viewThread->SetSequence( looksSequence, 0.0 );
damageThread = 0;
int i;
for (i = 0; i < Player::NUM_ANIMS; i ++)
{
animIndex[i] = myThread->GetSequenceIndex((char *) data->animData[i].name);
if(animIndex[i] == -1)
animIndex[i] = 0;
}
Point3F pos;
clearAnimTransform ();
for (int j = 0; j < Player::NUM_ANIMS; j ++)
{
if((j >= ANIM_MOVE_FIRST && j <= ANIM_MOVE_LAST) ||
(j >= ANIM_CROUCH_MOVE_FIRST && j <= ANIM_CROUCH_MOVE_LAST))
{
myThread->setTimeScale(1.0);
myThread->SetSequence(animIndex[j]);
myThread->AdvanceTime(1.0);
myThread->UpdateSubscriberList();
image.shape->animateRoot();
pos = getAnimTransform();
offsetList[j].dist = pos.len();
offsetList[j].dir = pos;
if(offsetList[j].dist >= 0.1)
{
if (data->animData[j].direction <= 0)
offsetList[j].dir *= -1 / offsetList[j].dist;
else
offsetList[j].dir *= 1 / offsetList[j].dist;
}
clearAnimTransform();
offsetList[j].hasOffset = true;
}
else
offsetList[j].hasOffset = false;
myThread->SetSequence(0);
}
if(currentAnimation != -1)
{
// it's a death animation: set it to the end
myThread->SetSequence(animIndex[currentAnimation]);
if (data->animData[currentAnimation].direction > 0)
myThread->SetPosition (0.99f);
else
myThread->SetPosition (0);
pickNewAnimation = false;
}
delete flameImage.shape;
flameImage.shape = 0;
flameThread = 0;
if (isGhost()) {
char name[256];
strcpy(name, data->flameShapeName);
strcat(name, ".dts");
ResourceManager *rm = SimResource::get(manager);
Resource<TSShape> shape = rm->load(name, true);
if(bool(shape))
{
flameImage.shape = new TSShapeInstance(shape, *rm);
flameThread = flameImage.shape->CreateThread();
flameThread->setTimeScale(1.0f);
flameThread->SetSequence("activation");
}
}
// Container & Collision
boundingBox.fMin.x = -data->boxWidth;
boundingBox.fMin.y = -data->boxDepth;
boundingBox.fMin.z = 0;
boundingBox.fMax.x = data->boxWidth;
boundingBox.fMax.y = data->boxDepth;
boundingBox.fMax.z = data->boxNormalHeight;
collisionImage.bbox.fMin = boundingBox.fMin;
collisionImage.bbox.fMax = boundingBox.fMax;
collisionImage.crouchBox.fMin = boundingBox.fMin;
collisionImage.crouchBox.fMax = boundingBox.fMax;
setBoundingBox ();
collisionImage.sphere.radius = (collisionImage.bbox.fMax.z - collisionImage.bbox.fMin.z) / 2;
collisionImage.sphere.center = Point3F(0.0f,0.0f, collisionImage.sphere.radius);
collisionImage.shapeInst = image.shape;
collisionImage.collisionDetail = 0;
chaseNode = image.shape->getShape().findNode ("dummyalways chasecam");
eyeNode = image.shape->getNodeAtCurrentDetail("dummy eye");
// Resolve all the mount node indexes.
for(i = 0; i < MaxMountPoints; i++) {
image.shape->setDetailLevel(0);
mountNode[i] = image.shape->getNodeAtCurrentDetail(NodeMountName[i]);
// HACK Alert!
// Lower detail nodes are patch to reference the same
// transform as the highest detail.
TS::ShapeInstance::NodeInstance *node = image.shape->getNode(mountNode[i]);
for (int d = 1; d < image.shape->getShape().fDetails.size(); d++) {
image.shape->setDetailLevel(d);
int dn = image.shape->getNodeAtCurrentDetail(NodeMountName[i]);
if (dn != -1)
image.shape->getNode(dn)->fpTransform = node->fpTransform;
}
}
image.shape->setDetailLevel(0);
// Update initial state of images transfered from the server.
for (i = 0; i < MaxItemImages; i++) {
ItemImageEntry& itemImage = itemImageList[i];
if (itemImage.state == ItemImageEntry::Fire)
setImageState(i,ItemImageEntry::Fire);
}
return true;
}
bool
SimInterior::loadShape(const char* fileName)
{
// setFilename returns false if the filename is invalid, OR if the filename
// is the same as the one already set. In either case, we exit wo/ doing
// any work...
//
if (setFilename(fileName) == false) {
return false;
}
// NOTE: This function is VERY poor on error checking, there are only a few
// asserts in ITRInstance(). Maybe restructure to be a bit more robust?
//
ResourceManager *rm = SimResource::get(manager);
Resource<ITRShape> itrShape;
bool missionLit;
// check if we need to try and find the missionlit ver
if( rm->findFile( fileName ) )
{
missionLit = missionLitName();
itrShape = rm->load( fileName);
}
else
{
if( !missionLitName() )
return( false );
String base = String(fileName);
getBaseFilename( base );
if( rm->findFile( base.c_str() ) )
itrShape = rm->load(base.c_str());
missionLit = false;
}
if( !bool( itrShape ) )
return( false );
// If we make it to here, then all is cool, nuke the old resources...
//
unloadResources();
ITRInstance* pInstance = new ITRInstance(rm, itrShape, 0);
if( missionLit )
pInstance->setMissionLit();
renderImage.instance = pInstance;
// Set the geometry for the database and collision image. Note that this
// is the highest level of state 0 for the interior. May have to change
// the collision image geometry pointer on detail level change, probably
// will only change the database pointer on state switches...
//
updateBoundingBox();
SimContainer* root = NULL;
root = findObject(manager,SimRootContainerId,root);
root->addObject(this);
getInstance()->getAutoStartIDs(animatingLights);
SimSet* pITRTimerSet = dynamic_cast<SimSet*>(manager->findObject(SimITRTimerSetId));
if (pITRTimerSet == NULL)
manager->addObject(new SimTimerSet(1.0f/15.0f, SimITRTimerSetId));
bool timerSuccess = addToSet(SimITRTimerSetId);
AssertFatal(timerSuccess == true, "Could not add to SimITRTimerSet");
return true;
}
