void initialize(void) {
// Set background (clear) color to blue
glClearColor(0.4, 0.4, 0.4, 0.0);
// Enable depth testing
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
// Setup shaders and shader program
CreateShaderProgram();
// create light sources
LightSource tmp(glm::vec3(1, 6.5, 0), glm::vec3(1, 1, 0), .01);
lightSources.push_back(tmp);
LightSource tmp1(glm::vec3(5, -8.0f, 0), glm::vec3(0, .5, 1), 0);
lightSources.push_back(tmp1);
// init all Objects
for (unsigned int i = 0; i < graphicObjects.size(); i++) {
graphicObjects[i].initObj(0, 0, 0);
}
}
//static variables
GLuint ab=0;
#define BUFFER_OFFSET(i) ((char *)NULL + (i))
int main ()
{
int i=0;
int ab=0;
float clr[3] = {0.0f, 0.3f, 0.6f};
float add[3] = {0.001f, 0.002f, 0.003f};
unsigned int position_attrib_idx = 0;
//GL stuff
SShader vertexShader;
SShader fragmentShader;
SShaderProgram program;
CPlatform platform;
Create(&platform, "", 2, 1, 1024, 768, 8, 8, 8, 8, 16, 8, 0);
//-------------------
//setup the shaders
CreateShader(&vertexShader, VERT, &pVertexShader, 1);
CreateShader(&fragmentShader, FRAG, &pFragmentShader, 1);
CreateShaderProgram(&program);
AddShaderToProgram(&program, &vertexShader);
AddShaderToProgram(&program, &fragmentShader);
SetAttributeLocation(&program, position_attrib_idx, "position"); //needs to be calleb before linking
LinkShaderProgram(&program);
glGenBuffers(1, &ab); //array buffer
//fill buffers
glBindBuffer(GL_ARRAY_BUFFER, ab);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
//-------------------
//tell openGL how to interperet the data
glBindBuffer(GL_ARRAY_BUFFER, ab);
glEnableVertexAttribArray(0);
glVertexAttribPointer(position_attrib_idx, 3, GL_FLOAT, GL_FALSE, 12, 0);
//set rendering states
glEnable(GL_CULL_FACE);
glClearColor(0, 0, 0, 0.0f); //alpha to 0, should make triangle appear over console
Start(&program); //even when glDeleteProgram is called the program won't be deleted until it is out of use
while (!IS_BUTTON_PRESSED(platform.m_keyboard.key[KB_ESC]))
{
Tick(&platform);
glClear(GL_COLOR_BUFFER_BIT);
SetVec3ByName(&program, "uColour", clr);
glDrawArrays( GL_TRIANGLES, 0, 3);
SwapBuffers(&platform);
for(i=0;i<3;i++)
{
clr[i]+=add[i];
if(clr[i]>1.0f)add[i]*=-1.0f;
if(clr[i]<0.0f)add[i]*=-1.0f;
}
}
Stop();
void Initialize(void)
{
/* Set background (clear) color to dark blue */
glClearColor(0.0, 0.0, 0.4, 0.0);
/* Enable depth testing */
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
/* Transform matrix for the bar in the middle*/
/*copy objects into buffer*/
memcpy(vertex_buffer_data1, vertex_octagon, sizeof(vertex_octagon));
memcpy(vertex_buffer_data2, vertex_pyramid, sizeof(vertex_pyramid));
memcpy(vertex_buffer_data3, vertex_mainBar, sizeof(vertex_mainBar));
memcpy(vertex_buffer_data4, vertex_cube, sizeof(vertex_cube));
memcpy(vertex_buffer_data5, vertex_cube, sizeof(vertex_cube));
memcpy(vertex_buffer_data6, vertex_cube, sizeof(vertex_cube));
memcpy(vertex_buffer_data7, vertex_cube, sizeof(vertex_cube));
/*
memcpy(color_buffer_data1, color_octagon, sizeof(color_octagon));
memcpy(color_buffer_data2, color_pyramid, sizeof(color_pyramid));
memcpy(color_buffer_data3, color_mainBar, sizeof(color_mainBar));
memcpy(color_buffer_data4, color_cube, sizeof(color_cube));
memcpy(color_buffer_data5, color_cube, sizeof(color_cube));
memcpy(color_buffer_data6, color_cube, sizeof(color_cube));
memcpy(color_buffer_data7, color_cube, sizeof(color_cube));
*/
memcpy(index_buffer_data1, index_octagon, sizeof(index_octagon));
memcpy(index_buffer_data2, index_pyramid, sizeof(index_pyramid));
memcpy(index_buffer_data3, index_mainBar, sizeof(index_mainBar));
memcpy(index_buffer_data4, index_cube, sizeof(index_cube));
memcpy(index_buffer_data5, index_cube, sizeof(index_cube));
memcpy(index_buffer_data6, index_cube, sizeof(index_cube));
memcpy(index_buffer_data7, index_cube, sizeof(index_cube));
/* Setup vertex, color, and index buffer objects */
SetupDataBuffers();
/* Setup shaders and shader program */
CreateShaderProgram();
/* Initialize matrices */
SetIdentityMatrix(ProjectionMatrix);
SetIdentityMatrix(ViewMatrix);
int i = 0;
for(;i<OBJECTS;i++) {
SetIdentityMatrix(ModelMatrix[i]);
}
printf("DEBUG: adding light-source ...\n");
/* Add lighting source to the code */
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glEnable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_LIGHT0); // adds first light-source to the scene
GLfloat ambientLight[] = {0.2, 0.2, 0.2, 1.0};
GLfloat diffuseLight[] = {0.8, 0.8, 0.8, 1.0};
GLfloat specularLight[]= {1.0, 1.0, 1.0, 1.0};
GLfloat positionLight[]= {5.0, 0.0, 0.0, 0.0};
//glShadeModel(GL_SMOOTH);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);
glLightfv(GL_LIGHT0, GL_SPECULAR, specularLight);
glLightfv(GL_LIGHT0, GL_POSITION, positionLight);
GLfloat black[] = {0.0, 0.0, 0.0, 1.0};
GLfloat green[] = {0.0, 1.0, 0.0, 1.0};
GLfloat white[] = {1.0, 1.0, 1.0, 1.0};
glMaterialfv(GL_FRONT, GL_AMBIENT, green);
glMaterialfv(GL_FRONT, GL_DIFFUSE, green);
glMaterialfv(GL_FRONT, GL_SPECULAR, white);
glMaterialf(GL_FRONT, GL_SHININESS, 60.0);
printf("DEBUG: finished adding light-source\n");
/* Set projection transform */
float fovy = 45.0;
float aspect = 1.0;
float nearPlane = 1.0;
float farPlane = 50.0;
SetPerspectiveMatrix(fovy, aspect, nearPlane, farPlane, ProjectionMatrix);
/* Set viewing transform */
float camera_disp = -10.0;
SetTranslation(0.0, 0.0, camera_disp, ViewMatrix);
/* Translate and rotate cube */
SetTranslation(0, 0, 0, TranslateOrigin);
SetRotationX(0.0, RotateX);
SetRotationZ(0.0, RotateZ);
/* Translate down */
SetTranslation(0, -sqrtf(sqrtf(2.0) * 1.0), 0, TranslateDown);
/* Initial transformation matrix */
MultiplyMatrix(RotateX, TranslateOrigin, InitialTransform);
MultiplyMatrix(RotateZ, InitialTransform, InitialTransform);
}
void GLReplay::InitDebugData()
{
if(m_pDriver == NULL) return;
{
uint64_t id = MakeOutputWindow(NULL, true);
m_DebugCtx = &m_OutputWindows[id];
}
DebugData.outWidth = 0.0f; DebugData.outHeight = 0.0f;
DebugData.blitvsSource = GetEmbeddedResource(blit_vert);
DebugData.blitfsSource = GetEmbeddedResource(blit_frag);
DebugData.blitProg = CreateShaderProgram(DebugData.blitvsSource.c_str(), DebugData.blitfsSource.c_str());
string texfs = GetEmbeddedResource(texdisplay_frag);
DebugData.texDisplayProg = CreateShaderProgram(DebugData.blitvsSource.c_str(), texfs.c_str());
string checkerfs = GetEmbeddedResource(checkerboard_frag);
DebugData.checkerProg = CreateShaderProgram(DebugData.blitvsSource.c_str(), checkerfs.c_str());
DebugData.genericvsSource = GetEmbeddedResource(generic_vert);
DebugData.genericfsSource = GetEmbeddedResource(generic_frag);
DebugData.genericProg = CreateShaderProgram(DebugData.genericvsSource.c_str(), DebugData.genericfsSource.c_str());
string meshvs = GetEmbeddedResource(mesh_vert);
DebugData.meshProg = CreateShaderProgram(meshvs.c_str(), DebugData.genericfsSource.c_str());
WrappedOpenGL &gl = *m_pDriver;
{
float data[] = {
0.0f, -1.0f, 0.0f, 1.0f,
1.0f, -1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 0.0f, 1.0f,
};
gl.glGenBuffers(1, &DebugData.outlineStripVB);
gl.glBindBuffer(eGL_ARRAY_BUFFER, DebugData.outlineStripVB);
gl.glBufferData(eGL_ARRAY_BUFFER, sizeof(data), data, eGL_STATIC_DRAW);
gl.glGenVertexArrays(1, &DebugData.outlineStripVAO);
gl.glBindVertexArray(DebugData.outlineStripVAO);
gl.glVertexAttribPointer(0, 4, eGL_FLOAT, false, 0, (const void *)0);
gl.glEnableVertexAttribArray(0);
}
gl.glGenSamplers(1, &DebugData.linearSampler);
gl.glSamplerParameteri(DebugData.linearSampler, eGL_TEXTURE_MIN_FILTER, eGL_LINEAR_MIPMAP_NEAREST);
gl.glSamplerParameteri(DebugData.linearSampler, eGL_TEXTURE_MAG_FILTER, eGL_LINEAR);
gl.glSamplerParameteri(DebugData.linearSampler, eGL_TEXTURE_WRAP_S, eGL_CLAMP_TO_EDGE);
gl.glSamplerParameteri(DebugData.linearSampler, eGL_TEXTURE_WRAP_T, eGL_CLAMP_TO_EDGE);
gl.glGenSamplers(1, &DebugData.pointSampler);
gl.glSamplerParameteri(DebugData.pointSampler, eGL_TEXTURE_MIN_FILTER, eGL_NEAREST_MIPMAP_NEAREST);
gl.glSamplerParameteri(DebugData.pointSampler, eGL_TEXTURE_MAG_FILTER, eGL_NEAREST);
gl.glSamplerParameteri(DebugData.pointSampler, eGL_TEXTURE_WRAP_S, eGL_CLAMP_TO_EDGE);
gl.glSamplerParameteri(DebugData.pointSampler, eGL_TEXTURE_WRAP_T, eGL_CLAMP_TO_EDGE);
gl.glGenBuffers(ARRAY_COUNT(DebugData.UBOs), DebugData.UBOs);
for(size_t i=0; i < ARRAY_COUNT(DebugData.UBOs); i++)
{
gl.glBindBuffer(eGL_UNIFORM_BUFFER, DebugData.UBOs[i]);
gl.glBufferData(eGL_UNIFORM_BUFFER, DebugData.UBOSize, NULL, eGL_DYNAMIC_DRAW);
}
DebugData.overlayTexWidth = DebugData.overlayTexHeight = 0;
DebugData.overlayTex = DebugData.overlayFBO = 0;
gl.glGenFramebuffers(1, &DebugData.pickPixelFBO);
gl.glBindFramebuffer(eGL_FRAMEBUFFER, DebugData.pickPixelFBO);
gl.glGenTextures(1, &DebugData.pickPixelTex);
gl.glBindTexture(eGL_TEXTURE_2D, DebugData.pickPixelTex);
gl.glTexStorage2D(eGL_TEXTURE_2D, 1, eGL_RGBA32F, 1, 1);
gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MIN_FILTER, eGL_NEAREST);
gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MAG_FILTER, eGL_NEAREST);
gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_WRAP_S, eGL_CLAMP_TO_EDGE);
gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_WRAP_T, eGL_CLAMP_TO_EDGE);
gl.glFramebufferTexture(eGL_FRAMEBUFFER, eGL_COLOR_ATTACHMENT0, DebugData.pickPixelTex, 0);
gl.glGenVertexArrays(1, &DebugData.emptyVAO);
gl.glBindVertexArray(DebugData.emptyVAO);
MakeCurrentReplayContext(&m_ReplayCtx);
gl.glGenVertexArrays(1, &DebugData.meshVAO);
gl.glBindVertexArray(DebugData.meshVAO);
}
void Initialize()
{
int k, i;
int success;
int vert, indx;
/* Load OBJ models */
char* filename[15];
filename[0] = "models/ring.obj";
filename[1] = "models/bar_01.obj";
filename[2] = "models/bar_02.obj";
filename[3] = "models/bar_03.obj";
filename[4] = "models/bar_04.obj";
filename[5] = "models/cone.obj";
filename[6] = "models_n/ball_01.obj";
filename[7] = "models_n/ball_02.obj";
filename[8] = "models/cone_small.obj";
filename[9] = "models/rectangle_small.obj";
filename[10] = "models/rectangle_big.obj";
filename[11] = "models_n/elliptic_ring.obj";
filename[12] = "models/ellipse.obj";
filename[13] = "models_n/stand.obj";
filename[14] = "models_n/surrounding.obj";
for(k=0; k<model_count; ++k){
success = parse_obj_scene(&data[k], filename[k]);
if(!success)
printf("Could not load file. Exiting.\n");
}
/* Copy mesh data from structs into appropriate arrays */
for(k=0; k<model_count; ++k){
vert = data[k].vertex_count;
indx = data[k].face_count;
vertex_buffer_data[k] = (GLfloat*) calloc (vert*3, sizeof(GLfloat));
index_buffer_data[k] = (GLushort*) calloc (indx*3, sizeof(GLushort));
/* Vertices */
for(i=0; i<vert; i++)
{
vertex_buffer_data[k][i*3] = (GLfloat)(*data[k].vertex_list[i]).e[0] ;
vertex_buffer_data[k][i*3+1] = (GLfloat)(*data[k].vertex_list[i]).e[1];
vertex_buffer_data[k][i*3+2] = (GLfloat)(*data[k].vertex_list[i]).e[2];
}
/* Indices */
for(i=0; i<indx; i++){
index_buffer_data[k][i*3] = (GLushort)(*data[k].face_list[i]).vertex_index[0];
index_buffer_data[k][i*3+1] = (GLushort)(*data[k].face_list[i]).vertex_index[1];
index_buffer_data[k][i*3+2] = (GLushort)(*data[k].face_list[i]).vertex_index[2];
}
}
/* Set background (clear) color to blue */
glClearColor(0.1, 0.2, 0.5, 0.0);
/* Setup Vertex array object - INTEL FIX*/
GLuint VAO;
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
/* Enable depth testing */
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
/* Setup vertex, color, and index buffer objects */
SetupDataBuffers();
/* Setup shaders and shader program */
CreateShaderProgram();
/* Initialize matrices */
SetIdentityMatrix(ProjectionMatrix);
SetIdentityMatrix(ViewMatrix);
// set all Model matrices
for(k=0; k<model_count; ++k){
SetIdentityMatrix(ModelMatrix[k]);
}
/* Initialize animation matrices */
SetIdentityMatrix(RotationMatrixAnimX);
SetIdentityMatrix(RotationMatrixAnimY);
SetIdentityMatrix(RotationMatrixAnimZ);
SetIdentityMatrix(RotationMatrixAnim);
/* Set projection transform */
SetPerspectiveMatrix(fovy, aspect, nearPlane, farPlane, ProjectionMatrix);
/* Set initial viewing transform */
SetTranslation(0.0, 0.0, camera_disp, ViewMatrix); // camera_disp == z coordinate of camera
}
static void SetupShaders(void){
int got = 0;
SShader vtxTxShdr, frgTxShdr;
SShader vtxClrShdr, frgClrShdr;
SShader vtxLightShdr, frgLightShdr;
const char *pDVertStr[3] = {0,0,0}, *pDFragStr[3] = {0,0,0};
glswInit();
glswSetPath("./id1/shaders/", ".glsl");
glswAddDirectiveToken("Shared", HASH_DEFINE_VALUE(TRANSFORM_UBO_BINDING));
glswAddDirectiveToken("Shared", HASH_DEFINE_VALUE(LIGHT_UBO_BINDING));
glswAddDirectiveToken("Shared", HASH_DEFINE_VALUE(MAX_DIRECTION_LIGHTS));
glswAddDirectiveToken("Shared", HASH_DEFINE_VALUE(MAX_POINT_LIGHTS));
glswAddDirectiveToken("Shared", HASH_DEFINE_VALUE(MAX_SPOT_LIGHTS));
glswAddDirectiveToken("Shared", HASH_DEFINE_VALUE(TEXT_TEX_UNIT));
glswAddDirectiveToken("Vertex", HASH_DEFINE_VALUE(POSITION_LOCATION));
glswAddDirectiveToken("Vertex", HASH_DEFINE_VALUE(COLOUR_LOCATION));
glswAddDirectiveToken("Vertex", HASH_DEFINE_VALUE(NORMAL_LOCATION));
glswAddDirectiveToken("Vertex", HASH_DEFINE_VALUE(JOINT_WEIGHT_LOCATION));
glswAddDirectiveToken("Vertex", HASH_DEFINE_VALUE(JOINT_INDEX_LOCATION));
glswAddDirectiveToken("Vertex", HASH_DEFINE_VALUE(UV_LOCATION0));
glswAddDirectiveToken("Vertex", HASH_DEFINE_VALUE(UV_LOCATION1));
glswAddDirectiveToken("Vertex", HASH_DEFINE_VALUE(TEXT_LOCATION));
//glswAddDirectiveToken("Shared", HASH_DEFINE_VALUE(SKINNING_TEXTURE_BINDING));
//glswAddDirectiveToken("Shared", HASH_DEFINE_VALUE(WEIGHTS_PER_VERTEX));
//glswAddDirectiveToken("Shared", HASH_DEFINE(TEXTURE_BUFFER_SKINNING));
//glswAddDirectiveToken("Shared", HASH_DEFINE_VALUE(RESERVED_JOINTS));
//shader (TEXTURED)
got = glswGetShadersAlt("shaders.Header.Vertex+shaders.Shared+shaders.SimpleVertexTextured", pDVertStr, 3);
CreateShader(&vtxTxShdr, VERT, pDVertStr, got);
got = glswGetShadersAlt("shaders.Header.Fragment+shaders.Shared+shaders.SimpleFragmentTextured", pDFragStr, 3);
CreateShader(&frgTxShdr, FRAG, pDFragStr, got);
CreateShaderProgram(&texture_shader);
AddShaderToProgram(&texture_shader,&vtxTxShdr);
AddShaderToProgram(&texture_shader,&frgTxShdr);
LinkShaderProgram(&texture_shader);
//shader (COLOUR)
got = glswGetShadersAlt("shaders.Header.Vertex+shaders.Shared+shaders.SimpleVertexColoured", pDVertStr, 3);
CreateShader(&vtxClrShdr, VERT, pDVertStr, got);
got = glswGetShadersAlt("shaders.Header.Fragment+shaders.Shared+shaders.SimpleFragmentColoured", pDFragStr, 3);
CreateShader(&frgClrShdr, FRAG, pDFragStr, got);
CreateShaderProgram(&colour_shader);
AddShaderToProgram(&colour_shader,&vtxClrShdr);
AddShaderToProgram(&colour_shader,&frgClrShdr);
LinkShaderProgram(&colour_shader);
//shader (LIGHTMAP)
got = glswGetShadersAlt("shaders.Header.Vertex+shaders.Shared+shaders.SimpleVertexLightmap", pDVertStr, 3);
CreateShader(&vtxLightShdr, VERT, pDVertStr, got);
got = glswGetShadersAlt("shaders.Header.Fragment+shaders.Shared+shaders.SimpleFragmentLightmap", pDFragStr, 3);
CreateShader(&frgLightShdr, FRAG, pDFragStr, got);
CreateShaderProgram(&light_map_shader);
AddShaderToProgram(&light_map_shader, &vtxLightShdr);
AddShaderToProgram(&light_map_shader, &frgLightShdr);
LinkShaderProgram(&light_map_shader);
//this will delete them after we have deleted the program associated with them
DeleteShader(&vtxTxShdr);
DeleteShader(&frgTxShdr);
DeleteShader(&vtxClrShdr);
DeleteShader(&frgClrShdr);
DeleteShader(&vtxLightShdr);
DeleteShader(&frgLightShdr);
}
int main()
{
try {
// Camera settings
Camera camera;
glm::vec3 vrp(0.0f, 0.0f, 10.0f);
glm::vec3 vpn(0.0f, 0.0f, 1.0f);
glm::vec3 vup(0.0f, 1.0f, 0.0f);
glm::vec3 prp(0.0f, 0.0f, 100.0f);
float F = 10.0f;
float B = -80.0f;
glm::vec2 lower_left(-20.0f, -20.0f);
glm::vec2 upper_right(20.0f, 20.0f);
camera = Camera(vrp, vpn, vup, prp, lower_left, upper_right, F, B);
// Examples
int curves = 4; // Amount of examples
BezierRow G[curves];
G[0] = BezierRow(glm::vec3(-15.0f, -15.0f, 0.0f),
glm::vec3(-10.0f, 25.0f, 0.0f),
glm::vec3(10.0f, 25.0f, 0.0f),
glm::vec3(15.0f, -15.0f, 0.0f));
G[1] = BezierRow(glm::vec3(-20.0f, 0.0f, 0.0f),
glm::vec3(-1.0f, 55.0f, 0.0f),
glm::vec3(1.0f, -55.0f, 0.0f),
glm::vec3(20.0f, 0.0f, 0.0f));
G[2] = BezierRow(glm::vec3(-1.0f, -5.0f, 0.0f),
glm::vec3(-60.0f, 5.0f, 0.0f),
glm::vec3(60.0f, 5.0f, 0.0f),
glm::vec3(1.0f, -5.0f, 0.0f));
G[3] = BezierRow(glm::vec3(-10.0f, -5.0f, 0.0f),
glm::vec3(60.0f, 5.0f, 0.0f),
glm::vec3(-60.0f, 5.0f, 0.0f),
glm::vec3(10.0f, -5.0f, 0.0f));
int currentfigure = 3; // Set figure between 4 different examples
// Decide whether to use sampling or subdivision
int decider = 1;
int Npoint = 0;
std::vector<glm::vec3> points;
// Sampling
if(decider == 0){
float t = 0.0f;
float step = 12.0f;
sampling(G[currentfigure], t, step, points);
Npoint = step*2;
}
// Subdivision
else if(decider == 1){
DLB /= 8.0f;
DRB /= 8.0f;
int n = 3; // Amount of curves (smoothness)
int npow = pow(2, n+1); // Amount of points
subdivide(G[currentfigure], n, points);
Npoint = npow;
}
else{
printf("No method chosen\n"); return 1;
}
glm::mat4x4 CTM = camera.CurrentTransformationMatrix();
std::cout << "CTM = " << std::endl << CTM << std::endl;
// Initialize the graphics
InitializeGLFW();
GLFWwindow* Window = CreateWindow(WindowWidth, WindowHeight, WindowTitle.c_str());
InitializeGLEW();
InitializeOpenGL();
glfwSwapBuffers(Window);
// Read and Compile the vertex program vertextransform.vert
GLuint vertexprogID = CreateGpuProgram("vertextransform.vert", GL_VERTEX_SHADER);
// Read and Compile the fragment program linefragment.frag
GLuint linefragmentprogID = CreateGpuProgram("linefragment.frag", GL_FRAGMENT_SHADER);
// Create a lineshader program and Link it with the vertex and linefragment programs
GLuint lineshaderID = CreateShaderProgram(vertexprogID, linefragmentprogID);
// Now comes the OpenGL core part
// This is where the curve is initialized
// User data is in the global variable curveVertices, and the number of entries
// is in Ncurvevertices
// Make a VertexArrayObject - it is used by the VertexArrayBuffer, and it must be declared!
GLuint CurveVertexArrayID;
glGenVertexArrays(1, &CurveVertexArrayID);
glBindVertexArray(CurveVertexArrayID);
// Make a curvevertexbufferObject - it uses the previous VertexArrayBuffer!
GLuint curvevertexbuffer;
glGenBuffers(1, &curvevertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, curvevertexbuffer);
// Give our vertices to OpenGL.
glBufferData(GL_ARRAY_BUFFER, Npoint * 3 * sizeof(float), &points[0], GL_STATIC_DRAW);
// Validate the shader program
ValidateShader(lineshaderID, "Validating the lineshader");
// Get locations of Uniforms
GLuint curvevertextransform = glGetUniformLocation(lineshaderID, "CTM");
GLuint curvefragmentcolor = glGetUniformLocation(lineshaderID, "Color");
// Initialize Attributes
GLuint curvevertexattribute = glGetAttribLocation(lineshaderID, "VertexPosition");
glVertexAttribPointer(curvevertexattribute, 3, GL_FLOAT, GL_FALSE, 0, 0);
// The main loop
while (!glfwWindowShouldClose(Window)) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(lineshaderID);
glm::mat4x4 CTM = camera.CurrentTransformationMatrix();
glUniformMatrix4fv(curvevertextransform, 1, GL_FALSE, &CTM[0][0]);
glUniform3f(curvefragmentcolor, 0.2f, 0.2f, 0.2f);
glEnableVertexAttribArray(curvevertexattribute);
glBindVertexArray(CurveVertexArrayID); // This is very important! There are two "binds"!
glDrawArrays(GL_LINES, 0, Npoint);
glDisableVertexAttribArray(curvevertexattribute);
glUseProgram(0);
glfwSwapBuffers(Window);
std::stringstream errormessage;
errormessage << "End of loop: " << "assignment5.cpp" << ": " << __LINE__ << ": ";
ErrorCheck(errormessage.str());
glfwPollEvents();
}
}
catch (std::exception const& exception) {
std::cerr << "Exception: " << exception.what() << std::endl;
}
glfwTerminate();
return 0;
}
