//------------------------------------------------------------------------ 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; }