void TestGLCanvas::OnPaint( wxPaintEvent& WXUNUSED(event) )
{
// must always be here
wxPaintDC dc(this);
SetCurrent(*m_glRC);
// Initialize OpenGL
if (!m_gldata.initialized)
{
InitGL();
ResetProjectionMode();
m_gldata.initialized = true;
}
// Clear
glClearColor( 0.3f, 0.4f, 0.6f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
// Transformations
glLoadIdentity();
glTranslatef( 0.0f, 0.0f, -20.0f );
GLfloat m[4][4];
build_rotmatrix( m, m_gldata.quat );
glMultMatrixf( &m[0][0] );
m_renderer.Render();
// Flush
glFlush();
// Swap
SwapBuffers();
}
void Pcb3D_GLCanvas::Redraw( void )
/**********************************/
{
SetCurrent();
InitGL();
glMatrixMode(GL_MODELVIEW); /* position viewer */
/* transformations */
GLfloat mat[4][4];
glTranslatef(Draw3d_dx, Draw3d_dy, 0.0F);
build_rotmatrix( mat, g_Parm_3D_Visu.m_Quat );
glMultMatrixf( &mat[0][0] );
glRotatef(g_Parm_3D_Visu.m_Rot[0], 1.0, 0.0, 0.0);
glRotatef(g_Parm_3D_Visu.m_Rot[1], 0.0, 1.0, 0.0);
glRotatef(g_Parm_3D_Visu.m_Rot[2], 0.0, 0.0, 1.0);
if( m_gllist ) glCallList( m_gllist );
else
{
m_gllist = CreateDrawGL_List();
// m_gllist = DisplayCubeforTest();
}
glFlush();
SwapBuffers();
}
void Camera::updateTransform()
{
// Store the rotation matrix here.
float matRot[4][4];
// Determine rotation matrix from quaternion.
build_rotmatrix(matRot, m_fQuat);
// Normal camera direction
Vec3f vDirection(0,0,m_fDolly);
Vec3f vUpVector(0,1,0);
// Apply the rotation matrix to determine the camera's new direction.
Vec3f vNewDirection(
matRot[0][0] * vDirection[0] + matRot[0][1] * vDirection[1] + matRot[0][2] * vDirection[2],
matRot[1][0] * vDirection[0] + matRot[1][1] * vDirection[1] + matRot[1][2] * vDirection[2],
matRot[2][0] * vDirection[0] + matRot[2][1] * vDirection[1] + matRot[2][2] * vDirection[2]
);
// Apply the rotation matrix to determine the camera's new up-vector.
Vec3f vNewUpVector(
matRot[0][0] * vUpVector[0] + matRot[0][1] * vUpVector[1] + matRot[0][2] * vUpVector[2],
matRot[1][0] * vUpVector[0] + matRot[1][1] * vUpVector[1] + matRot[1][2] * vUpVector[2],
matRot[2][0] * vUpVector[0] + matRot[2][1] * vUpVector[1] + matRot[2][2] * vUpVector[2]
);
// Update camera.
m_vPosition = m_vLookAt + vNewDirection;
m_vUpVector = vNewUpVector;
// Not dirty anymore
m_bDirtyTransform = false;
}
void
drawBox(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glPushMatrix();
glTranslatef(
((stl_max_x(stl) + stl_min_x(stl))/2),
((stl_max_y(stl) + stl_min_y(stl))/2),
((stl_max_z(stl) + stl_min_z(stl))/2));
glScalef(zoom, zoom, zoom);
GLfloat rot_matrix[4][4];
build_rotmatrix(rot_matrix, rot_cur_quat);
glMultMatrixf(&rot_matrix[0][0]);
glTranslatef(
-((stl_max_x(stl) + stl_min_x(stl))/2),
-((stl_max_y(stl) + stl_min_y(stl))/2),
-((stl_max_z(stl) + stl_min_z(stl))/2));
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular );
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glCallList(model);
glPopMatrix();
glFlush();
glutSwapBuffers();
}
gint redrawGL2PS()
{
GLdouble m[4][4];
GtkWidget *widget = GLArea;
if(!GTK_IS_WIDGET(widget)) return TRUE;
if(!GTK_WIDGET_REALIZED(widget)) return TRUE;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
addFog();
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
set_background_color();
mYPerspective(45,(GLdouble)widget->allocation.width/(GLdouble)widget->allocation.height,1,100);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
if(optcol==-1) drawChecker();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(perspective)
mYPerspective(Zoom,(GLdouble)widget->allocation.width/(GLdouble)widget->allocation.height,zNear,zFar);
else
{
gdouble fw = (GLdouble)widget->allocation.width/(GLdouble)widget->allocation.height;
gdouble fh = 1.0;
glOrtho(-fw,fw,-fh,fh,-1,1);
}
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
if(perspective)
glTranslatef(Trans[0],Trans[1],Trans[2]);
else
{
glTranslatef(Trans[0]/10,Trans[1]/10,0);
glScalef(1/Zoom*2,1/Zoom*2,1/Zoom*2);
}
SetLight();
build_rotmatrix(m,Quat);
glMultMatrixd(&m[0][0]);
redrawGeometry();
redrawSurfaces();
redrawCell();
redrawContours();
redrawPlanesMapped();
if(get_show_symbols() || get_show_numbers() || get_show_charges()) showLabelSymbolsNumbersCharges();
if(get_show_dipole()) showLabelDipole();
if(get_show_distances()) showLabelDistances();
if(get_show_axes()) showLabelAxes();
if(get_show_axes()) showLabelPrincipalAxes();
showLabelTitle(GLArea->allocation.width,GLArea->allocation.height);
/* Swap backbuffer to front */
glFlush();
return TRUE;
}
void rotateBy(float axis[3], float phi) {
GLfloat m[4][4];
float q[4] = {0};
axis_to_quat(axis, RAD(phi), q);
build_rotmatrix(m, q);
glMultMatrixf(&m[0][0]);
}
static void
display()
{
GLfloat mat[4][4];
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// camera & rotate
gluLookAt(view_org[0], view_org[1], view_org[2],
view_tgt[0], view_tgt[1], view_tgt[2],
0.0, 1.0, 0.0);
build_rotmatrix(mat, curr_quat);
glMultMatrixf(&mat[0][0]);
glBindTexture(GL_TEXTURE_2D, gTexIDs[curr_layer]);
draw_mesh();
//glBegin(GL_POLYGON);
// glTexCoord2f(0 , 0); glVertex2f(-0.9 , -0.9);
// glTexCoord2f(0 , 1); glVertex2f(-0.9 , 0.9);
// glTexCoord2f(1 , 1); glVertex2f(0.9 , 0.9);
// glTexCoord2f(1 , 0); glVertex2f(0.9 , -0.9);
//glEnd();
glutSwapBuffers();
}
void
gl_window_orient_window(GtkGLArea *glarea)
{
gl_window_info *info = gtk_object_get_data(GTK_OBJECT(glarea), "info");
GLfloat median;
float m[4][4];
if (gtk_gl_area_make_current(GTK_GL_AREA(glarea))){
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
if(info->orientation == ORIENTATION_3D ||
info->orientation == ORIENTATION_TEXTURE ){
glMatrixMode(GL_PROJECTION);
glFrustum( -0.0005 * info->aspect_ratio, 0.0005 * info->aspect_ratio,
-0.0005 , 0.0005,
0.001, 1000
);
}else{
if(info->x_median >= info->y_median)
median = info->x_median;
else
median = info->y_median;
glOrtho(-1 * info->x_median, info->x_median, // left, right
-1 * info->y_median, info->y_median, // bottom, top
median * -3, median * 3 // near, far
);
}
switch(info->orientation)
{
case ORIENTATION_FRONT: break;
case ORIENTATION_3D:
case ORIENTATION_TEXTURE:
glMatrixMode(GL_MODELVIEW);
glTranslatef(0,0,-1 * info->zoom);
build_rotmatrix(m, info->quat);
glMultMatrixf(&m[0][0]);
break;
case ORIENTATION_TOP: glRotatef(-90, 1,0,0); break;
case ORIENTATION_BOTTOM: glRotatef( 90, 1,0,0); break;
case ORIENTATION_LEFT: glRotatef(90, 0,1,0); break;
case ORIENTATION_RIGHT: glRotatef(-90, 0,1,0); break;
case ORIENTATION_BACK: glRotatef(180, 0,1,0); break;
default: break;
}
}/*if(gtk_gl_area_make_current(glarea))*/
}
/* Execute the rotations current encapsulated in the trackball_state:
this does something analagous to glRotatef().
*/
void
gltrackball_rotate (trackball_state *ts)
{
GLfloat m[4][4];
build_rotmatrix (m, ts->q);
glMultMatrixf (&m[0][0]);
}
void RenderScenePass()
{
// We can't simply call this to clear so we take another approach.
// This is done before this function is called.
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0, 0, -2.5);
glPushMatrix();
GLfloat m[4][4];
build_rotmatrix(m, _gCurQuat);
glMultMatrixf(&m[0][0]);
if (_gScalingFactor == 1.0) {
glDisable(GL_NORMALIZE);
} else {
glEnable(GL_NORMALIZE);
}
glScalef(_gScalingFactor, _gScalingFactor, _gScalingFactor);
_gNewModel = 0;
glColor3f(1.0f, 1.0f, 1.0f); DrawModel(_gModel);
glPopMatrix();
}
void transform()
{
float fnear = 0.01f;
float ffar = 10.0f;
float fov = 45;
float aspect = (float)windowWidth / (float)windowHeight;
glm::mat4 projMX, modelMX, viewMX;
glm::mat4 modelInvTranspMX;
projMX = glm::perspective(fov, aspect, fnear, ffar);
viewMX = glm::mat4(1.0f);
modelMX = glm::translate(glm::mat4(1.0f), glm::vec3(modelTranslation[0],
modelTranslation[1],
modelTranslation[2]));
modelInvTranspMX = glm::transpose(glm::inverse(modelMX));
glm::mat4 m;
build_rotmatrix(m, curquat);
modelMX = glm::mat4(modelMX*m);
glUniformMatrix4fv(glGetUniformLocation(program, "model_mat"),
1, GL_FALSE, glm::value_ptr(modelMX));
glUniformMatrix4fv(glGetUniformLocation(program, "view_mat"),
1, GL_FALSE, glm::value_ptr(viewMX));
glUniformMatrix4fv(glGetUniformLocation(program, "proj_mat"),
1, GL_FALSE, glm::value_ptr(projMX));
glUniformMatrix4fv(glGetUniformLocation(program, "model_it_mat"),
1, GL_FALSE, glm::value_ptr(modelInvTranspMX));
}
void glt_stream_server_t::build_trans_matrix() {
glLoadIdentity();
glTranslatef( xcam, ycam, zcam);
GLfloat m[4][4];
build_rotmatrix( m, quat );
glMultMatrixf( &m[0][0] );
}
void
tbMatrix(void)
{
GLfloat m[4][4];
assert(tb_button != -1);
build_rotmatrix(m, curquat);
glMultMatrixf(&m[0][0]);
}
static void Display( void )
{
GLfloat rot[4][4];
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glPushMatrix();
build_rotmatrix(rot, CurQuat);
glMultMatrixf(&rot[0][0]);
/* First pass: diffuse lighting with base texture */
glMaterialfv(GL_FRONT, GL_DIFFUSE, Diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, Black);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, BaseTexture);
glCallList(Object);
/* Second pass: specular lighting with reflection texture */
glEnable(GL_POLYGON_OFFSET_FILL);
glBlendFunc(GL_ONE, GL_ONE); /* add */
glEnable(GL_BLEND);
glMaterialfv(GL_FRONT, GL_DIFFUSE, Black);
glMaterialfv(GL_FRONT, GL_SPECULAR, White);
if (DoSpecTexture) {
glBindTexture(GL_TEXTURE_2D, SpecularTexture);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
}
else {
glDisable(GL_TEXTURE_2D);
}
glCallList(Object);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_BLEND);
glDisable(GL_POLYGON_OFFSET_FILL);
glPopMatrix();
glutSwapBuffers();
if (Animate) {
GLint t = glutGet(GLUT_ELAPSED_TIME);
Frames++;
if (t - T0 >= 5000) {
GLfloat seconds = (t - T0) / 1000.0;
GLfloat fps = Frames / seconds;
printf("%d frames in %g seconds = %g FPS\n", Frames, seconds, fps);
fflush(stdout);
T0 = t;
Frames = 0;
}
}
}
static gboolean
draw(GtkWidget *widget,
cairo_t *cr,
gpointer data)
{
GdkGLContext *glcontext = gtk_widget_get_gl_context(widget);
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(widget);
GLfloat m[4][4];
mesh_info *info = (mesh_info*)g_object_get_data(G_OBJECT(widget), "mesh_info");
/*** OpenGL BEGIN ***/
if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
goto NO_GL;
/* basic initialization */
if (info->do_init == TRUE) {
initgl();
info->do_init = FALSE;
}
/* view */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(info->zoom, VIEW_ASPECT, 1,100);
glMatrixMode(GL_MODELVIEW);
/* draw object */
glClearColor(.3,.4,.6,1);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0,0,-30);
add_quats(info->dquat, info->quat, info->quat);
build_rotmatrix(m,info->quat);
glMultMatrixf(&m[0][0]);
lw_object_show(info->lwobject);
/* swap backbuffer to front */
if (gdk_gl_drawable_is_double_buffered(gldrawable))
gdk_gl_drawable_swap_buffers(gldrawable);
else
glFlush();
gdk_gl_drawable_gl_end(gldrawable);
/*** OpenGL END ***/
NO_GL:
return TRUE;
}
void
recalcModelView(void)
{
GLfloat m[4][4]; /*the matrix*/
glPopMatrix();
glPushMatrix();
build_rotmatrix(m, curquat);
glMultMatrixf(&m[0][0]);
glScalef(glb_scalefactor, glb_scalefactor, glb_scalefactor);
glb_newmodel=0;
}
void resetModelView() {
GLfloat m[4][4];
glPopMatrix();
glPushMatrix();
build_rotmatrix(m, empty);
glMultMatrixf(&m[0][0]);
if (scalefactor == 1.0) {
glDisable(GL_NORMALIZE);
} else {
glEnable(GL_NORMALIZE);
}
glScalef(scalefactor, scalefactor, scalefactor);
}
void
recalcModelView(void)
{
GLfloat m[4][4];
glPopMatrix();
glPushMatrix();
build_rotmatrix(m, curquat);
glMultMatrixf(&m[0][0]);
glScalef(scalefactor, scalefactor, scalefactor);
glTranslatef(-8, -8, -bodyWidth / 2);
newModel = 0;
}
void
recalcModelView(void)
{
GLfloat m[4][4]; /*the matrix*/
/* The pop and push are useful */
glPopMatrix();
glPushMatrix();
build_rotmatrix(m, curquat);
glMultMatrixf(m[0]);
glScalef(glb_scalefactor, glb_scalefactor, glb_scalefactor);
glb_newModel=0;
}
// FUNCTION ====== camera
void camera (){
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho ( -zoom*ASPECT_RATIO, zoom*ASPECT_RATIO, -zoom, zoom, -VIEW_DEPTH, +VIEW_DEPTH );
//glRotatef( 45, 1, 2, 3);
glMatrixMode (GL_MODELVIEW);
float camMatrix[4][4];
build_rotmatrix (camMatrix, qCamera );
//printf( "qCamera: %f %f %f %f qCameraOld: %f %f %f %f mouse: %f %f \n", qCamera[0], qCamera[1], qCamera[2], qCamera[3], qCameraOld[0], qCameraOld[1], qCameraOld[2], qCameraOld[3], mouse_begin_x, mouse_begin_y );
//glTranslatef (shift.x, shift.y, 0);
//glMultMatrixf (&camMatrix[0][0]);
glLoadMatrixf(&camMatrix[0][0]);
}
void display(void)
{
GLfloat m[4][4];
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
build_rotmatrix(m, curquat);
glMultMatrixf(&m[0][0]);
draw_cube();
glPopMatrix();
glutSwapBuffers();
}
void camera(){
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho ( -zoom*ASPECT_RATIO, zoom*ASPECT_RATIO, -zoom, zoom, -VIEW_DEPTH, +VIEW_DEPTH );
glMatrixMode (GL_MODELVIEW);
float camMatrix[4][4];
build_rotmatrix (camMatrix, qCamera );
glLoadMatrixf(&camMatrix[0][0]);
/*
glMatrixMode (GL_MODELVIEW);
glLoadIdentity();
glTranslatef( -1.5f+(mouseX*0.005-0.5), 0.0f-(mouseY*0.005-0.5), -6.0f );
*/
}
void recalcModelView(void)
{
GLdouble m[4][4];
glPopMatrix();
glPushMatrix();
build_rotmatrix(m, curquat);
glMultMatrixd(&m[0][0]);
if(scalefactor == 1.0) {
glDisable(GL_NORMALIZE);
}
else {
glEnable(GL_NORMALIZE);
}
glScalef(scalefactor, scalefactor, scalefactor);
// glTranslatef(-8, -8, -bodyWidth / 2);
newModel = 0;
}
void TestGLCanvas::OnPaint( wxPaintEvent& WXUNUSED(event) )
{
/* must always be here */
wxPaintDC dc(this);
#ifndef __WXMOTIF__
if (!GetContext()) return;
#endif
SetCurrent();
// Initialize OpenGL
if (info.do_init)
{
InitGL();
info.do_init = false;
}
// View
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective( info.zoom, VIEW_ASPECT, 1.0, 100.0 );
glMatrixMode( GL_MODELVIEW );
// Clear
glClearColor( 0.3f, 0.4f, 0.6f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
// Transformations
GLfloat m[4][4];
glLoadIdentity();
glTranslatef( 0.0f, 0.0f, -30.0f );
build_rotmatrix( m,info.quat );
glMultMatrixf( &m[0][0] );
// Draw object
lw_object_show( info.lwobject );
// Flush
glFlush();
// Swap
SwapBuffers();
}
static gboolean
draw(GtkWidget *widget,
cairo_t *cr,
gpointer data)
{
GLfloat m[4][4];
mesh_info *info = (mesh_info*)g_object_get_data(G_OBJECT(widget), "mesh_info");
/*** OpenGL BEGIN ***/
if (!gtk_widget_begin_gl (widget))
goto NO_GL;
/* basic initialization */
if (info->do_init == TRUE) {
initgl();
info->do_init = FALSE;
}
/* view */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(info->zoom, VIEW_ASPECT, 1,100);
glMatrixMode(GL_MODELVIEW);
/* draw object */
glClearColor(.3,.4,.6,1);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0,0,-30);
add_quats(info->dquat, info->quat, info->quat);
build_rotmatrix(m,info->quat);
glMultMatrixf(&m[0][0]);
lw_object_show(info->lwobject);
gtk_widget_end_gl(widget, TRUE);
/*** OpenGL END ***/
NO_GL:
return TRUE;
}
void
drawAll(void)
{
int i, j;
int piece;
char done[PIECES + 1];
float m[4][4];
build_rotmatrix(m, curquat);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -10);
glMultMatrixf(&(m[0][0]));
glRotatef(180, 0, 0, 1);
if (depth) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
} else {
glClear(GL_COLOR_BUFFER_BIT);
}
for (i = 1; i <= PIECES; i++) {
done[i] = 0;
}
glLoadName(0);
drawContainer();
for (i = 0; i < HEIGHT; i++) {
for (j = 0; j < WIDTH; j++) {
piece = thePuzzle[i][j];
if (piece == 0)
continue;
if (done[piece])
continue;
done[piece] = 1;
glLoadName(piece);
if (piece == movingPiece) {
drawBox(piece, move_x, move_y);
} else {
drawBox(piece, j, i);
}
}
}
}
static void
Redisplay(void)
{
GLfloat rot[4][4];
GLfloat trans[16], mvp[16];
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
/* Build the modelview * projection matrix */
build_rotmatrix(rot, CurQuat);
mat_translate(trans, 0, 0, -10);
mat_multiply(mvp, trans, (GLfloat *) rot);
mat_multiply(mvp, Projection, mvp);
/* Set the MVP matrix */
glUniformMatrix4fv(uModelViewProj, 1, GL_FALSE, (float *) mvp);
/* Draw */
glDrawArrays(GL_TRIANGLES, 0, 3);
glutSwapBuffers();
}
/* Execute the rotations current encapsulated in the trackball_state:
this does something analagous to glRotatef().
*/
void
gltrackball_rotate (trackball_state *ts)
{
GLfloat m[4][4];
if (!ts->button_down_p &&
(ts->ddx != 0 ||
ts->ddy != 0))
{
/* Apply inertia: keep moving in the same direction as the last move. */
gltrackball_track_1 (ts,
ts->x + ts->dx,
ts->y + ts->dy,
ts->ow, ts->oh);
/* Dampen inertia: gradually stop spinning. */
gltrackball_dampen (&ts->dx, &ts->ddx);
gltrackball_dampen (&ts->dy, &ts->ddy);
}
build_rotmatrix (m, ts->q);
glMultMatrixf (&m[0][0]);
}
void rotate(int by, float axis[3][3], int phi) {
GLfloat m[4][4];
float q[4] = {0};
int i;
for (i=0; i<4; i++) {
q[i] = 0;
}
axis_to_quat(axis[by],RAD(phi), q);
build_rotmatrix(m, q);
for (i=0; i<3; i++) {
if (i != by) {
multiply(m, axis[i], axis[i]);
}
}
for (i=0; i<NV; i++) {
multiply(m, vertexes[i], vertexes[i]);
}
for (i=0; i<4; i++) {
multiply(m, originalVertex[i], originalVertex[i]);
}
}
/*
* The callback function when a redraw has been requested
*/
void DisplayFunc()
{
// Create the screen for both colour and depth values
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// The modelview matrix is pushed before drawing the scene
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
// Set up the trackball transformation
float rotmatrix[4][4];
build_rotmatrix(rotmatrix, quat);
glMultMatrixf(&rotmatrix[0][0]);
// Draw the scene from the display list
if (current_display == DISPLAY_TEAPOT)
glCallList(teapot_list);
else {
/*
*
* Draw your hierarchical tin robot model here
*
*/
glColor3f(0.0, 0.0, 1.0);
DrawBox(400, 400, 400);
}
glPopMatrix();
// Redraw the screen by swapping the buffer
glutSwapBuffers();
}
