root/trunk/orca/gl/dlist.c

/*============================================================================
    ORCA OpenGL Module
    Copyright (C) 2005-2006  Karl Robillard

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
===========================================================================*/


#include "gx.h"
#include "os.h"
#include "dlist.h"
#include "cbparse.h"


DrawListResource* createDrawList()
{
    DrawListResource* dr = memAlloc( sizeof(DrawListResource) );
    if( dr )
    {
        dr->res.resType = RES_TYPE_DRAWLIST;
        //dr->name        = 0;
        dr->prog        = 0;
        dr->argCtxHold  = OR_INVALID_HOLD;
        dr->glist       = 0;
        dr->glistCount  = 0;
    }
    return dr;
}


void clearDrawList( DrawListResource* dr )
{
    //if( dr->name )
    //    memFree( dr->name );

    if( dr->prog )
    {
        memFree( dr->prog );
        dr->prog = 0;
    }

    if( orHoldIsValid(dr->argCtxHold) )
    {
        orRelease( dr->argCtxHold );
        dr->argCtxHold = OR_INVALID_HOLD;
    }

    if( dr->glistCount )
    {
        glDeleteLists( dr->glist, dr->glistCount );
        dr->glistCount = 0;
    }
}


void destroyDrawList( Resource* res )
{
    if( res )
    {
        clearDrawList( (DrawListResource*) res );
        memFree( res );
    }
}


//----------------------------------------------------------------------------


#define DLP_CALL_INT         0
#define DLP_CALL_BLOCK       1
#define DLP_PUSH_MATRIX      2
#define DLP_PUSH             3
#define DLP_POP              4
#define DLP_TRANSLATE        5
#define DLP_ROTATE           6
#define DLP_SCALE            7
#define DLP_COLOR_TUPLE      8
#define DLP_PEN_PAIR         9
#define DLP_PEN_CURRENT     10
#define DLP_FONT            11
#define DLP_TEXT_STR        12
#define DLP_TEXT_VAL        13
#define DLP_VERTS           14
#define DLP_NORMALS         15
#define DLP_COLORS          16
#define DLP_UVS             17
#define DLP_QUADS           18
#define DLP_TRIS            19
#define DLP_STRIP           20
#define DLP_FAN             21
#define DLP_POINTS          22
#define DLP_LINES           23
#define DLP_POINT_SIZE      24
#define DLP_TEXTURE         25
#define DLP_LIGHT_ON        26
#define DLP_LIGHT_OFF       27
#define DLP_LIGHT_VEC3      28


static GLfloat _dlFloat( OValue* val )
{
    if( val->type == OT_DECIMAL )
        return (GLfloat) orDecimal(val);
    else if( val->type == OT_INTEGER )
        return (GLfloat) orInt(val);
    return 0.0f;
}


static RenderWord* _dlAddVec3( OArray* rarr, OValue* val )
{
    RenderWord* pc = ((RenderWord*) rarr->buf) + rarr->used;

    if( val->type == OT_VEC3 )
    {
        pc[0].f = val->vec3.x;
        pc[1].f = val->vec3.y;
        pc[2].f = val->vec3.z;
    }
    else if( val->type == OT_DECIMAL )
    {
        GLfloat f = (GLfloat) orDecimal(val);
        pc[0].f = pc[1].f = pc[2].f = f;
    }
    else if( val->type == OT_INTEGER )
    {
        GLfloat f = (GLfloat) orInt(val);
        pc[0].f = pc[1].f = pc[2].f = f;
    }

    // RP_INC * 3
    rarr->used += 3;
    return pc + 3;
}


#define PRIM_KEY_END        0
#define PRIM_KEY_VERTEX     1
#define PRIM_KEY_NORMAL     2
#define PRIM_KEY_COLOR      3
#define PRIM_KEY_UV0        4
#define PRIM_KEY_UV1        5
#define PRIM_KEY_IGNORE     6


