Commits

Jason McKesson committed 80244e0

Renamed the tutorial 3 code and shader files.

Comments (0)

Files changed (16)

Documents/Tutorial 03/Tutorial 03.xml

         <para>The simplest way one might think to move a triangle or other object around is to
             simply modify the vertex position data directly. From the previous tutorial, we learned
             that the vertex data is stored in a buffer object. This is what
-                <filename>tut2a.cpp</filename> does.</para>
+                <filename>cpuPositionOffset.cpp</filename> does.</para>
         <para>The modifications are done in two steps. The first step is to generate the X, Y offset
             that will be applied to each position. The second is to apply that offset to each vertex
             position. The generation of the offset is done with the
         <para>Remember what it is that we are doing. We compute an offset. Then we apply that offset
             to each vertex position. Vertex shaders are given each vertex position. So it makes
             sense to simply give the vertex shader the offset and let it compute the final vertex
-            position. This is what <filename>tut2b.cpp</filename> does.</para>
+            position. This is what <filename>vertPositionOffset.cpp</filename> does.</para>
         <para>The vertex shader used here is as follows:</para>
         <example>
             <title>Offsetting Vertex Shader</title>
             all of <function>ComputePositionOffsets</function> to the vertex shader?</para>
         <para>Well, no. The call to <function>glutGet(GL_ELAPSED_TIME)</function> can't be moved
             there, since GLSL code cannot directly call C/C++ functions. But everything else can be
