gsub.c

tracciatore di mani con webcam

#include <stdio.h>
#include <stdlib.h>
#if defined(_WIN32)
#include <windows.h>
#include <string.h>
#endif
#ifndef __APPLE__
#include <GL/gl.h>
#else
#include <OpenGL/gl.h>
#endif
#include "sdlut.h"
#include <AR/config.h>
#include <AR/param.h>
#include <AR/ar.h>
#include "gsub.h"

#ifndef GL_ABGR
#define GL_ABGR GL_ABGR_EXT
#endif
#ifndef GL_BGRA
#define GL_BGRA GL_BGRA_EXT
#endif
#ifndef GL_BGR
#define GL_BGR GL_BGR_EXT
#endif
#ifndef GL_RGBA
#define GL_RGBA GL_RGBA_EXT
#endif
#ifndef GL_RGB
#define GL_RGB GL_RGB_EXT
#endif

#define   MINIWIN_MAX    8
#define   REVERSE_LR     1
#define   LEFTEYE        1
#define   RIGHTEYE       2
#define   GMINI          2

/*int  argDrawMode   = DEFAULT_DRAW_MODE;*/
int  argDrawMode   = AR_DRAW_BY_GL_DRAW_PIXELS;
int  argTexmapMode = DEFAULT_DRAW_TEXTURE_IMAGE;


static ARParam  gCparam;
static double   gl_cpara[16];
static double   gl_lpara[16];
static double   gl_rpara[16];
static int      gl_hmd_flag      = 0;
static int      gl_hmd_para_flag = 0;

static double   gZoom;
static int      gXsize, gYsize;
static int      gMiniXnum,  gMiniYnum;
static int      gMiniXsize, gMiniYsize;
static int      gWinXsize, gWinYsize;
static int      gImXsize, gImYsize;
/*static int      win;*/
static GLuint   glid[3];

static void (*gMouseFunc)(int button, int state, int x, int y);
static void (*gKeyFunc)(unsigned char key, int x, int y);
static void (*gMainFunc)(void);


/* static void argInit2( int fullFlag ); */
static void argInitLoop(void);
static void argInitStencil(void);
static void argSetStencil( int flag );
static void argConvGLcpara2( double cparam[3][4], int width, int height, double gnear, double gfar, double m[16] );


static int    tex1Xsize1 = 1;
static int    tex1Xsize2 = 1;
static int    tex1Ysize  = 1;
static int    tex2Xsize  = 1;
static int    tex2Ysize  = 1;
static void   argDispImageTex3( ARUint8 *image, int xwin, int ywin, int mode );
static void   argDispImageTex4( ARUint8 *image, int xwin, int ywin, int mode );
static void   argDispHalfImageTex( ARUint8 *image, int xwin, int ywin, int mode );
static void   argDispImageDrawPixels( ARUint8 *image, int xwin, int ywin );
static void   argDispHalfImageDrawPixels( ARUint8 *image, int xwin, int ywin );

void argInqSetting( int *hmdMode,
                    int *gMiniXnum2, int *gMiniYnum2,
                    void (**mouseFunc)(int button, int state, int x, int y),
                    void (**keyFunc)(unsigned char key, int x, int y),
                    void (**mainFunc)(void) )
{
    *hmdMode    = gl_hmd_flag;
    *gMiniXnum2 = gMiniXnum;
    *gMiniYnum2 = gMiniYnum;
    *mouseFunc = gMouseFunc;
    *keyFunc   = gKeyFunc;
    *mainFunc  = gMainFunc;
}

void argInit( ARParam *cparam, double zoom, /*int fullFlag,*/ int xwin, int ywin, int hmd_flag )
{
    int       i;

#ifdef __APPLE__
    {
        static int initF = 0;
        int        argc = 1;
        char      *argv[1] = {"ARToolKit for MacOSX"};
/*
        if( initF == 0 ) { glutInit(&argc, argv); initF = 1; }
*/
    }
#endif

    gl_hmd_flag = hmd_flag;
    gZoom  = zoom;
    gImXsize = cparam->xsize;
    gImYsize = cparam->ysize;
    if( gl_hmd_flag == 0 ) {
        gXsize = (double)cparam->xsize * gZoom;
        gYsize = (double)cparam->ysize * gZoom;
    }
    else {
        gXsize = AR_HMD_XSIZE;
        gYsize = AR_HMD_YSIZE;
    }
    gMiniXsize = (double)cparam->xsize * gZoom / GMINI;
    gMiniYsize = (double)cparam->ysize * gZoom / GMINI;

    if( xwin * ywin > MINIWIN_MAX ) {
        if( xwin > MINIWIN_MAX ) xwin = MINIWIN_MAX;
        ywin = MINIWIN_MAX / xwin;
    }
    gMiniXnum = xwin;
    gMiniYnum = ywin;
    gWinXsize = (gMiniXsize*gMiniXnum > gXsize)?
                     gMiniXsize*gMiniXnum: gXsize;
    gWinYsize = gYsize + gMiniYsize*gMiniYnum;

    gCparam = *cparam;
    for( i = 0; i < 4; i++ ) {
        gCparam.mat[1][i] = (gCparam.ysize-1)*(gCparam.mat[2][i]) - gCparam.mat[1][i];
    }
    argConvGLcpara( &gCparam, AR_GL_CLIP_NEAR, AR_GL_CLIP_FAR, gl_cpara );

/*    argInit2( fullFlag ); */
}