/*
   Returns zero if atom is bad.
*/
uint32_t mapPrimKey( const OAtom atom )
{
    uint32_t key = 0;
    const char* cp = orAtomCString( atom );
    const char* end;

    end = cp;
    while( *end )
        ++end;

    if( (end - cp) > 5 )
        return 0;

    // NOTE: Using '1' may be a problem since words cannot start with a digit.

    while( cp != end )
    {
        --end;
        switch( *end )
        {
            case 'v': key |= PRIM_KEY_VERTEX; key <<= 4; break;
            case 'n': key |= PRIM_KEY_NORMAL; key <<= 4; break;
            case 'c': key |= PRIM_KEY_COLOR;  key <<= 4; break;
            case 't': key |= PRIM_KEY_UV0;    key <<= 4; break;
            case '1': key |= PRIM_KEY_UV1;    key <<= 4; break;
            case '-': key |= PRIM_KEY_IGNORE; key <<= 4; break;
            default: return 0;
        }
    }

    return key >> 4;
}


/*
   Returns zero if successful or OValue where error occured.
*/
OValue* compileProg( OValue* it, OValue* end, OArray* prog )
{
    CBParser cbp;
    OValue* val;
    OValue* match;
    RenderWord* pc;


#define RP_INC \
    ++pc; \
    ++prog->used

#if defined(__BIG_ENDIAN__)
#define RP_ADD(op) \
    pc->list = op << 24; \
    RP_INC
#else
#define RP_ADD(op) \
    pc->list = op; \
    RP_INC
#endif

#define RP_ADD_ARG(oa,ra,aa) \
    pc->ins.op  = oa; \
    pc->ins.ref = ra; \
    pc->ins.arg = aa; \
    RP_INC

#define RP_ADD_FLOAT(val) \
    pc->f = _dlFloat(val); \
    RP_INC

#define RP_ADD_VEC3(val)    pc = _dlAddVec3(prog,val)


    cbp_beginParse( &cbp, it, end, orBLOCKS + gEnv.drawListDialectBlkN );
    while( (match = cbp_matchRule( &cbp )) )
    {
        // Reserve enough space for largest instruction + ROP_END.
        orArrayReserve( prog, sizeof(RenderWord), prog->used + 6 );
        pc = ((RenderWord*) prog->buf) + prog->used;

        switch( orInt(match) )
        {
            case DLP_CALL_INT:
                RP_ADD( ROP_GL_CALL );
                pc->list = cbp.values[1].integer;
                RP_INC;
                break;

            case DLP_CALL_BLOCK:
                RP_ADD( ROP_GL_CALL );
                //val = cbp.values + 1;
                pc->list = 0; //compileList( orBLOCK(val), 0 );
                RP_INC;
                break;

            case DLP_PUSH_MATRIX:
                // TODO: Hold matrix string.
                RP_ADD( ROP_GL_MULT_MATRIX );
                pc->list = cbp.values[1].index;
                RP_INC;
                break;

            case DLP_PUSH:
                RP_ADD( ROP_GL_PUSH );
                break;

            case DLP_POP:
                RP_ADD( ROP_GL_POP );
                break;

            case DLP_TRANSLATE:
                RP_ADD( ROP_GL_TRANSLATE );
                RP_ADD_VEC3( cbp.values + 1 );
                break;

            case DLP_ROTATE:
                RP_ADD( ROP_GL_ROTATE );
                RP_ADD_FLOAT( cbp.values + 1 );
                RP_ADD_VEC3( cbp.values + 2 );
                break;

            case DLP_SCALE:
                RP_ADD( ROP_GL_SCALE );
                RP_ADD_VEC3( cbp.values + 1 );
                break;

            case DLP_COLOR_TUPLE:
                val = cbp.values;
                if( val->argc > 3 )
                {
                    RP_ADD( ROP_GL_COLOR4 );
                    pc->color.a = val->tuple[3];
                }
                else
                {
                    RP_ADD( ROP_GL_COLOR3 );
                    pc->color.a = 0;
                }
                pc->color.r = val->tuple[0];
                pc->color.g = val->tuple[1];
                pc->color.b = val->tuple[2];
                RP_INC;
                /*
                printf( "KR color %d.%d.%d\n",
                        (int) val->tuple[0],
                        (int) val->tuple[1],
                        (int) val->tuple[2] );
                */
                break;

            case DLP_PEN_PAIR:
                RP_ADD( ROP_PEN );
                val = cbp.values + 1;
                pc->f = (GLfloat) val->pair[0];
                RP_INC;
                pc->f = (GLfloat) val->pair[1];
                RP_INC;
                break;

            case DLP_PEN_CURRENT:
                RP_ADD( ROP_PEN );
                pc->f = gEnv.state.penX;
                RP_INC;
                pc->f = gEnv.state.penY;
                RP_INC;
                break;

            case DLP_FONT:
                RP_ADD( ROP_FONT );
                val = cbp.values + 1;
                pc->list = gxHashString( val );
                RP_INC;
                break;

            case DLP_TEXT_STR:
                // TODO: Hold string.
                RP_ADD_ARG( ROP_TEXT, 0, cbp.values[1].series.it );
                pc->list = cbp.values[1].index;
                RP_INC;
                break;

            case DLP_TEXT_VAL:
                // TODO: Hold context.
                RP_ADD_ARG( ROP_TEXT_VAL, 0, cbp.values[1].word.index );
                pc->list = cbp.values[1].word.context;
                RP_INC;
                break;

            case DLP_VERTS:
                // TODO: Hold block.
                RP_ADD_ARG( ROP_VERTS, 0, cbp.values[1].series.it );
                pc->list = cbp.values[1].index;
                RP_INC;
                break;

            case DLP_NORMALS:
                // TODO: Hold block.
                RP_ADD_ARG( ROP_NORMALS, 0, cbp.values[1].series.it );
                pc->list = cbp.values[1].index;
                RP_INC;
                break;

            case DLP_COLORS:
                // TODO: Hold block.
                RP_ADD_ARG( ROP_COLORS, 0, cbp.values[1].series.it );
                pc->list = cbp.values[1].index;
                RP_INC;
                break;

            case DLP_UVS:
                // TODO: Hold block.
                RP_ADD_ARG( ROP_UVS, 0, cbp.values[1].series.it );
                pc->list = cbp.values[1].index;
                RP_INC;
                break;

            case DLP_QUADS:
                // TODO: Hold block.
                RP_ADD_ARG( ROP_QUADS, 0, cbp.values[2].series.it );
                pc->list = cbp.values[2].index;
                RP_INC;
                pc->list = mapPrimKey( cbp.values[1].word.atom );
                RP_INC;
                break;

            case DLP_TRIS:
                // TODO: Hold block.
                RP_ADD_ARG( ROP_TRIS, 0, cbp.values[2].series.it );
                pc->list = cbp.values[2].index;
                RP_INC;
                pc->list = mapPrimKey( cbp.values[1].word.atom );
                RP_INC;
                break;

            case DLP_STRIP:
                // TODO: Hold block.
                RP_ADD_ARG( ROP_TRISTRIP, 0, cbp.values[2].series.it );
                pc->list = cbp.values[2].index;
                RP_INC;
                pc->list = mapPrimKey( cbp.values[1].word.atom );
                RP_INC;
                break;

            case DLP_FAN:
                // TODO: Hold block.
                RP_ADD_ARG( ROP_TRIFAN, 0, cbp.values[2].series.it );
                pc->list = cbp.values[2].index;
                RP_INC;
                pc->list = mapPrimKey( cbp.values[1].word.atom );
                RP_INC;
                break;

            case DLP_POINTS:
                // TODO: Hold block.
                RP_ADD_ARG( ROP_POINTS, 0, cbp.values[2].series.it );
                pc->list = cbp.values[2].index;
                RP_INC;
                pc->list = mapPrimKey( cbp.values[1].word.atom );
                RP_INC;
                break;

            case DLP_LINES:
                // TODO: Hold block.
                RP_ADD_ARG( ROP_LINES, 0, cbp.values[2].series.it );
                pc->list = cbp.values[2].index;
                RP_INC;
                pc->list = mapPrimKey( cbp.values[1].word.atom );
                RP_INC;
                break;

            case DLP_POINT_SIZE:
                RP_ADD( ROP_POINT_SIZE );
                RP_ADD_FLOAT( cbp.values + 1 );
                break;

            case DLP_TEXTURE:
                RP_ADD_ARG( ROP_TEXTURE, cbp.values[1].integer, 0 );
                pc->list = gxLoadTexture( cbp.values + 2 );
                RP_INC;
                break;

            case DLP_LIGHT_ON:     
                RP_ADD_ARG( ROP_LIGHT_ENABLE, cbp.values[1].integer, 1 );
                break;

            case DLP_LIGHT_OFF:
                RP_ADD_ARG( ROP_LIGHT_ENABLE, cbp.values[1].integer, 0 );
                break;

            case DLP_LIGHT_VEC3:    
                RP_ADD_ARG( ROP_LIGHT_POS, cbp.values[1].integer, 0 );
                RP_ADD_VEC3( cbp.values + 2 );
                pc->f = 0.0f;
                RP_INC;
                break;
        }
    }

    if( ! cbp.error )
    {
        RP_ADD( ROP_END );
    }

    return cbp.error;
}