-            moved. This is what <filename>tut2c.cpp</filename> does.</para>
+            moved. This is what <filename>vertCalcOffset.cpp</filename> does.</para>
         <para>This is the first tutorial that loads its shaders from files rather than using
             hard-coded data in the .cpp file. The vertex program is found in
                 <filename>data\tut2c.vert</filename>.</para>
 {
     std::vector&lt;GLuint> shaderList;
     
-    shaderList.push_back(LoadShader(GL_VERTEX_SHADER, "tut2c.vert"));
-    shaderList.push_back(CreateShader(GL_FRAGMENT_SHADER, strFragmentShader));
+    shaderList.push_back(Framework::LoadShader(GL_VERTEX_SHADER, "calcOffset.vert"));
+    shaderList.push_back(Framework::LoadShader(GL_FRAGMENT_SHADER, "standard.frag"));
     
-    theProgram = CreateProgram(shaderList);
+    theProgram = Framework::CreateProgram(shaderList);
     
     positionAttrib = glGetAttribLocation(theProgram, "position");
     elapsedTimeUniform = glGetUniformLocation(theProgram, "time");
         <para>Well, moving the triangle around is nice and all, but it would also be good if we
             could do something time-based in the fragment shader. Fragment shaders cannot affect the
             position of the object, but they can control its color. And this is what
-                <filename>tut2d.cpp</filename> does.</para>
+                <filename>fragChangeColor.cpp</filename> does.</para>
         <para>The fragment shader in this tutorial is also loaded from the file
                 <filename>data\tut2d.frag</filename>:</para>
         <example>
 {
     std::vector&lt;GLuint> shaderList;
     
-    shaderList.push_back(LoadShader(GL_VERTEX_SHADER, "tut2d.vert"));
-    shaderList.push_back(LoadShader(GL_FRAGMENT_SHADER, "tut2d.frag"));
+    shaderList.push_back(Framework::LoadShader(GL_VERTEX_SHADER, "calcOffset.vert"));
+    shaderList.push_back(Framework::LoadShader(GL_FRAGMENT_SHADER, "calcColor.frag"));
     
-    theProgram = CreateProgram(shaderList);
-    
+    theProgram = Framework::CreateProgram(shaderList);
+
     positionAttrib = glGetAttribLocation(theProgram, "position");
     elapsedTimeUniform = glGetUniformLocation(theProgram, "time");
     
     </section>
     <section>
         <title>Vertex Shader Performance</title>
-        <para>These tutorials are simple, but it is still important to look at the performance
-            implications of various operations. In this tutorial, we present 3 ways of moving vertex
-            data: transform it yourself on the CPU and upload it to buffer objects, generate
-            transform parameters on the CPU and have the vertex shader use them to do the transform,
-            and put as much as possible in the vertex shader and only have the CPU provide the most
-            basic parameters. Which is the best to use?</para>
+        <para>These tutorials are simple and should run fast enough, but it is still important to
+            look at the performance implications of various operations. In this tutorial, we present
+            3 ways of moving vertex data: transform it yourself on the CPU and upload it to buffer
+            objects, generate transform parameters on the CPU and have the vertex shader use them to
+            do the transform, and put as much as possible in the vertex shader and only have the CPU
+            provide the most basic parameters. Which is the best to use?</para>
         <para>This is not an easy question to answer. However, it is almost always the case that CPU
             transformations will be slower than doing it on the GPU. The only time it won't be is if
             you need to do the exact same transformations many times within the same frame. And even

Tut 02 Playing with Colors/premake4.lua

 
 dofile("../framework/framework.lua")
 
-SetupSolution("Tutorial3")
+SetupSolution("Tutorial2")
 SetupProject("Fragment Position", "FragPosition.cpp")
 SetupProject("Vertex Colors", "VertexColors.cpp")

Tut 03 OpenGLs Moving Triangle/cpuPositionOffset.cpp

+
+#include <string>
+#include <vector>
+#include <math.h>
+#include <glloader/gl_3_2_comp.h>
+#include <GL/freeglut.h>
+#include "../framework/framework.h"
+
+#define ARRAY_COUNT( array ) (sizeof( array ) / (sizeof( array[0] ) * (sizeof( array ) != sizeof(void*) || sizeof( array[0] ) <= sizeof(void*))))
+
+GLuint theProgram;
+GLuint positionAttrib;
+
+void InitializeProgram()
+{
+	std::vector<GLuint> shaderList;
+
+	shaderList.push_back(Framework::LoadShader(GL_VERTEX_SHADER, "standard.vert"));
+	shaderList.push_back(Framework::LoadShader(GL_FRAGMENT_SHADER, "standard.frag"));
+
+	theProgram = Framework::CreateProgram(shaderList);
+
+	positionAttrib = glGetAttribLocation(theProgram, "position");
+}
+
+const float vertexPositions[] = {
+	0.25f, 0.25f, 0.0f, 1.0f,
+	0.25f, -0.25f, 0.0f, 1.0f,
+	-0.25f, -0.25f, 0.0f, 1.0f,
+};
+
+GLuint positionBufferObject;
+GLuint vao;
+
+
+void InitializeVertexBuffer()
+{
+	glGenBuffers(1, &positionBufferObject);
+
+	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STREAM_DRAW);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+
+//Called after the window and OpenGL are initialized. Called exactly once, before the main loop.
+void init()
+{
+	InitializeProgram();
+	InitializeVertexBuffer();
+
+	glGenVertexArrays(1, &vao);
+	glBindVertexArray(vao);
+}
+
+
+void ComputePositionOffsets(float &fXOffset, float &fYOffset)
+{
+	const float fLoopDuration = 5.0f;
+	const float fScale = 3.14159f * 2.0f / fLoopDuration;
+
+	float fElapsedTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0f;
+
+	float fCurrTimeThroughLoop = fmodf(fElapsedTime, fLoopDuration);
+
+	fXOffset = cosf(fCurrTimeThroughLoop * fScale) * 0.5f;
+	fYOffset = sinf(fCurrTimeThroughLoop * fScale) * 0.5f;
+}
+
+void AdjustVertexData(float fXOffset, float fYOffset)
+{
+	std::vector<float> fNewData(ARRAY_COUNT(vertexPositions));
+	memcpy(&fNewData[0], vertexPositions, sizeof(vertexPositions));
+
+	for(int iVertex = 0; iVertex < ARRAY_COUNT(vertexPositions); iVertex += 4)
+	{
+		fNewData[iVertex] += fXOffset;
+		fNewData[iVertex + 1] += fYOffset;
+	}
+
+	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
+	glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertexPositions), &fNewData[0]);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+
+//Called to update the display.
+//You should call glutSwapBuffers after all of your rendering to display what you rendered.
+//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
+void display()
+{
+	float fXOffset = 0.0f, fYOffset = 0.0f;
+	ComputePositionOffsets(fXOffset, fYOffset);
+	AdjustVertexData(fXOffset, fYOffset);
+
+	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+	glClear(GL_COLOR_BUFFER_BIT);
+
+	glUseProgram(theProgram);
+
+	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
+	glEnableVertexAttribArray(positionAttrib);
+	glVertexAttribPointer(positionAttrib, 4, GL_FLOAT, GL_FALSE, 0, 0);
+
+	glDrawArrays(GL_TRIANGLES, 0, 3);
+
+	glDisableVertexAttribArray(positionAttrib);
+	glUseProgram(0);
+
+	glutSwapBuffers();
+	glutPostRedisplay();
+}
+
+//Called whenever the window is resized. The new window size is given, in pixels.
+//This is an opportunity to call glViewport or glScissor to keep up with the change in size.
+void reshape (int w, int h)
+{
+	glViewport(0, 0, (GLsizei) w, (GLsizei) h);
+}
+
+//Called whenever a key on the keyboard was pressed.
+//The key is given by the ''key'' parameter, which is in ASCII.
+//It's often a good idea to have the escape key (ASCII value 27) call glutLeaveMainLoop() to 
+//exit the program.
+void keyboard(unsigned char key, int x, int y)
+{
+	switch (key)
+	{
+	  case 27:
+		  glutLeaveMainLoop();
+		  break;
+	}
+}
+
+

Tut 03 OpenGLs Moving Triangle/data/calcColor.frag

+#version 150
+
+out vec4 outputColor;
+
+uniform float fragLoopDuration;
+uniform float time;
+
+const vec4 firstColor = vec4(1.0f, 1.0f, 1.0f, 1.0f);
+const vec4 secondColor = vec4(0.0f, 1.0f, 0.0f, 1.0f);
+
+void main()
+{
+	float currTime = mod(time, fragLoopDuration);
+	float currLerp = currTime / fragLoopDuration;
+	
+	outputColor = mix(firstColor, secondColor, currLerp);
+}

Tut 03 OpenGLs Moving Triangle/data/calcOffset.vert

+#version 150
+
+in vec4 position;
+uniform float loopDuration;
+uniform float time;
+
+void main()
+{
+	float timeScale = 3.14159f * 2.0f / loopDuration;
+	
+	float currTime = mod(time, loopDuration);
+	vec4 totalOffset = vec4(
+		cos(currTime * timeScale) * 0.5f,
+		sin(currTime * timeScale) * 0.5f,
+		0.0f,
+		0.0f);
+
+	gl_Position = position + totalOffset;
+}

Tut 03 OpenGLs Moving Triangle/data/tut2c.vert

-#version 150
-
-in vec4 position;
-uniform float loopDuration;
-uniform float time;
-
-void main()
-{
-	float timeScale = 3.14159f * 2.0f / loopDuration;
-	
-	float currTime = mod(time, loopDuration);
-	vec4 totalOffset = vec4(
-		cos(currTime * timeScale) * 0.5f,
-		sin(currTime * timeScale) * 0.5f,
-		0.0f,
-		0.0f);
-
-	gl_Position = position + totalOffset;
-}

Tut 03 OpenGLs Moving Triangle/data/tut2d.frag

-#version 150
-
-out vec4 outputColor;
-
-uniform float fragLoopDuration;
-uniform float time;
-
-const vec4 firstColor = vec4(1.0f, 1.0f, 1.0f, 1.0f);
-const vec4 secondColor = vec4(0.0f, 1.0f, 0.0f, 1.0f);
-
-void main()
-{
-	float currTime = mod(time, fragLoopDuration);
-	float currLerp = currTime / fragLoopDuration;
-	
-	outputColor = mix(firstColor, secondColor, currLerp);
-}

Tut 03 OpenGLs Moving Triangle/data/tut2d.vert

-#version 150
-
-in vec4 position;
-uniform float loopDuration;
-uniform float time;
-
-void main()
-{
-	float timeScale = 3.14159f * 2.0f / loopDuration;
-	
-	float currTime = mod(time, loopDuration);
-	vec4 totalOffset = vec4(
-		cos(currTime * timeScale) * 0.5f,
-		sin(currTime * timeScale) * 0.5f,
-		0.0f,
-		0.0f);
-
-	gl_Position = position + totalOffset;
-}

Tut 03 OpenGLs Moving Triangle/fragChangeColor.cpp

+
+#include <string>
+#include <vector>
+#include <math.h>
+#include <glloader/gl_3_2_comp.h>
+#include <GL/freeglut.h>
+#include "../framework/framework.h"
+
+GLuint theProgram;
+GLuint positionAttrib;
+GLuint elapsedTimeUniform;
+
+void InitializeProgram()
+{
+	std::vector<GLuint> shaderList;
+
+	shaderList.push_back(Framework::LoadShader(GL_VERTEX_SHADER, "calcOffset.vert"));
+	shaderList.push_back(Framework::LoadShader(GL_FRAGMENT_SHADER, "calcColor.frag"));
+
+	theProgram = Framework::CreateProgram(shaderList);
+
+	positionAttrib = glGetAttribLocation(theProgram, "position");
+	elapsedTimeUniform = glGetUniformLocation(theProgram, "time");
+
+	GLuint loopDurationUnf = glGetUniformLocation(theProgram, "loopDuration");
+	GLuint fragLoopDurUnf = glGetUniformLocation(theProgram, "fragLoopDuration");
+
+
+	glUseProgram(theProgram);
+	glUniform1f(loopDurationUnf, 5.0f);
+	glUniform1f(fragLoopDurUnf, 10.0f);
+	glUseProgram(0);
+}
+
+const float vertexPositions[] = {
+	0.25f, 0.25f, 0.0f, 1.0f,
+	0.25f, -0.25f, 0.0f, 1.0f,
+	-0.25f, -0.25f, 0.0f, 1.0f,
+};
+
+GLuint positionBufferObject;
+GLuint vao;
+
+
+void InitializeVertexBuffer()
+{
+	glGenBuffers(1, &positionBufferObject);
+
+	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STREAM_DRAW);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+
+//Called after the window and OpenGL are initialized. Called exactly once, before the main loop.
+void init()
+{
+	InitializeProgram();
+	InitializeVertexBuffer();
+
+	glGenVertexArrays(1, &vao);
+	glBindVertexArray(vao);
+}
+
+//Called to update the display.
+//You should call glutSwapBuffers after all of your rendering to display what you rendered.
+//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
+void display()
+{
+	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+	glClear(GL_COLOR_BUFFER_BIT);
+
+	glUseProgram(theProgram);
+
+	glUniform1f(elapsedTimeUniform, glutGet(GLUT_ELAPSED_TIME) / 1000.0f);
+
+	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
+	glEnableVertexAttribArray(positionAttrib);
+	glVertexAttribPointer(positionAttrib, 4, GL_FLOAT, GL_FALSE, 0, 0);
+
+	glDrawArrays(GL_TRIANGLES, 0, 3);
+
+	glDisableVertexAttribArray(positionAttrib);
+	glUseProgram(0);
+
+	glutSwapBuffers();
+	glutPostRedisplay();
+}
+
+//Called whenever the window is resized. The new window size is given, in pixels.
+//This is an opportunity to call glViewport or glScissor to keep up with the change in size.
+void reshape (int w, int h)
+{
+	glViewport(0, 0, (GLsizei) w, (GLsizei) h);
+}
+
+//Called whenever a key on the keyboard was pressed.
+//The key is given by the ''key'' parameter, which is in ASCII.
+//It's often a good idea to have the escape key (ASCII value 27) call glutLeaveMainLoop() to 
+//exit the program.
+void keyboard(unsigned char key, int x, int y)
+{
+	switch (key)
+	{
+	case 27:
+		glutLeaveMainLoop();
+		break;
+	}
+}
+
+

Tut 03 OpenGLs Moving Triangle/premake4.lua

 
 dofile("../framework/framework.lua")
 
-SetupSolution("Tutorial2")
-SetupProject("Tutorial2a", "tut2a.cpp")
-SetupProject("Tutorial2b", "tut2b.cpp")
-SetupProject("Tutorial2c", "tut2c.cpp")
-SetupProject("Tutorial2d", "tut2d.cpp")
+SetupSolution("Tutorial3")
+SetupProject("CPU Position Offset", "cpuPositionOffset.cpp")
+SetupProject("Shader Position Offset", "vertPositionOffset.cpp")
+SetupProject("Shader Calc Offset", "vertCalcOffset.cpp")
+SetupProject("Fragment Change Color", "fragChangeColor.cpp")

Tut 03 OpenGLs Moving Triangle/tut2a.cpp

-
-#include <string>
-#include <vector>
-#include <math.h>
-#include <glloader/gl_3_2_comp.h>
-#include <GL/freeglut.h>
-#include "../framework/framework.h"
-
-#define ARRAY_COUNT( array ) (sizeof( array ) / (sizeof( array[0] ) * (sizeof( array ) != sizeof(void*) || sizeof( array[0] ) <= sizeof(void*))))
-
-GLuint theProgram;
-GLuint positionAttrib;
-
-void InitializeProgram()
-{
-	std::vector<GLuint> shaderList;
-
-	shaderList.push_back(Framework::LoadShader(GL_VERTEX_SHADER, "standard.vert"));
-	shaderList.push_back(Framework::LoadShader(GL_FRAGMENT_SHADER, "standard.frag"));
-
-	theProgram = Framework::CreateProgram(shaderList);
-
-	positionAttrib = glGetAttribLocation(theProgram, "position");
-}
-
-const float vertexPositions[] = {
-	0.25f, 0.25f, 0.0f, 1.0f,
-	0.25f, -0.25f, 0.0f, 1.0f,
-	-0.25f, -0.25f, 0.0f, 1.0f,
-};
-
-GLuint positionBufferObject;
-GLuint vao;
-
-
-void InitializeVertexBuffer()
-{
-	glGenBuffers(1, &positionBufferObject);
-
-	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
-	glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STREAM_DRAW);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-}
-
-//Called after the window and OpenGL are initialized. Called exactly once, before the main loop.
-void init()
-{
-	InitializeProgram();
-	InitializeVertexBuffer();
-
-	glGenVertexArrays(1, &vao);
-	glBindVertexArray(vao);
-}
-
-
-void ComputePositionOffsets(float &fXOffset, float &fYOffset)
-{
-	const float fLoopDuration = 5.0f;
-	const float fScale = 3.14159f * 2.0f / fLoopDuration;
-
-	float fElapsedTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0f;
-
-	float fCurrTimeThroughLoop = fmodf(fElapsedTime, fLoopDuration);
-
-	fXOffset = cosf(fCurrTimeThroughLoop * fScale) * 0.5f;
-	fYOffset = sinf(fCurrTimeThroughLoop * fScale) * 0.5f;
-}
-
-void AdjustVertexData(float fXOffset, float fYOffset)
-{
-	std::vector<float> fNewData(ARRAY_COUNT(vertexPositions));
-	memcpy(&fNewData[0], vertexPositions, sizeof(vertexPositions));
-
-	for(int iVertex = 0; iVertex < ARRAY_COUNT(vertexPositions); iVertex += 4)
-	{
-		fNewData[iVertex] += fXOffset;
-		fNewData[iVertex + 1] += fYOffset;
-	}
-
-	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
-	glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertexPositions), &fNewData[0]);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-}
-
-//Called to update the display.
-//You should call glutSwapBuffers after all of your rendering to display what you rendered.
-//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
-void display()
-{
-	float fXOffset = 0.0f, fYOffset = 0.0f;
-	ComputePositionOffsets(fXOffset, fYOffset);
-	AdjustVertexData(fXOffset, fYOffset);
-
-	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-	glClear(GL_COLOR_BUFFER_BIT);
-
-	glUseProgram(theProgram);
-
-	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
-	glEnableVertexAttribArray(positionAttrib);
-	glVertexAttribPointer(positionAttrib, 4, GL_FLOAT, GL_FALSE, 0, 0);
-
-	glDrawArrays(GL_TRIANGLES, 0, 3);
-
-	glDisableVertexAttribArray(positionAttrib);
-	glUseProgram(0);
-
-	glutSwapBuffers();
-	glutPostRedisplay();
-}
-
-//Called whenever the window is resized. The new window size is given, in pixels.
-//This is an opportunity to call glViewport or glScissor to keep up with the change in size.
-void reshape (int w, int h)
-{
-	glViewport(0, 0, (GLsizei) w, (GLsizei) h);
-}
-
-//Called whenever a key on the keyboard was pressed.
-//The key is given by the ''key'' parameter, which is in ASCII.
-//It's often a good idea to have the escape key (ASCII value 27) call glutLeaveMainLoop() to 
-//exit the program.
-void keyboard(unsigned char key, int x, int y)
-{
-	switch (key)
-	{
-	  case 27:
-		  glutLeaveMainLoop();
-		  break;
-	}
-}
-
-