void argInitContext( int fullFlag, int fsaaFlag )
{
/*
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL);
    glutInitWindowPosition(0, 0);
    glutInitWindowSize(gWinXsize, gWinYsize);
    win = glutCreateWindow("");
    if( fullFlag ) {
        glutFullScreen();
        gWinXsize = glutGet(GLUT_SCREEN_WIDTH);
        gWinYsize = glutGet(GLUT_SCREEN_HEIGHT);
    }
*/
    sdlutInit();

    if( fsaaFlag )
      sdlutInitDisplayMode(SDLUT_DOUBLE | SDLUT_RGB | 
                           SDLUT_DEPTH | SDLUT_STENCIL | SDLUT_FSAA);
    else
      sdlutInitDisplayMode(SDLUT_DOUBLE | SDLUT_RGB | 
                           SDLUT_DEPTH | SDLUT_STENCIL);
    if( fullFlag ) {
      sdlutCreateWindow("", gWinXsize, gWinYsize, 24, SDLUT_FULLSCREEN);
    } 
    else {
      sdlutCreateWindow("", gWinXsize, gWinYsize, 24, 0);
    }


    gMouseFunc = NULL;
    gKeyFunc   = NULL;
    gMainFunc  = NULL;


    glGenTextures(3, glid);
    glBindTexture( GL_TEXTURE_2D, glid[0] );
    glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL );
    glBindTexture( GL_TEXTURE_2D, glid[1] );
    glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL );
    glBindTexture( GL_TEXTURE_2D, glid[2] );
    glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL );

    if( gImXsize > 512 ) {
        tex1Xsize1 = 512;
        tex1Xsize2 = 1;
        while( tex1Xsize2 < gImXsize - tex1Xsize1 ) tex1Xsize2 *= 2;
    }
    else {
        tex1Xsize1 = 1;
        while( tex1Xsize1 < gImXsize ) tex1Xsize1 *= 2;
    }
    tex1Ysize  = 1;
    while( tex1Ysize < gImYsize ) tex1Ysize *= 2;

    tex2Xsize = 1;
    while( tex2Xsize < gImXsize/2 ) tex2Xsize *= 2;
    tex2Ysize = 1;
    while( tex2Ysize < gImYsize/2 ) tex2Ysize *= 2;
}

void argCleanup( void )
{
/*
    glutDestroyWindow( win );
*/
    sdlutDestroyWindow();
}

void argSwapBuffers( void )
{
/*
    glutSwapBuffers();
*/
    sdlutSwapBuffers();
}

void argMainLoop( void (*mouseFunc)(int button, int state, int x, int y),
                  void (*keyFunc)(unsigned char key, int x, int y),
                  void (*mainFunc)(void) )
{
    gMouseFunc = mouseFunc;
    gKeyFunc   = keyFunc;
    gMainFunc  = mainFunc;

/*
    glutDisplayFunc( argInitLoop );
    glutMainLoop();
*/
    sdlutDisplayFunc( argInitLoop );
    sdlutMainLoop();
}

static void argInitLoop(void)
{
    arUtilSleep( 500 );

    argDrawMode2D();
    if( gl_hmd_flag ) {
        glClearColor( 0.0, 0.0, 0.0, 0.0 );
        glClear(GL_COLOR_BUFFER_BIT);
        argInitStencil();
        argSwapBuffers();
    }

    glClearColor( 0.0, 0.0, 0.0, 0.0 );
    glClear(GL_COLOR_BUFFER_BIT);
    argSwapBuffers();
    glClear(GL_COLOR_BUFFER_BIT);
    argSwapBuffers();

/*
    glutKeyboardFunc( gKeyFunc );
    glutMouseFunc( gMouseFunc );
    glutDisplayFunc( gMainFunc );
    glutIdleFunc( gMainFunc );
*/
    sdlutGlutKeyboardFunc( gKeyFunc );
    sdlutGlutMouseFunc( gMouseFunc );
    sdlutDisplayFunc( gMainFunc );
    sdlutIdleFunc( gMainFunc );
}

