unsigned int UpdateSpecialItem(std::vector<std::shared_ptr<VisibleObject> > &objVec, Map &map, const unsigned int requiredScore, ResourceManager &resMan) { unsigned int score(requiredScore); if(score > 5000) score += 5000; else score *= 1.5; std::shared_ptr<unsigned int> texture(resMan.GetTexture("scenery2.png")); std::shared_ptr<unsigned int> vao(resMan.GetVao("vao bottom right")); for(auto & obj : objVec) { std::shared_ptr<unsigned int> objVao(obj->GetNextVao()); if(objVao) { if(*(obj->GetTexture()) == *texture && *objVao == *vao) { obj->SwitchVaos(); map.UpdateSpecialObj(glm::ivec2((int)obj->GetX(), (int)obj->GetY())); break; } } } return score; }
void UpdateEnemysDieStatus(std::vector<std::shared_ptr<VisibleObject> > &objVec, ResourceManager &resMan) { std::shared_ptr<unsigned int> wolfTexture(resMan.GetTexture("wolf.png")), bearTexture(resMan.GetTexture("bear.png")), snakeTexture(resMan.GetTexture("snake.png")); for(auto & enemy : objVec) { if(*(enemy->GetTexture()) == *bearTexture || *(enemy->GetTexture()) == *wolfTexture || *(enemy->GetTexture()) == *snakeTexture) { enemy->ChangeCanDie(); } } }
std::string GetName(ResourceManager &resourceManager) { glClearColor(0.0f, 0.0f, 0.0f, 1.0f); std::string name(""); std::vector<std::string> strVec{"Name: ", name}; TextRenderer textRenderer(resourceManager.GetTexture("text.png")); textRenderer.AddTextHorizontalAlign(strVec, TextRenderer::Alignment::Center, TextRenderer::Alignment::Center, 30, glm::vec4(1.0f, 0.0f, 0.0f, 1.0f)); bool playing(true); glfwSetKeyCallback(glfwGetCurrentContext(), GetInput); bool enterPressed(false); while(playing && !glfwWindowShouldClose(glfwGetCurrentContext())) { glClear(GL_COLOR_BUFFER_BIT); name = Input(strVec.back()); if(name != strVec.back()) { textRenderer.RemoveText(strVec.back()); strVec.back() = name; textRenderer.AddTextHorizontalAlign(strVec, TextRenderer::Alignment::Center, TextRenderer::Alignment::Center, 30, glm::vec4(1.0f, 0.0f, 0.0f, 1.0f)); } if(glfwGetKey(glfwGetCurrentContext(), GLFW_KEY_ENTER) == GLFW_PRESS && !enterPressed) { enterPressed = true; } else if(glfwGetKey(glfwGetCurrentContext(), GLFW_KEY_ENTER) == GLFW_RELEASE && enterPressed) { playing = false; if(strVec.back().empty()) { strVec.back() = "Player"; } } textRenderer.DrawAll(); glfwSwapBuffers(glfwGetCurrentContext()); glfwPollEvents(); } return name; }
void ParticleGenerator::Update(Transform eTransform, float dt, float tt) { ResourceManager* rManager = ResourceManager::Instance(); ID3D11DeviceContext* deviceContext = rManager->GetDeviceContext(); UINT stride = sizeof(Particle); UINT offset = 0; generatorVS = dynamic_cast<SimpleVertexShader*>(rManager->GetShader("ParticleGeneratorVS")); generatorGS = dynamic_cast<SimpleGeometryShader*>(rManager->GetShader("ParticleGeneratorGS")); DirectX::XMMATRIX translationMat = DirectX::XMMatrixTranslation(position.x, position.y, position.z); DirectX::XMMATRIX rotationMat = DirectX::XMMatrixRotationRollPitchYaw(eTransform.GetRotation().x * 2, eTransform.GetRotation().y * 2, eTransform.GetRotation().z * 2); DirectX::XMFLOAT4X4 transformMat; DirectX::XMStoreFloat4x4(&transformMat, DirectX::XMMatrixTranspose(translationMat * rotationMat)); DirectX::XMFLOAT3 finalPos = DirectX::XMFLOAT3(eTransform.GetTranslation().x + transformMat._14, eTransform.GetTranslation().y + transformMat._24, eTransform.GetTranslation().z + transformMat._34); // Set constant variables generatorGS->SetFloat("dt", dt); generatorGS->SetFloat("tt", tt); generatorGS->SetFloat3("generatorPos", finalPos); generatorGS->SetFloat("spawnRate", spawnRate); generatorGS->SetFloat("lifeTime", lifeTime); generatorGS->SetSamplerState("randomSampler", rManager->GetSamplerState("trilinear")); generatorGS->SetShaderResourceView("randomTexture", rManager->GetTexture("randomTexture")); // Activate shaders generatorVS->SetShader(true); generatorGS->SetShader(true); deviceContext->PSSetShader(0, 0, 0); // Unbind vertex buffers (incase) ID3D11Buffer* unset = 0; UINT unsetStride = 0; deviceContext->IASetVertexBuffers(0, 1, &unset, &stride, &offset); deviceContext->IASetVertexBuffers(0, 1, &readBuff, &stride, &offset); deviceContext->SOSetTargets(1, &writeBuff, &offset); deviceContext->DrawAuto(); // Kill everything SimpleGeometryShader::UnbindStreamOutStage(deviceContext); deviceContext->GSSetShader(0, 0, 0); SwapBuffers(); }
void DisplayHighscores(ResourceManager &resourceManager) { TextRenderer textRenderer(resourceManager.GetTexture("text.png")); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); textRenderer.AddText("Press Enter To Return To The Main Menu", TextRenderer::Alignment::Center, TextRenderer::Alignment::Bottom, 20, glm::vec4(0.0f, 0.0f, 1.0f, 1.0f)); std::vector<std::string> strVec{"Highscores:"}; if(AddAllTextToHighscores(strVec)) { textRenderer.AddTextVerticalAlign(strVec, TextRenderer::Alignment::Center, TextRenderer::Alignment::Center, 30, glm::vec4(0.0f, 0.0f, 1.0f, 1.0f)); bool enterPressed(false); for(bool playing(true); playing && !glfwWindowShouldClose(glfwGetCurrentContext());) { while(!glfwWindowShouldClose(glfwGetCurrentContext()) && playing) { glClear(GL_COLOR_BUFFER_BIT); if(glfwGetKey(glfwGetCurrentContext(), GLFW_KEY_ENTER) == GLFW_PRESS && !enterPressed) enterPressed = true; else if(glfwGetKey(glfwGetCurrentContext(), GLFW_KEY_ENTER) == GLFW_RELEASE && enterPressed) playing = false; textRenderer.DrawAll(); glfwSwapBuffers(glfwGetCurrentContext()); glfwPollEvents(); } } } return; }
ParticleGenerator::ParticleGenerator(Particle p, DirectX::XMFLOAT3 pos, float lt, float sr, float numRoots) { init = false; lifeTime = lt; spawnRate = sr; position = pos; // Get necessary resources ResourceManager* rManager = ResourceManager::Instance(); ID3D11Device* device = rManager->GetDevice(); ID3D11DeviceContext* deviceContext = rManager->GetDeviceContext(); generatorVS = dynamic_cast<SimpleVertexShader*>(rManager->GetShader("ParticleGeneratorVS")); generatorGS = dynamic_cast<SimpleGeometryShader*>(rManager->GetShader("ParticleGeneratorGS")); // Create Stream Output variables generatorGS->CreateCompatibleStreamOutBuffer(&readBuff, 1000000); generatorGS->CreateCompatibleStreamOutBuffer(&writeBuff, 1000000); // Create initial ROOT vertex buffer UINT stride = sizeof(Particle); UINT offset = 0; Particle vertices[] = { p }; D3D11_BUFFER_DESC vbd; vbd.Usage = D3D11_USAGE_IMMUTABLE; vbd.ByteWidth = sizeof(Particle); vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER; vbd.CPUAccessFlags = 0; vbd.MiscFlags = 0; vbd.StructureByteStride = 0; D3D11_SUBRESOURCE_DATA initialVertexData; initialVertexData.pSysMem = vertices; device->CreateBuffer(&vbd, &initialVertexData, &particleBuff); // Set constant variables generatorGS->SetFloat("dt", 0.0f); generatorGS->SetFloat("tt", 0.0f); generatorGS->SetFloat("lifeTime", lifeTime); generatorGS->SetFloat("spawnRate", spawnRate); generatorGS->SetFloat3("generatorPos", position); generatorGS->SetSamplerState("randomSampler", rManager->GetSamplerState("trilinear")); generatorGS->SetShaderResourceView("randomTexture", rManager->GetTexture("randomTexture")); // Activate shaders generatorVS->SetShader(true); generatorGS->SetShader(true); deviceContext->PSSetShader(0, 0, 0); deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST); // Unbind vertex buffers (incase) ID3D11Buffer* unset = 0; deviceContext->IASetVertexBuffers(0, 1, &unset, &stride, &offset); deviceContext->IASetVertexBuffers(0, 1, &particleBuff, &stride, &offset); deviceContext->SOSetTargets(1, &writeBuff, &offset); deviceContext->Draw(1, 0); SimpleGeometryShader::UnbindStreamOutStage(deviceContext); deviceContext->GSSetShader(0, 0, 0); SwapBuffers(); }
void Scene::AttachComponent(string & compID, GameObject * go, XMLElement* attributesElement) { string tID = compID; auto iter = componentIDValues.find(tID); if (iter == componentIDValues.end()) tID = ""; switch (componentIDValues[tID]) { case COMPONENT_NOTFOUND: cout << "Component " << compID << " does not exist" << endl; return; case CAMERA_BEHAVIOUR: { float fTemp; attributesElement->QueryFloatAttribute("speed", &fTemp); go->AttachComponent(new CameraBehaviour(camera, fTemp)); } break; case TERRAIN: { string texture = TEXTURE_PATH + attributesElement->Attribute("texture"); float scaleX = attributesElement->FloatAttribute("scalex"); float scaleY = attributesElement->FloatAttribute("scaley"); float scaleZ = attributesElement->FloatAttribute("scalez"); go->AttachComponent(new TerrainComp(texture, vec3(scaleX, scaleY, scaleZ))); } break; case SKYBOX: { string name = attributesElement->Attribute("texture1"); string name2 = attributesElement->Attribute("texture2"); bool iTD = false; attributesElement->QueryBoolAttribute("isTimeDay", &iTD); ResourceManager *rm = resourceManager; if (iTD) go->AttachComponent(new Skybox(rm->GetTexture(name), rm->GetModel("skyModel"), rm->GetShader("SkyBox"), rm->GetTexture(name2), iTD)); if (!iTD) go->AttachComponent(new Skybox(rm->GetTexture(name), rm->GetModel("skyModel"), rm->GetShader("SkyBox"), rm->GetTexture(name), iTD)); } break; case TIMEDAY: { string tF = attributesElement->Attribute("font"); go->AttachComponent(new TimeDay(resourceManager->GetFont(tF))); } break; case MOVEGOBEHAVIOUR: go->AttachComponent(new MoveGameObjectBehaviour()); break; case LIGHT: { string colorString = attributesElement->Attribute("color"); vector<string> splits = split(colorString, ','); float r = atof(splits[0].c_str()); float g = atof(splits[1].c_str()); float b = atof(splits[2].c_str()); float a = atof(splits[3].c_str()); vec4 color(r, g, b, a); go->AttachComponent(new Light(color)); } break; case WATERCOMP: { go->AttachComponent(new WaterComp()); } break; } }
void MenuWidget::OnConstantItemActivated(const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn* /* column */) { Gtk::TreeModel::iterator iter = m_ConstantTableTreeModel->get_iter(path); if (iter) { Gtk::TreeModel::Row row = *iter; if (!iter->parent()->get_stamp() || !iter->parent()->parent()->get_stamp()) return; // Not good; std::cout << "Row activated: Name=" << row->get_value(m_TableColumn) << std::endl; for (unsigned int p = 0; p < m_arrShaderPassDesc.size(); p++) { if (m_arrShaderPassDesc[p].name == row->parent()->parent()->get_value(m_TableColumn)) { for (unsigned int i = 0; i < m_arrShaderPassDesc[p].constants.size(); i++) { if (m_arrShaderPassDesc[p].constants[i].name == row->get_value(m_TableColumn)) { switch (m_arrShaderPassDesc[p].constants[i].inputType) { case IT_BOOL: case IT_FLOAT: case IT_INT: { Gtk::Dialog matrixDialog; Gtk::VBox rowBox; Gtk::HBox colBox[4]; Gtk::Entry entry[16]; for (unsigned int j = 0; j < 16; j++) { char temp[32]; sprintf_s(temp, "%f", m_arrShaderPassDesc[p].constants[i].valueFloat[j]); entry[j].set_text(temp); } unsigned int rows = m_arrShaderPassDesc[p].constants[i].rows; unsigned int cols = m_arrShaderPassDesc[p].constants[i].cols; unsigned int sizeOfArray = m_arrShaderPassDesc[p].constants[i].sizeOfArray; matrixDialog.get_vbox()->pack_start(rowBox); for (unsigned int r = 0; r < rows; r++) { rowBox.pack_start(colBox[r]); for (unsigned int c = 0; c < cols; c++) { colBox[r].pack_start(entry[r*cols + c]); } } matrixDialog.add_button(GTK_STOCK_OK, Gtk::RESPONSE_OK); matrixDialog.set_modal(); matrixDialog.show_all(); int ret = matrixDialog.run(); if (ret == Gtk::RESPONSE_OK) for (unsigned int r = 0; r < rows; r++) for (unsigned int c = 0; c < cols; c++) { m_arrShaderPassDesc[p].constants[i].valueFloat[r*cols + c] = (float)atof(entry[r*cols + c].get_text().c_str()); } break; } case IT_SAMPLER: case IT_SAMPLER1D: case IT_SAMPLER2D: case IT_SAMPLER3D: case IT_SAMPLERCUBE: { Gtk::FileChooserDialog textureDialog("Choose texture file"); textureDialog.add_button("Select", Gtk::RESPONSE_OK); int ret = textureDialog.run(); if (ret == Gtk::RESPONSE_OK) { Renderer* render = Renderer::GetInstance(); ResourceManager* resMan = render->GetResourceManager(); const unsigned int texIdx = resMan->CreateTexture(textureDialog.get_filename().c_str()); m_arrShaderPassDesc[p].constants[i].sampler.boundTexture = resMan->GetTexture(texIdx); } break; } default: return; } return; } } return; } } } }
bool PlayGame(Map &map, ResourceManager &resourceManager, const unsigned int livesIn) { bool nextMap(true), menu(true); SoundPlayer soundPlayer(alcGetCurrentContext()); unsigned int lives(livesIn); unsigned int specialItemScoreRequired(1000); unsigned int score(0), changedScore(score); TextRenderer textRender(resourceManager.GetTexture("text.png")); std::vector<std::string> stringVec{"Score:", "0"}; std::vector<std::string> livesVec{"Lives: ", std::to_string(lives)}; textRender.AddTextVerticalAlign(stringVec, TextRenderer::Alignment::Right, TextRenderer::Alignment::Top, 20.0f); textRender.AddTextHorizontalAlign(livesVec, TextRenderer::Alignment::Right, TextRenderer::Alignment::Bottom, 20.0f); glm::mat4 view(glm::ortho(0.0f, 40.0f, 0.0f, 30.0f, 1.0f, -1.0f)); std::vector<std::shared_ptr<VisibleObject>> objectVec; std::vector<Movement> movementVec; std::vector<std::shared_ptr<AI>> aiVec; std::vector<float> aiStateSwitchTimes; std::vector<DeadPlayers> deadPlayerVec; int level(0); int timesToChange(7); while(nextMap && !glfwWindowShouldClose(glfwGetCurrentContext())) { ++level; timesToChange = UpdateAiSwitchVec(aiStateSwitchTimes, timesToChange, level); bool playing = true; map.LoadNextMap(); GetVecFullOfObjects(objectVec, map, resourceManager, aiVec); textRender.AddTextHorizontalAlign(livesVec, TextRenderer::Alignment::Right, TextRenderer::Alignment::Bottom, 20.0f); CollisionDetection collisionDetect; collisionDetect.AddPlayersAndEnemys(objectVec); map.HideSpecialObj(); double currTime = glfwGetTime(), prevTime = glfwGetTime(), mapStartTime = glfwGetTime(), enemyKillFinish(0.0); while(playing && !glfwWindowShouldClose(glfwGetCurrentContext())) { glClear(GL_COLOR_BUFFER_BIT); if(AISwitchModes(aiVec, currTime - mapStartTime, aiStateSwitchTimes.back())) { soundPlayer.AddToPlay(*(resourceManager.GetSound("wolfhowl.ogg"))); aiStateSwitchTimes.erase(aiStateSwitchTimes.end() - 1); } if(score >= specialItemScoreRequired) specialItemScoreRequired = UpdateSpecialItem(objectVec, map, specialItemScoreRequired, resourceManager); if(enemyKillFinish != 0.0) { if(currTime >= enemyKillFinish) { UpdateEnemysDieStatus(objectVec, resourceManager); enemyKillFinish = 0.0; } } if(!deadPlayerVec.empty()) { for(auto player(deadPlayerVec.begin()); player != deadPlayerVec.end();) { if((*player).timeEnemyShouldLive <= currTime) { (*player).player->SwitchDeathVao(); (*player).player->ResetToOriginalSquare(); player = deadPlayerVec.erase(player); } else ++player; } } if(GetInput(movementVec, aiVec, map)) { if(PauseMenu(resourceManager, menu)) { playing = false; nextMap = false; break; } glfwSetTime(currTime); } for(auto & obj : objectVec) { if(obj->GetPlayer() > 0) { UpdatePlayerMovement(obj, movementVec, map, currTime - prevTime); if(obj->GetPlayer() == 1) { if(UpdateMap(obj, objectVec, map, changedScore, soundPlayer, resourceManager)) { if(enemyKillFinish == 0.0f) { enemyKillFinish = currTime; UpdateEnemysDieStatus(objectVec, resourceManager); } currTime -= 5.0; glfwSetTime(currTime); } if(score != changedScore) { UpdateScore(changedScore, textRender, stringVec); score = changedScore; if(map.HasFinished()) { playing = false; nextMap = true; } } } } obj->Draw(view); } textRender.DrawAll(); if(collisionDetect.DetectCollisions(lives, changedScore, deadPlayerVec, resourceManager, soundPlayer)) { soundPlayer.AddToPlay(*(resourceManager.GetSound("death.ogg"))); if(UpdateLives(lives, textRender, livesVec)) { playing = false; nextMap = false; UpdateHighscore(score, resourceManager); } } glfwSwapBuffers(glfwGetCurrentContext()); glfwPollEvents(); prevTime = currTime; currTime = glfwGetTime(); } } if(glfwWindowShouldClose(glfwGetCurrentContext())) nextMap = false; return menu; }
void CreateResources(ResourceManager &resourceManager) { std::vector<Textures> texVec; std::vector<Sounds> soundVec; if(!resourceManager.GetTexture("geoff.png")) texVec.push_back(Textures("geoff.png")); if(!resourceManager.GetTexture("wolf.png")) texVec.push_back(Textures("wolf.png")); if(!resourceManager.GetTexture("bear.png")) texVec.push_back(Textures("bear.png")); if(!resourceManager.GetTexture("scenery.png")) texVec.push_back(Textures("scenery.png")); if(!resourceManager.GetTexture("scenery2.png")) texVec.push_back(Textures("scenery2.png")); if(!resourceManager.GetTexture("text.png")) texVec.push_back(Textures("text.png")); if(!resourceManager.GetTexture("snake.png")) texVec.push_back(Textures("snake.png")); if(!resourceManager.GetSound("bear.ogg")) soundVec.push_back(Sounds("bear.ogg")); if(!resourceManager.GetSound("chainsaw.ogg")) soundVec.push_back(Sounds("chainsaw.ogg")); if(!resourceManager.GetSound("chop.ogg")) soundVec.push_back(Sounds("chop.ogg")); if(!resourceManager.GetSound("death.ogg")) soundVec.push_back(Sounds("death.ogg")); if(!resourceManager.GetSound("snake.ogg")) soundVec.push_back(Sounds("snake.ogg")); if(!resourceManager.GetSound("wolfhowl.ogg")) soundVec.push_back(Sounds("wolfhowl.ogg")); if(!resourceManager.GetSound("woodpile.ogg")) soundVec.push_back(Sounds("woodpile.ogg")); resourceManager.GetOrCreateProgram("textured.vs", "textured.fs"); resourceManager.GetOrCreateProgram("character.vs", "textured.fs"); resourceManager.GetOrCreateProgram("colouredsquare.vs", "colouredsquare.fs"); std::shared_ptr<unsigned int> buffer(resourceManager.GetVao("buffer")); if(!buffer) { buffer = std::make_shared<unsigned int>(CreateBuffer()); resourceManager.AddVao("buffer", buffer); } if(!resourceManager.GetVao("full vao")) { std::shared_ptr<unsigned int> vao(new unsigned int (CreateVAO(*buffer, 1))); resourceManager.AddVao("full vao", vao); } if(!resourceManager.GetVao("vao top left")) { std::shared_ptr<unsigned int> vaoTopLeft(new unsigned int (CreateVAO(*buffer, 2))); resourceManager.AddVao("vao top left", vaoTopLeft); } if(!resourceManager.GetVao("vao top right")) { std::shared_ptr<unsigned int> vaoTopRight(new unsigned int (CreateVAO(*buffer, 3))); resourceManager.AddVao("vao top right", vaoTopRight); } if(!resourceManager.GetVao("vao bottom left")) { std::shared_ptr<unsigned int> vaoBottomLeft(new unsigned int (CreateVAO(*buffer, 4))); resourceManager.AddVao("vao bottom left", vaoBottomLeft); } if(!resourceManager.GetVao("vao bottom right")) { std::shared_ptr<unsigned int> vaoBottomRight(new unsigned int (CreateVAO(*buffer, 5))); resourceManager.AddVao("vao bottom right", vaoBottomRight); } if(!resourceManager.GetVao("vao plain colour")) { std::shared_ptr<unsigned int> vaoPlainColour(new unsigned int (SetupStandardVAO(*buffer))); resourceManager.AddVao("vao plain colour", vaoPlainColour); } CreateTexturesAndSound(texVec, soundVec); for(auto object(texVec.begin()); object != texVec.end(); ++object) { std::shared_ptr<unsigned int> ptr( new unsigned int(CreateOpenGLTexture((*object).texVec, (*object).width, (*object).height))); resourceManager.AddTexture((*object).filename, ptr); } texVec.clear(); for(auto object(soundVec.begin()); object != soundVec.end(); ++object) { std::shared_ptr<unsigned int> ptr( new unsigned int(object->sound)); resourceManager.AddSound((*object).filename, ptr); } soundVec.clear(); }