Tut 03 OpenGLs Moving Triangle/tut2b.cpp

-
-#include <string>
-#include <vector>
-#include <math.h>
-#include <glloader/gl_3_2_comp.h>
-#include <GL/freeglut.h>
-#include "../framework/framework.h"
-
-GLuint theProgram;
-GLuint positionAttrib;
-GLuint offsetLocation;
-
-void InitializeProgram()
-{
-	std::vector<GLuint> shaderList;
-
-	shaderList.push_back(Framework::LoadShader(GL_VERTEX_SHADER, "positionOffset.vert"));
-	shaderList.push_back(Framework::LoadShader(GL_FRAGMENT_SHADER, "standard.frag"));
-
-	theProgram = Framework::CreateProgram(shaderList);
-
-	positionAttrib = glGetAttribLocation(theProgram, "position");
-	offsetLocation = glGetUniformLocation(theProgram, "offset");
-}
-
-const float vertexPositions[] = {
-	0.25f, 0.25f, 0.0f, 1.0f,
-	0.25f, -0.25f, 0.0f, 1.0f,
-	-0.25f, -0.25f, 0.0f, 1.0f,
-};
-
-GLuint positionBufferObject;
-GLuint vao;
-
-
-void InitializeVertexBuffer()
-{
-	glGenBuffers(1, &positionBufferObject);
-
-	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
-	glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STREAM_DRAW);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-}
-
-//Called after the window and OpenGL are initialized. Called exactly once, before the main loop.
-void init()
-{
-	InitializeProgram();
-	InitializeVertexBuffer();
-
-	glGenVertexArrays(1, &vao);
-	glBindVertexArray(vao);
-}
-
-
-void ComputePositionOffsets(float &fXOffset, float &fYOffset)
-{
-	const float fLoopDuration = 5.0f;
-	const float fScale = 3.14159f * 2.0f / fLoopDuration;
-
-	float fElapsedTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0f;
-
-	float fCurrTimeThroughLoop = fmodf(fElapsedTime, fLoopDuration);
-
-	fXOffset = cosf(fCurrTimeThroughLoop * fScale) * 0.5f;
-	fYOffset = sinf(fCurrTimeThroughLoop * fScale) * 0.5f;
-}
-
-//Called to update the display.
-//You should call glutSwapBuffers after all of your rendering to display what you rendered.
-//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
-void display()
-{
-	float fXOffset = 0.0f, fYOffset = 0.0f;
-	ComputePositionOffsets(fXOffset, fYOffset);
-
-	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-	glClear(GL_COLOR_BUFFER_BIT);
-
-	glUseProgram(theProgram);
-
-	glUniform2f(offsetLocation, fXOffset, fYOffset);
-
-	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
-	glEnableVertexAttribArray(positionAttrib);
-	glVertexAttribPointer(positionAttrib, 4, GL_FLOAT, GL_FALSE, 0, 0);
-
-	glDrawArrays(GL_TRIANGLES, 0, 3);
-
-	glDisableVertexAttribArray(positionAttrib);
-	glUseProgram(0);
-
-	glutSwapBuffers();
-	glutPostRedisplay();
-}
-
-//Called whenever the window is resized. The new window size is given, in pixels.
-//This is an opportunity to call glViewport or glScissor to keep up with the change in size.
-void reshape (int w, int h)
-{
-	glViewport(0, 0, (GLsizei) w, (GLsizei) h);
-}
-
-//Called whenever a key on the keyboard was pressed.
-//The key is given by the ''key'' parameter, which is in ASCII.
-//It's often a good idea to have the escape key (ASCII value 27) call glutLeaveMainLoop() to 
-//exit the program.
-void keyboard(unsigned char key, int x, int y)
-{
-	switch (key)
-	{
-	case 27:
-		glutLeaveMainLoop();
-		break;
-	}
-}
-
-

