draw_object.c

Go to the documentation of this file.

/*
** draw_object function for AR tracking sample code 
** uses glut functions to draw simple objects
**
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#if defined(_WIN32)
#include <windows.h>
#else
#include <strings.h>
#endif
#ifndef __APPLE__
#include <GL/gl.h>
#include <GL/glut.h>
#else
#include <OpenGL/gl.h>
#include <GLUT/glut.h>
#endif
#include <AR/gsub.h>
#include <AR/matrix.h>
#include "draw_object.h"



static void setup_light( void );
static void draw_camera( double trans[3][4] );
static int  draw_object( char *name, double gl_para[16], int xwin, int ywin );
static void get_trans( double a, double b, double r, double trans[3][4] );
static void draw_axis( void );


void print_string( char *string )
{
  int     i;

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  /* display the position data */
  glTranslatef(-0.95, -0.20, 0.0);

  /* draw a white polygon */
  glColor3f(1.0, 1.0, 1.0);
  glBegin(GL_POLYGON);
    glVertex2f(1.50, 0.10);
    glVertex2f(1.50, -0.12);
    glVertex2f(0.001, -0.12);
    glVertex2f(0.001, 0.10);
  glEnd();

  /* draw red text on the polygon */
  glColor3f(0.75, 0.0, 0.0);
  glRasterPos2i(0.0, 0.0);
  for (i=0; i<(int)strlen(string); i++) {
      if(string[i] != '\n' ) {
          glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, string[i]);
      }
      else {
          glTranslatef(0.0, -0.07, 0.0);
          glRasterPos2i(0.0, 0.0);
      }
  }

  return;
}

int draw_exview( double a, double b, double r, double trans[3][4], int xwin, int ywin )
{
    double      vtrans[3][4];
    double      gl_para[16];
    int         i, j;

    argDrawMode3D();
    argDraw3dCamera( xwin, ywin );
    glDepthFunc(GL_LEQUAL);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_NORMALIZE);

    get_trans( a, b, r, vtrans );
    argConvGlpara(vtrans, gl_para);
    glMatrixMode(GL_PROJECTION);
    glMultMatrixd( gl_para );

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    setup_light();

    glPushMatrix();
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
          
    for( j = -300; j <= 200; j+= 100 ) {
        for( i = -300; i <= 200; i+= 100 ) {
            glBegin(GL_QUADS);
            glNormal3f( 0.0, 0.0, 1.0 );
            if( (j/100+i/100)%2 ) glColor4f( 0.6, 0.6, 0.6, 1.0 );
             else                 glColor4f( 0.0, 0.3, 0.0, 1.0 );
            glVertex3f( i,     j,     0.0 );
            glVertex3f( i,     j+100, 0.0 );
            glVertex3f( i+100, j+100, 0.0 );
            glVertex3f( i+100, j,     0.0 );
            glEnd();
        }
    }
    draw_axis();

    glColor4f( 0.0, 0.0, 0.5, 1.0 );
    glTranslatef( 0.0, 0.0, 25.0 );
    glutSolidCube(50.0);

    glDisable( GL_LIGHTING );
    glPopMatrix();

    draw_camera( trans );

    glDisable(GL_NORMALIZE);
    glDisable( GL_DEPTH_TEST );
    argDrawMode2D();

    return 0;
}


static void draw_camera( double trans[3][4] )
{
/*
    double      gl_para[16];
*/
    double      btrans[3][4];
    double      quat[4], pos[3], angle;

    arUtilMatInv( trans, btrans );

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
      arUtilMat2QuatPos( btrans, quat, pos );
      angle = -acos(quat[3])*360.0/3.141592;
      glTranslatef( pos[0], pos[1], pos[2] );
      glRotated( angle, quat[0], quat[1], quat[2] );
/*
      argConvGlpara(btrans, gl_para);
      glMultMatrixd( gl_para );
*/

      glEnable(GL_LIGHTING);
      glEnable(GL_LIGHT0);

      glPushMatrix();
        glColor4f( 0.9, 0.9, 0.0, 1.0 );
        glTranslatef( 0.0, 0.0, -10.0 );
        glScalef( 10.0, 10.0, 20.0 );
        glutSolidCube(1.0);
      glPopMatrix();

      glColor4f( 0.9, 0.0, 0.9, 1.0 );
      glPushMatrix();
        glTranslatef( 0.0, 0.0, -40.0 );
        glScalef( 30.0, 30.0, 50.0 );
        glutSolidCube(1.0);
      glPopMatrix();

      glDisable( GL_LIGHTING );
    glPopMatrix();

    return;
}


