int main (int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow("Shaders");
glutReshapeFunc(changeViewport);
glutDisplayFunc(render);
glewInit();
GLfloat vertices[] = {
-0.5f, -0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
0.0f, 0.5f, 0.0f
};
GLfloat colors[] = {
1.0f, 0.0f, 0.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f
};
char* vertexShaderSourceCode = readFile("vertexShader.vsh");
char* fragmentShaderSourceCode = readFile("fragmentShader.fsh");
GLuint vertShaderID = makeVertexShader(vertexShaderSourceCode);
GLuint fragShaderID = makeFragmentShader(fragmentShaderSourceCode);
GLuint shaderProgramID = makeShaderProgram(vertShaderID, fragShaderID);
printf ("vertShaderID jest %d\n", vertShaderID);
printf ("fragShaderID jest %d\n", fragShaderID);
printf ("shaderProgramID jest %d\n", shaderProgramID);
printf ("s_vPosition's ID jest %d\n", positionID);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
//tworzy pusty bufor
glBufferData(GL_ARRAY_BUFFER, 7*3*sizeof(GLfloat), NULL, GL_STATIC_DRAW);
//³adowanie punktów
glBufferSubData(GL_ARRAY_BUFFER, 0, 3*3*sizeof(GLfloat), vertices);
//³adowanie kolorów
glBufferSubData(GL_ARRAY_BUFFER, 3*3*sizeof(GLfloat), 3*4*sizeof(GLfloat), colors);
positionID = glGetAttribLocation(shaderProgramID, "s_vPosition");
colorID = glGetAttribLocation(shaderProgramID, "s_vColor");
glVertexAttribPointer(positionID, 3, GL_FLOAT, GL_FALSE, 0, 0);
glVertexAttribPointer(colorID, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(3*3*sizeof(GLfloat)));
glUseProgram(shaderProgramID);
glEnableVertexAttribArray(positionID);
glEnableVertexAttribArray(colorID);
glutMainLoop();
return 0;
}
int myprogrammer::makeAndManageProgram(char* vpath, char* fpath)
{
unsigned int program;
shaderInfo info;
info.v = makeVertexShader(vpath,NULL);
info.f = makeFragmentShader(fpath,NULL);
program = makeProgram(info.v, info.f);
char eyeposname[] = "eyepos";
info.leyepos = glGetUniformLocation (program, eyeposname);
char texname[] = "tex";
info.ltex = glGetUniformLocation(program, texname);
if(program > 0)
programs[program] = info;
return program;
}
int main (int argc, char** argv) {
// Standard stuff...
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow("Diffuse Lighting");
glutReshapeFunc(changeViewport);
glutDisplayFunc(render);
glewInit();
initMatrices();
GLfloat vertices[]= {
-0.5f,0.5f,0.5f, -0.5f,-0.5f,0.5f, 0.5f,-0.5f,0.5f, -0.5f,0.5f,0.5f, 0.5f,-0.5f,0.5f, 0.5f,0.5f, 0.5f,
0.5f,0.5f,0.5f, 0.5f,-0.5f,0.5f, 0.5f,-0.5f,-0.5f, 0.5f,0.5f,0.5f, 0.5f,-0.5f,-0.5f, 0.5f,0.5f,-0.5f,
0.5f,-0.5f,0.5f, -0.5f,-0.5f,0.5f, -0.5f,-0.5f,-0.5f, 0.5f,-0.5f,0.5f, -0.5f,-0.5f,-0.5f, 0.5f,-0.5f,-0.5f,
0.5f,0.5f,-0.5f, -0.5f, 0.5f,-0.5f, -0.5f,0.5f,0.5f, 0.5f,0.5f,-0.5f, -0.5f,0.5f,0.5f, 0.5f,0.5f,0.5f,
-0.5f,-0.5f,-0.5f, -0.5f,0.5f,-0.5f, 0.5f,0.5f,-0.5f, -0.5f,-0.5f,-0.5f, 0.5f,0.5f,-0.5f, 0.5f,-0.5f,-0.5f,
-0.5f,0.5f,-0.5f, -0.5f,-0.5f,-0.5f, -0.5f,-0.5f,0.5f, -0.5f,0.5f,-0.5f, -0.5f,-0.5f,0.5f, -0.5f,0.5f,0.5f,
};
//GLuint indices[] = {1,0,3,2,2,3,7,6,3,0,4,7,6,5,1,2,4,5,6,7,5,4,0,1};
GLfloat normals[]={
0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f,
1.0f,0.0f,0.0f, 1.0f,0.0f,0.0f, 1.0f,0.0f,0.0f, 1.0f,0.0f,0.0f, 1.0f,0.0f,0.0f, 1.0f,0.0f,0.0f,
0.0f,-1.0f,0.0f, 0.0f,-1.0f,0.0f, 0.0f,-1.0f,0.0f, 0.0f,-1.0f,0.0f, 0.0f,-1.0f,0.0f, 0.0f,-1.0f,0.0f,
0.0f,1.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,1.0f,0.0f,
0.0f,0.0f,-1.0f, 0.0f,0.0f,-1.0f, 0.0f,0.0f,-1.0f, 0.0f,0.0f,-1.0f, 0.0f,0.0f,-1.0f, 0.0f,0.0f,-1.0f,
-1.0f,0.0f,0.0f, -1.0f,0.0f,0.0f, -1.0f,0.0f,0.0f, -1.0f,0.0f,0.0f, -1.0f,0.0f,0.0f, -1.0f,0.0f,0.0f,
};
/*GLfloat vertices[] = {0.0f, 0.5f, 0.0f, // 0
-0.25f, 0.0f, 0.0f, // 1
0.25f, 0.0f, 0.0f, // 2
-0.5f, -0.5f, 0.0f, // 3
0.0f, -0.5f, 0.0f, // 4
0.5f, -0.5f, 0.0f // 5
};
GLuint indices[] = {0, 1, 2, 1, 3, 4, 2, 4, 5};
GLfloat normals[]={
0.0f,0.0f,1.0f,
0.0f,0.0f,1.0f,
0.0f,0.0f,1.0f,
0.0f,0.0f,1.0f,
0.0f,0.0f,1.0f,
0.0f,0.0f,1.0f
};*/
// Make a shader
char* vertexShaderSourceCode = readFile("vertexShader.vsh");
char* fragmentShaderSourceCode = readFile("fragmentShader.fsh");
GLuint vertShaderID = makeVertexShader(vertexShaderSourceCode);
GLuint fragShaderID = makeFragmentShader(fragmentShaderSourceCode);
shaderProgramID = makeShaderProgram(vertShaderID, fragShaderID);
// Create the "remember all"
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// Create the buffer, but don't load anything yet
//glBufferData(GL_ARRAY_BUFFER, 7*NUM_VERTICES*sizeof(GLfloat), NULL, GL_STATIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, 6*NUM_VERTICES*sizeof(GLfloat), NULL, GL_STATIC_DRAW); // NEW!! - We're only loading vertices and normals (6 elements, not 7)
// Load the vertex points
glBufferSubData(GL_ARRAY_BUFFER, 0, 3*NUM_VERTICES*sizeof(GLfloat), vertices);
// Load the colors right after that
//glBufferSubData(GL_ARRAY_BUFFER, 3*NUM_VERTICES*sizeof(GLfloat),4*NUM_VERTICES*sizeof(GLfloat), colors);
glBufferSubData(GL_ARRAY_BUFFER, 3*NUM_VERTICES*sizeof(GLfloat),3*NUM_VERTICES*sizeof(GLfloat), normals);
#ifdef USING_INDEX_BUFFER
glGenBuffers(1, &indexBufferID);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, NUM_INDICES*sizeof(GLuint), indices, GL_STATIC_DRAW);
#endif
// Find the position of the variables in the shader
positionID = glGetAttribLocation(shaderProgramID, "s_vPosition");
normalID = glGetAttribLocation(shaderProgramID, "s_vNormal");
lightID = glGetUniformLocation(shaderProgramID, "vLight"); // NEW
// ============ glUniformLocation is how you pull IDs for uniform variables===============
perspectiveMatrixID = glGetUniformLocation(shaderProgramID, "mP");
viewMatrixID = glGetUniformLocation(shaderProgramID, "mV");
modelMatrixID = glGetUniformLocation(shaderProgramID, "mM");
allRotsMatrixID = glGetUniformLocation(shaderProgramID, "mRotations"); // NEW
//=============================================================================================
glVertexAttribPointer(positionID, 3, GL_FLOAT, GL_FALSE, 0, 0);
//glVertexAttribPointer(colorID, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(vertices)));
glVertexAttribPointer(normalID, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(vertices)));
glUseProgram(shaderProgramID);
glEnableVertexAttribArray(positionID);
glEnableVertexAttribArray(normalID);
glEnable(GL_CULL_FACE); // NEW! - we're doing real 3D now... Cull (don't render) the backsides of triangles
glCullFace(GL_BACK); // Other options? GL_FRONT and GL_FRONT_AND_BACK
glEnable(GL_DEPTH_TEST);// Make sure the depth buffer is on. As you draw a pixel, update the screen only if it's closer than previous ones
glClearColor( 1.0, 1.0, 1.0, 1.0 );
glutKeyboardFunc( keyboard );
glutMainLoop();
return 0;
}
int main (int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowSize(600, 600);
glutCreateWindow("Grid Plane");
glutReshapeFunc(changeViewport);
glutDisplayFunc(render);
glewInit();
//loop for vertex creation
GLfloat vertices[3*NUM_VERTICES];
int count = 0;
for (int y = 0; y < DEPTH+1; ++y)
{
for (int x = 0; x < DEPTH+1; ++x)
{
vertices[count++] = (x - (float)(DEPTH/2))/DEPTH;
vertices[count++] = (y - (float)(DEPTH/2))/DEPTH;
vertices[count++] = 0.0f;
}
}
GLuint indices[NUM_INDICES];
count = 0;
//loop for index creation
for (int i = 0; i < DEPTH; ++i)
{
for (int start = ((DEPTH*i)+i)+1; start < ((DEPTH*i)+i)+DEPTH+1; ++start)
{
indices[count++]=start;
indices[count++]=start+DEPTH;
indices[count++]=start-1;
indices[count++]=start;
indices[count++]=start+DEPTH+1;
indices[count++]=start+DEPTH;
}
}
char* vertexShaderSourceCode = readFile("vertexShader.glsl");
char* fragmentShaderSourceCode = readFile("fragmentShader.glsl");
GLuint vertShaderID = makeVertexShader(vertexShaderSourceCode);
GLuint fragShaderID = makeFragmentShader(fragmentShaderSourceCode);
shaderProgramID = makeShaderProgram(vertShaderID, fragShaderID);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, 3*NUM_VERTICES*sizeof(GLfloat), NULL, GL_STATIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, 3*NUM_VERTICES*sizeof(GLfloat), vertices);
glGenBuffers(1, &indexBufferID);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, NUM_INDICES*sizeof(GLuint), indices, GL_STATIC_DRAW);
positionID = glGetAttribLocation(shaderProgramID, "s_vPosition");
var = glGetUniformLocation(shaderProgramID, "var");
glVertexAttribPointer(positionID, 3, GL_FLOAT, GL_FALSE, 0, 0);
glUseProgram(shaderProgramID);
glEnableVertexAttribArray(positionID);
Timer(0);
glutMainLoop();
return 0;
}
int main (int argc, char** argv) {
// Standard stuff...
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow("Lab 1");
glutReshapeFunc(changeViewport);
glutDisplayFunc(render);
glutMouseFunc(mousefunc);
glewInit();
// Vertices and colors of a triangle
// notice, position values are between -1.0f and +1.0f
GLfloat vertices[] = {
///////////Square///////////
-0.5f, -0.5f, 0.0f, // Lower-left
0.5f, -0.5f, 0.0f, // Lower-right
0.5f, 0.5f, 0.0f, // Top-right
-0.5f, 0.5f, 0.0f, // Top-left
////////////Octo////////////
0.5f, 0.25f, 0.0f, //CCW
0.25f, 0.5f, 0.0f,
-0.25f, 0.5f, 0.0f,
-0.5f, 0.25f, 0.0f,
-0.5f, -0.25f, 0.0f,
-0.25f, -0.5f, 0.0f,
0.25f, -0.5f, 0.0f,
0.5f, -0.25f, 0.0f,
////////////Star////////////
0.1f, 0.1f, 0.0f, //CCW
0.0f, 0.5f, 0.0f,
-0.1f, 0.1f, 0.0f,
-0.5f, 0.0f, 0.0f,
-0.1f, -0.1f, 0.0f,
0.0f, -0.5f, 0.0f,
0.1f, -0.1f, 0.0f,
0.5f, 0.0f, 0.0f
};
GLfloat colors[] = {
///////////Square//////////
0.0f, 0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
0.0f, 1.0f, 1.0f, 1.0f,
///////////Octo////////////
0.0f, 0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
0.0f, 1.0f, 1.0f, 1.0f,
1.0f, 0.0f, 0.0f, 1.0f,
1.0f, 0.0f, 1.0f, 1.0f,
1.0f, 1.0f, 0.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f,
///////////Star/////////////
0.0f, 0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
0.0f, 1.0f, 1.0f, 1.0f,
1.0f, 0.0f, 0.0f, 1.0f,
1.0f, 0.0f, 1.0f, 1.0f,
1.0f, 1.0f, 0.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f,
};
// Make a shader
char* vertexShaderSourceCode = readFile("vertexshader.glsl");
char* fragmentShaderSourceCode = readFile("fragmentshader.glsl");
GLuint vertShaderID = makeVertexShader(vertexShaderSourceCode);
GLuint fragShaderID = makeFragmentShader(fragmentShaderSourceCode);
shaderProgramID = makeShaderProgram(vertShaderID, fragShaderID);
printf ("vertShaderID is %d\n", vertShaderID);
printf ("fragShaderID is %d\n", fragShaderID);
printf ("shaderProgramID is %d\n", shaderProgramID);
// Create the "remember all"
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// Create the buffer, but don't load anything yet
glBufferData(GL_ARRAY_BUFFER, 7*20*sizeof(GLfloat), NULL, GL_STATIC_DRAW);
// Load the vertex points
glBufferSubData(GL_ARRAY_BUFFER, 0, 3*20*sizeof(GLfloat), vertices);
// Load the colors right after that
glBufferSubData(GL_ARRAY_BUFFER, 3*20*sizeof(GLfloat),4*20*sizeof(GLfloat), colors);
// Find the position of the variables in the shader
positionID = glGetAttribLocation(shaderProgramID, "s_vPosition");
colorID = glGetAttribLocation(shaderProgramID, "s_vColor");
printf ("s_vPosition's ID is %d\n", positionID);
printf ("s_vColor's ID is %d\n", colorID);
glVertexAttribPointer(positionID, 3, GL_FLOAT, GL_FALSE, 0, 0);
glVertexAttribPointer(colorID, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(3*20*sizeof(GLfloat)));
//glVertexAttribPointer(colorID, 4, GL_FLOAT, GL_FALSE, 0, 0);
glUseProgram(shaderProgramID);
glEnableVertexAttribArray(positionID);
glEnableVertexAttribArray(colorID);
glutMainLoop();
return 0;
}
int main (int argc, char** argv) {
// GLUT initialisation and matrices
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow("GCP Assignment");
glutReshapeFunc(changeViewport);
glutKeyboardFunc(keyboardFunc);
glutDisplayFunc(render);
glewInit();
initMatrices();
// Make shaders
char* vertexShaderSourceCode = readFile("vertexShader.vsh");
char* fragmentShaderSourceCode = readFile("fragmentShader.fsh");
GLuint vertShaderID = makeVertexShader(vertexShaderSourceCode);
GLuint fragShaderID = makeFragmentShader(fragmentShaderSourceCode);
shaderProgramID = makeShaderProgram(vertShaderID, fragShaderID);
// create and bind the VBO toi the VAO"
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// Create the buffer of the size necessary to store the model 3 flaots for RGB 3 for the vertices XYZ
glBufferData(GL_ARRAY_BUFFER, 6*NUM_VERTICES*sizeof(GLfloat), NULL, GL_STATIC_DRAW);
// Load the vertex points
glBufferSubData(GL_ARRAY_BUFFER, 0, 3*NUM_VERTICES*sizeof(GLfloat), vertices);
// Load the colors right after that
glBufferSubData(GL_ARRAY_BUFFER, 3*NUM_VERTICES*sizeof(GLfloat),3*NUM_VERTICES*sizeof(GLfloat), normals);
#ifdef USING_INDEX_BUFFER
glGenBuffers(1, &indexBufferID);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, NUM_INDICES*sizeof(GLuint), indices, GL_STATIC_DRAW);
#endif
// the console output
std::cout << "Giannandrea Grone Assignment \n";
std::cout << "Simple demonstration of rotating a model around itself with Quaternions or Matrices\n ";
std::cout << "The results seem similar but the maths behind it is significantly different\n ";
std::cout << "How to use: \n ";
std::cout << "Press P to toggle between Matrices and Quaternions \n ";
std::cout << "Press O to toggle between Automatic and Manual \n ";
std::cout << "WASD to move the camera (left, right, forward, backward \n ";
std::cout << "QE to move the camera upward downward \n ";
std::cout << "RT FG CV to rotate the camera on XYZ \n ";
std::cout << "(Manual only) YU HJ NM to rotate the model on XYZ \n";
// bind the data with the shaders
positionID = glGetAttribLocation(shaderProgramID, "s_vPosition");
normalID = glGetAttribLocation(shaderProgramID, "s_vNormal");
lightID = glGetUniformLocation(shaderProgramID, "vLight"); // NEW
// gives the data to the shaders
perspectiveMatrixID = glGetUniformLocation(shaderProgramID, "mP");
viewMatrixID = glGetUniformLocation(shaderProgramID, "mV");
modelMatrixID = glGetUniformLocation(shaderProgramID, "mM");
allRotsMatrixID = glGetUniformLocation(shaderProgramID, "mRotations");
glVertexAttribPointer(positionID, 3, GL_FLOAT, GL_FALSE, 0, 0);
glVertexAttribPointer(normalID, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(vertices)));
glUseProgram(shaderProgramID);
glEnableVertexAttribArray(positionID);
glEnableVertexAttribArray(normalID);
// Turn on depth cullint
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glEnable(GL_DEPTH_TEST);
glutMainLoop();
return 0;
}
int main (int argc, char** argv) {
// Standard stuff...
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow("Index Buffers");
glutReshapeFunc(changeViewport);
glewInit();
initMatrices(); // New <========================================
vao=gen_particles();
/*#ifdef USING_INDEX_BUFFER
#endif*/
// Make a shader
char* vertexShaderSourceCode = readFile("vertexShader1.vsh");
char* fragmentShaderSourceCode = readFile("fragmentShader1.fsh");
GLuint vertShaderID = makeVertexShader(vertexShaderSourceCode);
GLuint fragShaderID = makeFragmentShader(fragmentShaderSourceCode);
shaderProgramID = makeShaderProgram(vertShaderID, fragShaderID);
/*/ / Create the "remember all"
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// Create the buffer, but don't load anything yet
//glBufferData(GL_ARRAY_BUFFER, 7*NUM_VERTICES*sizeof(GLfloat), NULL, GL_STATIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, 6*NUM_VERTICES*sizeof(GLfloat), NULL, GL_STATIC_DRAW);
// Load the vertex points
glBufferSubData(GL_ARRAY_BUFFER, 0, 3*NUM_VERTICES*sizeof(GLfloat), vertices);
// Load the colors right after that
//glBufferSubData(GL_ARRAY_BUFFER, 3*NUM_VERTICES*sizeof(GLfloat),4*NUM_VERTICES*sizeof(GLfloat), colors);
glBufferSubData(GL_ARRAY_BUFFER, 3*NUM_VERTICES*sizeof(GLfloat),3*NUM_VERTICES*sizeof(GLfloat), normals);*/
/*#ifdef USING_INDEX_BUFFER
glGenBuffers(1, &indexBufferID);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, NUM_INDICES*sizeof(GLuint), indices, GL_STATIC_DRAW);
#endif*/
// Find the position of the variables in the shader
//ositionID = glGetAttribLocation(shaderProgramID, "v_i");
//colorID = glGetAttribLocation(shaderProgramID, "elapsed_system_time");
// ============ New! glUniformLocation is how you pull IDs for uniform variables===============
perspectiveMatrixID = glGetUniformLocation(shaderProgramID, "P");
viewMatrixID = glGetUniformLocation(shaderProgramID, "V");
emitterID=glGetUniformLocation(shaderProgramID, "emitter_pos_wor");
timeID=glGetUniformLocation(shaderProgramID, "elapsed_system_time");
//=============================================================================================
/*glVertexAttribPointer(positionID, 3, GL_FLOAT, GL_FALSE, 0, 0);
//glVertexAttribPointer(colorID, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(vertices)));
glVertexAttribPointer(colorID, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(vertices)));
printf ("BUFFER_OFFSET is: %d\n", sizeof(vertices));*/
glUseProgram(shaderProgramID);
//glEnableVertexAttribArray(positionID);
//glEnableVertexAttribArray(colorID);
//glEnable(GL_DEPTH_TEST);
//glClearColor( 0.0, 0.0, 0.0, 0.2 );
//current_seconds=Timer();
glutDisplayFunc(render);
glutKeyboardFunc( keyboard );
glutMainLoop();
return 0;
}