Tut 03 OpenGLs Moving Triangle/tut2c.cpp

-
-#include <string>
-#include <vector>
-#include <math.h>
-#include <glloader/gl_3_2_comp.h>
-#include <GL/freeglut.h>
-#include "../framework/framework.h"
-
-GLuint theProgram;
-GLuint positionAttrib;
-GLuint elapsedTimeUniform;
-
-void InitializeProgram()
-{
-	std::vector<GLuint> shaderList;
-
-	shaderList.push_back(Framework::LoadShader(GL_VERTEX_SHADER, "tut2c.vert"));
-	shaderList.push_back(Framework::LoadShader(GL_FRAGMENT_SHADER, "standard.frag"));
-
-	theProgram = Framework::CreateProgram(shaderList);
-
-	positionAttrib = glGetAttribLocation(theProgram, "position");
-	elapsedTimeUniform = glGetUniformLocation(theProgram, "time");
-
-	GLuint loopDurationUnf = glGetUniformLocation(theProgram, "loopDuration");
-	glUseProgram(theProgram);
-	glUniform1f(loopDurationUnf, 5.0f);
-	glUseProgram(0);
-}
-
-const float vertexPositions[] = {
-	0.25f, 0.25f, 0.0f, 1.0f,
-	0.25f, -0.25f, 0.0f, 1.0f,
-	-0.25f, -0.25f, 0.0f, 1.0f,
-};
-
-GLuint positionBufferObject;
-GLuint vao;
-
-
-void InitializeVertexBuffer()
-{
-	glGenBuffers(1, &positionBufferObject);
-
-	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
-	glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STREAM_DRAW);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-}
-
-//Called after the window and OpenGL are initialized. Called exactly once, before the main loop.
-void init()
-{
-	InitializeProgram();
-	InitializeVertexBuffer();
-
-	glGenVertexArrays(1, &vao);
-	glBindVertexArray(vao);
-}
-
-//Called to update the display.
-//You should call glutSwapBuffers after all of your rendering to display what you rendered.
-//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
-void display()
-{
-	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-	glClear(GL_COLOR_BUFFER_BIT);
-
-	glUseProgram(theProgram);
-
-	glUniform1f(elapsedTimeUniform, glutGet(GLUT_ELAPSED_TIME) / 1000.0f);
-
-	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
-	glEnableVertexAttribArray(positionAttrib);
-	glVertexAttribPointer(positionAttrib, 4, GL_FLOAT, GL_FALSE, 0, 0);
-
-	glDrawArrays(GL_TRIANGLES, 0, 3);
-
-	glDisableVertexAttribArray(positionAttrib);
-	glUseProgram(0);
-
-	glutSwapBuffers();
-	glutPostRedisplay();
-}
-
-//Called whenever the window is resized. The new window size is given, in pixels.
-//This is an opportunity to call glViewport or glScissor to keep up with the change in size.
-void reshape (int w, int h)
-{
-	glViewport(0, 0, (GLsizei) w, (GLsizei) h);
-}
-
-//Called whenever a key on the keyboard was pressed.
-//The key is given by the ''key'' parameter, which is in ASCII.
-//It's often a good idea to have the escape key (ASCII value 27) call glutLeaveMainLoop() to 
-//exit the program.
-void keyboard(unsigned char key, int x, int y)
-{
-	switch (key)
-	{
-	case 27:
-		glutLeaveMainLoop();
-		break;
-	}
-}
-
-

