void Ex08_09::InitGL()
{
if (! LoadGL() )
return;
ShaderInfo object_shaders[] = {
{ GL_VERTEX_SHADER, "Shaders/sh08_09.vert" },
{ GL_FRAGMENT_SHADER, "Shaders/sh08_09.frag" },
{ GL_NONE, NULL }
};
object_prog = LoadShaders( object_shaders );
glLinkProgram(object_prog);
object_mat_mv_loc = glGetUniformLocation(object_prog, "MVMatrix");
object_mat_mvp_loc = glGetUniformLocation(object_prog, "MVPMatrix");
GLuint object_light_pos_loc = glGetUniformLocation(object_prog, "LightPosition");
GLuint object_mat_normal_loc = glGetUniformLocation(object_prog, "NormalMatrix");
glUseProgram(object_prog);
GLfloat normal_matrix[3 * 3] = {
1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f
};
glUniformMatrix3fv(object_mat_normal_loc, 1, GL_TRUE, normal_matrix);
glUniform3fv(object_light_pos_loc, 1, vmath::vec3(0.5f, 0.5f, -1.0f));
object.LoadFromVBM("Media/torus.vbm", 0, 1, 2);
}
CGLTexture::CGLTexture(CLog *pInLog,string f) {
Initialize();
if(pInLog){
bMadeLog=false;
pLog=pInLog;
}
LoadGL(f);
}
void Ex06_16::InitGL()
{
if (! LoadGL() )
return;
ShaderInfo base_shaders[] = {
{ GL_VERTEX_SHADER, "Shaders/sh06_16.vert" },
{ GL_FRAGMENT_SHADER, "Shaders/sh06_16.frag" },
{ GL_NONE, NULL }
};
base_prog = LoadShaders( base_shaders );
glGenBuffers(1, &quad_vbo);
glBindBuffer(GL_ARRAY_BUFFER, quad_vbo);
static const GLfloat quad_data[] =
{
1.0f, -1.0f,
-1.0f, -1.0f,
-1.0f, 1.0f,
1.0f, 1.0f,
0.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.0f,
0.0f, 1.0f
};
glBufferData(GL_ARRAY_BUFFER, sizeof(quad_data), quad_data, GL_STATIC_DRAW);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(8 * sizeof(float)));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glLinkProgram(base_prog);
char buf[1024];
glGetProgramInfoLog(base_prog, 1024, NULL, buf);
tc_rotate_loc = glGetUniformLocation(base_prog, "tc_rotate");
vglImageData image;
tex = vglLoadTexture("Media/cloud.dds", 0, &image);
glTexParameteri(image.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
vglUnloadImage(&image);
}
void Ex09_08::InitGL()
{
if (! LoadGL() )
return;
// Create a vertex array object
GLuint vao;
glGenVertexArrays( 1, &vao );
glBindVertexArray( vao );
// Create and initialize a buffer object
enum { ArrayBuffer, ElementBuffer, NumVertexBuffers };
GLuint buffers[NumVertexBuffers];
glGenBuffers( NumVertexBuffers, buffers );
glBindBuffer( GL_ARRAY_BUFFER, buffers[ArrayBuffer] );
glBufferData( GL_ARRAY_BUFFER, sizeof(TeapotVertices),
TeapotVertices, GL_STATIC_DRAW );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, buffers[ElementBuffer] );
glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof(TeapotIndices),
TeapotIndices, GL_STATIC_DRAW );
// Load shaders and use the resulting shader program
ShaderInfo shaders[] = {
{ GL_VERTEX_SHADER, "Shaders/teapot.vert" },
{ GL_TESS_CONTROL_SHADER, "Shaders/teapot.cont" },
{ GL_TESS_EVALUATION_SHADER, "Shaders/teapot.eval" },
{ GL_FRAGMENT_SHADER, "Shaders/teapot.frag" },
{ GL_NONE, NULL }
};
program = LoadShaders( shaders );
glUseProgram( program );
// set up vertex arrays
GLuint vPosition = glGetAttribLocation( program, "vPosition" );
glEnableVertexAttribArray( vPosition );
glVertexAttribPointer( vPosition, 3, GL_DOUBLE, GL_FALSE, 0,
BUFFER_OFFSET(0) );
PLoc = glGetUniformLocation( program, "P" );
MVLoc = glGetUniformLocation( program, "MV" );
InnerLoc = glGetUniformLocation( program, "Inner" );
OuterLoc = glGetUniformLocation( program, "Outer" );
glUniform1f( InnerLoc, Inner );
glUniform1f( OuterLoc, Outer );
glPatchParameteri( GL_PATCH_VERTICES, NumTeapotVerticesPerPatch );
glClearColor( 0.0, 0.0, 0.0, 1.0 );
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
}
void Ex04_01::InitGL()
{
if (! LoadGL() )
return;
glGenVertexArrays( NumVAOs, VAOs );
glBindVertexArray( VAOs[Triangles] );
struct VertexData {
GLubyte color[4];
GLfloat position[4];
};
VertexData vertices[NumVertices] = {
{{ 255, 0, 0, 255 }, { -0.90, -0.90 }}, // Triangle 1
{{ 0, 255, 0, 255 }, { 0.85, -0.90 }},
{{ 0, 0, 255, 255 }, { -0.90, 0.85 }},
{{ 10, 10, 10, 255 }, { 0.90, -0.85 }}, // Triangle 2
{{ 100, 100, 100, 255 }, { 0.90, 0.90 }},
{{ 255, 255, 255, 255 }, { -0.85, 0.90 }}
};
glGenBuffers( NumBuffers, Buffers );
glBindBuffer( GL_ARRAY_BUFFER, Buffers[ArrayBuffer] );
glBufferData( GL_ARRAY_BUFFER, sizeof(vertices),
vertices, GL_STATIC_DRAW );
ShaderInfo shaders[] = {
{ GL_VERTEX_SHADER, "Shaders/gouraud.vert" },
{ GL_FRAGMENT_SHADER, "Shaders/gouraud.frag" },
{ GL_NONE, NULL }
};
GLuint program = LoadShaders( shaders );
glUseProgram( program );
glVertexAttribPointer( vColor, 4, GL_UNSIGNED_BYTE,
GL_TRUE, sizeof(VertexData), BUFFER_OFFSET(0) );
glVertexAttribPointer( vPosition, 2, GL_FLOAT,
GL_FALSE, sizeof(VertexData),
BUFFER_OFFSET(sizeof(vertices[0].color)) );
glEnableVertexAttribArray( vColor );
glEnableVertexAttribArray( vPosition );
}
void Ex07_03::InitGL()
{
if (! LoadGL() )
return;
ShaderInfo object_shaders[] = {
{ GL_VERTEX_SHADER, "Shaders/sh07_03.vert" },
{ GL_FRAGMENT_SHADER, "Shaders/sh07_03.frag" },
{ GL_NONE, NULL }
};
object_prog = LoadShaders( object_shaders );
glLinkProgram(object_prog);
object_mat_mvp_loc = glGetUniformLocation(object_prog, "MVPMatrix");
GLuint object_color_loc = glGetUniformLocation(object_prog, "VertexColor");
GLuint object_ambient_loc = glGetUniformLocation(object_prog, "Ambient");
GLuint object_LightColor_loc = glGetUniformLocation(object_prog, "LightColor");
GLuint object_LightDirection_loc = glGetUniformLocation(object_prog, "LightDirection");
GLuint object_HalfVector_loc = glGetUniformLocation(object_prog, "HalfVector");
GLuint object_Shininess_loc = glGetUniformLocation(object_prog, "Shininess");
GLuint object_Strength_loc = glGetUniformLocation(object_prog, "Strength");
GLuint object_mat_normal_loc = glGetUniformLocation(object_prog, "NormalMatrix");
glUseProgram(object_prog);
glUniform4fv(object_color_loc, 1, vmath::vec4(0.5f, 0.5f, 0.7f, 0.7f));
glUniform3fv(object_ambient_loc, 1, vmath::vec3(0.2f, 0.2f, 0.5f));
glUniform3fv(object_LightColor_loc, 1, vmath::vec3(0.3f, 0.3f, 1.0f));
glUniform3fv(object_LightDirection_loc, 1, vmath::vec3(0.5f, 0.5f, -1.0f));
glUniform3fv(object_HalfVector_loc, 1, vmath::vec3(1.0f, 1.0f, 0.0f));
glUniform1f(object_Shininess_loc, 20.0f);
glUniform1f(object_Strength_loc, 10.5f);
GLfloat normal_matrix[3 * 3] = {
0.5f, 0.0f, 0.0f,
0.0f, 0.5f, 0.0f,
0.0f, 0.0f, 1.0f
};
glUniformMatrix3fv(object_mat_normal_loc, 1, GL_TRUE, normal_matrix);
object.LoadFromVBM("Media/torus.vbm", 0, 1, 2);
}
bool CGLTexture::Draw(int x,int y,int x2,int y2,u_char r,u_char g,u_char b,u_char r2,u_char g2,u_char b2) {
if(!glBmap) { LoadGL(filename.c_str()); return false; }
int x3=(x2-x);
int y3=(y2-y);
x=x/2;
y=(-y/2)+(SDL_GetVideoSurface()->h/2);
glDisable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0,SDL_GetVideoSurface()->w,0,SDL_GetVideoSurface()->h);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glTranslated(x,y,0);
glBindTexture(GL_TEXTURE_2D,glBmap);
glColor3ub(r,g,b);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(float(x), float(y-y3), 1);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(float(x+x3), float(y-y3), 1);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(float(x+x3), float(y), 1);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(float(x), float(y), 1);
glEnd();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glEnable(GL_DEPTH_TEST);
return 1;
}
bool zglCoreContextWin::CreateCoreContext()
{
if ( !m_tempContext )
return false;
bool makeCurResult = wglMakeCurrent( m_hDC, m_tempContext );
bool bCore = GL_LoadCreateWinCoreContext();
if (!bCore)
return false;
GetGLVersion(&m_major, &m_minor);
if( !makeCurResult || m_major < MAJOR || ( m_major == MAJOR && m_minor < MINOR ) )
{
wglMakeCurrent(NULL,NULL);
wglDeleteContext(m_tempContext);
return false;
}
int attribs[] =
{
WGL_CONTEXT_MAJOR_VERSION_ARB, m_major,
WGL_CONTEXT_MINOR_VERSION_ARB, m_minor,
WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
0
};
m_Context = wglCreateContextAttribsARB(m_hDC,0, attribs);
if ( !m_Context )
return false;
LoadGL();
wglMakeCurrent(NULL,NULL);
wglDeleteContext(m_tempContext);
return true;
}
void Ex08_11::InitGL()
{
if (! LoadGL() )
return;
ShaderInfo object_shaders[] = {
{ GL_VERTEX_SHADER, "Shaders/sh08_11.vert" },
{ GL_FRAGMENT_SHADER, "Shaders/sh08_11.frag" },
{ GL_NONE, NULL }
};
object_prog = LoadShaders( object_shaders );
glLinkProgram(object_prog);
object_mat_mv_loc = glGetUniformLocation(object_prog, "MVMatrix");
object_mat_mvp_loc = glGetUniformLocation(object_prog, "MVPMatrix");
GLuint NormalMatrix_loc = glGetUniformLocation(object_prog, "NormalMatrix");
GLuint LightPosition_loc = glGetUniformLocation(object_prog, "LightPosition");
GLuint Color0_loc = glGetUniformLocation(object_prog, "Color0");
GLuint Color1_loc = glGetUniformLocation(object_prog, "Color1");
GLuint Frequency_loc = glGetUniformLocation(object_prog, "Frequency");
glUseProgram(object_prog);
GLfloat normal_matrix[3 * 3] = {
0.5f, 0.0f, 0.0f,
0.0f, 0.5f, 0.0f,
0.0f, 0.0f, 1.0f
};
glUniformMatrix3fv(NormalMatrix_loc, 1, GL_TRUE, normal_matrix);
glUniform3fv(LightPosition_loc, 1, vmath::vec3(0.0f, 0.0f, -1.0f));
glUniform3fv(Color0_loc, 1, vmath::vec3(0.0f, 0.0f, 0.7f));
glUniform3fv(Color1_loc, 1, vmath::vec3(1.0f, 1.0f, 1.0f));
glUniform1f(Frequency_loc, 24.0f);
object.LoadFromVBM("Media/torus.vbm", 0, 1, 2);
}
void Ex08_01::InitGL()
{
if (! LoadGL() )
return;
ShaderInfo object_shaders[] = {
{ GL_VERTEX_SHADER, "Shaders/sh08_01.vert" },
{ GL_FRAGMENT_SHADER, "Shaders/sh08_01.frag" },
{ GL_NONE, NULL }
};
object_prog = LoadShaders( object_shaders );
glLinkProgram(object_prog);
GLuint LightPosition_loc = glGetUniformLocation(object_prog, "LightPosition");
GLuint LightColor_loc = glGetUniformLocation(object_prog, "LightColor");
GLuint EyePosition_loc = glGetUniformLocation(object_prog, "EyePosition");
GLuint Specular_loc = glGetUniformLocation(object_prog, "Specular");
GLuint Ambient_loc = glGetUniformLocation(object_prog, "Ambient");
GLuint Kd_loc = glGetUniformLocation(object_prog, "Kd");
object_mat_mv_loc = glGetUniformLocation(object_prog, "MVMatrix");
object_mat_mvp_loc = glGetUniformLocation(object_prog, "MVPMatrix");
GLuint NormalMatrix_loc = glGetUniformLocation(object_prog, "NormalMatrix");
GLuint StripeColor_loc = glGetUniformLocation(object_prog, "StripeColor");
GLuint BackColor_loc = glGetUniformLocation(object_prog, "BackColor");
GLuint Width_loc = glGetUniformLocation(object_prog, "Width");
GLuint Fuzz_loc = glGetUniformLocation(object_prog, "Fuzz");
GLuint Scale_loc = glGetUniformLocation(object_prog, "Scale");
glUseProgram(object_prog);
glUniform3fv(LightPosition_loc, 1, vmath::vec3(0.5f, 0.5f, -1.0f));
glUniform3fv(LightColor_loc, 1, vmath::vec3(1.0f, 1.0f, 1.0f));
glUniform3fv(EyePosition_loc, 1, vmath::vec3(-0.5f, -0.5f, 1.0f));
glUniform3fv(Specular_loc, 1, vmath::vec3(0.1f, 0.1f, 0.1f));
glUniform4fv(Ambient_loc, 1, vmath::vec4(1.0f, 1.0f, 1.0f, 1.0f));
glUniform1f(Kd_loc, 1.0f);
GLfloat normal_matrix[3 * 3] = {
0.5f, 0.0f, 0.0f,
0.0f, 0.5f, 0.0f,
0.0f, 0.0f, 1.0f
};
glUniformMatrix3fv(NormalMatrix_loc, 1, GL_TRUE, normal_matrix);
glUniform3fv(StripeColor_loc, 1, vmath::vec3(0.0f, 0.0f, 0.7f));
glUniform3fv(BackColor_loc, 1, vmath::vec3(1.0f, 1.0f, 1.0f));
glUniform1f(Width_loc, 0.5f);
glUniform1f(Fuzz_loc, 0.1f);
glUniform1f(Scale_loc, 20.0f);
object.LoadFromVBM("Media/torus.vbm", 0, 1, 2);
}
void Ex06_14::InitGL()
{
if (! LoadGL() )
return;
ShaderInfo base_shaders[] = {
{ GL_VERTEX_SHADER, "Shaders/sh06_14.vert" },
{ GL_FRAGMENT_SHADER, "Shaders/sh06_14.frag" },
{ GL_NONE, NULL }
};
base_prog = LoadShaders( base_shaders );
glGenBuffers(1, &quad_vbo);
glBindBuffer(GL_ARRAY_BUFFER, quad_vbo);
static const GLfloat quad_data[] =
{
1.0f, -1.0f,
-1.0f, -1.0f,
-1.0f, 1.0f,
1.0f, 1.0f,
0.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.0f,
0.0f, 1.0f
};
glBufferData(GL_ARRAY_BUFFER, sizeof(quad_data), quad_data, GL_STATIC_DRAW);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(8 * sizeof(float)));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glLinkProgram(base_prog);
char buf[1024];
glGetProgramInfoLog(base_prog, 1024, NULL, buf);
// prog is the name of a linked program containing our example
// vertex and fragment shaders
glUseProgram(base_prog);
// For the first texture, we will use texture unit 0...
// Get the uniform location
GLint tex1_uniform_loc = glGetUniformLocation(base_prog, "tex1");
// Set it to 0
glUniform1i(tex1_uniform_loc, 0);
// Select texture unit 0
glActiveTexture(GL_TEXTURE0);
// Bind a texture to it
glBindTexture(GL_TEXTURE_2D, tex1);
// Repeat the above process for texture unit 1
GLint tex2_uniform_loc = glGetUniformLocation(base_prog, "tex2");
glUniform1i(tex2_uniform_loc, 1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, tex2);
time_loc = glGetUniformLocation(base_prog, "time");
vglImageData image;
tex1 = vglLoadTexture("Media/test.dds", 0, &image);
glTexParameteri(image.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
vglUnloadImage(&image);
tex2 = vglLoadTexture("Media/test3.dds", 0, &image);
vglUnloadImage(&image);
}
/*
VID_Init
This routine is responsible for initializing the OS specific portions
of OpenGL. Under Win32 this means dealing with the pixelformats and
doing the wgl interface stuff.
*/
qboolean VID_Init(void)
{
const char *extensions;
int ret;
gl_driver = Cvar_Get("gl_driver", "opengl32", CVAR_ARCHIVE | CVAR_REFRESH);
gl_drawbuffer = Cvar_Get("gl_drawbuffer", "GL_BACK", 0);
gl_swapinterval = Cvar_Get("gl_swapinterval", "1", CVAR_ARCHIVE);
gl_allow_software = Cvar_Get("gl_allow_software", "0", 0);
gl_colorbits = Cvar_Get("gl_colorbits", "0", CVAR_REFRESH);
gl_depthbits = Cvar_Get("gl_depthbits", "0", CVAR_REFRESH);
gl_stencilbits = Cvar_Get("gl_stencilbits", "8", CVAR_REFRESH);
gl_multisamples = Cvar_Get("gl_multisamples", "0", CVAR_REFRESH);
// don't allow absolute or relative paths
FS_SanitizeFilenameVariable(gl_driver);
// load and initialize the OpenGL driver
ret = LoadGL(gl_driver->string);
// attempt to recover if this was a minidriver
if (ret == FAIL_SOFT && glw.minidriver) {
Com_Printf("...falling back to opengl32\n");
Cvar_Reset(gl_driver);
ret = LoadGL(gl_driver->string);
}
// it failed, abort
if (ret)
return qfalse;
// initialize WGL extensions
WGL_InitExtensions(QWGL_ARB_extensions_string);
if (qwglGetExtensionsStringARB)
extensions = qwglGetExtensionsStringARB(win.dc);
else
extensions = NULL;
// fall back to GL_EXTENSIONS for legacy drivers
if (!extensions || !*extensions)
extensions = (const char *)qwglGetString(GL_EXTENSIONS);
glw.extensions = WGL_ParseExtensionString(extensions);
if (glw.extensions & QWGL_EXT_swap_control) {
if (glw.extensions & QWGL_EXT_swap_control_tear)
Com_Printf("...enabling WGL_EXT_swap_control(_tear)\n");
else
Com_Printf("...enabling WGL_EXT_swap_control\n");
WGL_InitExtensions(QWGL_EXT_swap_control);
gl_swapinterval->changed = gl_swapinterval_changed;
gl_swapinterval_changed(gl_swapinterval);
} else {
Com_Printf("WGL_EXT_swap_control not found\n");
Cvar_Set("gl_swapinterval", "0");
}
gl_drawbuffer->changed = gl_drawbuffer_changed;
gl_drawbuffer_changed(gl_drawbuffer);
VID_SetMode();
return qtrue;
}
void Ex08_13::InitGL()
{
if (! LoadGL() )
return;
ShaderInfo object_shaders[] = {
{ GL_VERTEX_SHADER, "Shaders/sh08_13.vert" },
{ GL_FRAGMENT_SHADER, "Shaders/sh08_13.frag" },
{ GL_NONE, NULL }
};
object_prog = LoadShaders( object_shaders );
glGenBuffers(1, &quad_vbo);
glBindBuffer(GL_ARRAY_BUFFER, quad_vbo);
static const GLfloat quad_data[] =
{
0.75f, -0.75f,
-0.75f, -0.75f,
-0.75f, 0.75f,
0.75f, 0.75f,
0.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.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
};
glBufferData(GL_ARRAY_BUFFER, sizeof(quad_data), quad_data, GL_STATIC_DRAW);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(8 * sizeof(float)));
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET((8 + 8) * sizeof(float)));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glLinkProgram(object_prog);
object_mat_mv_loc = glGetUniformLocation(object_prog, "MVMatrix");
object_mat_mvp_loc = glGetUniformLocation(object_prog, "MVPMatrix");
GLuint NormalMatrix_loc = glGetUniformLocation(object_prog, "NormalMatrix");
GLuint LightPosition_loc = glGetUniformLocation(object_prog, "LightPosition");
GLuint Color0_loc = glGetUniformLocation(object_prog, "Color0");
GLuint Color1_loc = glGetUniformLocation(object_prog, "Color1");
GLuint AvgColor_loc = glGetUniformLocation(object_prog, "AvgColor");
GLuint Frequency_loc = glGetUniformLocation(object_prog, "Frequency");
glUseProgram(object_prog);
GLfloat normal_matrix[3 * 3] = {
0.5f, 0.0f, 0.0f,
0.0f, 0.5f, 0.0f,
0.0f, 0.0f, 1.0f
};
glUniformMatrix3fv(NormalMatrix_loc, 1, GL_TRUE, normal_matrix);
glUniform3fv(LightPosition_loc, 1, vmath::vec3(0.0f, 0.0f, -1.0f));
glUniform3fv(Color0_loc, 1, vmath::vec3(0.0f, 0.0f, 0.7f));
glUniform3fv(Color1_loc, 1, vmath::vec3(1.0f, 1.0f, 0.0f));
glUniform3fv(AvgColor_loc, 1, vmath::vec3(1.0f, 1.0f, 1.0f));
glUniform1f(Frequency_loc, 3.0f);
}
void Ex08_07::InitGL()
{
if (! LoadGL() )
return;
ShaderInfo object_shaders[] = {
{ GL_VERTEX_SHADER, "Shaders/sh08_07.vert" },
{ GL_FRAGMENT_SHADER, "Shaders/sh08_07.frag" },
{ GL_NONE, NULL }
};
object_prog = LoadShaders( object_shaders );
glLinkProgram(object_prog);
// uniform vec4 MCBallCenter;
// uniform mat4 MVMatrix;
// uniform mat4 MVPMatrix;
// uniform mat3 NormalMatrix;
object_mat_mv_loc = glGetUniformLocation(object_prog, "MVMatrix");
object_mat_mvp_loc = glGetUniformLocation(object_prog, "MVPMatrix");
GLuint NormalMatrix_loc = glGetUniformLocation(object_prog, "NormalMatrix");
GLuint MCBallCenter_loc = glGetUniformLocation(object_prog, "MCBallCenter");
// uniform vec4 HalfSpace[5]; // half-spaces used to define star pattern
// uniform float StripeWidth;
// uniform float InOrOutInit; // -3.0
// uniform float FWidth; // = 0.005
//
// uniform vec4 StarColor;
// uniform vec4 StripeColor;
// uniform vec4 BaseColor;
//
// uniform vec4 LightDir; // light direction, should be normalized
// uniform vec4 HVector; // reflection vector for infinite light
// uniform vec4 SpecularColor;
// uniform float SpecularExponent;
//
// uniform float Ka;
// uniform float Kd;
// uniform float Ks;
GLuint HalfSpace0_loc = glGetUniformLocation(object_prog, "HalfSpace[0]");
GLuint HalfSpace1_loc = glGetUniformLocation(object_prog, "HalfSpace[1]");
GLuint HalfSpace2_loc = glGetUniformLocation(object_prog, "HalfSpace[2]");
GLuint HalfSpace3_loc = glGetUniformLocation(object_prog, "HalfSpace[3]");
GLuint HalfSpace4_loc = glGetUniformLocation(object_prog, "HalfSpace[4]");
GLuint StripeWidth_loc = glGetUniformLocation(object_prog, "StripeWidth");
GLuint InOrOutInit_loc = glGetUniformLocation(object_prog, "InOrOutInit");
GLuint FWidth_loc = glGetUniformLocation(object_prog, "FWidth");
GLuint StarColor_loc = glGetUniformLocation(object_prog, "StarColor");
GLuint StripeColor_loc = glGetUniformLocation(object_prog, "StripeColor");
GLuint BaseColor_loc = glGetUniformLocation(object_prog, "BaseColor");
GLuint LightDir_loc = glGetUniformLocation(object_prog, "LightDir");
GLuint HVector_loc = glGetUniformLocation(object_prog, "HVector");
GLuint SpecularColor_loc = glGetUniformLocation(object_prog, "SpecularColor");
GLuint SpecularExponent_loc = glGetUniformLocation(object_prog, "SpecularExponent");
GLuint Ka_loc = glGetUniformLocation(object_prog, "Ka");
GLuint Kd_loc = glGetUniformLocation(object_prog, "Kd");
GLuint Ks_loc = glGetUniformLocation(object_prog, "Ks");
glUseProgram(object_prog);
GLfloat normal_matrix[3 * 3] = {
0.5f, 0.0f, 0.0f,
0.0f, 0.5f, 0.0f,
0.0f, 0.0f, 1.0f
};
glUniformMatrix3fv(NormalMatrix_loc, 1, GL_TRUE, normal_matrix);
glUniform4fv(MCBallCenter_loc, 1, vmath::vec4(0.0f, 0.0f, 0.0f, 1.0f));
glUniform4fv(HalfSpace0_loc, 1, vmath::vec4(1.0, 0.0, 0.0, 0.2));
glUniform4fv(HalfSpace1_loc, 1, vmath::vec4(0.309016994, 0.951056516, 0.0, 0.2));
glUniform4fv(HalfSpace2_loc, 1, vmath::vec4(-0.809016994, 0.587785252, 0.0, 0.2));
glUniform4fv(HalfSpace3_loc, 1, vmath::vec4(-0.809016994, -0.587785252, 0.0, 0.2));
glUniform4fv(HalfSpace4_loc, 1, vmath::vec4(0.309016994, -0.951056516, 0.0, 0.2));
glUniform1f(StripeWidth_loc, 0.3);
glUniform1f(InOrOutInit_loc, -3.0);
glUniform1f(FWidth_loc, 0.005);
glUniform4fv(StarColor_loc, 1, vmath::vec4(0.6, 0.0, 0.0, 1.0));
glUniform4fv(StripeColor_loc, 1, vmath::vec4(0.0, 0.3, 0.6, 1.0));
glUniform4fv(BaseColor_loc, 1, vmath::vec4(0.6, 0.5, 0.0, 1.0));
glUniform4fv(LightDir_loc, 1, vmath::vec4(0.57735, 0.57735, 0.57735, 0.0));
glUniform4fv(HVector_loc, 1, vmath::vec4(0.32506, 0.32506, 0.88808, 0.0));
glUniform4fv(SpecularColor_loc, 1, vmath::vec4(1.0, 1.0, 1.0, 1.0));
glUniform1f(SpecularExponent_loc, 200.0);
glUniform1f(Ka_loc, 0.3);
glUniform1f(Kd_loc, 0.7);
glUniform1f(Ks_loc, 0.4);
object.LoadFromVBM("Media/torus.vbm", 0, 1, 2);
}
void Ex06_02::InitGL()
{
if (! LoadGL() )
return;
ShaderInfo base_shaders[] = {
{ GL_VERTEX_SHADER, "Shaders/sh06_02.vert" },
{ GL_FRAGMENT_SHADER, "Shaders/sh06_02.frag" },
{ GL_NONE, NULL }
};
base_prog = LoadShaders( base_shaders );
glGenBuffers(1, &quad_vbo);
glBindBuffer(GL_ARRAY_BUFFER, quad_vbo);
static const GLfloat quad_data[] =
{
0.75f, -0.75f,
-0.75f, -0.75f,
-0.75f, 0.75f,
0.75f, 0.75f,
0.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.0f,
0.0f, 1.0f
};
glBufferData(GL_ARRAY_BUFFER, sizeof(quad_data), quad_data, GL_STATIC_DRAW);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(8 * sizeof(float)));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glLinkProgram(base_prog);
glGenTextures(1, &tex_checkerboard);
glBindTexture(GL_TEXTURE_2D, tex_checkerboard);
glTexStorage2D(GL_TEXTURE_2D, 4, GL_RGBA8, 8, 8);
// The following is an 8x8 checkerboard pattern using
// GL_RED, GL_UNSIGNED_BYTE data.
static const unsigned char tex_checkerboard_data[] =
{
0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF
};
glTexSubImage2D(GL_TEXTURE_2D,
0,
0, 0,
8, 8,
GL_RED, GL_UNSIGNED_BYTE,
tex_checkerboard_data);
static const GLint swizzles[] = { GL_RED, GL_RED, GL_RED, GL_ONE };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzles);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glGenerateMipmap(GL_TEXTURE_2D);
glGenTextures(1, &tex_color);
glBindTexture(GL_TEXTURE_2D, tex_color);
glTexStorage2D(GL_TEXTURE_2D, 2, GL_RGBA32F, 2, 2);
// The following data represents a 2x2 texture with red,
// green, blue, and yellow texels represented as GL_RGBA,
// GL_FLOAT data.
static const GLfloat tex_color_data[] =
{
// Red texel Green texel
1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f,
// Blue texel Yellow texel
0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f
};
glTexSubImage2D(GL_TEXTURE_2D, // target
0, // First mipmap level
0, 0, // x and y offset
2, 2, // width and height
GL_RGBA, GL_FLOAT, // format and type
tex_color_data); // data
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glGenerateMipmap(GL_TEXTURE_2D);
}
CGLTexture::CGLTexture(string f) {
Initialize();
pLog=new CLog("texture.log");
bMadeLog=true;
LoadGL(f);
}
void Ex11_04::InitGL()
{
if (! LoadGL() )
return;
render_scene_prog = -1;
resolve_program = -1;
InitPrograms();
// Create palette texture
glGenBuffers(1, &image_palette_buffer);
glBindBuffer(GL_TEXTURE_BUFFER, image_palette_buffer);
glBufferData(GL_TEXTURE_BUFFER, 256 * 4 * sizeof(float), NULL, GL_STATIC_DRAW);
glGenTextures(1, &image_palette_texture);
glBindTexture(GL_TEXTURE_BUFFER, image_palette_texture);
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, image_palette_buffer);
vmath::vec4 * data = (vmath::vec4 *)glMapBuffer(GL_TEXTURE_BUFFER, GL_WRITE_ONLY);
for (int i = 0; i < 256; i++)
{
data[i] = vmath::vec4((float)i);
}
glUnmapBuffer(GL_TEXTURE_BUFFER);
// Create head pointer texture
glActiveTexture(GL_TEXTURE0);
glGenTextures(1, &output_texture);
glBindTexture(GL_TEXTURE_2D, output_texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, MAX_FRAMEBUFFER_WIDTH, MAX_FRAMEBUFFER_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
glBindImageTexture(0, output_texture, 0, GL_TRUE, 0, GL_READ_WRITE, GL_RGBA32F);
// Create buffer for clearing the head pointer texture
glGenBuffers(1, &output_texture_clear_buffer);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, output_texture_clear_buffer);
glBufferData(GL_PIXEL_UNPACK_BUFFER, MAX_FRAMEBUFFER_WIDTH * MAX_FRAMEBUFFER_HEIGHT * sizeof(GLuint), NULL, GL_STATIC_DRAW);
data = (vmath::vec4 *)glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY);
memset(data, 0x00, MAX_FRAMEBUFFER_WIDTH * MAX_FRAMEBUFFER_HEIGHT * sizeof(GLuint));
glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
// Create VAO containing quad for the final blit
glGenVertexArrays(1, &quad_vao);
glBindVertexArray(quad_vao);
static const GLfloat quad_verts[] =
{
-1.0f, -1.0f,
1.0f, -1.0f,
-1.0f, 1.0f,
1.0f, 1.0f,
};
glGenBuffers(1, &quad_vbo);
glBindBuffer(GL_ARRAY_BUFFER, quad_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(quad_verts), quad_verts, GL_STATIC_DRAW);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(0);
glClearDepth(1.0f);
object.LoadFromVBM("Media/torus.vbm", 0, 1, 2);
}
