void GameOver::draw(struct MyMesh* mesh, VSShaderLib& shader, GLint& pvm_uniformId, GLint& vm_uniformId, GLint& normal_uniformId, GLint& texMode_uniformId, int *objId){
*objId=11;
GLint loc;
// send the material
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.ambient");
glUniform4fv(loc, 1, mesh[*objId].mat.ambient);
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.diffuse");
glUniform4fv(loc, 1, mesh[*objId].mat.diffuse);
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.specular");
glUniform4fv(loc, 1, mesh[*objId].mat.specular);
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.shininess");
glUniform1f(loc,mesh[*objId].mat.shininess);
pushMatrix(MODEL);
translate(MODEL, -7.5f, 0.0f, 15.0f);
scale(MODEL, 15.0f, 0.0f, 30.0f);
rotate(MODEL, 90.0, 0.0f, 0.0f, 1.0f);
rotate(MODEL, 180.0, 1.0f, 0.0f, 0.0f);
// send matrices to OGL
computeDerivedMatrix(PROJ_VIEW_MODEL);
glUniformMatrix4fv(vm_uniformId, 1, GL_FALSE, mCompMatrix[VIEW_MODEL]);
glUniformMatrix4fv(pvm_uniformId, 1, GL_FALSE, mCompMatrix[PROJ_VIEW_MODEL]);
computeNormalMatrix3x3();
glUniformMatrix3fv(normal_uniformId, 1, GL_FALSE, mNormal3x3);
// Render mesh
glUniform1i(texMode_uniformId, 4); // apenas o texel
glBindVertexArray(mesh[*objId].vao);
glDrawElements(mesh[*objId].type,mesh[*objId].numIndexes, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
popMatrix(MODEL);
}
// ------------------------------------------------------------
//
// Render stuff
//
void renderScene(void) {
glClear(
GL_COLOR_BUFFER_BIT |
GL_DEPTH_BUFFER_BIT )
;
vsml->loadIdentity(VSMathLib::MODEL);
vsml->loadIdentity(VSMathLib::VIEW);
vsml->lookAt(camX, camY, camZ, 0,0,0, 0,1,0);
//cam->lookAt(vsml);
//std::cout
// << '('
// << camX
// << ','
// << camY
// << ','
// << camZ
// << ')'
// << std::endl
// << *cam
// << std::endl;
{
// set the shader to render models
//glUseProgram(shaders[shader_group_now][shader_now].getProgramIndex());
glUseProgram(shader1.getProgramIndex());
// start counting primitives
// render array of models
for (float x = -2.0f ; x < 3.0f ; x += 2.0f) {
for (float z = -2.0f; z < 3.0f ; z += 2.0f) {
vsml->pushMatrix(VSMathLib::MODEL);
vsml->translate(VSMathLib::MODEL, x, 0.0f, z);
if ( x < -1.0f || x > 1.0f || z < -1.0f || z > 1.0f )
teapot.render();
vsml->popMatrix(VSMathLib::MODEL);
}
}
// stop counting primitives
{
//glUseProgram(player.shaders[shader_group_now].getProgramIndex());
glUseProgram(shader2.getProgramIndex());
vsml->pushMatrix(VSMathLib::MODEL);
//vsml->translate(VSMathLib::MODEL, player.position.x, player.position.y, player.position.z);
//vsml->translate(VSMathLib::MODEL, 0, 0, 0);
teapot.render();
vsml->popMatrix(VSMathLib::MODEL);
}
//{
// player->draw(vsml);
//}
}
glutSwapBuffers();
}
void Renderer::Init(){
glCullFace(GL_BACK);
shader.init();
shader.loadShader(VSShaderLib::VERTEX_SHADER, "simple.vert");
shader.loadShader(VSShaderLib::FRAGMENT_SHADER, "simple.frag");
shader.prepareProgram();
cout << shader.getAllInfoLogs() << "\n";
//SetUpLightning();
}
void HudMessage::render(VSShaderLib &shader, GLint &pvm_uniformId, GLint &vm_uniformId, GLint &normal_uniformId, GLint &texMode_uniformId) {
GLuint loc;
for (int i = 0; i < meshLength; ++i) {
if (mesh[i].mat.texCount != 0) {
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh[i].texUnits[messageType]);
glUniform1i(texMode_uniformId, 2);
}
for (int j = 0; j < mesh[i].vaoElements; j++) {
// send the material
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.ambient");
glUniform4fv(loc, 1, mesh[i].mat.ambient);
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.diffuse");
glUniform4fv(loc, 1, mesh[i].mat.diffuse);
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.specular");
glUniform4fv(loc, 1, mesh[i].mat.specular);
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.shininess");
glUniform1f(loc, mesh[i].mat.shininess);
pushMatrix(MODEL);
translate(MODEL, current_position[0], current_position[1], current_position[2]);
if (i == 0) {
scale(MODEL, 4.0f, 4.0f, 0.0f);
}
// send matrices to OGL
computeDerivedMatrix(PROJ_VIEW_MODEL);
glUniformMatrix4fv(vm_uniformId, 1, GL_FALSE, mCompMatrix[VIEW_MODEL]);
glUniformMatrix4fv(pvm_uniformId, 1, GL_FALSE, mCompMatrix[PROJ_VIEW_MODEL]);
computeNormalMatrix3x3();
glUniformMatrix3fv(normal_uniformId, 1, GL_FALSE, mNormal3x3);
// Render mesh
glBindVertexArray(mesh[i].vao);
glDrawElements(mesh[i].type, mesh[i].numIndexes, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
popMatrix(MODEL);
}
glUniform1i(texMode_uniformId, 0);
}
glBindTexture(GL_TEXTURE_2D, 0);
}
void Renderer::doRender(){
SetUpCamera();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
GLfloat qaLightPosition[] = {.5, 1, 0.0, 1.0};
glLightfv(GL_LIGHT0, GL_POSITION, qaLightPosition);
// Set material properties
GLfloat qaBlack[] = {0.0, 0.0, 0.0, 1.0};
GLfloat qaGreen[] = {0.0, 1.0, 0.0, 1.0};
GLfloat qaWhite[] = {1.0, 1.0, 1.0, 1.0};
glMaterialfv(GL_FRONT, GL_AMBIENT, qaGreen);
glMaterialfv(GL_FRONT, GL_DIFFUSE, qaGreen);
glMaterialfv(GL_FRONT, GL_SPECULAR, qaWhite);
glMaterialf(GL_FRONT, GL_SHININESS, 60.0);
DrawAxes();
// Draw square with many little squares
glPushMatrix();
//glTranslatef(0, 0, 5);
//glRotated(angle, 0, 1,0);
//angle += 0.01;
//path.push_back(position);
if(GetKeyState('A')& 0x80){
direction.x -= 0.001;
}
if(GetKeyState('D')& 0x80){
direction.x += 0.001;
}
position.x += cos(direction.x)*speed;
position.y += sin(direction.x)*speed;
glUseProgram(shader.getProgramIndex());
//drawBox();
//
glLineWidth(10.0);
//glBegin(GL_LINE_STRIP);{
glPushMatrix();
//for(vector<Vector5>::iterator item = path.begin(); item != path.end(); item++){
glTranslated(position.x,position.y, position.z);
GLUquadric *obj = gluNewQuadric();
gluSphere(obj, 0.1, 20,20);
//glVertex3d(item->x, item->y, item->z);
//}
glPopMatrix();
//}glEnd();
//
glPopMatrix();
}
void Particles::render(GLint texture, struct MyMesh mesh, GLint pvm_uniformId, GLint vm_uniformId, GLint normal_uniformId, VSShaderLib shader, float angle)
{
float particle_color[4];
// draw fireworks particles
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texture);
glDisable(GL_DEPTH_TEST); /* não interessa o z-buffer: as partículas podem ser desenhadas umas por cima das outras sem problemas de ordenação */
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
for (int i = 0; i < MAX_PARTICULAS; i++)
{
if (particula[i].life > 0.0f) /* só desenha as que ainda estão vivas */
{
/* A vida da partícula representa o canal alpha da cor. Como o blend está activo a cor final é a soma da cor rgb do fragmento multiplicada pelo
alpha com a cor do pixel destino */
particle_color[0] = particula[i].r;
particle_color[1] = particula[i].g;
particle_color[2] = particula[i].b;
particle_color[3] = particula[i].life;
// send the material - diffuse color modulated with texture
GLint loc = glGetUniformLocation(shader.getProgramIndex(), "mat.diffuse");
glUniform4fv(loc, 1, particle_color);
pushMatrix(MODEL);
translate(MODEL, particula[i].x, particula[i].y, particula[i].z);
rotate(MODEL, angle, 0, 1, 0);
scale(MODEL, 0.3, 0.3, 0.3);
//rotate(MODEL, 180, 0, 0, 1);
// send matrices to OGL
computeDerivedMatrix(PROJ_VIEW_MODEL);
glUniformMatrix4fv(vm_uniformId, 1, GL_FALSE, mCompMatrix[VIEW_MODEL]);
glUniformMatrix4fv(pvm_uniformId, 1, GL_FALSE, mCompMatrix[PROJ_VIEW_MODEL]);
computeNormalMatrix3x3();
glUniformMatrix3fv(normal_uniformId, 1, GL_FALSE, mNormal3x3);
glBindVertexArray(mesh.vao);
glDrawElements(mesh.type, mesh.numIndexes, GL_UNSIGNED_INT, 0);
popMatrix(MODEL);
}
}
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBindVertexArray(0);
glBindTexture(GL_TEXTURE_2D, 0);
glEnable(GL_DEPTH_TEST);
}
GLuint setupShaders() {
// ADD STUFF HERE
shader.init();
shader.loadShader(VSShaderLib::VERTEX_SHADER, "anim.vert");
shader.loadShader(VSShaderLib::FRAGMENT_SHADER, "anim.frag");
//shader.setProgramOutput(0, "colorFS");
shader.setVertexAttribName(VSShaderLib::VERTEX_COORD_ATTRIB, "position");
shader.prepareProgram();
glUseProgram(shader.getProgramIndex());
return 1;
char *vs = NULL,*fs = NULL,*fs2 = NULL;
v = glCreateShader(GL_VERTEX_SHADER);
f = glCreateShader(GL_FRAGMENT_SHADER);
f2 = glCreateShader(GL_FRAGMENT_SHADER);
vs = textFileRead("anim.vert");
fs = textFileRead("anim.frag");
const char * vv = vs;
const char * ff = fs;
glShaderSource(v, 1, &vv,NULL);
glShaderSource(f, 1, &ff,NULL);
free(vs);free(fs);
glCompileShader(v);
glCompileShader(f);
printShaderInfoLog(v);
printShaderInfoLog(f);
printShaderInfoLog(f2);
p = glCreateProgram();
glAttachShader(p,v);
glAttachShader(p,f);
glLinkProgram(p);
//printProgramInfoLog(p);
glUseProgram(p);
GLuint loc = glGetUniformLocation(p,"time");
return 0;
}
void Billboard::draw(struct MyMesh* mesh, VSShaderLib& shader, GLint& pvm_uniformId, GLint& vm_uniformId, GLint& normal_uniformId, GLint& texMode_uniformId, int *objId){
float modelview[16];
float pos[3];
//pos[0] = getPosX(); pos[1] = getPosY(); pos[2] = getPosZ();
float cam[3];
cam[0] = getCamX(); cam[1] = getCamY(); cam[2] = getCamZ();
GLint loc;
//Draw trees billboards
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUniform1i(texMode_uniformId, 1); // draw textured quads
for(int j = 1; j < 3; j++) {
pushMatrix(MODEL);
translate(MODEL,-7.0,0.0,-10.0+j*5);
pos[0] = -7.0; pos[1] = 0; pos[2] = -10.0+j*5;
if (getType() == 2){
l3dBillboardSphericalBegin(cam,pos);
}
else if (getType() == 3){
l3dBillboardCylindricalBegin(cam,pos);
}
*objId=17; //quad for tree
//diffuse and ambient color are not used in the tree quads
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.specular");
glUniform4fv(loc, 1, mesh[*objId].mat.specular);
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.shininess");
glUniform1f(loc,mesh[*objId].mat.shininess);
pushMatrix(MODEL);
translate(MODEL, 0.0, 3.0, 0.0f);
// send matrices to OGL
if (getType() == 0 || getType() == 1) { //Cheating matrix reset billboard techniques
computeDerivedMatrix(VIEW_MODEL);
memcpy(modelview, mCompMatrix[VIEW_MODEL], sizeof(float) * 16); //save VIEW_MODEL in modelview matrix
//reset VIEW_MODEL
if(getType()==0){
BillboardCheatSphericalBegin();
}
else{
BillboardCheatCylindricalBegin();
}
computeDerivedMatrix_PVM(); // calculate PROJ_VIEW_MODEL
}
else computeDerivedMatrix(PROJ_VIEW_MODEL);
glUniform1i(texMode_uniformId, 13);
glUniformMatrix4fv(vm_uniformId, 1, GL_FALSE, mCompMatrix[VIEW_MODEL]);
glUniformMatrix4fv(pvm_uniformId, 1, GL_FALSE, mCompMatrix[PROJ_VIEW_MODEL]);
computeNormalMatrix3x3();
glUniformMatrix3fv(normal_uniformId, 1, GL_FALSE, mNormal3x3);
glBindVertexArray(mesh[*objId].vao);
glDrawElements(mesh[*objId].type,mesh[*objId].numIndexes, GL_UNSIGNED_INT, 0);
popMatrix(MODEL);
popMatrix(MODEL);
}
glDisable(GL_BLEND);
}
// --------------------------------------------------------
//
// Shader Stuff
//
GLuint setupShaders() {
//// Shader for fonts and models
//shaders[0][0].init();
///*shader.loadShader(VSShaderLib::VERTEX_SHADER, "../shaders/dirlightdiffambpix.vert");
//shader.loadShader(VSShaderLib::FRAGMENT_SHADER, "shaders/dirlightdiffambpix.frag");*/
//shaders[0][0].loadShader(
// VSShaderLib::VERTEX_SHADER,
// "../shaders/light/direct/diffuse.vert.glsl")
// ;
//shaders[0][0].loadShader(
// VSShaderLib::FRAGMENT_SHADER,
// "../shaders/light/direct/diffuse.frag.glsl")
// ;
//// set semantics for the shader variables
//shaders[0][0].setProgramOutput( 0 , "color" );
//shaders[0][0].setVertexAttribName(
// VSShaderLib::VERTEX_COORD_ATTRIB,
// "position")
// ;
////shader.setVertexAttribName(VSShaderLib::TEXTURE_COORD_ATTRIB, "texCoord");
//shaders[0][0].setVertexAttribName(
// VSShaderLib::NORMAL_ATTRIB,
// "normal")
// ;
//shaders[0][0].prepareProgram();
//VSGLInfoLib::getProgramInfo(shaders[0][0].getProgramIndex());
//printf("%s\n", shaders[0][0].getAllInfoLogs().c_str());
//// uniforms
////float lpos[4] = { 1.0 , 0.0 , 1.0 , 0.0 };
////shaders[0].setUniform( "lightPos" , lpos );
//{
// float ldir[3] = { 1.0 , 0.0 , 0.0 };
// float ldif[3] = { 1.0 , 0.0 , 0.0 };
// shaders[0][0].setUniform( "light_dir" , ldir );
// shaders[0][0].setUniform( "diffuse" , ldif );
//}
//// shader#2
//// Shader for fonts and models
//shaders[0][1].init();
///*shader.loadShader(VSShaderLib::VERTEX_SHADER, "../shaders/dirlightdiffambpix.vert");
//shader.loadShader(VSShaderLib::FRAGMENT_SHADER, "shaders/dirlightdiffambpix.frag");*/
//shaders[0][1].loadShader(
// VSShaderLib::VERTEX_SHADER,
// "../shaders/light/direct/difamb.vert.glsl")
// ;
//shaders[0][1].loadShader(
// VSShaderLib::FRAGMENT_SHADER,
// "../shaders/light/direct/difamb.frag.glsl")
// ;
//// set semantics for the shader variables
//shaders[0][1].setProgramOutput( 0 , "color" );
//shaders[0][1].setVertexAttribName(
// VSShaderLib::VERTEX_COORD_ATTRIB,
// "position")
// ;
////shader.setVertexAttribName(VSShaderLib::TEXTURE_COORD_ATTRIB, "texCoord");
//shaders[0][1].setVertexAttribName(
// VSShaderLib::NORMAL_ATTRIB,
// "normal")
// ;
//shaders[0][1].prepareProgram();
//VSGLInfoLib::getProgramInfo(shaders[0][1].getProgramIndex());
//printf("%s\n", shaders[0][1].getAllInfoLogs().c_str());
//// uniforms
//{
// float ldir[3] = { 1.0f , 0.0f , 0.0f };
// float ldif[3] = { 1.0f , 0.0f , 0.0f };
// float lamb[3] = { 0.3f , 0.0f , 0.0f };
// shaders[0][1].setUniform( "light_dir" , ldir );
// shaders[0][1].setUniform( "diffuse" , ldif );
// shaders[0][1].setUniform( "ambient" , lamb );
//}
//
//// shader#3
//// Shader for fonts and models
//shaders[0][2].init();
///*shader.loadShader(VSShaderLib::VERTEX_SHADER, "../shaders/dirlightdiffambpix.vert");
//shader.loadShader(VSShaderLib::FRAGMENT_SHADER, "shaders/dirlightdiffambpix.frag");*/
//shaders[0][2].loadShader(
// VSShaderLib::VERTEX_SHADER,
// "../shaders/light/direct/gouraud.vert.glsl")
// ;
//shaders[0][2].loadShader(
// VSShaderLib::FRAGMENT_SHADER,
// "../shaders/light/direct/gouraud.frag.glsl")
// ;
//// set semantics for the shader variables
//shaders[0][2].setProgramOutput( 0 , "color" );
//shaders[0][2].setVertexAttribName(
// VSShaderLib::VERTEX_COORD_ATTRIB,
// "position")
// ;
////shader.setVertexAttribName(VSShaderLib::TEXTURE_COORD_ATTRIB, "texCoord");
//shaders[0][2].setVertexAttribName(
// VSShaderLib::NORMAL_ATTRIB,
// "normal")
// ;
//shaders[0][2].prepareProgram();
//VSGLInfoLib::getProgramInfo(shaders[0][2].getProgramIndex());
//printf("%s\n", shaders[0][2].getAllInfoLogs().c_str());
//// uniforms
//{
// float ldir[3] = { 1.0f , 0.0f , 0.0f };
// float ldif[3] = { 1.0f , 0.0f , 0.0f };
// float lamb[3] = { 0.3f , 0.0f , 0.0f };
// float lspc[3] = { 1.0f , 1.0f , 1.0f };
// shaders[0][2].setUniform( "light_dir" , ldir );
// shaders[0][2].setUniform( "diffuse" , ldif );
// shaders[0][2].setUniform( "ambient" , lamb );
// shaders[0][2].setUniform( "specular" , lspc );
// shaders[0][2].setUniform( "shininess" , 100.0f );
//}
//// shader#4
//// Shader for fonts and models
//shaders[0][3].init();
///*shader.loadShader(VSShaderLib::VERTEX_SHADER, "../shaders/dirlightdiffambpix.vert");
//shader.loadShader(VSShaderLib::FRAGMENT_SHADER, "shaders/dirlightdiffambpix.frag");*/
//shaders[0][3].loadShader(
// VSShaderLib::VERTEX_SHADER,
// "../shaders/light/direct/phong.vert.glsl")
// ;
//shaders[0][3].loadShader(
// VSShaderLib::FRAGMENT_SHADER,
// "../shaders/light/direct/phong.frag.glsl")
// ;
//// set semantics for the shader variables
//shaders[0][3].setProgramOutput( 0 , "color" );
//shaders[0][3].setVertexAttribName(
// VSShaderLib::VERTEX_COORD_ATTRIB,
// "position")
// ;
////shader.setVertexAttribName(VSShaderLib::TEXTURE_COORD_ATTRIB, "texCoord");
//shaders[0][3].setVertexAttribName(
// VSShaderLib::NORMAL_ATTRIB,
// "normal")
// ;
//shaders[0][3].prepareProgram();
//VSGLInfoLib::getProgramInfo(shaders[0][3].getProgramIndex());
//printf("%s\n", shaders[0][3].getAllInfoLogs().c_str());
//// uniforms
//{
// float ldir[3] = { 1.0f , 0.0f , 0.0f };
// float ldif[3] = { 1.0f , 0.0f , 0.0f };
// float lamb[3] = { 0.3f , 0.0f , 0.0f };
// float lspc[3] = { 1.0f , 1.0f , 1.0f };
// shaders[0][3].setUniform( "light_dir" , ldir );
// shaders[0][3].setUniform( "diffuse" , ldif );
// shaders[0][3].setUniform( "ambient" , lamb );
// shaders[0][3].setUniform( "specular" , lspc );
// shaders[0][3].setUniform( "shininess" , 100.0f );
//}
//// shader#5
//// Shader for fonts and models
//shaders[1][3].init();
///*shader.loadShader(VSShaderLib::VERTEX_SHADER, "../shaders/dirlightdiffambpix.vert");
//shader.loadShader(VSShaderLib::FRAGMENT_SHADER, "shaders/dirlightdiffambpix.frag");*/
//shaders[1][3].loadShader(
// VSShaderLib::VERTEX_SHADER,
// "../shaders/light/point/phong.vert.glsl")
// ;
//shaders[1][3].loadShader(
// VSShaderLib::FRAGMENT_SHADER,
// "../shaders/light/point/phong.frag.glsl")
// ;
//// set semantics for the shader variables
//shaders[1][3].setProgramOutput( 0 , "color" );
//shaders[1][3].setVertexAttribName(
// VSShaderLib::VERTEX_COORD_ATTRIB,
// "position")
// ;
////shader.setVertexAttribName(VSShaderLib::TEXTURE_COORD_ATTRIB, "texCoord");
//shaders[1][3].setVertexAttribName(
// VSShaderLib::NORMAL_ATTRIB,
// "normal")
// ;
//shaders[1][3].prepareProgram();
//VSGLInfoLib::getProgramInfo(shaders[1][3].getProgramIndex());
//printf("%s\n", shaders[1][3].getAllInfoLogs().c_str());
//// uniforms
//{
// float lpos[4] = { 30.0 , 5.0 , 0.0 , 1.0 };
// float ldif[3] = { 1.0 , 0.0 , 0.0 };
// //float lamb[3] = { 0.3 , 0.0 , 0.0 };
// float lspc[3] = { 1.0 , 1.0 , 1.0 };
// shaders[1][3].setUniform( "lightPosition" , lpos );
// shaders[1][3].setUniform( "diffuse" , ldif );
// //shaders[1][3].setUniform( "ambient" , lamb );
// shaders[1][3].setUniform( "specular" , lspc );
// shaders[1][3].setUniform( "shininess" , 100.0f );
//}
//// shader#6
//// Shader for fonts and models
//shaders[2][3].init();
///*shader.loadShader(VSShaderLib::VERTEX_SHADER, "../shaders/dirlightdiffambpix.vert");
//shader.loadShader(VSShaderLib::FRAGMENT_SHADER, "shaders/dirlightdiffambpix.frag");*/
//shaders[2][3].loadShader(
// VSShaderLib::VERTEX_SHADER,
// "../shaders/light/spot/phong.vert.glsl")
// ;
//shaders[2][3].loadShader(
// VSShaderLib::FRAGMENT_SHADER,
// "../shaders/light/spot/phong.frag.glsl")
// ;
//// set semantics for the shader variables
//shaders[2][3].setProgramOutput( 0 , "color" );
//shaders[2][3].setVertexAttribName(
// VSShaderLib::VERTEX_COORD_ATTRIB,
// "position")
// ;
////shader.setVertexAttribName(VSShaderLib::TEXTURE_COORD_ATTRIB, "texCoord");
//shaders[2][3].setVertexAttribName(
// VSShaderLib::NORMAL_ATTRIB,
// "normal")
// ;
//shaders[2][3].prepareProgram();
//VSGLInfoLib::getProgramInfo(shaders[2][3].getProgramIndex());
//printf("%s\n", shaders[2][3].getAllInfoLogs().c_str());
//// uniforms
//{
// float spos[4] = { 0.0 , 1.0 , 0.0 , 1.0 };
// float sdir[3] = { 1.0 , -1.0 , 0.0 };
// float ldif[3] = { 1.0 , 0.0 , 0.0 };
// //float lamb[3] = { 0.3 , 0.0 , 0.0 };
// float lspc[3] = { 1.0 , 1.0 , 1.0 };
// shaders[2][3].setUniform( "spotPosition" , spos );
// shaders[2][3].setUniform( "spotDirection" , sdir );
// shaders[2][3].setUniform( "spotLimitAngle" , blaf::deg2rad(7.5f) );
// shaders[2][3].setUniform( "diffuse" , ldif );
// //shaders[1][3].setUniform( "ambient" , lamb );
// shaders[2][3].setUniform( "specular" , lspc );
// shaders[2][3].setUniform( "shininess" , 100.0f );
//}
/*
// player shader#1
// Shader for fonts and models
player.shaders[0].init();
//shader.loadShader(VSShaderLib::VERTEX_SHADER, "../shaders/dirlightdiffambpix.vert");
//shader.loadShader(VSShaderLib::FRAGMENT_SHADER, "shaders/dirlightdiffambpix.frag");
player.shaders[0].loadShader(
VSShaderLib::VERTEX_SHADER,
"../shaders/light/direct/phong.vert.glsl")
;
player.shaders[0].loadShader(
VSShaderLib::FRAGMENT_SHADER,
"../shaders/light/direct/phong.frag.glsl")
;
// set semantics for the shader variables
player.shaders[0].setProgramOutput( 0 , "color" );
player.shaders[0].setVertexAttribName(
VSShaderLib::VERTEX_COORD_ATTRIB,
"position")
;
//shader.setVertexAttribName(VSShaderLib::TEXTURE_COORD_ATTRIB, "texCoord");
player.shaders[0].setVertexAttribName(
VSShaderLib::NORMAL_ATTRIB,
"normal")
;
player.shaders[0].prepareProgram();
VSGLInfoLib::getProgramInfo(player.shaders[0].getProgramIndex());
printf("%s\n", player.shaders[0].getAllInfoLogs().c_str());
// uniforms
{
float ldir[3] = { 1.0 , 0.0 , 0.0 };
float ldif[3] = { 0.0 , 1.0 , 0.0 };
//float lamb[3] = { 0.3 , 0.0 , 0.0 };
float lspc[3] = { 1.0 , 1.0 , 1.0 };
player.shaders[0].setUniform( "light_dir" , ldir );
player.shaders[0].setUniform( "diffuse" , ldif );
//shaders[0][3].setUniform( "ambient" , lamb );
player.shaders[0].setUniform( "specular" , lspc );
player.shaders[0].setUniform( "shininess" , 100.0f );
}
// player shader#2
// Shader for fonts and models
player.shaders[1].init();
//shader.loadShader(VSShaderLib::VERTEX_SHADER, "../shaders/dirlightdiffambpix.vert");
//shader.loadShader(VSShaderLib::FRAGMENT_SHADER, "shaders/dirlightdiffambpix.frag");
player.shaders[1].loadShader(
VSShaderLib::VERTEX_SHADER,
"../shaders/light/point/phong.vert.glsl")
;
player.shaders[1].loadShader(
VSShaderLib::FRAGMENT_SHADER,
"../shaders/light/point/phong.frag.glsl")
;
// set semantics for the shader variables
player.shaders[1].setProgramOutput( 0 , "color" );
player.shaders[1].setVertexAttribName(
VSShaderLib::VERTEX_COORD_ATTRIB,
"position")
;
//shader.setVertexAttribName(VSShaderLib::TEXTURE_COORD_ATTRIB, "texCoord");
player.shaders[1].setVertexAttribName(
VSShaderLib::NORMAL_ATTRIB,
"normal")
;
player.shaders[1].prepareProgram();
VSGLInfoLib::getProgramInfo(player.shaders[1].getProgramIndex());
printf("%s\n", player.shaders[1].getAllInfoLogs().c_str());
// uniforms
{
float lpos[4] = { 30.0 , 5.0 , 0.0 , 1.0 };
float ldif[3] = { 0.0 , 1.0 , 0.0 };
//float lamb[3] = { 0.3 , 0.0 , 0.0 };
float lspc[3] = { 1.0 , 1.0 , 1.0 };
player.shaders[1].setUniform( "lightPosition" , lpos );
player.shaders[1].setUniform( "diffuse" , ldif );
//shaders[1][3].setUniform( "ambient" , lamb );
player.shaders[1].setUniform( "specular" , lspc );
player.shaders[1].setUniform( "shininess" , 100.0f );
}
// player shader#3
// Shader for fonts and models
player.shaders[2].init();
//shader.loadShader(VSShaderLib::VERTEX_SHADER, "../shaders/dirlightdiffambpix.vert");
//shader.loadShader(VSShaderLib::FRAGMENT_SHADER, "shaders/dirlightdiffambpix.frag");
player.shaders[2].loadShader(
VSShaderLib::VERTEX_SHADER,
"../shaders/light/spot/phong.vert.glsl")
;
player.shaders[2].loadShader(
VSShaderLib::FRAGMENT_SHADER,
"../shaders/light/spot/phong.frag.glsl")
;
// set semantics for the shader variables
player.shaders[2].setProgramOutput( 0 , "color" );
player.shaders[2].setVertexAttribName(
VSShaderLib::VERTEX_COORD_ATTRIB,
"position")
;
//shader.setVertexAttribName(VSShaderLib::TEXTURE_COORD_ATTRIB, "texCoord");
player.shaders[2].setVertexAttribName(
VSShaderLib::NORMAL_ATTRIB,
"normal")
;
player.shaders[2].prepareProgram();
VSGLInfoLib::getProgramInfo(player.shaders[2].getProgramIndex());
printf("%s\n", player.shaders[2].getAllInfoLogs().c_str());
// uniforms
{
float spos[4] = { 0.0 , 1.0 , 0.0 , 1.0 };
float sdir[3] = { 1.0 , -1.0 , 0.0 };
float ldif[3] = { 0.0 , 1.0 , 0.0 };
//float lamb[3] = { 0.3 , 0.0 , 0.0 };
float lspc[3] = { 1.0 , 1.0 , 1.0 };
player.shaders[2].setUniform( "spotPosition" , spos );
player.shaders[2].setUniform( "spotDirection" , sdir );
player.shaders[2].setUniform( "spotLimitAngle" , DEG2RAD(7.5f) );
player.shaders[2].setUniform( "diffuse" , ldif );
//shaders[1][3].setUniform( "ambient" , lamb );
player.shaders[2].setUniform( "specular" , lspc );
player.shaders[2].setUniform( "shininess" , 100.0f );
}
*/
// shader1
shader1.init();
shader1.loadShader(
VSShaderLib::VERTEX_SHADER,
"../shaders/light/point/phong.vert.glsl")
;
shader1.loadShader(
VSShaderLib::FRAGMENT_SHADER,
"../shaders/light/point/phong.frag.glsl")
;
// set semantics for the shader variables
shader1.setProgramOutput( 0 , "color" );
shader1.setVertexAttribName(
VSShaderLib::VERTEX_COORD_ATTRIB,
"position")
;
shader1.setVertexAttribName(
VSShaderLib::NORMAL_ATTRIB,
"normal")
;
shader1.prepareProgram();
VSGLInfoLib::getProgramInfo(shader1.getProgramIndex());
printf("%s\n", shader1.getAllInfoLogs().c_str());
// uniforms
{
float lpos[4] = { 30.0 , 5.0 , 0.0 , 1.0 };
float ldif[3] = { 1.0 , 0.0 , 0.0 };
//float lamb[3] = { 0.3 , 0.0 , 0.0 };
float lspc[3] = { 1.0 , 1.0 , 1.0 };
shader1.setUniform( "lightPosition" , lpos );
shader1.setUniform( "diffuse" , ldif );
//shader1.setUniform( "ambient" , lamb );
shader1.setUniform( "specular" , lspc );
shader1.setUniform( "shininess" , 100.0f );
}
// shader2
shader2.init();
shader2.loadShader(
VSShaderLib::VERTEX_SHADER,
"../shaders/light/point/phong.vert.glsl")
;
shader2.loadShader(
VSShaderLib::FRAGMENT_SHADER,
"../shaders/light/point/phong.frag.glsl")
;
// set semantics for the shader variables
shader2.setProgramOutput( 0 , "color" );
shader2.setVertexAttribName(
VSShaderLib::VERTEX_COORD_ATTRIB,
"position")
;
//shader.setVertexAttribName(VSShaderLib::TEXTURE_COORD_ATTRIB, "texCoord");
shader2.setVertexAttribName(
VSShaderLib::NORMAL_ATTRIB,
"normal")
;
shader2.prepareProgram();
VSGLInfoLib::getProgramInfo(shader2.getProgramIndex());
printf("%s\n", shader2.getAllInfoLogs().c_str());
// uniforms
{
float lpos[4] = { 30.0 , 5.0 , 0.0 , 1.0 };
float ldif[3] = { 0.0 , 1.0 , 0.0 };
//float lamb[3] = { 0.3 , 0.0 , 0.0 };
float lspc[3] = { 1.0 , 1.0 , 1.0 };
shader2.setUniform( "lightPosition" , lpos );
shader2.setUniform( "diffuse" , ldif );
//shader2.setUniform( "ambient" , lamb );
shader2.setUniform( "specular" , lspc );
shader2.setUniform( "shininess" , 100.0f );
}
return(1);
}
