torus.cpp

Go to the documentation of this file.

#include <GL/glut.h>
#include <GL/glu.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <assert.h>

#include "config.h"
#include "Cg.h"
#include "texture.h"

#include "math.h"

// Cg Objects
// Per-Vertex
static CgVertexProgram _vp_pv;
static CgFragmentProgram _fp_pv;
// Per-Pixel
static CgVertexProgram _vp_pp;
static CgFragmentProgram _fp_pp;


/**********************************************
 **********************************************
   TORUS RENDERING CODE
 **********************************************
 *********************************************/

void setProgramMaterialColor( const float *mc )
{
  CgProgram *prog = NULL;
  if (g_bPerPixelLighting) {
    prog = &_fp_pp;
  }
  else {
    prog = &_vp_pv;
  }

  // Ambient material color
  float ambient[4];
  const float af = 0.3f;
  ambient[0] = mc[0] * af;
  ambient[1] = mc[1] * af;
  ambient[2] = mc[2] * af;
  ambient[3] = mc[3] * af;
  prog->setParameter( "AmbientColor", 4, ambient );


  // Diffuse material color
  float diffuse[4];
  const float df = 1.0 - af;
  diffuse[0] = mc[0] * df;
  diffuse[1] = mc[1] * df;
  diffuse[2] = mc[2] * df;
  diffuse[3] = mc[3] * df;
  prog->setParameter( "DiffuseColor", 4, diffuse );


  prog->setParameter( "SpecularExponent", 1, &g_specularExponent );
  if (g_bBlinnPhong) {
    // Specular color is white
    prog->setParameter( "SpecularColor", 4, colorWhite );
  }
  else {
    // Specular color is black, so specular term disabled
    prog->setParameter( "SpecularColor", 4, colorNone );
  }
}


void initTorus()
{
  // Load CG objects
  _vp_pv.setFilename( "vertex_program.cg" );
  _vp_pv.setup();

  _fp_pv.setFilename( "fragment_program.cg" );
  _fp_pv.setup();

  _vp_pp.setFilename( "vertex_program_pp.cg" );
  _vp_pp.setup();

  _fp_pp.setFilename( "fragment_program_pp.cg" );
  _fp_pp.setup();
  
}

extern void computeLightPosition(float *, float *);

void drawTorus( const float *eyePoint )
{
  CgVertexProgram *vp = NULL;
  CgFragmentProgram *fp = NULL;
  CgProgram *lightprog = NULL;
  if (g_bPerPixelLighting) {
    vp = &_vp_pp;
    fp = &_fp_pp;
    lightprog = &_fp_pp;
  }
  else {
    vp = &_vp_pv;
    fp = &_fp_pv;
    lightprog = &_vp_pv;
  }

float textureMatrix[16];
float modelViewProj[16];
float modelView[16];
float vector[4];
float bias[16];
float lightFrustum[16];
float lightView[16];
float tex[16];
float trbias[16];

bias[0] = .5; bias[1] = 0; bias[2] = 0; bias[3] = .5;
bias[4] = 0 ; bias[5] = .5; bias[6] = 0; bias[7] =.5;
bias[8] = 0 ; bias[9] = 0; bias[10] = .5; bias[11] = .5;
bias[12] = 0; bias[13] = 0; bias[14] = 0; bias[15] = 1;

//transposed bias

trbias[0] = .5; trbias[1] = 0; trbias[2] = 0; trbias[3] = 0;
trbias[4] = 0 ; trbias[5] = .5; trbias[6] = 0; trbias[7] = 0;
trbias[8] = 0 ; trbias[9] = 0; trbias[10] = .5; trbias[11] = 0;
trbias[12] = 0.5; trbias[13] = 0.5; trbias[14] = 0.5; trbias[15] = 1;


glGetFloatv(CG_GL_MODELVIEW_PROJECTION_MATRIX, modelViewProj);

glGetFloatv(GL_MODELVIEW_MATRIX, modelView);

vp->setParameter("bias", 16, (const float *) trbias );

//vp->setParameter("eye", 16, (const float *) ModelViewMatrix);

glBindTexture(GL_TEXTURE_2D, TEX_ROCK );

glMatrixMode(GL_TEXTURE);
glPushMatrix();
glLoadIdentity();
glMultMatrixf(trbias);
glFrustum(-1, 1, -1, 1, 1, 15);
gluLookAt(-3, 3, -3,  0,0,0,  0, 5,0);
//glTranslatef(-5, -5, -5);
//glRotatef(135, 0, 1, 0);
//glRotatef(135, 1, 0, 0);
//glRotatef(135, 0, 0, 1);
glMultMatrixf(ModelViewMatrix);
glGetFloatv(GL_TEXTURE_MATRIX, tex);
glPushMatrix();
vp->setParameter("TM", 16, (const float *) tex);
glPopMatrix();
glPopMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);

