velage/engine/object.cpp

#include "object.hpp"
#include "camera.hpp"
#include "rendering.hpp"
#include "shader.hpp"
#include "vector.hpp"
#include <glm/detail/qualifier.hpp>
#include <glm/ext/matrix_float4x4.hpp>
#include <glm/ext/matrix_transform.hpp>
#include <glm/ext/quaternion_exponential.hpp>
#include <glm/ext/vector_float3.hpp>
#include <glm/fwd.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <iostream>
#include <string>
#include <vector>

void cke();

vertex::vertex(GLfloat x, GLfloat y, GLfloat z) { pos = vector3f(x, y, z); }

glm::mat4 scaleMatAroundPoint(glm::mat4 mat, glm::vec3 pivot, glm::vec3 scalar){
  return glm::translate(glm::mat4(1.0),-pivot)
    * glm::scale(mat, scalar)
    * glm::translate(glm::mat4(1.0), pivot);

  // return 
  // glm::translate(
  //   glm::scale(
  //       glm::translate(mat, pivot)
  //     , scalar)
  //   , -pivot)
  // ;
}

glm::mat4 toCameraWorldSpace(glm::mat4 scaleMat, glm::mat4 rotMat, glm::mat4 posMat, glm::vec3 campos, GLfloat distmult){
  return scaleMat * glm::scale(glm::mat4(1.0), glm::vec3(1.0/distmult)) 
    * scaleMatAroundPoint(posMat, campos, glm::vec3(1.0/distmult))
    * rotMat;
}

void gameobject::render(camera cam) {
  GLint current;
  // glBindBuffer(GL_ARRAY_BUFFER, vao);
  rend_shader->use();
  setUniform(cam.proj, shdProjId);


  if(!spaceAct) setUniform(cam.view, shdViewId);
  else{
    glm::quat corrRot=cam.rotation*glm::angleAxis(glm::radians(90.f), glm::vec3(1.f, 0.f, 0.f) * cam.rotation);
    setUniform(glm::toMat4(corrRot), shdViewId);
  }
  glBindVertexArray(vao);

  setUniform(
    toCameraWorldSpace(scaleMatrix, rotationMatrix, positionMatrix, cam.pos, distmult),
    shdTrnsId);


  // draw
  glDrawElementsBaseVertex(GL_TRIANGLES, element_number, GL_UNSIGNED_INT, 0, 0);
  glBindVertexArray(0);
}
/*
 * render in world space 
 * shdProjId and shdViewId must be set
 */


void gameobject::render(camera cam, shader *shader) {
  setUniform(cam.proj, shdProjId);

  if(!spaceAct) setUniform(cam.view, shdViewId);
  else{
    glm::quat corrRot=cam.rotation*glm::angleAxis(glm::radians(90.f), glm::vec3(1.f, 0.f, 0.f) * cam.rotation);
    setUniform(glm::toMat4(corrRot), shdViewId);
  }

  GLint current;
  // glBindBuffer(GL_ARRAY_BUFFER, vao);
  glBindVertexArray(vao);
  shader->use();
  setUniform(
    toCameraWorldSpace(scaleMatrix, rotationMatrix, positionMatrix, cam.pos, distmult),
    shdTrnsId);


  // draw
  glDrawElementsBaseVertex(GL_TRIANGLES, element_number, GL_UNSIGNED_INT, 0, 0);
  glBindVertexArray(0);
}

gameobject::gameobject(shader *render_shader) {
  rend_shader = render_shader;

  glGenVertexArrays(1, &vao);
  glBindVertexArray(vao);

  glGenBuffers(NUM_BUFFERS, vbo); // Generate 1 buffer

  glBindVertexArray(0);

  scaleMatrix = positionMatrix = rotationMatrix = glm::mat4(1.0f);

  glGenVertexArrays(1, &shadowVao);
  //glBindVertexArray(shadowVao);

  //glGenBuffers(1,shadowVbo); // Generate 1 buffer

  //glBindVertexArray(0);
}

void gameobject::genEbo(GLuint elements[], GLuint size) {

  this->elements = elements;
  element_number = size;

  glBindVertexArray(vao);

  // glGenBuffers(1, &ebo); // Generate 1 buffer

  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[INDEX_BUFFER]);

  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * element_number,
               elements, GL_STATIC_DRAW);

  //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[INDEX_BUFFER]);

  glBindVertexArray(0);
}