int draw( char *name, double trans[4][4], int xwin, int ywin )
{
    double      gl_para[16];
    
    argConvGlpara(trans, gl_para);
    draw_object( name, gl_para, xwin, ywin );
    
    return(0);
}

/* draw the user object */
static int  draw_object( char *name, double gl_para[16], int xwin, int ywin )
{
    argDrawMode3D();
    argDraw3dCamera( xwin, ywin );

    glDepthFunc(GL_LEQUAL);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_NORMALIZE);
    /* load the camera transformation matrix */
    glMatrixMode(GL_PROJECTION);
    glMultMatrixd( gl_para );

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    setup_light();
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);

    if( strcmp(name, "target") == 0 ) {
        draw_axis();
    }
    else {
        printf("unknown object type!!\n");
    }

    glDisable( GL_LIGHTING );
    glDisable( GL_NORMALIZE );
    glDisable( GL_DEPTH_TEST );
    argDrawMode2D();

    return 0;
}

static void setup_light()
{
    static int  mat_f = 1;
    GLfloat     mat_amb_diff[]  = {0.9, 0.9, 0.0, 1.0};
    GLfloat     mat_specular[]  = {0.5, 0.5, 0.5, 1.0};
    GLfloat     mat_shininess[] = {10.0};
    GLfloat     light_ambient[] = { 0.01, 0.01, 0.01, 1.0 };
    GLfloat     light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat     light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat     light_position[] = { 100.0, 300.0, 700.0, 1.0 };

    if( mat_f ) {
      glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_amb_diff);
      glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
      glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);      
      glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
      glEnable(GL_COLOR_MATERIAL);
      mat_f = 0;
    }

    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
}

static void get_trans( double a, double b, double r, double trans[3][4] )
{
    ARMat   *mat;
    double  sa, ca, sb, cb;
    double  x, y, z;
    int     i, j;

    sa = sin(a*3.141592/180.0);
    ca = cos(a*3.141592/180.0);
    sb = sin(b*3.141592/180.0);
    cb = cos(b*3.141592/180.0);

    x = 0.0;
    y = -r * cb;
    z = -r * sb;

    mat = arMatrixAlloc( 4, 4 );

    mat->m[0*4+0] =  ca;
    mat->m[0*4+1] =  sa*sb;
    mat->m[0*4+2] =  sa*cb;
    mat->m[1*4+0] = -sa;
    mat->m[1*4+1] =  ca*sb;
    mat->m[1*4+2] =  ca*cb;
    mat->m[2*4+0] =  0;
    mat->m[2*4+1] = -cb;
    mat->m[2*4+2] =  sb;
    mat->m[0*4+3] =  x*ca + y*sa;
    mat->m[1*4+3] = -x*sa + y*ca;
    mat->m[2*4+3] = z;
    mat->m[3*4+0] = 0;
    mat->m[3*4+1] = 0;
    mat->m[3*4+2] = 0;
    mat->m[3*4+3] = 1;

    arMatrixSelfInv( mat );
    for( j = 0; j < 3; j++ ) {
        for( i = 0; i < 4; i++ ) {
            trans[j][i] = mat->m[j*4+i];
        }
    }
    arMatrixFree( mat );

    return;
}

static void draw_axis( void )
{
    glPushMatrix();
        glRotatef( 90.0, 0.0, 1.0, 0.0 );
        glColor4f( 1.0, 0.0, 0.0, 1.0 );
        glutSolidCone(5.0, 100.0, 20, 24);
    glPopMatrix();

    glPushMatrix();
        glRotatef( -90.0, 1.0, 0.0, 0.0 );
        glColor4f( 0.0, 1.0, 0.0, 1.0 );
        glutSolidCone(5.0, 100.0, 20, 24);
    glPopMatrix();

    glPushMatrix();
        glRotatef( 00.0, 0.0, 0.0, 1.0 );
        glColor4f( 0.0, 0.0, 1.0, 1.0 );
        glutSolidCone(5.0, 100.0, 20, 24);
    glPopMatrix();

    return;
}