void Duck::update(float deltaTime){
spriteTimer += deltaTime;
if(spriteTimer <= 0.3f && !this->dead){
this->setPng("assets/enemies/devil_duck_walk1.png");
}else if(spriteTimer > 0.3f&& !this->dead){
this->setPng("assets/enemies/devil_duck_walk2.png");
}
if(spriteTimer <= 0.1f && this->dead){
this->setPng("assets/sheep/Loop0001.png");
}else if(spriteTimer <= 0.15f&& this->dead){
this->setPng("assets/sheep/Loop0002.png");
}else if(spriteTimer <= 0.2f&& this->dead){
this->setPng("assets/sheep/Loop0003.png");
}else if(spriteTimer <= 0.25f&& this->dead){
this->setPng("assets/sheep/Loop0004.png");
}else if(spriteTimer <= 0.3f&& this->dead){
this->setPng("assets/sheep/Loop0005.png");
}
if(!this->dead){
if(spriteTimer >= 0.6f){
spriteTimer = 0;
}
}else{
if(spriteTimer >= 0.35f){
spriteTimer = 0;
}
}
handleMovement(deltaTime);
}
void Player::update()
{
fireLaser();
handleInput();
m_velocity = handleMovement();
m_position += m_velocity;
handleCollisions();
//std::cout << "Enemy Size: " << EnemyManager::instance()->getEnemies().size() << "\n";
//std::cout << "Asteroid Size: " << AsteroidManagement::instance()->getAsteroids().size() << "\n";
//std::cout << "PLayer Laser Size: " << LaserHandler::instance()->getPlayerLasers().size() << "\n";
//std::cout << "Enemy Laser Size: " << LaserHandler::instance()->getEnemyLasers().size() << "\n\n\n";
}
int main(void)
{
setupHardware();
printf("\r\n++++++++++++++++++++++\r\n");
printf("Megalan Controller 2.3\r\n");
printf("++++++++++++++++++++++\r\n");
initializeVariables();
//wait pir to stabilize
delayMs(1000);
while (1)
{
printf("\r\nAwake\r\n");
if (processIRCommand)
{
handleIR();
}
if (checkPIR() && !pirActive)
{
handleMovement();
}
else if (!checkPIR() && pirActive)
{
handleMovementMissing();
}
if (rtcAlarm)
{
handleRTC();
}
gotoSLEEP();
//wait a bit
//otherwise we may put the device
//to sleep while it is receiving commands!
delayMs(500);
}
}
void Flying::update()
{
if (m_bXCollision)
{
m_velocity.x(-m_xSpeed);
}
else
{
m_velocity.x(m_xSpeed);
}
if (m_bYCollision)
{
m_velocity.y(m_ySpeed);
}
else
{
m_velocity.y(-m_ySpeed);
}
handleMovement(m_velocity);
handleAnimation();
}
void Chaser::update()
{
if (m_playerPos != nullptr)
{
Vector2D diff = *m_playerPos - m_position;
// Check if player is inside Chaser field of vision
if (diff.length() <= m_viewDistance)
{
if (abs(diff.x()) < m_treshold)
{
// Player caught in x axis, stop
m_velocity.x(0);
}
else
{
if (diff.x() < 0)
{
// x speed can be negative so we have to take abs value
m_velocity.x(-abs(m_xSpeed));
}
else if (diff.x() > 0)
{
//m_velocity.x(m_xSpeed);
m_velocity.x(abs(m_xSpeed));
}
}
}
else
{
// Player is outside Chaser's vision camp
m_velocity.x(0);
}
m_velocity.y(m_ySpeed);
handleMovement(m_velocity);
}
handleAnimation();
}
void Ball::update()
{
handleMovement();
}
int main()
{
GLsizei multiSamples = 8;
GLFWwindow* window = initWindow();
if (window == nullptr)
{
std::cout << "Unable to initialize window." << std::endl;
return -1;
}
// Start the timer
GLfloat deltaTime, lastFrame, currentFrame;
lastFrame = 0.0f;
currentFrame = 0.0f;
// Setup the viewport;
GLfloat screenWidth = 800, screenHeight = 600;
glViewport(0, 0, screenWidth, screenHeight);
// Setup Camera
Camera cam = initCamera();
glfwSetWindowUserPointer(window, &cam);
// Load Models
Model planet = Model("./Models/planet/planet.obj");
Model asteroid = Model("./Models/rock/rock.obj");
// Load and Compile Shaders
GLuint program = compileShaders("../OpenGL3-3/shaders/advanced/instance/basic.vert.glsl", "../OpenGL3-3/shaders/advanced/instance/basic.frag.glsl");
GLuint modelShader = compileShaders("../OpenGL3-3/shaders/newModel/model.vert.glsl", "../OpenGL3-3/shaders/newModel/model.frag.glsl");
GLuint instancedModelShader = compileShaders("../OpenGL3-3/shaders/newModel/imodel.vert.glsl", "../OpenGL3-3/shaders/newModel/model.frag.glsl");
GLuint frameBufferShader = compileShaders("../OpenGL3-3/shaders/advanced/fbo.vert.glsl", "../OpenGL3-3/shaders/advanced/fbo.frag.glsl");
// Setup MVP model
glm::mat4 model, view, proj;
view = cam.GetViewMatrix();
proj = glm::perspective(glm::radians(45.0f), (float)screenWidth / (float)screenHeight, 0.1f, 1000.0f);
#pragma region quad
GLfloat quadVertices[] = {
// Positions // Colors
-0.05f, 0.05f, 1.0f, 0.0f, 0.0f,
0.05f, -0.05f, 0.0f, 1.0f, 0.0f,
-0.05f, -0.05f, 0.0f, 0.0f, 1.0f,
-0.05f, 0.05f, 1.0f, 0.0f, 0.0f,
0.05f, -0.05f, 0.0f, 1.0f, 0.0f,
0.05f, 0.05f, 0.0f, 1.0f, 1.0f
};
glm::vec2 translations[100];
int index = 0;
GLfloat offset = 0.1f;
for (GLint y = -10; y < 10; y += 2)
{
for (GLint x = -10; x < 10; x += 2)
{
glm::vec2 translation;
translation.x = (GLfloat)x / 10.0f + offset;
translation.y = (GLfloat)y / 10.0f + offset;
translations[index++] = translation;
}
}
GLfloat fboQuad[] =
{
-1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, -1.0f, 0.0f, 0.0f,
1.0f, -1.0f, 1.0f, 0.0f,
1.0f, -1.0f, 1.0f, 0.0f,
1.0f, 1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, 0.0f, 1.0f
};
#pragma endregion
GLuint VBO, VAO, instanceVBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &instanceVBO);
glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec2) * 100, &translations[0], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Create the Framebuffer
GLuint FBO;
glGenFramebuffers(1, &FBO);
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, texture);
glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, multiSamples, GL_RGB, screenWidth, screenHeight, GL_TRUE);// , GL_RGB, 800, 600, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, texture, 0);
GLuint sampleRBO;
glGenRenderbuffers(1, &sampleRBO);
glBindRenderbuffer(GL_RENDERBUFFER, sampleRBO);
glRenderbufferStorageMultisample(GL_RENDERBUFFER, multiSamples, GL_DEPTH24_STENCIL8, screenWidth, screenHeight);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, sampleRBO);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
std::cout << "FRAMEBUFFER INCOMPLETE!" << std::endl;
glBindFramebuffer(GL_FRAMEBUFFER, 0);
GLuint regularFBO;
glGenFramebuffers(1, ®ularFBO);
glBindFramebuffer(GL_FRAMEBUFFER, regularFBO);
GLuint tex;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screenWidth, screenHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
std::cout << "FRAMEBUFFER 2 INCOMPLETE!" << std::endl;
glBindFramebuffer(GL_FRAMEBUFFER, 0);
GLuint fboVAO, fboVBO;
glGenVertexArrays(1, &fboVAO);
glGenBuffers(1, &fboVBO);
glBindVertexArray(fboVAO);
glBindBuffer(GL_ARRAY_BUFFER, fboVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(fboQuad), fboQuad, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)(2*sizeof(GLfloat)));
glBindVertexArray(0);
glBindVertexArray(VAO);
{
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), quadVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 5, (GLvoid*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 5, (GLvoid*)(sizeof(GLfloat) * 2));
glEnableVertexAttribArray(2);
glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (GLvoid*)0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glVertexAttribDivisor(2, 1);
}
glBindVertexArray(0);
std::cout << sizeof(glm::mat4) << std::endl;
const int amount = 100000;
glm::mat4* modelMats;
modelMats = new glm::mat4[amount];
srand(glfwGetTime());
GLfloat radius = 150.0f;
offset = 25.0f;
for (GLuint i = 0; i < amount; i++)
{
glm::mat4 model;
GLfloat angle = (GLfloat)i / (GLfloat)amount * 360.0f;
GLfloat displacement = (rand() % (GLint)(2 * offset)) / 100.0f - offset;
GLfloat x = sin(angle) * radius + displacement;
displacement = (rand() % (GLint)(2 * offset * 100)) / 100.0f - offset;
GLfloat y = displacement * 0.4f;
displacement = (rand() % (GLint)(2 * offset * 100)) / 100.0f - offset;
GLfloat z = cos(angle) * radius + displacement;
model = glm::translate(model, glm::vec3(x, y, z));
GLfloat scale = (rand() % 20) / 100.0f + 0.05f;
model = glm::scale(model, glm::vec3(scale));
GLfloat rotAngle = (rand() % 360);
model = glm::rotate(model, rotAngle, glm::vec3(0.4f, 0.6f, 0.8f));
modelMats[i] = model;
}
for (GLuint i = 0; i < asteroid.meshes.size(); i++)
{
GLuint VAO = asteroid.meshes[i].VAO;
GLuint buffer;
glBindVertexArray(VAO);
glGenBuffers(1, &buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glBufferData(GL_ARRAY_BUFFER, amount * sizeof(glm::mat4), &modelMats[0], GL_STATIC_DRAW);
GLsizei vec4Size = sizeof(glm::vec4);
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)0);
glEnableVertexAttribArray(4);
glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)(vec4Size));
glEnableVertexAttribArray(5);
glVertexAttribPointer(5, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)(2 * vec4Size));
glEnableVertexAttribArray(6);
glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)(3 * vec4Size));
glVertexAttribDivisor(3, 1);
glVertexAttribDivisor(4, 1);
glVertexAttribDivisor(5, 1);
glVertexAttribDivisor(6, 1);
glBindVertexArray(0);
}
glUseProgram(modelShader);
glUniformMatrix4fv(glGetUniformLocation(modelShader, "projection"), 1, GL_FALSE, glm::value_ptr(proj));
glUseProgram(instancedModelShader);
glUniformMatrix4fv(glGetUniformLocation(instancedModelShader, "projection"), 1, GL_FALSE, glm::value_ptr(proj));
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
while (!glfwWindowShouldClose(window))
{
glfwPollEvents();
currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
handleMovement(window, deltaTime);
glUseProgram(instancedModelShader);
glUniformMatrix4fv(glGetUniformLocation(instancedModelShader, "view"), 1, GL_FALSE, glm::value_ptr(cam.GetViewMatrix()));
glUseProgram(modelShader);
glUniformMatrix4fv(glGetUniformLocation(modelShader, "view"), 1, GL_FALSE, glm::value_ptr(cam.GetViewMatrix()));
glm::mat4 model;
model = glm::translate(model, glm::vec3(0.0f, -5.0f, 0.0f));
model = glm::scale(model, glm::vec3(4.0f));
glUniformMatrix4fv(glGetUniformLocation(modelShader, "model"), 1, GL_FALSE, glm::value_ptr(model));
planet.draw(modelShader);
glUseProgram(instancedModelShader);
glBindTexture(GL_TEXTURE_2D, asteroid.textures_loaded[0].id);
for (GLuint i = 0; i < asteroid.meshes.size(); i++)
{
glBindVertexArray(asteroid.meshes[i].VAO);
glDrawElementsInstanced(GL_TRIANGLES, asteroid.meshes[i].vertices.size(), GL_UNSIGNED_INT, 0, amount);
glBindVertexArray(0);
}
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebuffer(GL_READ_FRAMEBUFFER, FBO);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, regularFBO);
glBlitFramebuffer(0, 0, screenWidth, screenHeight, 0, 0, screenWidth, screenHeight, GL_COLOR_BUFFER_BIT, GL_NEAREST);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
glUseProgram(frameBufferShader);
glBindVertexArray(fboVAO);
glBindTexture(GL_TEXTURE_2D, tex);
//glUniform1i(glGetUniformLocation(frameBufferShader, "myTexture"), 0);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
glBindTexture(GL_TEXTURE_2D, 0);
glfwSwapBuffers(window);
}
glfwTerminate();
return 0;
}