void gameobject::genEboShadow() {

  glBindVertexArray(shadowVao);

  // glGenBuffers(1, &ebo); // Generate 1 buffer

  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[INDEX_BUFFER]);

  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * element_number,
               elements, GL_STATIC_DRAW);

  //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[INDEX_BUFFER]);

  glBindVertexArray(0);
}

void gameobject::genVbo(vertex vertices[], GLuint size) {
  glBindVertexArray(vao);

  this->vertices = vertices;
  vertice_number = size;

  glBindBuffer(GL_ARRAY_BUFFER, vbo[VERTEX_BUFFER]);

  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * size, vertices,
               GL_STATIC_DRAW);

  // glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[VERTEX_BUFFER]);

  glBindVertexArray(0);
}

void gameobject::genVbo(glm::vec3 vertices[], GLuint size) {
  glBindVertexArray(vao);

  //this->vertices = vertices;
  vertice_number = size;

  glBindBuffer(GL_ARRAY_BUFFER, vbo[VERTEX_BUFFER]);

  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * size, vertices,
               GL_STATIC_DRAW);

  // glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[VERTEX_BUFFER]);

}

void gameobject::genVboShadow() {
  glBindVertexArray(shadowVao);

  glBindBuffer(GL_ARRAY_BUFFER, vbo[VERTEX_BUFFER]);

  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertice_number, vertices,
               GL_STATIC_DRAW);

  // glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[VERTEX_BUFFER]);

  glBindVertexArray(0);
}

void gameobject::setBuffer(vertex vertices[], GLuint size, buffers buffer) {
  glBindVertexArray(vao);

  glBindBuffer(GL_ARRAY_BUFFER, vbo[buffer]);

  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * size, vertices,
               GL_STATIC_DRAW);

  // glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[VERTEX_BUFFER]);

  glBindVertexArray(0);
}

void gameobject::setUniform(glm::mat4 matrix, std::string name) {
  //glBindVertexArray(vao);
  glUniformMatrix4fv(rend_shader->getUniformId(name),1,GL_FALSE, glm::value_ptr(matrix));

  //glBindVertexArray(0);
}

void gameobject::setUniform(glm::mat4 matrix, GLint name) {
  //glBindVertexArray(vao);
  glUniformMatrix4fv(name,1,GL_FALSE, glm::value_ptr(matrix));

  //glBindVertexArray(0);
}

void gameobject::setUniform(float v, std::string name) {
  //glBindVertexArray(vao);
  glUniform1f(rend_shader->getUniformId(name), v);

  //glBindVertexArray(0);
}

void gameobject::setUniform(float v, GLint name) {
  //glBindVertexArray(vao);
  glUniform1f(name,v);

  //glBindVertexArray(0);
}

void gameobject::setUniform(glm::vec3 v, std::string name) {
  //glBindVertexArray(vao);
  glUniform3f(rend_shader->getUniformId(name),v.x,v.y,v.z);

  //glBindVertexArray(0);
}

void gameobject::setUniform(glm::vec3 v, GLint name) {
  //glBindVertexArray(vao);
  glUniform3f(name,v.x,v.y,v.z);

  //glBindVertexArray(0);
}

void gameobject::setVertexAtribPointer(std::string param, const void *pointer) {
  glBindVertexArray(vao);

  GLint posAttrib = rend_shader->getInputId(param);
  glEnableVertexAttribArray(posAttrib);
  std::cout << posAttrib;
  glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE,
                        0 /*stride * sizeof(GL_FLOAT)*/, pointer);

  glBindVertexArray(0);
}
void gameobject::setVertexAtribPointerShadow(std::string param, shader *depthshd, const void *pointer) {
  glBindVertexArray(shadowVao);

  GLint posAttrib = depthshd->getInputId(param);
  glEnableVertexAttribArray(posAttrib);
  std::cout << posAttrib;
  glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE,
                        0 /*stride * sizeof(GL_FLOAT)*/, pointer);

  glBindVertexArray(0);
}

gameobject::~gameobject(){
  glDeleteBuffers(1, &vao);
  glDeleteBuffers(NUM_BUFFERS, vbo);
}