#if 0
static OValue* compileList( OBlock* blk, GLuint list )
{
    OValue* err;
    OArray prog;
    orArrayInit( &prog, sizeof(RenderWord), blk->used );

    err = compileProg( blk, &prog );
    if( ! err )
    {
        //list = glGenLists( 1 );
        glNewList( list, GL_COMPILE );
        gxRunRenderProgram( (RenderWord*) prog.buf );
        glEndList();
    }

    orArrayFree( &prog );
    return err;
}
#endif


/*
   Compile render program.
*/
OR_NATIVE_PUB( renderProgramNative )
{
    OValue* error;
    DrawListResource* res;
    OArray prog;
    OBlock* blk;
    OValue* a2 = a1 + 1;


    {
    uint32_t key;
    if( a1->type == OT_RESOURCE )
    {
        if( gxResType(a1) != RES_TYPE_DRAWLIST )
        {
            orError("render-prog passed bad resource type (%d)", gxResType(a1));
            return;
        }
        key = orInt(a1);
    }
    else
    {
        key = gxHashString(a1);
    }

    res = gxDList( key );
    if( res )
    {
        clearDrawList( res );
    }
    else
    {
        res = createDrawList();
        resd_add( &gEnv.resd, &res->res, key );
    }
    }


    blk = orBLOCK(a2);
    orArrayInit( &prog, sizeof(RenderWord), orSeriesLen(blk,a2) );

    error = compileProg( blk->values + a2->series.it,
                         blk->values + blk->used, &prog );
    if( error )
    {
        orArrayFree( &prog );

        orError( "render-prog invalid" );
        orSetErrorLoc( a2->index, error - blk->values );
        return;
    }

    res->prog = (RenderWord*) prog.buf;
    gxResultRES( res )
}