Tut 03 OpenGLs Moving Triangle/tut2d.cpp

-
-#include <string>
-#include <vector>
-#include <math.h>
-#include <glloader/gl_3_2_comp.h>
-#include <GL/freeglut.h>
-#include "../framework/framework.h"
-
-GLuint theProgram;
-GLuint positionAttrib;
-GLuint elapsedTimeUniform;
-
-void InitializeProgram()
-{
-	std::vector<GLuint> shaderList;
-
-	shaderList.push_back(Framework::LoadShader(GL_VERTEX_SHADER, "tut2d.vert"));
-	shaderList.push_back(Framework::LoadShader(GL_FRAGMENT_SHADER, "tut2d.frag"));
-
-	theProgram = Framework::CreateProgram(shaderList);
-
-	positionAttrib = glGetAttribLocation(theProgram, "position");
-	elapsedTimeUniform = glGetUniformLocation(theProgram, "time");
-
-	GLuint loopDurationUnf = glGetUniformLocation(theProgram, "loopDuration");
-	GLuint fragLoopDurUnf = glGetUniformLocation(theProgram, "fragLoopDuration");
-
-
-	glUseProgram(theProgram);
-	glUniform1f(loopDurationUnf, 5.0f);
-	glUniform1f(fragLoopDurUnf, 10.0f);
-	glUseProgram(0);
-}
-
-const float vertexPositions[] = {
-	0.25f, 0.25f, 0.0f, 1.0f,
-	0.25f, -0.25f, 0.0f, 1.0f,
-	-0.25f, -0.25f, 0.0f, 1.0f,
-};
-
-GLuint positionBufferObject;
-GLuint vao;
-
-
-void InitializeVertexBuffer()
-{
-	glGenBuffers(1, &positionBufferObject);
-
-	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
-	glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STREAM_DRAW);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-}
-
-//Called after the window and OpenGL are initialized. Called exactly once, before the main loop.
-void init()
-{
-	InitializeProgram();
-	InitializeVertexBuffer();
-
-	glGenVertexArrays(1, &vao);
-	glBindVertexArray(vao);
-}
-
-//Called to update the display.
-//You should call glutSwapBuffers after all of your rendering to display what you rendered.
-//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
-void display()
-{
-	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-	glClear(GL_COLOR_BUFFER_BIT);
-
-	glUseProgram(theProgram);
-
-	glUniform1f(elapsedTimeUniform, glutGet(GLUT_ELAPSED_TIME) / 1000.0f);
-
-	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
-	glEnableVertexAttribArray(positionAttrib);
-	glVertexAttribPointer(positionAttrib, 4, GL_FLOAT, GL_FALSE, 0, 0);
-
-	glDrawArrays(GL_TRIANGLES, 0, 3);
-
-	glDisableVertexAttribArray(positionAttrib);
-	glUseProgram(0);
-
-	glutSwapBuffers();
-	glutPostRedisplay();
-}
-
-//Called whenever the window is resized. The new window size is given, in pixels.
-//This is an opportunity to call glViewport or glScissor to keep up with the change in size.
-void reshape (int w, int h)
-{
-	glViewport(0, 0, (GLsizei) w, (GLsizei) h);
-}
-
-//Called whenever a key on the keyboard was pressed.
-//The key is given by the ''key'' parameter, which is in ASCII.
-//It's often a good idea to have the escape key (ASCII value 27) call glutLeaveMainLoop() to 
-//exit the program.
-void keyboard(unsigned char key, int x, int y)
-{
-	switch (key)
-	{
-	case 27:
-		glutLeaveMainLoop();
-		break;
-	}
-}
-
-

