void display(){
/* display callback, clear frame buffer and z buffer,
rotate cube and draw, swap buffers */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(dx1,dy1,dz1);
glRotatef(theta1[0], 1.0, 0.0, 0.0);
glRotatef(theta1[1], 0.0, 1.0, 0.0);
glRotatef(theta1[2], 0.0, 0.0, 1.0);
glScalef(scale1,scale1,scale1);
colorcube();
glLoadIdentity();
glTranslatef(dx2,dy2,dz2);
glRotatef(theta2[0], 1.0, 0.0, 0.0);
glRotatef(theta2[1], 0.0, 1.0, 0.0);
glRotatef(theta2[2], 0.0, 0.0, 1.0);
glScalef(scale2,scale2,scale2);
colorcube();
glLoadIdentity();
//button
glColor3f(0.6,0.6,0.6);
glBegin(GL_QUADS);
glVertex2f(-0.2,-1.5);
glVertex2f(0.2, -1.5);
glVertex2f(0.2, -1.67);
glVertex2f(-0.2, -1.67);
glEnd();
label();
glFlush();
glutSwapBuffers();
}
// initialization
void generateCube(GLuint program, ShapeData* data) {
colorcube(data, 1);
data->enableTangentArray( program, true );
data->enableUVArray( program, true );
data->bind(program);
}
int
main(int argc, char **argv)
{
colorcube();
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutInitContextVersion( 3, 2 );
glutInitContextProfile( GLUT_CORE_PROFILE );
glutCreateWindow("colorcube");
glewExperimental = GL_TRUE;
glewInit();
program = InitShader("vshader72.glsl", "fshader72.glsl");
init();
glutReshapeFunc(myReshape);
glutDisplayFunc(display);
glutIdleFunc(spinCube);
glutMouseFunc(mouse);
glutKeyboardFunc(key);
glutMainLoop();
return 0;
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
/* ビュー変換 */
glLoadIdentity();
glTranslatef(0.0, 0.0, viewxform_z);
if ( trackballMove ){
glPushMatrix();
glLoadIdentity();
glRotatef( angle, axis[0], axis[1], axis[2] );
glMultMatrixf( (GLfloat*)trackballXform );
glGetFloatv( GL_MODELVIEW_MATRIX, trackballXform );
glPopMatrix();
}
glPushMatrix();
glMultMatrixf( (GLfloat*)lightXform );
setLightPos();
glPopMatrix();
glPushMatrix();
glMultMatrixf( (GLfloat*)objectXform );
colorcube();
glPopMatrix();
glutSwapBuffers();
}
ShapeData* genCube(GLuint program, float tex_size) {
ShapeData* ret = new ShapeData(numCubeVertices);
colorcube(ret, tex_size);
ret->enableTangentArray( program, true );
ret->enableUVArray( program, true );
ret->bind(program);
return ret;
}
void init()
{
colorcube();
GLubyte red[3] = {255, 0, 0};
GLubyte green[3] = {0, 255, 0};
GLubyte blue[3] = {0, 0, 255};
GLubyte cyan[3] = {0, 255, 255};
GLubyte magenta[3] = {255, 0, 255};
GLubyte yellow[3] = {255, 255, 0};
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_CUBE_MAP);
glGenTextures(1, tex);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_CUBE_MAP, tex[0]);
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X ,0,3,1,1,0,GL_RGB,GL_UNSIGNED_BYTE, red);
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X ,0,3,1,1,0,GL_RGB,GL_UNSIGNED_BYTE, green);
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y ,0,3,1,1,0,GL_RGB,GL_UNSIGNED_BYTE, blue);
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y ,0,3,1,1,0,GL_RGB,GL_UNSIGNED_BYTE, cyan);
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z ,0,3,1,1,0,GL_RGB,GL_UNSIGNED_BYTE, magenta);
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z ,0,3,1,1,0,GL_RGB,GL_UNSIGNED_BYTE, yellow);
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
// Create a vertex array object
GLuint vao;
glGenVertexArrays( 1, &vao );
glBindVertexArray( vao );
loc = glGetAttribLocation(program, "vPosition");
glEnableVertexAttribArray(loc);
glVertexAttribPointer(loc, 4, GL_FLOAT, GL_TRUE, 0, points);
loc2 = glGetAttribLocation(program, "Normal");
glEnableVertexAttribArray(loc2);
glVertexAttribPointer(loc2, 4, GL_FLOAT, GL_TRUE, 0, normals);
ctm_loc = glGetUniformLocation(program, "ModelView");
projection_loc = glGetUniformLocation(program, "Projection");
glUniformMatrix4fv(projection_loc, 1, GL_TRUE, projection);
/* set up uniform parameter */
texMapLocation = glGetUniformLocation(program, "texMap");
glUniform1i(texMapLocation, tex[0]);
glGenBuffers(1, buffers);
glBindBuffer( GL_ARRAY_BUFFER, buffers[0]);
glBufferData( GL_ARRAY_BUFFER, sizeof(points) + sizeof(normals),
NULL, GL_DYNAMIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, sizeof(points), points );
glBufferSubData( GL_ARRAY_BUFFER, sizeof(points), sizeof(normals), normals );
glClearColor(1.0,1.0,1.0,1.0);
}
void display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glRotatef(theta[0], 1, 0, 0);
glRotatef(theta[1], 0, 1, 0);
glRotatef(theta[2], 0, 0, 1);
colorcube();
glutSwapBuffers();
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
if(axis==0) glRotatef(theta[0],1.0,0.0,0.0);
if(axis==1) glRotatef(theta[1],0.0,1.0,0.0);
if(axis==2) glRotatef(theta[2],0.0,0.0,1.0);
colorcube();
glFlush();
glutSwapBuffers();
}
void display( void )
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /*clear the window */
ctm = RotateX(theta[0])*RotateY(theta[1])*RotateZ(theta[2]);
colorcube();
glBufferSubData( GL_ARRAY_BUFFER, 0, sizeof(points), points );
glBufferSubData( GL_ARRAY_BUFFER, sizeof(points), sizeof(quad_color), quad_color );
glDrawArrays(GL_TRIANGLES, 0, NumVertices);
glutSwapBuffers();
}
void
init( void )
{
colorcube();
/* set up particles with random locations and velocities */
for ( int i = 0; i < num_particles; i++ ) {
particles[i].mass = 1.0;
particles[i].color = i % NUM_COLORS;
for ( int j = 0; j < 3; j++ ) {
particles[i].position[j] =
2.0 * ( ( float ) rand() / RAND_MAX ) - 1.0;
particles[i].velocity[j] =
speed * 2.0 * ( ( float ) rand() / RAND_MAX ) - 1.0;
}
particles[i].position[3] = 1.0;
}
// Create a vertex array object
GLuint vao;
glGenVertexArraysAPPLE( 1, &vao );
glBindVertexArrayAPPLE( vao );
// Create and initialize a buffer object
glGenBuffers( 1, &buffer );
glBindBuffer( GL_ARRAY_BUFFER, buffer );
glBufferData( GL_ARRAY_BUFFER, sizeof(points) + sizeof(point_colors),
NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, sizeof(points), points );
glBufferSubData( GL_ARRAY_BUFFER, sizeof(points), sizeof(point_colors), point_colors );
// Load shaders and use the resulting shader program
GLuint program = InitShader( "vshader91.glsl", "fshader91.glsl" );
glUseProgram( program );
// set up vertex arrays
GLuint vPosition = glGetAttribLocation( program, "vPosition" );
glEnableVertexAttribArray( vPosition );
glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(0) );
GLuint vColor = glGetAttribLocation( program, "vColor" );
glEnableVertexAttribArray( vColor );
glVertexAttribPointer( vColor, 4, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(sizeof(points)) );
model_view_loc = glGetUniformLocation( program, "ModelView" );
projection_loc = glGetUniformLocation( program, "Projection" );
glClearColor( 0.5, 0.5, 0.5, 1.0 );
glPointSize( point_size );
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glClearColor(0.0,0.0,0.0,1.0);
glLoadIdentity();
gluLookAt(viewer[0],viewer[1],viewer[2],0.0,0.0,0.0,0.0,1.0,0.0);
glRotatef(theta[0],1.0,0.0,0.0);
glRotatef(theta[1],0.0,1.0,0.0);
glRotatef(theta[2],0.0,0.0,1.0);
colorcube();
glFlush();
glutSwapBuffers();
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
/* view transform */
if (trackballMove) {
glRotatef(angle, axis[0], axis[1], axis[2]);
}
colorcube();
glPopMatrix();
glutSwapBuffers();
}
// initialization
void generateCube(GLuint program, ShapeData* cubeData)
{
colorcube();
cubeData->numVertices = numCubeVertices;
// Create a vertex array object
glGenVertexArrays( 1, &cubeData->vao );
glBindVertexArray( cubeData->vao );
// Set vertex attributes
setVertexAttrib(program,
(float*)cubePoints, sizeof(cubePoints),
(float*)cubeNormals, sizeof(cubeNormals),0,0);
// (float*)cubeUV, sizeof(cubeUV));
}
void display(void)
{
/* display callback, clear frame buffer and z buffer,
rotate cube and draw, swap buffers */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glRotatef(theta[0], 1.0, 0.0, 0.0);
glRotatef(theta[1], 0.0, 1.0, 0.0);
glRotatef(theta[2], 0.0, 0.0, 1.0);
//draw the cube
colorcube();
glFlush();
glutSwapBuffers();
}
//rotate cube using quaternion
void display(void)
{
//clear buffer
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
/* view transform */
if (trackballMove)
{
//rotate plane with quaternion
glRotatef(angle, axis[0], axis[1], axis[2]);
}
//draw the cube
colorcube();
glutSwapBuffers();
}
void
init( void )
{
colorcube();
// Initialize tree
initNodes();
// Create a vertex array object
GLuint vao;
glGenVertexArrays( 1, &vao );
glBindVertexArray( vao );
// Create and initialize a buffer object
GLuint buffer;
glGenBuffers( 1, &buffer );
glBindBuffer( GL_ARRAY_BUFFER, buffer );
glBufferData( GL_ARRAY_BUFFER, sizeof(points) + sizeof(colors),
NULL, GL_DYNAMIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, sizeof(points), points );
glBufferSubData( GL_ARRAY_BUFFER, sizeof(points), sizeof(colors),
colors );
// Load shaders and use the resulting shader program
GLuint program = InitShader( "vshader83.glsl", "fshader83.glsl" );
glUseProgram( program );
GLuint vPosition = glGetAttribLocation( program, "vPosition" );
glEnableVertexAttribArray( vPosition );
glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(0) );
GLuint vColor = glGetAttribLocation( program, "vColor" );
glEnableVertexAttribArray( vColor );
glVertexAttribPointer( vColor, 4, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(points) );
ModelView = glGetUniformLocation( program, "ModelView" );
Projection = glGetUniformLocation( program, "Projection" );
glEnable( GL_DEPTH_TEST );
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
glClearColor( 1.0, 1.0, 1.0, 1.0 );
}
void myinit()
{
int i, j;
colorcube();
/* set up particles with random locations and velocities */
for(i=0; i<num_particles; i++)
{
particles[i].mass = 1.0;
particles[i].color = i%NUM_COLORS;
for(j=0; j<3; j++)
{
particles[i].position[j] = 2.0*((float) rand()/RAND_MAX)-1.0;
particles[i].velocity[j] = speed*2.0*((float) rand()/RAND_MAX)-1.0;
}
particles[i].position[3] = 1.0;
}
glPointSize(point_size);
/* set clear color to grey */
glClearColor(0.5, 0.5, 0.5, 1.0);
loc = glGetAttribLocation(program, "vPosition");
glEnableVertexAttribArray(loc);
glVertexAttribPointer(loc, 4, GL_FLOAT, GL_FALSE, 0, points);
loc2 = glGetAttribLocation(program, "vColor"); //vertex color in shader
glEnableVertexAttribArray(loc2);
glVertexAttribPointer(loc2, 4, GL_FLOAT, GL_FALSE, 0, point_colors);
model_view_loc = glGetUniformLocation(program, "model_view");
projection_loc = glGetUniformLocation(program, "projection");
/* set up vertex buffer object */
glGenBuffers(1, buffers);
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(points), NULL, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, buffers[1]);
glBufferData(GL_ARRAY_BUFFER, sizeof(point_colors), point_colors, GL_DYNAMIC_DRAW);
}
// OpenGL initialization
void
init()
{
colorcube();
GLuint vao;
glGenVertexArrays(1 ,&vao);
glBindVertexArray( vao );
GLuint buffer[2];
glGenBuffers(2, buffer);
glBindBuffer( GL_ARRAY_BUFFER, buffer[0]);
glBufferData( GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
glBindBuffer( GL_ARRAY_BUFFER, buffer[1]);
glBufferData( GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);
GLuint program = InitShader("vshader.glsl", "fshader.glsl");
glUseProgram( program );
glBindBuffer( GL_ARRAY_BUFFER, buffer[0]);
GLuint vPosition = glGetAttribLocation( program, "vPosition");
glEnableVertexAttribArray(vPosition);
glVertexAttribPointer( vPosition/*atrib*/, 4/*size*/, GL_FLOAT/*type*/,
GL_FALSE/*normalized*/, 0/*stride*/, 0/*pointer*/);
glBindBuffer( GL_ARRAY_BUFFER, buffer[1]);
GLuint vColor= glGetAttribLocation( program, "vColor");
glEnableVertexAttribArray(vColor);
glVertexAttribPointer( vColor/*atrib*/, 4/*size*/, GL_FLOAT/*type*/,
GL_FALSE/*normalized*/, 0/*stride*/, 0/*pointer*/);
model_view = glGetUniformLocation( program, "model_view");
projection = glGetUniformLocation( program, "projection");
glEnable(GL_DEPTH_TEST);
glClearColor(1,1,1,1);
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* Update viewer position in modelview matrix */
glLoadIdentity();
gluLookAt(viewer[0],viewer[1],viewer[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
/* rotate cube */
glRotatef(theta[0], 1.0, 0.0, 0.0);
glRotatef(theta[1], 0.0, 1.0, 0.0);
glRotatef(theta[2], 0.0, 0.0, 1.0);
colorcube();
glFlush();
glutSwapBuffers();
}
void display12()
{ /* display callback, clear frame buffer and z buffer,
rotate cube and draw, swap buffers */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glColor3f(1.0,1.0,1.0);
glRasterPos2f(-2.03,-1.57);
Write("Close");
glutMouseFunc(OnClick1);
if(xo>24&&xo<54&&yo>64&&yo<85)
glutHideWindow();
gluLookAt(viewer[0],viewer[1],viewer[2],0.0,0.0,0.0,0.0,1.0,0.0);
glRotatef(theta[0], 1.0, 0.0, 0.0);
glRotatef(theta[1], 0.0, 1.0, 0.0);
glRotatef(theta[2], 0.0, 0.0, 1.0);
colorcube();
glFlush();
glutSwapBuffers();
}
// OpenGL initialization
void
init()
{
colorcube();
// Create a vertex array object
GLuint vao;
glGenVertexArraysAPPLE( 1, &vao );
glBindVertexArrayAPPLE( vao );
// Create and initialize a buffer object
GLuint buffer;
glGenBuffers( 1, &buffer );
glBindBuffer( GL_ARRAY_BUFFER, buffer );
glBufferData( GL_ARRAY_BUFFER, sizeof(points) + sizeof(colors),
NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, sizeof(points), points );
glBufferSubData( GL_ARRAY_BUFFER, sizeof(points), sizeof(colors), colors );
// Load shaders and use the resulting shader program
GLuint program = InitShader( "vshader42.glsl", "fshader42.glsl" );
glUseProgram( program );
// set up vertex arrays
GLuint vPosition = glGetAttribLocation( program, "vPosition" );
glEnableVertexAttribArray( vPosition );
glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(0) );
GLuint vColor = glGetAttribLocation( program, "vColor" );
glEnableVertexAttribArray( vColor );
glVertexAttribPointer( vColor, 4, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(sizeof(points)) );
model_view = glGetUniformLocation( program, "model_view" );
projection = glGetUniformLocation( program, "projection" );
glEnable( GL_DEPTH_TEST );
glClearColor( 1.0, 1.0, 1.0, 1.0 );
}
void init( void ) {
Index = 0;
pos = vec3(-10, 0, 0);
colorcube();
// Create a vertex array object
glGenVertexArrays( 1, &vao );
glBindVertexArray( vao );
// Create and initialize a buffer object
glGenBuffers( 1, &buffer );
glBindBuffer( GL_ARRAY_BUFFER, buffer );
glBufferData( GL_ARRAY_BUFFER, sizeof(points) + sizeof(colors), NULL, GL_DYNAMIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, sizeof(points), points );
glBufferSubData( GL_ARRAY_BUFFER, sizeof(points), sizeof(colors), colors );
glEnableVertexAttribArray( vPosition );
glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0) );
glEnableVertexAttribArray( vColor );
glVertexAttribPointer( vColor, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(points)) );
//glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
}
Cube::Cube(vec3 pos, vec3 s)
{
numVertices = 36;
quadIndex = 0;
position = pos;
scale = s;
points = new point4[numVertices];
normals = new vec3[numVertices];
diffuse = color4(0.2, 0.2, 0.6, 1.0);
ambient = color4(1.0, 1.0, 1.0, 1.0);
specular = color4(1.0, 1.0, 1.0, 1.0);
shininess = 100.0;
vertices = new point4[8];
vertices[0] = point4( -0.5, -0.5, 0.5, 1.0 );
vertices[1] = point4( -0.5, 0.5, 0.5, 1.0 );
vertices[2] = point4( 0.5, 0.5, 0.5, 1.0 );
vertices[3] = point4( 0.5, -0.5, 0.5, 1.0 );
vertices[4] = point4( -0.5, -0.5, -0.5, 1.0 );
vertices[5] = point4( -0.5, 0.5, -0.5, 1.0 );
vertices[6] = point4( 0.5, 0.5, -0.5, 1.0 );
vertices[7] = point4( 0.5, -0.5, -0.5, 1.0 );
vertex_colors = new point4[8];
vertex_colors[0] = color4( 0.0, 0.0, 0.0, 1.0 );
vertex_colors[1] = color4( 1.0, 0.0, 0.0, 1.0 );
vertex_colors[2] = color4( 1.0, 1.0, 0.0, 1.0 );
vertex_colors[3] = color4( 0.0, 1.0, 0.0 , 1.0 );
vertex_colors[4] = color4( 0.0, 0.0, 1.0, 1.0 );
vertex_colors[5] = color4( 1.0, 0.0, 1.0, 1.0 );
vertex_colors[6] = color4( 1.0, 1.0, 1.0, 1.0 );
vertex_colors[7] = color4( 0.0, 1.0, 1.0, 1.0 );
colorcube();
setUpShader();
}
void CChildView::InitGL()
{
// Create a checkerboard pattern
for (int i = 0; i < 64; i++) {
for (int j = 0; j < 64; j++) {
GLubyte c;
c = (((i & 0x8) == 0) ^ ((j & 0x8) == 0)) * 255;
image[i][j][0] = c;
image[i][j][1] = c;
image[i][j][2] = c;
image2[i][j][0] = c;
image2[i][j][1] = 0;
image2[i][j][2] = c;
}
}
colorcube();
m_program = LoadShaders( "ShaderWnd/vertex.glsl", "ShaderWnd/fragment.glsl" );
static const vec4 g_vertex_buffer_data[] = {
vec4(-1.0f, -1.0f, 0.0f, 1.0f),
vec4(1.0f, -1.0f, 0.0f, 1.0f),
vec4(0.0f, 0.5f, 0.0f, 1.0f)
};
static const vec4 g_color_buffer_data[] = {
vec4(1.0f, 0.0f, 0.0f, 1.0f),
vec4(0.0f, 1.0f, 0.0f, 1.0f),
vec4(0.0f, 0.0f, 1.0f, 1.0f)
};
//GLuint vertexbuffer;
glUseProgram(m_program);
GLuint vao;
glGenVertexArrays( 1, &vao);
glBindVertexArray( vao);
/*glGenBuffers(1, &vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);*/
glGenTextures(2, textures);
glBindTexture(GL_TEXTURE_2D, textures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TextureSize, TextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, textures[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TextureSize, TextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, image2);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glActiveTexture( GL_TEXTURE0 );
glBindTexture( GL_TEXTURE_2D, textures[0]);
glActiveTexture( GL_TEXTURE1 );
glBindTexture( GL_TEXTURE_2D, textures[1]);
// Create and initialize a buffer object
GLuint buffer;
glGenBuffers(1, &buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(points) + sizeof(tex_coords) + sizeof(normals), NULL, GL_STATIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(points), value_ptr(points[0]));
glBufferSubData(GL_ARRAY_BUFFER, sizeof(points), sizeof(normals), value_ptr(normals[0]));
glBufferSubData(GL_ARRAY_BUFFER, sizeof(points) + sizeof(normals), sizeof(tex_coords), value_ptr(tex_coords[0]));
point4 light_position (-5.f, 5.f, -5.f, 0.f);
color4 light_ambient (0.2f, 0.2f, 0.2f, 1.f);
color4 light_diffuse (1.f, 1.f, 1.f, 1.f);
color4 light_specular (1.f, 1.f, 1.f, 1.f);
color4 material_ambient(.3f, .6f, .3f, 1.f);
color4 material_diffuse (0.3f, .6f, 0.3f, 1.f);
color4 material_specular (1.f, 1.f, 1.f, 1.f);
float material_shininess = 100.0f;
color4 ambient_product = light_ambient*material_ambient;
color4 diffuse_product = light_diffuse*material_diffuse;
color4 specular_product = light_specular*material_specular;
glUniform4fv(glGetUniformLocation(m_program, "AmbientProduct"), 1, value_ptr(ambient_product));
glUniform4fv(glGetUniformLocation(m_program, "DiffuseProduct"), 1, value_ptr(diffuse_product));
glUniform4fv(glGetUniformLocation(m_program, "SpecularProduct"), 1, value_ptr(specular_product));
glUniform4fv(glGetUniformLocation(m_program, "LightPosition"), 1, value_ptr(light_position));
glUniform1f(glGetUniformLocation(m_program, "Shininess"), material_shininess);
// set up vertex arrays (after shaders are loaded)
GLuint vPosition = glGetAttribLocation(m_program, "vPosition");
glEnableVertexAttribArray(vPosition);
glVertexAttribPointer(vPosition, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
GLuint vNormal = glGetAttribLocation(m_program, "vNormal");
glEnableVertexAttribArray(vNormal);
glVertexAttribPointer(vNormal, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(points)));
GLuint vTex = glGetAttribLocation(m_program, "vTexCoord");
glEnableVertexAttribArray(vTex);
glVertexAttribPointer(vTex, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(points)+sizeof(normals)));
// Set the value of the fragment shader texture sampler variable
// ("texture") to the the appropriate texture unit. In this case,
// zero, for GL_TEXTURE0 which was previously set by calling
// glActiveTexture().
glUniform1i( glGetUniformLocation(m_program, "diffuse_mat"), 0);
m_nPVM = glGetUniformLocation(m_program, "mPVM");
m_nVM = glGetUniformLocation(m_program, "mVM");
glClearColor(1.f,1.f,1.f,1.f);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
}
// OpenGL initialization
void
init()
{
colorcube();
// Create a vertex array object
GLuint vao;
glGenVertexArrays( 1, &vao );
glBindVertexArray( vao );
// Create and initialize a buffer object
GLuint buffer;
glGenBuffers( 1, &buffer );
glBindBuffer( GL_ARRAY_BUFFER, buffer );
glBufferData( GL_ARRAY_BUFFER, sizeof(points) + sizeof(normals),
NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, sizeof(points), points );
glBufferSubData( GL_ARRAY_BUFFER, sizeof(points),
sizeof(normals), normals );
// Load shaders and use the resulting shader program
GLuint program = InitShader( "vshader53.glsl", "fshader53.glsl" );
glUseProgram( program );
// set up vertex arrays
GLuint vPosition = glGetAttribLocation( program, "vPosition" );
glEnableVertexAttribArray( vPosition );
glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(0) );
GLuint vNormal = glGetAttribLocation( program, "vNormal" );
glEnableVertexAttribArray( vNormal );
glVertexAttribPointer( vNormal, 3, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(sizeof(points)) );
// Initialize shader lighting parameters
point4 light_position( 0.0, 0.0, -1.0, 0.0 );
color4 light_ambient( 0.2, 0.2, 0.2, 1.0 );
color4 light_diffuse( 1.0, 1.0, 1.0, 1.0 );
color4 light_specular( 1.0, 1.0, 1.0, 1.0 );
color4 material_ambient( 1.0, 0.0, 1.0, 1.0 );
color4 material_diffuse( 1.0, 0.8, 0.0, 1.0 );
color4 material_specular( 1.0, 0.8, 0.0, 1.0 );
float material_shininess = 100.0;
color4 ambient_product = light_ambient * material_ambient;
color4 diffuse_product = light_diffuse * material_diffuse;
color4 specular_product = light_specular * material_specular;
glUniform4fv( glGetUniformLocation(program, "AmbientProduct"),
1, ambient_product );
glUniform4fv( glGetUniformLocation(program, "DiffuseProduct"),
1, diffuse_product );
glUniform4fv( glGetUniformLocation(program, "SpecularProduct"),
1, specular_product );
glUniform4fv( glGetUniformLocation(program, "LightPosition"),
1, light_position );
glUniform1f( glGetUniformLocation(program, "Shininess"),
material_shininess );
// Retrieve transformation uniform variable locations
ModelView = glGetUniformLocation( program, "ModelView" );
Projection = glGetUniformLocation( program, "Projection" );
glEnable( GL_DEPTH_TEST );
glShadeModel(GL_FLAT);
glClearColor( 1.0, 1.0, 1.0, 1.0 );
}
void
init()
{
colorcube();
// Create a checkerboard pattern
for ( int i = 0; i < 64; i++ ) {
for ( int j = 0; j < 64; j++ ) {
GLubyte c = (((i & 0x8) == 0) ^ ((j & 0x8) == 0)) * 255;
image[i][j][0] = c;
image[i][j][1] = c;
image[i][j][2] = c;
image2[i][j][0] = c;
image2[i][j][1] = 0;
image2[i][j][2] = c;
}
}
// Initialize texture objects
glGenTextures( 2, textures );
glBindTexture( GL_TEXTURE_2D, textures[0] );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, TextureSize, TextureSize, 0,
GL_RGB, GL_UNSIGNED_BYTE, image );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
glBindTexture( GL_TEXTURE_2D, textures[1] );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, TextureSize, TextureSize, 0,
GL_RGB, GL_UNSIGNED_BYTE, image2 );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
glActiveTexture( GL_TEXTURE0 );
glBindTexture( GL_TEXTURE_2D, textures[0] );
// Create a vertex array object
GLuint vao;
glGenVertexArrays( 1, &vao );
glBindVertexArray( vao );
// Create and initialize a buffer object
GLuint buffer;
glGenBuffers( 1, &buffer );
glBindBuffer( GL_ARRAY_BUFFER, buffer );
glBufferData( GL_ARRAY_BUFFER,
sizeof(points) + sizeof(quad_colors) + sizeof(tex_coords),
NULL, GL_STATIC_DRAW );
// Specify an offset to keep track of where we're placing data in our
// vertex array buffer. We'll use the same technique when we
// associate the offsets with vertex attribute pointers.
GLintptr offset = 0;
glBufferSubData( GL_ARRAY_BUFFER, offset, sizeof(points), points );
offset += sizeof(points);
glBufferSubData( GL_ARRAY_BUFFER, offset,
sizeof(quad_colors), quad_colors );
offset += sizeof(quad_colors);
glBufferSubData( GL_ARRAY_BUFFER, offset, sizeof(tex_coords), tex_coords );
// Load shaders and use the resulting shader program
GLuint program = InitShader( "vshader71.glsl", "fshader71.glsl" );
glUseProgram( program );
// set up vertex arrays
offset = 0;
GLuint vPosition = glGetAttribLocation( program, "vPosition" );
glEnableVertexAttribArray( vPosition );
glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(offset) );
offset += sizeof(points);
GLuint vColor = glGetAttribLocation( program, "vColor" );
glEnableVertexAttribArray( vColor );
glVertexAttribPointer( vColor, 4, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(offset) );
offset += sizeof(quad_colors);
GLuint vTexCoord = glGetAttribLocation( program, "vTexCoord" );
glEnableVertexAttribArray( vTexCoord );
glVertexAttribPointer( vTexCoord, 2, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(offset) );
// Set the value of the fragment shader texture sampler variable
// ("texture") to the the appropriate texture unit. In this case,
// zero, for GL_TEXTURE0 which was previously set by calling
// glActiveTexture().
glUniform1i( glGetUniformLocation(program, "texture"), 0 );
theta = glGetUniformLocation( program, "theta" );
glEnable( GL_DEPTH_TEST );
glClearColor( 1.0, 1.0, 1.0, 1.0 );
}