//----------------------------------------------------------------------------


extern void getVector( int count, OValue* val, GLdouble* vec );

static void makePrims( OValue* idx, OValue* end, uint32_t primKey )
{
    GLdouble vec[3];
    uint32_t itype;
    int vindex;

    if( ! primKey )
        return;

    itype = primKey;

    while( idx != end )
    {
        // Silently skip non-integers.
        // This allows us to mix other data with the indices.

        if( idx->type == OT_INTEGER )
        {
            switch( itype & 0x0f )
            {
                case PRIM_KEY_VERTEX:
                    vindex = orInt(idx) * 3;
                    getVector( 3, gEnv.state.vertVals + vindex, vec );
                    glVertex3dv( vec );
                    //printf( "KR vert %g %g %g\n", vec[0], vec[1], vec[2] );
                    break;

                case PRIM_KEY_NORMAL:
                    vindex = orInt(idx) * 3;
                    getVector( 3, gEnv.state.normVals + vindex, vec );
                    glNormal3dv( vec );
                    //printf( "KR norm %g %g %g\n", vec[0], vec[1], vec[2] );
                    break;

                case PRIM_KEY_COLOR:
                {
                    OValue* cval = gEnv.state.colorVals + orInt(idx);
                    if( orIs(cval, OT_TUPLE) )
                    {
                        if( cval->argc > 3 )
                            glColor4ubv( cval->tuple );
                        else
                            glColor3ubv( cval->tuple );
                    }
                }
                    break;

                case PRIM_KEY_UV0:
                    vindex = orInt(idx) * 2;
                    getVector( 2, gEnv.state.uvVals + vindex, vec );
                    //printf( "KR UV0 %g %g\n", vec[0], vec[1] );
                    glTexCoord2dv( vec );
                    //gleMultiTexCoord2dARB( GL_TEXTURE0_ARB, vec[0], vec[1] );
                    break;

                case PRIM_KEY_UV1:
                    break;

                case PRIM_KEY_IGNORE:
                    break;
            }

            itype >>= 4;
            if( itype == PRIM_KEY_END )
                itype = primKey;
        }

        ++idx;
    }
}