Tut 03 OpenGLs Moving Triangle/vertCalcOffset.cpp

+
+#include <string>
+#include <vector>
+#include <math.h>
+#include <glloader/gl_3_2_comp.h>
+#include <GL/freeglut.h>
+#include "../framework/framework.h"
+
+GLuint theProgram;
+GLuint positionAttrib;
+GLuint elapsedTimeUniform;
+
+void InitializeProgram()
+{
+	std::vector<GLuint> shaderList;
+
+	shaderList.push_back(Framework::LoadShader(GL_VERTEX_SHADER, "calcOffset.vert"));
+	shaderList.push_back(Framework::LoadShader(GL_FRAGMENT_SHADER, "standard.frag"));
+
+	theProgram = Framework::CreateProgram(shaderList);
+
+	positionAttrib = glGetAttribLocation(theProgram, "position");
+	elapsedTimeUniform = glGetUniformLocation(theProgram, "time");
+
+	GLuint loopDurationUnf = glGetUniformLocation(theProgram, "loopDuration");
+	glUseProgram(theProgram);
+	glUniform1f(loopDurationUnf, 5.0f);
+	glUseProgram(0);
+}
+
+const float vertexPositions[] = {
+	0.25f, 0.25f, 0.0f, 1.0f,
+	0.25f, -0.25f, 0.0f, 1.0f,
+	-0.25f, -0.25f, 0.0f, 1.0f,
+};
+
+GLuint positionBufferObject;
+GLuint vao;
+
+
+void InitializeVertexBuffer()
+{
+	glGenBuffers(1, &positionBufferObject);
+
+	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STREAM_DRAW);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+
+//Called after the window and OpenGL are initialized. Called exactly once, before the main loop.
+void init()
+{
+	InitializeProgram();
+	InitializeVertexBuffer();
+
+	glGenVertexArrays(1, &vao);
+	glBindVertexArray(vao);
+}
+
+//Called to update the display.
+//You should call glutSwapBuffers after all of your rendering to display what you rendered.
+//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
+void display()
+{
+	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+	glClear(GL_COLOR_BUFFER_BIT);
+
+	glUseProgram(theProgram);
+
+	glUniform1f(elapsedTimeUniform, glutGet(GLUT_ELAPSED_TIME) / 1000.0f);
+
+	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
+	glEnableVertexAttribArray(positionAttrib);
+	glVertexAttribPointer(positionAttrib, 4, GL_FLOAT, GL_FALSE, 0, 0);
+
+	glDrawArrays(GL_TRIANGLES, 0, 3);
+
+	glDisableVertexAttribArray(positionAttrib);
+	glUseProgram(0);
+
+	glutSwapBuffers();
+	glutPostRedisplay();
+}
+
+//Called whenever the window is resized. The new window size is given, in pixels.
+//This is an opportunity to call glViewport or glScissor to keep up with the change in size.
+void reshape (int w, int h)
+{
+	glViewport(0, 0, (GLsizei) w, (GLsizei) h);
+}
+
+//Called whenever a key on the keyboard was pressed.
+//The key is given by the ''key'' parameter, which is in ASCII.
+//It's often a good idea to have the escape key (ASCII value 27) call glutLeaveMainLoop() to 
+//exit the program.
+void keyboard(unsigned char key, int x, int y)
+{
+	switch (key)
+	{
+	case 27:
+		glutLeaveMainLoop();
+		break;
+	}
+}
+
+

