void SMM_Init(GLSLProgram *program, const char *projection_matrix_name, const char *modelview_matrix_name)
{
modelview_matrix_id = GLSL_GetUniform(program, modelview_matrix_name);
projection_matrix_id = GLSL_GetUniform(program, projection_matrix_name);
loadIdentity(&projection_matrix);
last_stack_matrix = 0;
loadIdentity(modelview_matrix_stack + last_stack_matrix);
}
Graphics::Graphics() {
glewExperimental = GL_TRUE;
glewInit();
glGenVertexArrays(1, &vertexArray);
glBindVertexArray(vertexArray);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
fragShader = new FragmentShader("data/fragment.glsl");
vertShader = new VertexShader("data/vertex.glsl");
shaderProgram = new ShaderProgram();
shaderProgram->setFragmentShader(fragShader);
shaderProgram->setVertexShader(vertShader);
shaderProgram->addBinding(0, "inVertex");
shaderProgram->addBinding(1, "inTexCoord");
shaderProgram->addBinding(2, "inColour");
shaderProgram->link();
shaderProgram->makeActive();
modelMatrixUniform = shaderProgram->getUniformLocation("inModelMatrix");
projectionMatrixUniform = shaderProgram->getUniformLocation("inProjectionMatrix");
viewMatrixUniform = shaderProgram->getUniformLocation("inViewMatrix");
texUniform = shaderProgram->getUniformLocation("inTexture");
setMatrixMode(MatrixMode::MODEL);
loadIdentity();
setMatrixMode(MatrixMode::VIEW);
loadIdentity();
setMatrixMode(MatrixMode::PROJECTION);
loadIdentity();
//ortho(-8, 8, -8, 8, 0, 0);
frustum(-(1 + ((3.0 / 4.0) / 2.0)), 1 + ((3.0 / 4.0) / 2.0), -1, 1, 1, 512);
setMatrixMode(MatrixMode::MODEL);
ResourceManager* rm = ResourceManager::getInstance();
floorMesh = rm->getResource("data/model.obj")->toOBJModel()->compose();
wallMesh = rm->getResource("data/wall.obj")->toOBJModel()->compose();
ceilingMesh = rm->getResource("data/ceiling.obj")->toOBJModel()->compose();
font = rm->getResource("data/DejaVuSansMono.ttf")->toFont();
if (!font) {
// Throw an error;
throw std::runtime_error("Graphics::Graphics(): Could not load font.");
}
}
void changeSize(int w, int h) {
loadIdentity(PROJECTION);
float ratio;
// Prevent a divide by zero, when window is too short
if(h == 0)
h = 1;
// set the viewport to be the entire window
glViewport(0, 0, w, h);
// set the projection matrix
ratio = (1.0f * w) / h;
loadIdentity(PROJECTION);
_cameras[_current_camera]->update(ratio);
}
void Graphics::drawWallTile(const int32_t x, const int32_t y, const Facing side, const uint32_t modelID) {
glUniform1i(texUniform, 0);
pushMatrix();
loadIdentity();
translate(x * 16.0f, 0.0f, y * 16.0f);
switch(side) {
case Facing::SOUTH:
rotate(toRadians(270), 0.0f, 1.0f, 0.0f);
break;
case Facing::WEST:
rotate(toRadians(180), 0.0f, 1.0f, 0.0f);
break;
case Facing::NORTH:
rotate(toRadians(90), 0.0f, 1.0f, 0.0f);
break;
case Facing::EAST:
rotate(toRadians(0), 0.0f, 1.0f, 0.0f);
break;
default:
break;
}
if (wallMesh) {
wallMesh->draw();
}
popMatrix();
}
void GmailSettings::load()
{
loadAccount();
loadImapResource();
loadMailtransportResource();
loadIdentity();
}
NodeOrthographicCamera::NodeOrthographicCamera(double left
, double right
, double bottom
, double top
, double zNear
, double zFar
)
:NodeCamera(NodeCamera::ORTHOGRAPHIC),
left_(left),
right_(right),
bottom_(bottom),
top_(top),
zNear_(zNear),
zFar_(zFar){
loadIdentity(projection_matrix_);
projection_matrix_[0] = 2.0/(right-left);
projection_matrix_[3] = -(right + left) / (right - left) ;
projection_matrix_[5] = 2.0/(top-bottom);
projection_matrix_[7] = -(top + bottom) / (top - bottom) ;
projection_matrix_[10] = -2.0/(zFar-zNear);
projection_matrix_[11] = -(zFar + zNear) / (zFar - zNear);
}
void Matrix::newScaleXYZ(float sa, float sb, float sc)
{
loadIdentity();
mm[0][0] = sa;
mm[1][1] = sb;
mm[2][2] = sc;
}
void Matrix::newTranslate(float x, float y, float z)
{
loadIdentity();
mm[3][0] = -x;
mm[3][1] = -y;
mm[3][2] = -z;
}
void Matrix::newRotateZ(float angle)
{
loadIdentity();
mm[0][0] = mm[1][1] = cosf(angle);
mm[1][0] = -sin(angle);
mm[0][1] = sin(angle);
}
void Renderer_Render(Renderer* renderer) {
Scene* scene = renderer->scene;
Vec3* light = Light_Serialize(scene->lampe, 6);
Shader_SendUniformArray(ShaderLibrary_Get("instance"), "lightPos[0]", GL_FLOAT_VEC3, 6, &light->x);
Shader_SendUniformArray(ShaderLibrary_Get("instance"), "lightColor[0]", GL_FLOAT_VEC3, 6, &light[6].x);
Shader_SendUniformArray(ShaderLibrary_Get("fullset"), "lightPos[0]", GL_FLOAT_VEC3, 6, &light->x);
Shader_SendUniformArray(ShaderLibrary_Get("fullset"), "lightColor[0]", GL_FLOAT_VEC3, 6, &light[6].x);
free(light);
Renderer_GenerateShadowMap(renderer);
Renderer_RenderMeshesShadowed(renderer);
loadIdentity(scene->skybox.matrix);
if (scene->player.camMode == CAMERAMODE_FREE)
translateByVec(scene->skybox.matrix, scene->player.posCam);
else
translateByVec(scene->skybox.matrix, scene->player.posRobot);
scale(scene->skybox.matrix, 2000, 2000, 2000);
Object3D_Draw(scene->skybox, renderer);
// shadowmap texture to quad
glDisable(GL_DEPTH_TEST);
Object3D_Draw(scene->objects[1], renderer);
glEnable(GL_DEPTH_TEST);
}
void matrix_stack_t::init(int depth) {
stack = new matrixf_t[depth];
ops = new uint8_t[depth];
maxDepth = depth;
depth = 0;
dirty = 0;
loadIdentity();
}
void Renderer_SetPerspective(Renderer* renderer) {
glViewport(0, 0, renderer->largeur, renderer->hauteur);
loadIdentity(renderer->camToClip);
projection(renderer->camToClip, 70, (float)renderer->largeur/renderer->hauteur, 1, 5000);
}
void Matrix4::loadTranslate(float x, float y, float z) {
loadIdentity();
data[kTranslateX] = x;
data[kTranslateY] = y;
data[kTranslateZ] = z;
mType = kTypeTranslate | kTypeRectToRect;
}
void Matrix4::loadScale(float sx, float sy, float sz) {
loadIdentity();
data[kScaleX] = sx;
data[kScaleY] = sy;
data[kScaleZ] = sz;
mType = kTypeScale | kTypeRectToRect;
}
void Graphics::drawQuad(float x, float y, float w, float h) {
glUniform1i(texUniform, 0);
pushMatrix();
loadIdentity();
translate(x, y, 0);
popMatrix();
}
GlFramework::GlFramework() : QGLWidget()
{
startTimer(30);
resize(1024, 768);
pViewMatrix.setIdentity();
loadIdentity();
m_CurrentShader = -1;
}
void Matrix4::loadOrtho(float left, float right, float bottom, float top, float near, float far) {
loadIdentity();
data[kScaleX] = 2.0f / (right - left);
data[kScaleY] = 2.0f / (top - bottom);
data[kScaleZ] = -2.0f / (far - near);
data[kTranslateX] = -(right + left) / (right - left);
data[kTranslateY] = -(top + bottom) / (top - bottom);
data[kTranslateZ] = -(far + near) / (far - near);
mType = kTypeTranslate | kTypeScale | kTypeRectToRect;
}
void Graphics::drawCeilingTile(const int32_t x, const int32_t y, const uint32_t modelID) {
glUniform1i(texUniform, 0);
pushMatrix();
loadIdentity();
translate(x * 16.0f, 0.0f, y * 16.0f);
if (ceilingMesh) {
ceilingMesh->draw();
}
popMatrix();
}
// gluPerspective implementation
void
VSMatrix::perspective(FLOATTYPE fov, FLOATTYPE ratio, FLOATTYPE nearp, FLOATTYPE farp)
{
FLOATTYPE f = 1.0f / tan (fov * (M_PI / 360.0f));
loadIdentity();
mMatrix[0] = f / ratio;
mMatrix[1 * 4 + 1] = f;
mMatrix[2 * 4 + 2] = (farp + nearp) / (nearp - farp);
mMatrix[3 * 4 + 2] = (2.0f * farp * nearp) / (nearp - farp);
mMatrix[2 * 4 + 3] = -1.0f;
mMatrix[3 * 4 + 3] = 0.0f;
}
void updateShadowMatrix(Renderer* renderer) {
static float angleY = 0;
static float angleX = 40;
loadIdentity(renderer->depth_mondeToCam);
rotate(renderer->depth_mondeToCam, angleX, angleY, 0);
Shader_SendUniform(ShaderLibrary_Get("instance"), "sunDirection", GL_FLOAT_VEC3, &renderer->depth_mondeToCam[8]);
Shader_SendUniform(ShaderLibrary_Get("fullset"), "sunDirection", GL_FLOAT_VEC3, &renderer->depth_mondeToCam[8]);
angleY += 0.1;
// angleX += 0.1;
// memcpy(renderer->depth_mondeToCam, renderer->player.mondeToCam, sizeof(float)*16);
loadIdentity(renderer->depth_camToProj);
// memcpy(renderer->depth_camToProj, renderer->fenetre.camToClip, sizeof(float)*16);
// ortho(renderer->depth_camToProj, -15, 15,-15, 15, -5, 10);
ortho(renderer->depth_camToProj, -150, 150,-150, 150, -120, 150);
// ortho(renderer->depth_camToProj, -150, 150,-150, 150, -270, 150); // Sponza
Shader_SendUniform(ShaderLibrary_Get("fullset"), "depth_mvp", GL_FLOAT_MAT4, MatxMat_GaucheVersDroite(renderer->depth_mondeToCam, renderer->depth_camToProj));
Shader_SendUniform(ShaderLibrary_Get("instance"), "depth_mvp", GL_FLOAT_MAT4, MatxMat_GaucheVersDroite(renderer->depth_mondeToCam, renderer->depth_camToProj));
}
// gl Ortho implementation
void
VSMatrix::ortho(FLOATTYPE left, FLOATTYPE right,
FLOATTYPE bottom, FLOATTYPE top,
FLOATTYPE nearp, FLOATTYPE farp)
{
loadIdentity();
mMatrix[0 * 4 + 0] = 2 / (right - left);
mMatrix[1 * 4 + 1] = 2 / (top - bottom);
mMatrix[2 * 4 + 2] = -2 / (farp - nearp);
mMatrix[3 * 4 + 0] = -(right + left) / (right - left);
mMatrix[3 * 4 + 1] = -(top + bottom) / (top - bottom);
mMatrix[3 * 4 + 2] = -(farp + nearp) / (farp - nearp);
}
/*
*------------------------------------------------
* Returns a rotation around z-axis matrix of
* theta degrees
*------------------------------------------------
*/
void MatRotateZ(double theta, Matrix4 *m)
{
double sine, cosine;
sine = sin( theta );
cosine = cos( theta );
loadIdentity( m );
m->element[0][0]= cosine;
m->element[1][0]= -sine;
m->element[0][1]= sine;
m->element[1][1]= cosine;
}
void Matrix4::loadRotate(float angle) {
angle *= float(M_PI / 180.0f);
float c = cosf(angle);
float s = sinf(angle);
loadIdentity();
data[kScaleX] = c;
data[kSkewX] = -s;
data[kSkewY] = s;
data[kScaleY] = c;
mType = kTypeUnknown;
}
void Matrix::frustum(float left, float right, float bottom, float top, float nearz, float farz)
{
float deltaX = right - left;
float deltaY = top - bottom;
float deltaZ = farz - nearz;
loadIdentity(*this);
this->m[0][0] = 2 * nearz / deltaX;
this->m[2][0] = (right + left) / deltaX;
this->m[1][1] = 2 * nearz / deltaY;
this->m[2][1] = (top + bottom) / deltaY;
this->m[2][2] = -(farz + nearz) / deltaZ;
this->m[3][2] = -2 * farz * nearz / deltaZ;
this->m[2][3] = -1;
this->m[3][3] = 0;
}
void Matrix4::loadSkew(float sx, float sy) {
loadIdentity();
data[kScaleX] = 1.0f;
data[kSkewX] = sx;
data[kTranslateX] = 0.0f;
data[kSkewY] = sy;
data[kScaleY] = 1.0f;
data[kTranslateY] = 0.0f;
data[kPerspective0] = 0.0f;
data[kPerspective1] = 0.0f;
data[kPerspective2] = 1.0f;
mType = kTypeUnknown;
}
NodePerspectiveCamera::NodePerspectiveCamera(double fovy
, double aspect
, double zNear
, double zFar)
:NodeCamera(NodeCamera::PERSPECTIVE){
loadIdentity(projection_matrix_);
double f = cos(fovy/2.0)/sin(fovy/2.0); // cotangent
projection_matrix_[0] = f/aspect;
projection_matrix_[5] = f;
projection_matrix_[10] = (zNear+zFar)/(zNear-zFar);
projection_matrix_[11] = (2.0*zNear*zFar)/(zNear-zFar);
projection_matrix_[14] = -1.0;
projection_matrix_[15] = 0;
}
void Matrix::ortho(float left, float right, float bottom, float top, float nearz, float farz)
{
float deltaX = right - left;
float deltaY = top - bottom;
float deltaZ = farz - nearz;
if ((deltaX == 0.0f) || (deltaY == 0.0f) || (deltaZ == 0.0f))
return;
loadIdentity(*this);
this->m[0][0] = 2.0 / deltaX;
this->m[3][0] = -(right + left) / deltaX;
this->m[1][1] = 2 / deltaY;
this->m[3][1] = -(top + bottom) / (top - bottom);
this->m[2][2] = -2 / deltaZ;
this->m[3][2] = -(farz + nearz) / nearz;
}
NodePerspectiveCamera::NodePerspectiveCamera(double left,
double right,
double bottom,
double top,
double zNear,
double zFar)
:NodeCamera(NodeCamera::PERSPECTIVE){
loadIdentity(projection_matrix_);
projection_matrix_[0] = (2.0*zNear)/(right-left);
projection_matrix_[2] = (right+left)/(right-left);
projection_matrix_[5] = (2.0*zNear)/(top-bottom);
projection_matrix_[6] = (top+bottom)/(top-bottom);
projection_matrix_[10] = - (zFar+zNear)/(zFar-zNear);
projection_matrix_[11] = - (2.0*zFar*zNear)/(zFar-zNear);
projection_matrix_[14] = -1.0;
projection_matrix_[15] = 0;
}
void Matrix::newUVN(Vector U, Vector V, Vector N)
{
U.norm();
V.norm();
N.norm();
loadIdentity();
mm[0][0] = U.vm[0];
mm[1][0] = U.vm[1];
mm[2][0] = U.vm[2];
mm[0][1] = V.vm[0];
mm[1][1] = V.vm[1];
mm[2][1] = V.vm[2];
mm[0][2] = N.vm[0];
mm[1][2] = N.vm[1];
mm[2][2] = N.vm[2];
}
void MQuaternion::normalize(void)
{
float distance = sqrtf(
values[0] * values[0] +
values[1] * values[1] +
values[2] * values[2] +
values[3] * values[3]
);
if(distance > 0.00000001f)
{
float invDist = 1.0f / distance;
values[0] *= invDist;
values[1] *= invDist;
values[2] *= invDist;
values[3] *= invDist;
}
else
{
loadIdentity();
}
}