void gameobject::renderShadows(light clight, GLuint SHADOW_WIDTH, GLuint SHADOW_HEIGHT, GLuint depthCubemap, shader *depthshd, GLuint dfbo, float farClipPlane, camera cam, bool first){
  depthshd->use();
  glBindVertexArray(vao);
  float aspect = (float)SHADOW_WIDTH/(float)SHADOW_HEIGHT;    
  float near = 0.1f;    
  float far = farClipPlane;    
  glm::mat4 shadowProj = glm::perspective(glm::radians(90.0f), aspect, near, far);

  glm::mat4 shadowTransfr[6];

  shadowTransfr[0]=shadowProj*glm::lookAt(clight.position, clight.position + glm::vec3(1.,0.,0.), glm::vec3(0.,-1., 0.));
  shadowTransfr[1]=shadowProj*glm::lookAt(clight.position, clight.position + glm::vec3(-1.,0.,0.), glm::vec3(0.,-1., 0.));
  shadowTransfr[2]=shadowProj*glm::lookAt(clight.position, clight.position + glm::vec3(0.,1.,0.), glm::vec3(0.,0.,  1.));
  shadowTransfr[3]=shadowProj*glm::lookAt(clight.position, clight.position + glm::vec3(0.,-1.,0.), glm::vec3(0.,0.,  -1.));
  shadowTransfr[4]=shadowProj*glm::lookAt(clight.position, clight.position + glm::vec3(0.,0.,1.), glm::vec3(0.,-1., 0.));
  shadowTransfr[5]=shadowProj*glm::lookAt(clight.position, clight.position + glm::vec3(0.,0.,-1.), glm::vec3(0.,-1., 0.));

  glViewport(0, 0, SHADOW_WIDTH,SHADOW_HEIGHT);

  glBindFramebuffer(GL_FRAMEBUFFER, dfbo);

  if(first){glClear(GL_DEPTH_BUFFER_BIT);}


  for (int i=0; i<6; i++) {
    setUniform(shadowTransfr[i], depthshd->getUniformId("shadowMatrices[" + std::to_string(i) + "]"));
  }
  setUniform(farClipPlane,depthshd->getUniformId("far_plane"));
  setUniform(clight.position,depthshd->getUniformId("lightPos"));
  setUniform(glm::mat4(1),depthshd->getUniformId("model"));


  //glActiveTexture(GL_TEXTURE0);
  //glBindTexture(GL_TEXTURE_CUBE_MAP, depthCubemap); 

  //glBindVertexArray(vao);

  if(!spaceAct) setUniform(cam.view, shdViewId);
  else{
    glm::quat corrRot=cam.rotation*glm::angleAxis(glm::radians(90.f), glm::vec3(1.f, 0.f, 0.f) * cam.rotation);
    setUniform(glm::toMat4(corrRot), shdViewId);
  }

  setUniform(
     toCameraWorldSpace(scaleMatrix, rotationMatrix, -positionMatrix, clight.position, distmult),
    shdTrnsId);


  // draw
  glDrawElementsBaseVertex(GL_TRIANGLES, element_number, GL_UNSIGNED_INT, 0, 0);
  glBindVertexArray(0);
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
  glViewport(0, 0, 800,600);

  //cke();

}

void gameobject::renderShadowCalc(camera cam, shader *shadowCalc){

  shadowCalc->use();

  setUniform(cam.proj, shdProjId);
  if(!spaceAct) setUniform(cam.view, shdViewId);
  else{
    glm::quat corrRot=cam.rotation*glm::angleAxis(glm::radians(90.f), glm::vec3(1.f, 0.f, 0.f) * cam.rotation);
    setUniform(glm::toMat4(corrRot), shdViewId);
  }

  glBindBuffer(GL_ARRAY_BUFFER, vao);
  glBindVertexArray(vao);

  

  setUniform(
    toCameraWorldSpace(scaleMatrix, rotationMatrix, positionMatrix, cam.pos, distmult),
    shdTrnsId);

  // draw
  glDrawElementsBaseVertex(GL_TRIANGLES, element_number, GL_UNSIGNED_INT, 0, 0);
  glBindVertexArray(0);
}


void gameobject::updateMatrix(camera cam){
  double clipPlane = 100; //temporary hack
  // vector Raw
  glm::vec4 vr = spacePos.toFloatSpace(clipPlane, cam.spacePos);

  positionMatrix = glm::translate(glm::mat4(1.0),glm::vec3(vr));

  scaleMatrix = glm::scale(glm::mat4(1.0), glm::vec3(glm::sqrt(vr.w)));

}