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();
}
