void drawSplashScreen(const std::string &filename){ if(splashScreen.ID) gl::DeleteTextures(1, &splashScreen.ID); else { ResourceLoader loader; loader.reloadShader("ApplyFBO"); splashScreen = loader.loadImage(filename); glfwShowWindow(Global::main.window); glfwSetWindowPos(Global::main.window, Global::main.screenSize.x/2.f - splashScreen.width/2, Global::main.screenSize.y/2.f - splashScreen.height/2); glfwSetWindowSize(Global::main.window, splashScreen.width, splashScreen.height); } gl::Viewport(0, 0, splashScreen.width, splashScreen.height); gl::ClearColor(0.f, 0.f, 0.f, 0.f); gl::Clear(gl::COLOR_BUFFER_BIT); gl::DepthMask(gl::FALSE_); gl::Enable(gl::BLEND); gl::BlendFunc(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA); gl::BindBuffer(gl::ARRAY_BUFFER, 0); gl::DisableVertexAttribArray(0); gl::BindFramebuffer(gl::DRAW_FRAMEBUFFER, 0); auto shader = assets::getShader("ApplyFBO"); shader.bind(); float width = Global::main.size.x; float height = Global::main.size.y; shader.texture("uTexture", splashScreen.ID); drawScreen(); glfwSwapBuffers(Global::main.window); CHECK_FOR_ERRORS }
void Particles::init(){ /// collect textures std::vector<std::string> &&images = listDirectory("../res/textures/CGI256"s); ResourceLoader loader; Global::main.commonResources.textureAtlas["Cgi256"] = loader.loadAtlas(images, "../res/textures/CGI256"s); createBuffer(); }
ControlTrayIcon::ControlTrayIcon(ControlProxy *serverControl, Notificator *notificator, ControlApplication *appControl, bool showAfterCreation) : NotifyIcon(showAfterCreation), m_serverControl(serverControl), m_notificator(notificator), m_appControl(appControl), m_inWindowProc(false), m_termination(false) { ResourceLoader *resLoader = ResourceLoader::getInstance(); m_iconWorking = new Icon(resLoader->loadIcon(MAKEINTRESOURCE(IDI_CONNECTED))); m_iconIdle = new Icon(resLoader->loadIcon(MAKEINTRESOURCE(IDI_IDLE))); m_iconDisabled = new Icon(resLoader->loadIcon(MAKEINTRESOURCE(IDI_DISABLED))); setWindowProcHolder(this); m_updateRemoteConfigCommand = new UpdateRemoteConfigCommand(m_serverControl); m_updateLocalConfigCommand = new UpdateLocalConfigCommand(m_serverControl); m_applyChangesMacroCommand = new MacroCommand(); m_applyChangesMacroCommand->addCommand(m_updateRemoteConfigCommand); m_applyChangesMacroCommand->addCommand(m_updateLocalConfigCommand); m_applyChangesControlCommand = new ControlCommand(m_applyChangesMacroCommand, m_notificator); m_configDialog = new ConfigDialog(); m_configDialog->setConfigReloadCommand(m_applyChangesControlCommand); setNotConnectedState(); syncStatusWithServer(); }
int loader_thread(void *loader) { ResourceLoader *resourceLoader = (ResourceLoader *) loader; IResourceManager *resourceManager = resourceLoader->getResourceManager(); LoadingJob *curJob; while (true) { // get a new job from the in list. curJob = resourceLoader->getJobIn(); // process the job switch (curJob->type) { case LOAD_JOB_MESH: // load a mesh curJob->data = resourceManager->readMeshData(curJob->ref->fileName, LOAD_NORMAL_VERTEX, 1.0); break; case LOAD_JOB_TEXTURE: // load a texture curJob->data = resourceManager->loadBMPImage(curJob->ref->fileName); break; default: cerr << "Unknown load job\n"; exit(1); break; } // put the finished job in the out list. resourceLoader->addJobOut(curJob); } return 0; }
void FileInfoListView::loadImages() { if (m_smallImageList != NULL) { ImageList_Destroy(m_smallImageList); } m_smallImageList = ImageList_Create(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), ILC_MASK, 1, 1); HICON icon; ResourceLoader *rLoader = ResourceLoader::getInstance(); icon = rLoader->loadIcon(MAKEINTRESOURCE(IDI_FILEUP)); _ASSERT(icon != NULL); ImageList_AddIcon(m_smallImageList, icon); DestroyIcon(icon); icon = rLoader->loadIcon(MAKEINTRESOURCE(IDI_FOLDER_ICON)); _ASSERT(icon != NULL); ImageList_AddIcon(m_smallImageList, icon); DestroyIcon(icon); icon = rLoader->loadIcon(MAKEINTRESOURCE(IDI_FILE_ICON)); _ASSERT(icon != NULL); ImageList_AddIcon(m_smallImageList, icon); DestroyIcon(icon); }
void GameStateController::loadGame(flat2d::GameData *gameData) { // Clean up first clearAllAssets(gameData); flat2d::EntityContainer *entityContainer = gameData->getEntityContainer(); CustomGameData *customGameData = static_cast<CustomGameData*>(gameData->getCustomGameData()); LayerService *layerService = customGameData->getLayerService(); MapParser parser; MapData map = maps[currentMapIndex]; parser.createMapFrom(gameData, map.path, map.file); // TODO(Linus): Will this layer system work? (esp the hardcoded layers) layerService->registerLayer(FRONT_LAYER); layerService->registerLayer(OVERLAY_LAYER); layerService->registerLayers(entityContainer); flat2d::Entity* soldier = new Soldier(200, 200); entityContainer->registerObject(soldier, layerService->getLayerIndex(FRONT_LAYER)); ResourceLoader *rLoader = customGameData->getResourceLoader(); rLoader->loadMusic(gameData); rLoader->loadSoundEffects(gameData); #ifdef FPS_DBG FrameCounter *counter = new FrameCounter(10, 10); entityContainer->registerObject(counter, layerService->getLayerIndex(OVERLAY_LAYER)); #endif // DEBUG }
void renderTitle(double elapsedTime, const ResourceLoader& resources) { auto tMain = resources.getTextures().getMainTitleTexture(); auto tSub = resources.getTextures().getSubTitleTexture(); auto tSpace = resources.getTextures().getSpacePressTexture(); auto main_y = elapsedTime < 1000 ? (elapsedTime / 1000.0) * (Window::Height() / 4.0f * 2.0f) - Window::Height() / 4.0f : Window::Height() / 4.0f; auto sub_y = 0.0; auto sub_angle = 0.0; auto main_w = tMain.size.x; if (elapsedTime < 1500) sub_y = -Window::Height() / 4.0f; else if (elapsedTime < 2500) sub_y = EaseOut(Easing::Bounce, (elapsedTime - 1500) / 1000.0) * (Window::Height() / 4.0f * 2.0f) - Window::Height() / 4.0f + 24.0f; else sub_y = Window::Height() / 4.0f + 24.0f; if (elapsedTime < 3000) sub_angle = 0.0; else if (elapsedTime < 3200) sub_angle = ((elapsedTime - 3000) / 200) * 5.0f; else sub_angle = 5.0f; tMain.draw(Vec2((Window::Width() - main_w) / 2.0f, main_y)); tSub.rotateAt(Vec2(0.0f, tSub.size.y), Math::Radians(sub_angle)).draw(Vec2((Window::Width() + main_w) / 2.0f, sub_y)); if (elapsedTime >= 4000) { if (Math::Fmod(elapsedTime, 1000.0) < 500.0) { tSpace.draw(Vec2((Window::Width() - tSpace.size.x) / 2.0, Window::Height() / 4.0 * 3.0)); } } }
void WebFrame::convertMainResourceLoadToDownload(DocumentLoader* documentLoader, const ResourceRequest& request, const ResourceResponse& response) { ASSERT(m_policyDownloadID); uint64_t policyDownloadID = m_policyDownloadID; m_policyDownloadID = 0; ResourceLoader* mainResourceLoader = documentLoader->mainResourceLoader(); #if ENABLE(NETWORK_PROCESS) if (WebProcess::shared().usesNetworkProcess()) { // Use 0 to indicate that there is no main resource loader. // This can happen if the main resource is in the WebCore memory cache. uint64_t mainResourceLoadIdentifier; if (mainResourceLoader) mainResourceLoadIdentifier = mainResourceLoader->identifier(); else mainResourceLoadIdentifier = 0; WebProcess::shared().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::ConvertMainResourceLoadToDownload(mainResourceLoadIdentifier, policyDownloadID, request, response), 0); return; } #endif if (!mainResourceLoader) { // The main resource has already been loaded. Start a new download instead. WebProcess::shared().downloadManager().startDownload(policyDownloadID, request); return; } WebProcess::shared().downloadManager().convertHandleToDownload(policyDownloadID, documentLoader->mainResourceLoader()->handle(), request, response); }
bool ResourceLoadScheduler::maybeLoadQuickLookResource(ResourceLoader& loader) { if (!loader.request().url().protocolIs(QLPreviewProtocol())) return false; loader.start(); return true; }
void TerrainWrapper::Enable() { Controller * ctrl = static_cast<Controller*>(GetManager()->Get("Controller")); DataManager * dm = static_cast<DataManager*>(GetManager()->Get("DataManager")); Techniques * tech = static_cast<Techniques*>(dm->Get("Techniques")); ResourceLoader * res = static_cast<ResourceLoader*>(dm->Get("Resources")); Environment * env = static_cast<Environment*>(res->Get("Environment")); Camera * camera = static_cast<Camera*>(ctrl->Get("Camera")); View * view = camera->GetView(); ViewInfo * info = camera->GetInfo(); Shader::Enable(); Shader::Set("myTextureSampler", 0); Shader::Set("myTextureSampler2", 1); Shader::Set("myTextureSampler3", 2); Shader::Set("shadow_map", 3); TerrainShader::SendTextureAttributes(terra->GetTextureAttributes(), 4); /** Raising to power for gamma correction */ getLight()->SetFog(glm::pow(env->fog_color, glm::vec3(2.2)), env->fog_density); getLight()->SetDirectionalLight(env->terrain_bright* glm::pow(env->sun_color, glm::vec3(2.2)), env->sun_dir, env->terrain_ambient, env->terrain_diffuse); Set("LightMatrix", Math::GetBiasMatrix()* tech->GetShadow()->GetDirectionalShadow(env, info, view)); tech->GetShadow()->GetShadowMap()->BindTexture(0, GL_TEXTURE3); tech->GetShadow()->GetShadowMap()->ResetTextureState(); ManagePlayerCollision(ctrl, false); }
void renderPlayer(double viewOffset, double playerAngle, const Vec2& playerPos, const ResourceLoader& resources) { // player render auto tPlayer = resources.getTextures().getPlayerTexture().scale(2); auto tPlayerBody = resources.getTextures().getPlayerBodyTexture().scale(2); tPlayer.rotateAt(Vec2(12, 8) * 2, Math::Radians(playerAngle)).draw((playerPos - Vec2(12 + viewOffset, 8)) * 2); tPlayerBody.rotateAt(Vec2(12, 13) * 2, Math::Radians(playerAngle)).draw((playerPos - Vec2(12 + viewOffset, 18)) * 2); }
// Creates an instance of Player // @param png - The path to the PNG representation of the sprite // @param plist - The path to the PLIST representation of the sprite Player* Player::create() { // Create an instance of Player Player* playerSprite = new Player(); // Reset travelled distance playerSprite->setDistanceTravelled(0); // Get resource loader instance ResourceLoader resLoader = ResourceLoader::getInstance(); // Get running animation Vector<SpriteFrame*> runningAnimation = resLoader.getAnimation(PLAYER_ANIMATION_RUNNING); // Generate player movement sprites if (playerSprite->initWithSpriteFrame(runningAnimation.at(0))) { auto animation = Animation::createWithSpriteFrames(runningAnimation); // Set delay between frames animation->setDelayPerUnit(PLAYER_SPRITE_DELAY_RUNNING); //Create running action auto runningAction = RepeatForever::create(Animate::create(animation)); //Set tag for action runningAction->setTag(PLAYER_ANIMATION_RUNNING); // Run animation forever playerSprite->runAction(runningAction); // Set properties playerSprite->autorelease(); playerSprite->initOptions(); playerSprite->setScale(Director::getInstance()->getWinSize().width * 1.8 / 800); playerSprite->scheduleUpdate(); // Add weapon Weapon* weapon = Weapon::create(); playerSprite->setWeapon(weapon); //Create physical body auto spriteBody = PhysicsBody::createBox(playerSprite->boundingBox().size, PhysicsMaterial(1.0f, 0.5f, 0.5f)); spriteBody->setAngularVelocityLimit(0.0f); spriteBody->setMass(1); spriteBody->setCollisionBitmask(PLAYER_COLLISION_BITMASK); spriteBody->setContactTestBitmask(true); playerSprite->setPhysicsBody(spriteBody); // Return return playerSprite; } CC_SAFE_DELETE(playerSprite); return NULL; }
static Resource *load(void *v) { ResourceLoader *l = static_cast< ResourceLoader * >(v); int fileSize; void *buffer = l->manager->loadFile(l->path, fileSize); if (!buffer) return NULL; Resource *res = l->fun(buffer, fileSize); free(buffer); return res; }
void TerrainWrapper::Render() { Controller * ctrl = static_cast<Controller*>(GetManager()->Get("Controller")); DataManager * dm = static_cast<DataManager*>(GetManager()->Get("DataManager")); Techniques * tech = static_cast<Techniques*>(dm->Get("Techniques")); ResourceLoader * res = static_cast<ResourceLoader*>(dm->Get("Resources")); Environment * env = static_cast<Environment*>(res->Get("Environment")); Camera * camera = static_cast<Camera*>(ctrl->Get("Camera")); View * view = camera->GetView(); ViewInfo * info = camera->GetInfo(); if (tech->GetSSAO()->OnGeometryPass()) { tech->GetSSAO()->SetGeometryPassUniforms(view->getCamera(), view->getViewMatrix()); } else if (tech->GetShadow()->OnShadowPass()) { tech->GetShadow()->UniformMVP(tech->GetShadow()->GetDirectionalShadow(env, info, view)); } else { Space(glm::mat4(1.0), view); } terra->Render(camera->GetFrustum(), false); }
bool ViewerWindow::onNotify(int idCtrl, LPNMHDR pnmh) { ResourceLoader *rLoader = ResourceLoader::getInstance(); LPTOOLTIPTEXT toolTipText = reinterpret_cast<LPTOOLTIPTEXT>(pnmh); if (toolTipText->hdr.code != TTN_NEEDTEXT) { return false; } int resId = static_cast<int>(toolTipText->hdr.idFrom); rLoader->loadString(resId, &m_strToolTip); toolTipText->lpszText = const_cast<TCHAR *>(m_strToolTip.getString()); return true; }
PlayGraphics::PlayGraphics(sf::RenderWindow& window) :m_window(window) { m_button.setSize(sf::Vector2f(BUTTON_WIDTH, BUTTON_HEIGHT)); m_button.setOutlineColor(sf::Color::Black); m_button.setFillColor(sf::Color::Transparent); m_button.setOutlineThickness(5); ResourceLoader resourceLoader; resourceLoader.loadFont(m_buttonFont, ResourceLoader::ARCON_FONT); m_buttonText.setFont(m_buttonFont); m_buttonText.setCharacterSize(20); }
void Player::update(float delta) { CCLOG(to_string(this->getPosition().y).c_str()); distanceTravelled++; framePassed--; if (this->getPhysicsBody()->getVelocity().y > 1000) { this->getPhysicsBody()->setVelocity(Vec2(this->getPhysicsBody()->getVelocity().x, 0)); } if (this->getPosition().y < Director::getInstance()->getWinSize().height / GROUND_PERCENTAGE_FOR_BOX) { this->getPhysicsBody()->setVelocity(Vec2(this->getPhysicsBody()->getVelocity().x, 0)); this->setPosition(Vec2(this->getPosition().x, Director::getInstance()->getWinSize().height / GROUND_PERCENTAGE_FOR_BOX)); } if (this->currentAction != Action::RUNNING && this->getPhysicsBody()->getVelocity().y > -1.0f && this->getPhysicsBody()->getVelocity().y < 1.0f) { // Get resource loader instance ResourceLoader resLoader = ResourceLoader::getInstance(); // Get running animation Vector<SpriteFrame*> runningAnimation = resLoader.getAnimation(PLAYER_ANIMATION_RUNNING); auto animation = Animation::createWithSpriteFrames(runningAnimation); animation->setDelayPerUnit(PLAYER_SPRITE_DELAY_RUNNING); auto runningAction = RepeatForever::create(Animate::create(animation)); runningAction->setTag(PLAYER_ANIMATION_RUNNING); this->runAction(runningAction); this->currentAction = Action::RUNNING; } if ((isKeyPressed(EventKeyboard::KeyCode::KEY_LEFT_ARROW) || isKeyPressed(EventKeyboard::KeyCode::KEY_A)) &&(bossMode)) { this->getPhysicsBody()->applyImpulse(Vect(-((Director::getInstance()->getWinSize().height - 600)/32 + 25), 0)); } if ((isKeyPressed(EventKeyboard::KeyCode::KEY_RIGHT_ARROW) || isKeyPressed(EventKeyboard::KeyCode::KEY_D)) &&(bossMode)) { this->getPhysicsBody()->applyImpulse(Vect(((Director::getInstance()->getWinSize().height - 600) / 32 + 25), 0)); } if (invurnerableTime != 0) invurnerableTime--; if (invurnerable && invurnerableTime == 0) invurnerable = false; }
// Load the resources for the scene from a resource loader void MainMenu::load(const ResourceLoader& resourceLoader) { Color normalColor(100, 100, 0), selectedColor(255, 255, 0); Font menuFont = resourceLoader.loadFont("mainMenu.ttf", 42); Game* game = getGame(); _mainMenu.addElement( menuFont, "Play", normalColor, selectedColor); _mainMenu.addElement( menuFont, "Settings", normalColor, selectedColor); _mainMenu.addElement( menuFont, "Quit", normalColor, selectedColor, [&game](){ game->quit(); }); }
void renderBackgrounds(double viewLeft, const ResourceLoader& resources) { // render background auto tBehindSun = resources.getTextures().getBackgroundTextureBehindSun().scale(2); auto tSun = resources.getTextures().getBackgroundSunTexture().scale(2); auto tFrontSun = resources.getTextures().getBackgroundTextureFrontSun().scale(2); auto map_offset_slow = Math::Fmod(viewLeft * 0.1f, Map::instance().width() * 8.0); auto map_offset_slowest = Math::Fmod(viewLeft * 0.05f, 320.0 + 96.0); tBehindSun.draw(Vec2(int(-map_offset_slow), 0.0f) * 2); tBehindSun.draw(Vec2(int(320.0f - map_offset_slow), 0.0f) * 2); tSun.draw(Vec2(int(320.0f - map_offset_slowest) * 2, Window::Height() / 3.0)); tFrontSun.draw(Vec2(int(-map_offset_slow), 0.0f) * 2); tFrontSun.draw(Vec2(int(320.0f - map_offset_slow), 0.0f) * 2); }
void Game::Impl::mountArchives(ResourceLoader &loader) { Logger::warning( "Game: mount archives begin" ); std::string errorStr; std::string c3res = SETTINGS_STR( c3gfx ); if( !c3res.empty() ) { vfs::Directory gfxDir( c3res ); vfs::Path c3sg2( "c3.sg2" ); vfs::Path c3path = gfxDir/c3sg2; if( !c3path.exist( vfs::Path::ignoreCase ) ) { errorStr = "This game use resources files (.sg2, .map) from Caesar III(c), but " "original game archive c3.sg2 not found in folder " + c3res + "!!!.\nBe sure that you copy all .sg2, .map and .smk files placed to resource folder"; SETTINGS_SET_VALUE( c3gfx, std::string( "" ) ); game::Settings::save(); } loader.loadFromModel( SETTINGS_RC_PATH( sg2model ), gfxDir ); engine->setFlag( Engine::batching, false ); } else { vfs::Path testPics = SETTINGS_RC_PATH( picsArchive ); if( !testPics.exist() ) { SETTINGS_SET_VALUE( resourcePath, Variant("") ); errorStr = "Not found graphics package. Use precompiled CaesarIA archive or use\n" "-c3gfx flag to set absolute path to Caesar III(r) installation folder,\n" "forexample, \"-c3gfx c:/games/caesar3/\""; } loader.loadFromModel( SETTINGS_RC_PATH( remakeModel ) ); } if( !errorStr.empty() ) { OSystem::error( "Resources error", errorStr ); Logger::warning( "CRITICAL: not found original resources in " + c3res ); exit( -1 ); //kill application } loader.loadFromModel( SETTINGS_RC_PATH( archivesModel ) ); }
void Player::isDead() { // Don't kill him if he's already dead if (dead) { return; } // Remember if he's dead or not dead = true; // Get the 'dead' sprite ResourceLoader resLoader = ResourceLoader::getInstance(); //Stop running animation and replace the sprite png to the DEAD one this->getActionManager()->removeActionByTag(PLAYER_ANIMATION_RUNNING, this); // Reinitialize with 'dead' sprite this->initWithFile(resLoader.getImageFile(PLAYER_ANIMATION_DEAD)); }
NAMESPACE_RESOURCES_BEGIN //-----------------------------------// void ResourceTaskRun(Task* task) { ResourceLoadOptions* options = (ResourceLoadOptions*) task->userdata; Stream* stream = options->stream; Resource* resource = options->resource; const Path& path = resource->getPath(); ResourceManager* res = GetResourceManager(); ResourceLoader* loader = res->findLoader( PathGetFileExtension(path) ); bool decoded = loader->decode(*options); if( !decoded ) { resource->setStatus( ResourceStatus::Error ); LogWarn("Error decoding resource '%s'", path.CString()); goto cleanup; } resource->setStatus( ResourceStatus::Loaded ); LogInfo("Loaded resource '%s'", path.CString()); if( options->sendLoadEvent ) { ResourceEvent event; event.resource = resource; res->resourceEvents.push_back(event); } cleanup: res->numResourcesQueuedLoad.decrement(); res->resourceFinishLoad->wakeOne(); if( !options->keepStreamOpen ) Deallocate(stream); Deallocate(options); }
void renderMap(double viewOffset, const ResourceLoader& resources) { // map Map::instance().render([&](int x, int y, int d) { resources.getTextures().getMapchipTexture(d) .scale(2).draw(Vec2(Math::Floor(x * 16.0f - Math::Fmod(viewOffset, Map::instance().width() * 8.0)), y * 16.0f) * 2); }); }
bool ResourceCompilerImpl::compile(const char* fileName, std::map<std::string, std::string>& options) { std::cout << "Compiling " << fileName << std::endl; engine::Hashed id(fileName); if(resourcesCompiled.count(id) > 0) { std::cout << fileName << " already compiled" << std::endl; return true; } ResourceLoader* loader = findLoader(engine::file::getExtension(fileName).c_str()); resourcesCompiled.insert(id); loader->compileResource(fileName, options); std::cout << "Compiled " << fileName << std::endl; return true; }
void initialize(ClimateType climate) { VariantMap climateArchives = config::load( SETTINGS_RC_PATH( climateModel ) ); std::string optName; if( climate == central ) { optName = CAESARIA_STR_A(central); } else if( climate == northen ) { optName = "north"; } else if( climate == desert ) { optName = "south"; } StringArray archives = climateArchives.get( optName ).toStringArray(); for( auto& str : archives ) { Path archivePath = str; Directory dir = archivePath.directory(); archivePath = dir.find( archivePath.baseName(), Path::ignoreCase ); ArchivePtr archive = FileSystem::instance().mountArchive( archivePath ); if( archive.isNull() ) { Logger::warning( "ClimateManager: can't load file " + archivePath.toString() ); continue; } ResourceLoader rc; NFile atlasInfo = archive->createAndOpenFile( "info" ); if( atlasInfo.isOpen() ) { rc.loadAtlases( atlasInfo, false ); } else { rc.loadFiles( archive ); } } }
void SkyWrapper::Enable() { Controller * ctrl = static_cast<Controller*>(GetManager()->Get("Controller")); DataManager * dm = static_cast<DataManager*>(GetManager()->Get("DataManager")); ResourceLoader * res = static_cast<ResourceLoader*>(dm->Get("Resources")); Environment * env = static_cast<Environment*>(res->Get("Environment")); Camera * camera = static_cast<Camera*>(ctrl->Get("Camera")); ViewInfo * info = camera->GetInfo(); View * view = camera->GetView(); glm::mat4 m_rot = Math::Rotate(0, glfwGetTime() / 150.0, 0); glm::mat4 ModelMatrix = Math::Translation(info->getCameraPos() - info->getDirection()*info->getDistance())* m_rot* Math::Scale(glm::vec3(info->getRenderDistance())); Shader::Enable(); Shader::Set("cube", 0); Shader::Set("MVP", view->getCamera()*ModelMatrix); Shader::Set("MV", view->getViewMatrix() * ModelMatrix); glm::vec4 f = glm::vec4(env->fog_color, 1.0); Shader::Set("fog_color", f); SkyRender::Enable(); Shader::Stop(); }
/*static*/ std::vector<Vector3> EngineHelper::LoadDravenVerts(){ vector<glm::vec3> out_vertices = vector<glm::vec3>(); vector<glm::vec2> out_uvs = vector<glm::vec2>(); vector<glm::vec3> out_normals = vector<glm::vec3>(); vector<Vector3> ret = vector<Vector3>(); ResourceLoader loader = ResourceLoader(); vector<Vector3> manequinVerts = vector<Vector3>(); loader.LoadMeshOBJ("D:/Tools/Development/Dropbox/Workspaces/WorkspaceCpp/Kevlar3D/K3Res/cube.obj",out_vertices,out_uvs,out_normals); int meshSize = out_vertices.size(); for (int i=0;i<meshSize;i++){ ret.push_back(Vector3(out_vertices.at(i))); } return ret; }
std::string ResourceManager::GetFilename( const std::string& path, const ResourceLoader& loader ) { std::string ident( loader.GetIdentifier() + ":" ); std::size_t ident_pos( path.find( ident ) ); if( ident_pos == std::string::npos || ident_pos != 0 ) { return path; } return path.substr( ident.size() ); }
std::shared_ptr<AudioClip> AudioClip::loadResource(ResourceLoader& loader) { bool streaming = loader.getMeta().getBool("streaming", false); int channels = loader.getMeta().getInt("channels", 1); auto result = std::make_shared<AudioClip>(size_t(channels)); if (streaming) { std::shared_ptr<ResourceDataStream> stream = loader.getStream(); Concurrent::execute([stream, result] () { result->loadFromStream(stream); }); } else { loader .getAsync() .then([result](std::unique_ptr<ResourceDataStatic> data) { result->loadFromStatic(std::shared_ptr<ResourceDataStatic>(std::move(data))); }); } return result; }
void ViewerWindow::changeCursor(int type) { HCURSOR hcur = 0; ResourceLoader *rLoader = ResourceLoader::getInstance(); switch (type) { case ConnectionConfig::DOT_CURSOR: hcur = rLoader->loadCursor(IDI_CDOT); break; case ConnectionConfig::SMALL_CURSOR: hcur = rLoader->loadCursor(IDI_CSMALLDOT); break; case ConnectionConfig::NO_CURSOR: hcur = rLoader->loadCursor(IDI_CNOCURSOR); break; case ConnectionConfig::NORMAL_CURSOR: hcur = rLoader->loadStandardCursor(IDC_ARROW); break; } setClassCursor(hcur); }