void argDrawMode2D( void )
{
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-0.5, gWinXsize-0.5, -0.5, gWinYsize-0.5, -1.0, 1.0);
    glViewport(0, 0, gWinXsize, gWinYsize);

    argSetStencil( 0 );
}

void argDraw2dLeft( void )
{
    if( gl_hmd_flag == 0 ) return;

    argSetStencil( LEFTEYE );
}

void argDraw2dRight( void )
{
    if( gl_hmd_flag == 0 ) return;

    argSetStencil( RIGHTEYE );
}

void argDrawMode3D( void )
{
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glScalef( 1, -1, -1 );
}

void argDraw3dLeft( void )
{
    if( gl_hmd_flag == 0 || gl_hmd_para_flag == 0 ) return;

    glViewport(0, gWinYsize-AR_HMD_YSIZE, AR_HMD_XSIZE, AR_HMD_YSIZE);
    argSetStencil( LEFTEYE );
    glMatrixMode(GL_PROJECTION);
    glLoadMatrixd( gl_lpara );
}

void argDraw3dRight( void )
{
    if( gl_hmd_flag == 0 || gl_hmd_para_flag == 0 ) return;

    glViewport(0, gWinYsize-AR_HMD_YSIZE, AR_HMD_XSIZE, AR_HMD_YSIZE);
    argSetStencil( RIGHTEYE );
    glMatrixMode(GL_PROJECTION);
    glLoadMatrixd( gl_rpara );
}


void argDraw3dCamera( int xwin, int ywin )
{
    if( xwin == 0 && ywin == 0 ) {
        glViewport(0, gWinYsize-(int)(gZoom*gImYsize),
                   (int)(gZoom*gImXsize), (int)(gZoom*gImYsize));
    }
    else {
        glViewport((xwin-1)*gMiniXsize, gWinYsize-gYsize-ywin*gMiniYsize,
					gMiniXsize, gMiniYsize);
    }

    argSetStencil( 0 );
    
    glMatrixMode(GL_PROJECTION);
    glLoadMatrixd( gl_cpara );
    glScalef( 1, -1, -1 );
}


void argMult3dCamera( int xwin, int ywin )
{
    if( xwin == 0 && ywin == 0 ) {
        glViewport(0, gWinYsize-(int)(gZoom*gImYsize),
                   (int)(gZoom*gImXsize), (int)(gZoom*gImYsize));
    }
    else {
        glViewport((xwin-1)*gMiniXsize, gWinYsize-gYsize-ywin*gMiniYsize,
					gMiniXsize, gMiniYsize);
    }

    argSetStencil( 0 );
    
    glMatrixMode(GL_PROJECTION);
    glMultMatrixd( gl_cpara );
    glScalef( 1, -1, -1 );
}


void argConvGlparad( double para[3][4], double gl_para[16] )
{
    int     i, j;

    for( j = 0; j < 3; j++ ) {
        for( i = 0; i < 4; i++ ) {
            gl_para[i*4+j] = para[j][i];
        }
    }
    gl_para[0*4+3] = gl_para[1*4+3] = gl_para[2*4+3] = 0.0;
    gl_para[3*4+3] = 1.0;
}


void argConvGlparaf( double para[3][4], float gl_para[16] )
{
    int     i, j;

    for( j = 0; j < 3; j++ ) {
        for( i = 0; i < 4; i++ ) {
            gl_para[i*4+j] = para[j][i];
        }
    }
    gl_para[0*4+3] = gl_para[1*4+3] = gl_para[2*4+3] = 0.0;
    gl_para[3*4+3] = 1.0;
}


void argDispImage( ARUint8 *image, int xwin, int ywin )
{
    if( argDrawMode == AR_DRAW_BY_GL_DRAW_PIXELS ) {
        argDispImageDrawPixels( image, xwin, ywin );
    }
    else {
        if( xwin == 0 && ywin == 0 ) {
            glScissor(0, gWinYsize-(int)(gZoom*gImYsize),
                      (int)(gZoom*gImXsize), (int)(gZoom*gImYsize));
        }
        else {
            glScissor((xwin-1)*gMiniXsize, gWinYsize-gYsize-ywin*gMiniYsize,
                       gMiniXsize, gMiniYsize);
        }
        glEnable( GL_SCISSOR_TEST );
        /* glDisable( GL_DEPTH_TEST ); */
        if( gImXsize > tex1Xsize1 )
            argDispImageTex3( image, xwin, ywin, 0 );
        else
            argDispImageTex4( image, xwin, ywin, 0 );
        glDisable( GL_SCISSOR_TEST );
    }
}

static void argDispImageDrawPixels( ARUint8 *image, int xwin, int ywin )
{
    int      sx, sy;
    GLfloat  zoom;

    if( xwin == 0 && ywin == 0 ) {