//vp->setParameter("lightFrustum", 16, (const float *) lightFrustum);
//vp->setParameter("lightView", 16, (const float *) lightView);

  // Set the current modelview-projection matrix to the vertex program
//  vp->setStateMatrixParameter( "Modelview", CG_GL_MODELVIEW_MATRIX );

//vp-> setParameter("Kd", 1, &Kd );

//lightprog -> setParameter("Kd", 1, &Kd);
//vp -> setStateMatrixParameter("modelViewProj", CG_GL_MODELVIEW_PROJECTION_MATRIX );


//vp -> setParameter("ModelViewProj", 16, modelViewProj );
  // Set normal transformation (inverse-transpose modelview)
//  vp->setStateMatrixParameter( "NormalTransform", CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE );


  // Set light direction
  float lightDir[3];
  lightDir[0] = g_lightPosEye[0];
  lightDir[1] = g_lightPosEye[1];
  lightDir[2] = g_lightPosEye[2];
  float l = sqrt( lightDir[0]*lightDir[0] + lightDir[1]*lightDir[1] + lightDir[2]*lightDir[2] ); 
  assert( l != 0 );
  lightDir[0] /= l;
  lightDir[1] /= l;
  lightDir[2] /= l;
//  lightprog->setParameter( "LightDir", 3, lightDir );
vp -> setParameter ("lightPosition", 3,  g_lightPos );

vp -> setStateMatrixParameter ("Projection", CG_GL_PROJECTION_MATRIX ); 



  // Set color state
  //setProgramMaterialColor( colorRed );

  // Set the texture to the fragment program
  fp->bindTexture( "Texture", texture( TEX_GRASS ));


  vp->setStateMatrixParameter( "ModelviewProjection", CG_GL_MODELVIEW_PROJECTION_MATRIX );
  vp->setStateMatrixParameter( "ModelviewProjectionIT", CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE );
  vp->setStateMatrixParameter( "Modelview", CG_GL_MODELVIEW_MATRIX );
  vp->setStateMatrixParameter( "ModelviewIT", CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE );

glEnable(GL_TEXTURE_2D);
//glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
//glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);

  // Render the torus
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glRotatef(g_fTorusX, 0, 1, 0);
glRotatef(g_fTorusY, 1, 0, 0);
glPushMatrix();
  // Enable vertex program
  vp->enable();
  // Enable fragment program
  fp->enable();
  
glPopMatrix();
glutSolidSphere(0.5f, 20, 20);

//  glutSolidTorus( 0.4f, 1.0f, 17,20 );
glPopMatrix();

//   

glPushMatrix();
    
    glBegin(GL_TRIANGLES);
        glVertex3d( -3, -3, 3);
        glVertex3d( -3, 0, 3);
        glVertex3d( 0, 0, 3);
        
        glVertex3d( 0, 0, 3);
        glVertex3d( 0, -3, 3);
        glVertex3d( -3, -3, 3);
        
        glVertex3d( -3, 0, 3);
        glVertex3d( -3, 3, 3);
        glVertex3d(  0, 3, 3);
        
        glVertex3d( 0, 3, 3);
        glVertex3d( 0, 0, 3);
        glVertex3d( -3, 0, 3);
        
        glVertex3d( 0, -3, 3);
        glVertex3d( 0, 0, 3);
        glVertex3d( 0, 3, 3);
        
        glVertex3d( 0,-3,3);
        glVertex3d( 0,0,3);
        glVertex3d( 3,0,3);
        
        glVertex3d( 3,0,3);
        glVertex3d( 3,-3,3);
        glVertex3d( 0,-3,3);
        
        glVertex3d( 0,0,3);
        glVertex3d( 0,3,3);
        glVertex3d( 3,3,3);
        
        glVertex3d( 3,3,3);
        glVertex3d( 3,0,3);
        glVertex3d( 0,0,3);
    glEnd();
glPopMatrix();

glPushMatrix();
    glBegin(GL_TRIANGLES);
        glVertex3d( -3, -3, -3);
        glVertex3d( -3, -3, 3);
        glVertex3d( 3, -3, 3);
        
        glVertex3d( 3,-3, 3);
        glVertex3d( 3,-3, -3);
        glVertex3d( -3,-3, -3);
    glEnd();
glPopMatrix();
glDisable(GL_TEXTURE_2D);
  // Restore state
  fp->disable();
  vp->disable();
}

---