static GLenum _beginMode[4] =
{
    GL_QUADS, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN
};


static void makePoints( OValue* idx, OValue* end, uint32_t primKey )
{
    glDisable( GL_LIGHTING );
    glEnable( GL_POINT_SMOOTH );
    glEnable( GL_BLEND );
    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );

    glBegin( GL_POINTS );
    makePrims( idx, end, primKey );
    glEnd();
}


#if 0
static GLfloat* color3f( GLubyte* rgb )
{
    static GLfloat color[3];

    color[0] = ((GLfloat) *rgb++) / 255.0f;
    color[1] = ((GLfloat) *rgb++) / 255.0f;
    color[2] = ((GLfloat) *rgb  ) / 255.0f;

    printf( "KR col3 %g %g %g\n", color[0], color[1], color[2] );
    return color;
}
#endif


void gxRunRenderProgram( RenderWord* pc )
{
    while( 1 )
    {
        switch( pc->ins.op )
        {
            case ROP_NOP:
                break;

            case ROP_GL_PUSH:
                glPushMatrix();
                break;

            case ROP_GL_POP:
                glPopMatrix();
                break;

            case ROP_GL_MULT_MATRIX:
            {
                OString* bin;
                ++pc;
                bin = orSTRINGS + pc->list;
                glPushMatrix();
                glMultMatrixf( bin->floats );
            }
                break;

            case ROP_GL_LOAD_MATRIX:
                glPushMatrix();
                //glLoadMatrix();
                break;

            case ROP_GL_CALL:
                ++pc;
                glCallList( pc->list );
                break;

            case ROP_GL_TRANSLATE:
                glTranslatef( pc[1].f, pc[2].f, pc[3].f );
                pc += 3;
                break;

            case ROP_GL_ROTATE:
                glRotatef( pc[1].f, pc[2].f, pc[3].f, pc[4].f );
                pc += 4;
                break;

            case ROP_GL_SCALE:
                glScalef( pc[1].f, pc[2].f, pc[3].f );
                pc += 3;
                break;

            case ROP_GL_COLOR3:
                ++pc;
                /*
                if( gEnv.state.stateId == GRS_MODEL )
                    glMaterialfv(GL_FRONT, GL_DIFFUSE, color3f((GLubyte*)pc));
                else
                */
                glColor3ubv( (GLubyte*) pc );
                break;

            case ROP_GL_COLOR4:
                ++pc;
                glColor4ubv( (GLubyte*) pc );
                break;

            case ROP_LOD:
                break;

            case ROP_PEN:
                gxSetPen( pc[1].f, pc[2].f );
                pc += 2;
                break;

            case ROP_FONT:
                ++pc;
                gEnv.state.fontKey = pc->list;
                break;

            case ROP_TEXT:
            {
                OString* str = orSTRINGS + pc[1].list;
                FontResource* fnt = gxFont( gEnv.state.fontKey );
                if( fnt )
                {
                    gxDrawText( fnt, str->charArray + pc->ins.arg,
                                     str->charArray + str->used );
                }
                ++pc;
            }
                break;

            case ROP_TEXT_VAL:
            {
                OBlock* ctx = orBlockPtr( pc[1].list );
                FontResource* fnt = gxFont( gEnv.state.fontKey );
                if( fnt )
                {
                    gxDrawTextValue( fnt, ctx->values + pc->ins.arg );
                }
                ++pc;
            }
                break;

            case ROP_SHADER:
                break;

            case ROP_VERTS:
            {
                OBlock* blk = orBLOCKS + pc[1].list;
                gEnv.state.vertVals = blk->values + pc->ins.arg;
                ++pc;
            }
                break;

            case ROP_NORMALS:
            {
                OBlock* blk = orBLOCKS + pc[1].list;
                gEnv.state.normVals = blk->values + pc->ins.arg;
                ++pc;
            }
                break;

            case ROP_COLORS:
            {
                OBlock* blk = orBLOCKS + pc[1].list;
                gEnv.state.colorVals = blk->values + pc->ins.arg;
                ++pc;
            }
                break;

            case ROP_UVS:
            {
                OBlock* blk = orBLOCKS + pc[1].list;
                gEnv.state.uvVals = blk->values + pc->ins.arg;
                ++pc;
            }
                break;

            case ROP_QUADS:
            case ROP_TRIS:
            case ROP_TRISTRIP:
            case ROP_TRIFAN:
            {
                OBlock* blk = orBLOCKS + pc[1].list;
                glBegin( _beginMode[ pc->ins.op - ROP_QUADS ] );
                makePrims( blk->values + pc->ins.arg,
                           blk->values + blk->used,
                           pc[2].list );
                glEnd();
                pc += 2;
            }
                break;

            case ROP_POINTS:
            {
                OBlock* blk = orBLOCKS + pc[1].list;
                makePoints( blk->values + pc->ins.arg,
                            blk->values + blk->used,
                            pc[2].list );
                pc += 2;
            }
                break;

            case ROP_LINES:
                break;

            case ROP_POINT_SIZE:
                ++pc;
                glPointSize( pc->f );
                break;

            case ROP_TEXTURE:
                //gleActiveTextureARB( GL_TEXTURE0_ARB + pc->ins.ref );
                ++pc;
                glEnable( GL_TEXTURE_2D );
                glBindTexture( GL_TEXTURE_2D, pc->list );
                break;

            case ROP_LIGHT_ENABLE:
                if( pc->ins.arg )
                    glEnable( GL_LIGHT0 + pc->ins.ref );
                else
                    glDisable( GL_LIGHT0 + pc->ins.ref );
                break;

            case ROP_LIGHT_POS:
                //printf( "KR light pos %g %g %g\n", pc[1].f,pc[2].f,pc[3].f );
                glLightfv( GL_LIGHT0 + pc->ins.ref, GL_POSITION, &pc[1].f );
                pc += 4;
                break;

            case ROP_END:
                return;

            default:
                dprint( "Unknown Opcode %d\n", pc->ins.op );
                return;
        }
        ++pc;
    }
}


//EOF