Tut 03 OpenGLs Moving Triangle/vertPositionOffset.cpp

+
+#include <string>
+#include <vector>
+#include <math.h>
+#include <glloader/gl_3_2_comp.h>
+#include <GL/freeglut.h>
+#include "../framework/framework.h"
+
+GLuint theProgram;
+GLuint positionAttrib;
+GLuint offsetLocation;
+
+void InitializeProgram()
+{
+	std::vector<GLuint> shaderList;
+
+	shaderList.push_back(Framework::LoadShader(GL_VERTEX_SHADER, "positionOffset.vert"));
+	shaderList.push_back(Framework::LoadShader(GL_FRAGMENT_SHADER, "standard.frag"));
+
+	theProgram = Framework::CreateProgram(shaderList);
+
+	positionAttrib = glGetAttribLocation(theProgram, "position");
+	offsetLocation = glGetUniformLocation(theProgram, "offset");
+}
+
+const float vertexPositions[] = {
+	0.25f, 0.25f, 0.0f, 1.0f,
+	0.25f, -0.25f, 0.0f, 1.0f,
+	-0.25f, -0.25f, 0.0f, 1.0f,
+};
+
+GLuint positionBufferObject;
+GLuint vao;
+
+
+void InitializeVertexBuffer()
+{
+	glGenBuffers(1, &positionBufferObject);
+
+	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STREAM_DRAW);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+
+//Called after the window and OpenGL are initialized. Called exactly once, before the main loop.
+void init()
+{
+	InitializeProgram();
+	InitializeVertexBuffer();
+
+	glGenVertexArrays(1, &vao);
+	glBindVertexArray(vao);
+}
+
+
+void ComputePositionOffsets(float &fXOffset, float &fYOffset)
+{
+	const float fLoopDuration = 5.0f;
+	const float fScale = 3.14159f * 2.0f / fLoopDuration;
+
+	float fElapsedTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0f;
+
+	float fCurrTimeThroughLoop = fmodf(fElapsedTime, fLoopDuration);
+
+	fXOffset = cosf(fCurrTimeThroughLoop * fScale) * 0.5f;
+	fYOffset = sinf(fCurrTimeThroughLoop * fScale) * 0.5f;
+}
+
+//Called to update the display.
+//You should call glutSwapBuffers after all of your rendering to display what you rendered.
+//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
+void display()
+{
+	float fXOffset = 0.0f, fYOffset = 0.0f;
+	ComputePositionOffsets(fXOffset, fYOffset);
+
+	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+	glClear(GL_COLOR_BUFFER_BIT);
+
+	glUseProgram(theProgram);
+
+	glUniform2f(offsetLocation, fXOffset, fYOffset);
+
+	glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
+	glEnableVertexAttribArray(positionAttrib);
+	glVertexAttribPointer(positionAttrib, 4, GL_FLOAT, GL_FALSE, 0, 0);
+
+	glDrawArrays(GL_TRIANGLES, 0, 3);
+
+	glDisableVertexAttribArray(positionAttrib);
+	glUseProgram(0);
+
+	glutSwapBuffers();
+	glutPostRedisplay();
+}
+
+//Called whenever the window is resized. The new window size is given, in pixels.
+//This is an opportunity to call glViewport or glScissor to keep up with the change in size.
+void reshape (int w, int h)
+{
+	glViewport(0, 0, (GLsizei) w, (GLsizei) h);
+}
+
+//Called whenever a key on the keyboard was pressed.
+//The key is given by the ''key'' parameter, which is in ASCII.
+//It's often a good idea to have the escape key (ASCII value 27) call glutLeaveMainLoop() to 
+//exit the program.
+void keyboard(unsigned char key, int x, int y)
+{
+	switch (key)
+	{
+	case 27:
+		glutLeaveMainLoop();
+		break;
+	}
+}
+
+
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.