// On successful return, the returned program object ID can be
// used to install the program as part of current state
// using glUseProgram(). Example:
//
// GLuint prog = makeShaderProgramFromFiles( vertShaderFile, fragShaderFile,
// myBindAttribLocFunc );
// if ( prog != 0 )
// {
// glUseProgram( prog );
//
// // Set values of uniform variables only
// // after the prog has become current.
// glUniform3f( getUniLoc(prog, "LightPosition"), 10.0, 10.0, 15.0 );
// printOpenGLError();
// glUniform1f( getUniLoc(prog, "Density"), 16.0 );
// printOpenGLError();
// }
//
// Use glUseProgram(0) to restore the original vertex processing
// and fragement processing fixed functionalities.
//
/////////////////////////////////////////////////////////////////////////////
GLuint makeShaderProgramFromFiles( const char *vertShaderSrcFilename,
const char *fragShaderSrcFilename,
void (*bindAttribLocFunc)( GLuint progObj ) )
{
// Read shaders' source files.
GLchar *vertSrc = NULL, *fragSrc = NULL;
if ( vertShaderSrcFilename != NULL )
if ( readShaderSource( vertShaderSrcFilename, &vertSrc ) == 0 )
{
free( vertSrc ); free( fragSrc );
return 0;
}
if ( fragShaderSrcFilename != NULL )
if ( readShaderSource( fragShaderSrcFilename, &fragSrc ) == 0 )
{
free( vertSrc ); free( fragSrc );
return 0;
}
// Create shader program object.
GLuint shaderProg = makeShaderProgram( vertSrc, fragSrc, bindAttribLocFunc);
free( vertSrc ); free( fragSrc );
return shaderProg;
}
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;
}
void ScreenAlignedQuadMaterial::initialize()
{
std::string vertFilename = "097Bashirov/shaders6/quad.vert";
std::string fragFilename = "097Bashirov/shaders6/quad.frag";
_programId = makeShaderProgram(vertFilename, fragFilename);
//=========================================================
//Инициализация uniform-переменных для текстурирования
_texUniform = glGetUniformLocation(_programId, "tex");
}
inline GLuint makeShaderProgramFromFile(const std::string &profile, const std::vector<GLenum> &stypes, const std::string &sourcefile) {
std::ifstream fileStream(sourcefile);
if (!fileStream) {
throw std::runtime_error("Error: Could not locate and open file " + sourcefile);
}
std::stringstream buffer;
buffer << fileStream.rdbuf();
return makeShaderProgram(profile, stypes, buffer.str());
}
inline GLuint makeShaderProgramFromFile(const std::vector<GLenum> &stypes, const std::vector<std::string> &sourcefiles) {
std::vector<std::string> sources;
for (std::string filename : sourcefiles) {
std::ifstream fileStream(filename);
if (!fileStream) {
throw std::runtime_error("Error: Could not locate and open file " + filename);
}
std::stringstream buffer;
buffer << fileStream.rdbuf();
sources.push_back(buffer.str());
}
return makeShaderProgram(stypes, sources);
}
/*
initialize the shader and loads a vertex, geometry, tesselation, fragment & compute shader
if you don't want to use a shader, then set the string to ""
*/
Shader::Shader(std::string vertexShaderPath, std::string geometryShaderPath, std::string tesselationControlShaderPath, std::string tesselationEvaluationShaderPath, std::string fragmentShaderPath, std::string computeShaderPath)
{
std::cout << "Shader was initialized" << std::endl;
//check which shader we are using and set the path of the shaders
if (vertexShaderPath != ""){
m_vertexShaderPath += SHADERS_PATH + vertexShaderPath;
m_usingVertexShader = true;
}
else{
m_usingVertexShader = false;
}
if (fragmentShaderPath != ""){
m_fragmentShaderPath += SHADERS_PATH + fragmentShaderPath;
m_usingFragmentShader = true;
}
else{
m_usingFragmentShader = false;
}
if (geometryShaderPath != ""){
m_geometryShaderPath += SHADERS_PATH + geometryShaderPath;
m_usingGeometryShader = true;
}
else{
m_usingGeometryShader = false;
}
if (tesselationControlShaderPath != "" && tesselationEvaluationShaderPath != ""){
m_tesselationControlShaderPath += SHADERS_PATH + tesselationControlShaderPath;
m_tesselationEvaluationShaderPath += SHADERS_PATH + tesselationEvaluationShaderPath;
m_usingTesselationShader = true;
}
else{
m_usingTesselationShader = false;
}
if (computeShaderPath != ""){
m_computeShaderPath += SHADERS_PATH + computeShaderPath;
}
else{
m_usingComputeShader = false;
}
//Open, compile and link the neccesary Shader
makeShaderProgram(m_usingVertexShader, m_usingGeometryShader, m_usingTesselationShader, m_usingFragmentShader, m_usingComputeShader);
}
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;
}
// Initialize shaders.
void initShaders() {
// Load a simple Vertex/Fragment shader
GLuint vertexShader = loadShader(GL_VERTEX_SHADER, "simple.vert");
GLuint fragmentShader = loadShader(GL_FRAGMENT_SHADER, "simple.frag");
objectShader.shaderProgram = makeShaderProgram(vertexShader, fragmentShader);
// Get locations of attributes and uniforms used inside.
objectShader.vertexPosition = glGetAttribLocation(objectShader.shaderProgram, "vertex");
objectShader.modelviewMatrix = glGetUniformLocation(objectShader.shaderProgram, "modelview");
objectShader.normalviewMatrix = glGetUniformLocation(objectShader.shaderProgram, "normalview");
objectShader.projectionMatrix = glGetUniformLocation(objectShader.shaderProgram, "projection");
objectShader.terrainTexture = glGetUniformLocation(objectShader.shaderProgram, "terrainTexture");
objectShader.lowTexture = glGetUniformLocation(objectShader.shaderProgram, "lowTexture");
objectShader.highTexture = glGetUniformLocation(objectShader.shaderProgram, "highTexture");
// Bind output variables
glBindFragDataLocation(objectShader.shaderProgram, 0, "outColor");
// Create particle depth rendering shader
vertexShader = loadShader(GL_VERTEX_SHADER, "particles.vert");
fragmentShader = loadShader(GL_FRAGMENT_SHADER, "particledepth.frag");
particleShader.shaderProgram = makeShaderProgram(vertexShader, fragmentShader);
// Get locations of attributes and uniforms used inside.
particleShader.vertexPosition = glGetAttribLocation(particleShader.shaderProgram, "vertex");
particleShader.modelviewMatrix = glGetUniformLocation(particleShader.shaderProgram, "modelview");
particleShader.projectionMatrix = glGetUniformLocation(particleShader.shaderProgram, "projection");
particleShader.screenSize = glGetUniformLocation(particleShader.shaderProgram, "screenSize");
particleShader.terrainTexture = glGetUniformLocation(particleShader.shaderProgram, "terrainTexture");
// Bind output variables
glBindFragDataLocation(particleShader.shaderProgram, 0, "particleDepth");
// Create particle thickness rendering shader
vertexShader = loadShader(GL_VERTEX_SHADER, "particles.vert");
fragmentShader = loadShader(GL_FRAGMENT_SHADER, "particlethickness.frag");
particleThicknessShader.shaderProgram = makeShaderProgram(vertexShader, fragmentShader);
// Get locations of attributes and uniforms used inside.
particleThicknessShader.vertexPosition = glGetAttribLocation(particleThicknessShader.shaderProgram, "vertex");
particleThicknessShader.modelviewMatrix = glGetUniformLocation(particleThicknessShader.shaderProgram, "modelview");
particleThicknessShader.projectionMatrix = glGetUniformLocation(particleThicknessShader.shaderProgram, "projection");
particleThicknessShader.screenSize = glGetUniformLocation(particleThicknessShader.shaderProgram, "screenSize");
particleThicknessShader.terrainTexture = glGetUniformLocation(particleThicknessShader.shaderProgram, "terrainTexture");
// Bind output variables
glBindFragDataLocation(particleThicknessShader.shaderProgram, 0, "particleThickness");
// Create particle thickness rendering shader
vertexShader = loadShader(GL_VERTEX_SHADER, "particles.vert");
fragmentShader = loadShader(GL_FRAGMENT_SHADER, "particlevelocity.frag");
particleVelocityShader.shaderProgram = makeShaderProgram(vertexShader, fragmentShader);
// Get locations of attributes and uniforms used inside.
particleVelocityShader.vertexPosition = glGetAttribLocation(particleVelocityShader.shaderProgram, "vertex");
particleVelocityShader.modelviewMatrix = glGetUniformLocation(particleVelocityShader.shaderProgram, "modelview");
particleVelocityShader.projectionMatrix = glGetUniformLocation(particleVelocityShader.shaderProgram, "projection");
particleVelocityShader.screenSize = glGetUniformLocation(particleVelocityShader.shaderProgram, "screenSize");
// Bind output variables
glBindFragDataLocation(particleVelocityShader.shaderProgram, 0, "velocityMap");
// Create curvature flow shader
vertexShader = loadShader(GL_VERTEX_SHADER, "quad.vert");
fragmentShader = loadShader(GL_FRAGMENT_SHADER, "curvatureflow.frag");
curvatureFlowShader.shaderProgram = makeShaderProgram(vertexShader, fragmentShader);
// Attributes / uniforms
curvatureFlowShader.vertexPosition = glGetAttribLocation(curvatureFlowShader.shaderProgram, "vertex");
curvatureFlowShader.particleTexture = glGetUniformLocation(curvatureFlowShader.shaderProgram, "particleTexture");
curvatureFlowShader.projectionMatrix = glGetUniformLocation(curvatureFlowShader.shaderProgram, "projection");
curvatureFlowShader.screenSize = glGetUniformLocation(curvatureFlowShader.shaderProgram, "screenSize");
// Output
glBindFragDataLocation(curvatureFlowShader.shaderProgram, 0, "outDepth");
// Create liquid shading shader
vertexShader = loadShader(GL_VERTEX_SHADER, "quad.vert");
fragmentShader = loadShader(GL_FRAGMENT_SHADER, "liquidshade.frag");
liquidShadeShader.shaderProgram = makeShaderProgram(vertexShader, fragmentShader);
// Attributes / uniforms
liquidShadeShader.vertexPosition = glGetAttribLocation(liquidShadeShader.shaderProgram, "vertex");
liquidShadeShader.particleTexture = glGetUniformLocation(liquidShadeShader.shaderProgram, "particleTexture");
liquidShadeShader.particleThicknessTexture = glGetUniformLocation(liquidShadeShader.shaderProgram, "particleThicknessTexture");
liquidShadeShader.environmentTexture = glGetUniformLocation(liquidShadeShader.shaderProgram, "environmentTexture");
liquidShadeShader.velocityTexture = glGetUniformLocation(liquidShadeShader.shaderProgram, "velocityTexture");
liquidShadeShader.projectionMatrix = glGetUniformLocation(liquidShadeShader.shaderProgram, "projection");
liquidShadeShader.modelviewMatrix = glGetUniformLocation(liquidShadeShader.shaderProgram, "modelview");
liquidShadeShader.screenSize = glGetUniformLocation(liquidShadeShader.shaderProgram, "screenSize");
liquidShadeShader.useThickness = glGetUniformLocation(liquidShadeShader.shaderProgram, "useThickness");
// Output
glBindFragDataLocation(liquidShadeShader.shaderProgram, 0, "outColor");
// Create composition shader
vertexShader = loadShader(GL_VERTEX_SHADER, "quad.vert");
fragmentShader = loadShader(GL_FRAGMENT_SHADER, "compose.frag");
compositionShader.shaderProgram = makeShaderProgram(vertexShader, fragmentShader);
// Attributes / uniforms
compositionShader.vertexPosition = glGetAttribLocation(compositionShader.shaderProgram, "vertex");
compositionShader.backgroundTexture = glGetUniformLocation(compositionShader.shaderProgram, "backgroundTexture");
compositionShader.terrainTexture = glGetUniformLocation(compositionShader.shaderProgram, "terrainTexture");
compositionShader.particleTexture = glGetUniformLocation(compositionShader.shaderProgram, "particleTexture");
compositionShader.modelviewMatrix = glGetUniformLocation(compositionShader.shaderProgram, "modelview");
// Output
glBindFragDataLocation(compositionShader.shaderProgram, 0, "outColor");
}
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;
}
