source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/dlm/dlm_bbox.c@ 56473

/* $Id: dlm_bbox.c 54905 2015-03-23 11:20:58Z vboxsync $ */
/**
 * Code to compute the bounding box of a DLM display list.
 * Matrix commands in the display list are observed to properly
 * transform the vertices we find.
 */

#include <float.h>
#include "cr_dlm.h"
#include "cr_mem.h"
#include "cr_spu.h"
#include "cr_glstate.h"
#include "dlm.h"


static CRMatrixStack ModelViewStack;
static CRMatrixStack DummyStack;
static CRMatrixStack *CurrentStack;


static GLfloat Xmin, Xmax, Ymin, Ymax, Zmin, Zmax;


static void
MatrixMode(GLenum matrix)
{
        switch (matrix) {
        case GL_MODELVIEW:
                CurrentStack = &ModelViewStack;
                break;
        default:
                CurrentStack = &DummyStack;
        }
}


static void
LoadMatrixf(const GLfloat m[16])
{
        crMatrixInitFromFloats(CurrentStack->top, m);
}


static void
LoadMatrixd(const GLdouble m[16])
{
        crMatrixInitFromDoubles(CurrentStack->top, m);
}


static void
LoadIdentity(void)
{
        crMatrixInit(CurrentStack->top);
}


static void
PushMatrix(void)
{
        if (CurrentStack->depth < CurrentStack->maxDepth) {
                /* copy matrix */
                *(CurrentStack->top + 1) = *(CurrentStack->top);
                /* Move the stack pointer */
                CurrentStack->depth++;
                CurrentStack->top = CurrentStack->stack + CurrentStack->depth;
        }
        else {
                crWarning("Stack overflow in dlm_bbox.c");
        }
}


static void
PopMatrix(void)
{
        if (CurrentStack->depth > 0) {
                CurrentStack->depth--;
                CurrentStack->top = CurrentStack->stack + CurrentStack->depth;
        }
        else {
                crWarning("Stack underflow in dlm_bbox.c");
        }
}


static void
MultMatrixf(const GLfloat m1[16])
{
        CRmatrix *m = CurrentStack->top;
        const GLdefault lm00 = m->m00;  
        const GLdefault lm01 = m->m01;  
        const GLdefault lm02 = m->m02;  
        const GLdefault lm03 = m->m03;  
        const GLdefault lm10 = m->m10;  
        const GLdefault lm11 = m->m11;  
        const GLdefault lm12 = m->m12;  
        const GLdefault lm13 = m->m13;  
        const GLdefault lm20 = m->m20;  
        const GLdefault lm21 = m->m21;  
        const GLdefault lm22 = m->m22;  
        const GLdefault lm23 = m->m23;  
        const GLdefault lm30 = m->m30;  
        const GLdefault lm31 = m->m31;  
        const GLdefault lm32 = m->m32;          
        const GLdefault lm33 = m->m33;          
        const GLdefault rm00 = (GLdefault) m1[0];       
        const GLdefault rm01 = (GLdefault) m1[1];       
        const GLdefault rm02 = (GLdefault) m1[2];       
        const GLdefault rm03 = (GLdefault) m1[3];       
        const GLdefault rm10 = (GLdefault) m1[4];       
        const GLdefault rm11 = (GLdefault) m1[5];               
        const GLdefault rm12 = (GLdefault) m1[6];       
        const GLdefault rm13 = (GLdefault) m1[7];       
        const GLdefault rm20 = (GLdefault) m1[8];       
        const GLdefault rm21 = (GLdefault) m1[9];       
        const GLdefault rm22 = (GLdefault) m1[10];      
        const GLdefault rm23 = (GLdefault) m1[11];      
        const GLdefault rm30 = (GLdefault) m1[12];      
        const GLdefault rm31 = (GLdefault) m1[13];      
        const GLdefault rm32 = (GLdefault) m1[14];      
        const GLdefault rm33 = (GLdefault) m1[15];      

        m->m00 = lm00*rm00 + lm10*rm01 + lm20*rm02 + lm30*rm03; 
        m->m01 = lm01*rm00 + lm11*rm01 + lm21*rm02 + lm31*rm03; 
        m->m02 = lm02*rm00 + lm12*rm01 + lm22*rm02 + lm32*rm03; 
        m->m03 = lm03*rm00 + lm13*rm01 + lm23*rm02 + lm33*rm03; 
        m->m10 = lm00*rm10 + lm10*rm11 + lm20*rm12 + lm30*rm13; 
        m->m11 = lm01*rm10 + lm11*rm11 + lm21*rm12 + lm31*rm13; 
        m->m12 = lm02*rm10 + lm12*rm11 + lm22*rm12 + lm32*rm13; 
        m->m13 = lm03*rm10 + lm13*rm11 + lm23*rm12 + lm33*rm13; 
        m->m20 = lm00*rm20 + lm10*rm21 + lm20*rm22 + lm30*rm23; 
        m->m21 = lm01*rm20 + lm11*rm21 + lm21*rm22 + lm31*rm23; 
        m->m22 = lm02*rm20 + lm12*rm21 + lm22*rm22 + lm32*rm23; 
        m->m23 = lm03*rm20 + lm13*rm21 + lm23*rm22 + lm33*rm23; 
        m->m30 = lm00*rm30 + lm10*rm31 + lm20*rm32 + lm30*rm33; 
        m->m31 = lm01*rm30 + lm11*rm31 + lm21*rm32 + lm31*rm33; 
        m->m32 = lm02*rm30 + lm12*rm31 + lm22*rm32 + lm32*rm33; 
        m->m33 = lm03*rm30 + lm13*rm31 + lm23*rm32 + lm33*rm33;
}


static void
MultMatrixd(const GLdouble m1[16])
{
        GLfloat m2[16];
        int i;
        for (i = 0; i < 16; i++)
                m2[i] = (GLfloat) m1[i];
        MultMatrixf(m2);
}


static void
Rotatef(GLfloat ang, GLfloat x, GLfloat y, GLfloat z) 
{
        crMatrixRotate(CurrentStack->top, ang, x, y, z);
}


static void
Rotated(GLdouble ang, GLdouble x, GLdouble y, GLdouble z) 
{
        crMatrixRotate(CurrentStack->top, (GLfloat) ang,
                                                                 (GLfloat) x, (GLfloat) y, (GLfloat) z);
}


static void
Translatef(GLfloat x, GLfloat y, GLfloat z) 
{
        crMatrixTranslate(CurrentStack->top, x, y, z);
}


static void
Translated(GLdouble x, GLdouble y, GLdouble z) 
{
        crMatrixTranslate(CurrentStack->top, (GLfloat) x, (GLfloat) y, (GLfloat) z);
}


static void
Scalef(GLfloat x, GLfloat y, GLfloat z) 
{
        crMatrixScale(CurrentStack->top, x, y, z);
}


static void
Scaled(GLdouble x, GLdouble y, GLdouble z) 
{
        crMatrixScale(CurrentStack->top, (GLfloat) x, (GLfloat) y, (GLfloat) z);
}


/**
 * Transform given (x,y,z,w) by current matrix and update the bounding box.
 */
static void
DoVertex(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
        const CRmatrix *m = CurrentStack->top;
        const GLfloat x2 = m->m00 * x + m->m10 * y + m->m20 * z + m->m30 * w;
        const GLfloat y2 = m->m01 * x + m->m11 * y + m->m21 * z + m->m31 * w;
        const GLfloat z2 = m->m02 * x + m->m12 * y + m->m22 * z + m->m32 * w;
        /*const GLfloat w2 = m->m03 * x + m->m13 * y + m->m23 * z + m->m33 * w;*/

        if (x2 < Xmin) Xmin = x2;
        if (x2 > Xmax) Xmax = x2;
        if (y2 < Ymin) Ymin = y2;
        if (y2 > Ymax) Ymax = y2;
        if (z2 < Zmin) Zmin = z2;
        if (z2 > Zmax) Zmax = z2;
}


static void
Vertex2f(GLfloat x, GLfloat y)
{
        DoVertex(x, y, 0.0f, 1.0f);
}

static void
Vertex2fv(const GLfloat *v)
{
        DoVertex(v[0], v[1], 0.0f, 1.0f);
}

static void
Vertex3f(GLfloat x, GLfloat y, GLfloat z)
{
        DoVertex(x, y, z, 1.0f);
}

static void
Vertex3fv(const GLfloat *v)
{
        DoVertex(v[0], v[1], v[2], 1.0f);
}

static void
Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
        DoVertex(x, y, z, w);
}

static void
Vertex4fv(const GLfloat *v)
{
        DoVertex(v[0], v[1], v[2], v[3]);
}


/**
 ** XXX TO DO:
 **
glVertex2d( GLdouble x, GLdouble y );
glVertex2f( GLfloat x, GLfloat y );
glVertex2i( GLint x, GLint y );
glVertex2s( GLshort x, GLshort y );
glVertex3d( GLdouble x, GLdouble y, GLdouble z );
glVertex3f( GLfloat x, GLfloat y, GLfloat z );
glVertex3i( GLint x, GLint y, GLint z );
glVertex3s( GLshort x, GLshort y, GLshort z );
glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
glVertex4i( GLint x, GLint y, GLint z, GLint w );
glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w );
glVertex2dv( const GLdouble *v );
glVertex2fv( const GLfloat *v );
glVertex2iv( const GLint *v );
glVertex2sv( const GLshort *v );
glVertex3dv( const GLdouble *v );
glVertex3fv( const GLfloat *v );
glVertex3iv( const GLint *v );
glVertex3sv( const GLshort *v );
glVertex4dv( const GLdouble *v );
glVertex4fv( const GLfloat *v );
glVertex4iv( const GLint *v );
glVertex4sv( const GLshort *v );

glVertexAttrib1dARB(GLuint, GLdouble);
glVertexAttrib1dvARB(GLuint, const GLdouble *);
glVertexAttrib1fARB(GLuint, GLfloat);
glVertexAttrib1fvARB(GLuint, const GLfloat *);
glVertexAttrib1sARB(GLuint, GLshort);
glVertexAttrib1svARB(GLuint, const GLshort *);
glVertexAttrib2dARB(GLuint, GLdouble, GLdouble);
glVertexAttrib2dvARB(GLuint, const GLdouble *);
glVertexAttrib2fARB(GLuint, GLfloat, GLfloat);
glVertexAttrib2fvARB(GLuint, const GLfloat *);
glVertexAttrib2sARB(GLuint, GLshort, GLshort);
glVertexAttrib2svARB(GLuint, const GLshort *);
glVertexAttrib3dARB(GLuint, GLdouble, GLdouble, GLdouble);
glVertexAttrib3dvARB(GLuint, const GLdouble *);
**/

static void
VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
        if (index == 0)
                DoVertex(x, y, z, 1.0f);
}

/**
glVertexAttrib3fvARB(GLuint, const GLfloat *);
glVertexAttrib3sARB(GLuint, GLshort, GLshort, GLshort);
glVertexAttrib3svARB(GLuint, const GLshort *);
glVertexAttrib4NbvARB(GLuint, const GLbyte *);
glVertexAttrib4NivARB(GLuint, const GLint *);
glVertexAttrib4NsvARB(GLuint, const GLshort *);
glVertexAttrib4NubARB(GLuint, GLubyte, GLubyte, GLubyte, GLubyte);
glVertexAttrib4NubvARB(GLuint, const GLubyte *);
glVertexAttrib4NuivARB(GLuint, const GLuint *);
glVertexAttrib4NusvARB(GLuint, const GLushort *);
glVertexAttrib4bvARB(GLuint, const GLbyte *);
glVertexAttrib4dARB(GLuint, GLdouble, GLdouble, GLdouble, GLdouble);
glVertexAttrib4dvARB(GLuint, const GLdouble *);
glVertexAttrib4fARB(GLuint, GLfloat, GLfloat, GLfloat, GLfloat);
glVertexAttrib4fvARB(GLuint, const GLfloat *);
glVertexAttrib4ivARB(GLuint, const GLint *);
glVertexAttrib4sARB(GLuint, GLshort, GLshort, GLshort, GLshort);
glVertexAttrib4svARB(GLuint, const GLshort *);
glVertexAttrib4ubvARB(GLuint, const GLubyte *);
glVertexAttrib4uivARB(GLuint, const GLuint *);
glVertexAttrib4usvARB(GLuint, const GLushort *);

glVertexAttrib1dNV(GLuint, GLdouble);
glVertexAttrib1dvNV(GLuint, const GLdouble *);
glVertexAttrib1fNV(GLuint, GLfloat);
glVertexAttrib1fvNV(GLuint, const GLfloat *);
glVertexAttrib1sNV(GLuint, GLshort);
glVertexAttrib1svNV(GLuint, const GLshort *);
glVertexAttrib2dNV(GLuint, GLdouble, GLdouble);
glVertexAttrib2dvNV(GLuint, const GLdouble *);
glVertexAttrib2fNV(GLuint, GLfloat, GLfloat);
glVertexAttrib2fvNV(GLuint, const GLfloat *);
glVertexAttrib2sNV(GLuint, GLshort, GLshort);
glVertexAttrib2svNV(GLuint, const GLshort *);
glVertexAttrib3dNV(GLuint, GLdouble, GLdouble, GLdouble);
glVertexAttrib3dvNV(GLuint, const GLdouble *);
glVertexAttrib3fNV(GLuint, GLfloat, GLfloat, GLfloat);
glVertexAttrib3fvNV(GLuint, const GLfloat *);
glVertexAttrib3sNV(GLuint, GLshort, GLshort, GLshort);
glVertexAttrib3svNV(GLuint, const GLshort *);
glVertexAttrib4dNV(GLuint, GLdouble, GLdouble, GLdouble, GLdouble);
glVertexAttrib4dvNV(GLuint, const GLdouble *);
glVertexAttrib4fNV(GLuint, GLfloat, GLfloat, GLfloat, GLfloat);
glVertexAttrib4fvNV(GLuint, const GLfloat *);
glVertexAttrib4sNV(GLuint, GLshort, GLshort, GLshort, GLshort);
glVertexAttrib4svNV(GLuint, const GLshort *);
glVertexAttrib4ubNV(GLuint, GLubyte, GLubyte, GLubyte, GLubyte);
glVertexAttrib4ubvNV(GLuint, const GLubyte *);

glVertexAttribs1dvNV(GLuint, GLsizei, const GLdouble *);
glVertexAttribs1fvNV(GLuint, GLsizei, const GLfloat *);
glVertexAttribs1svNV(GLuint, GLsizei, const GLshort *);
glVertexAttribs2dvNV(GLuint, GLsizei, const GLdouble *);
glVertexAttribs2fvNV(GLuint, GLsizei, const GLfloat *);
glVertexAttribs2svNV(GLuint, GLsizei, const GLshort *);
glVertexAttribs3dvNV(GLuint, GLsizei, const GLdouble *);
glVertexAttribs3fvNV(GLuint, GLsizei, const GLfloat *);
glVertexAttribs3svNV(GLuint, GLsizei, const GLshort *);
glVertexAttribs4dvNV(GLuint, GLsizei, const GLdouble *);
glVertexAttribs4fvNV(GLuint, GLsizei, const GLfloat *);
glVertexAttribs4svNV(GLuint, GLsizei, const GLshort *);
glVertexAttribs4ubvNV(GLuint, GLsizei, const GLubyte *);
**/


/**
 ** XXX also need to track evaluator coordinates (glutTeapot)
 **/


static void
InitDispatchTable(SPUDispatchTable *t)
{
        crMemZero(t, sizeof(*t));
        crSPUInitDispatchNops(t);
  /* drm1 */
        t->MatrixMode = (MatrixModeFunc_t)MatrixMode;
        t->LoadIdentity = (LoadIdentityFunc_t)LoadIdentity;
        t->LoadMatrixf = (LoadMatrixfFunc_t)LoadMatrixf;
        t->LoadMatrixd = (LoadMatrixdFunc_t)LoadMatrixd;
        t->PushMatrix = (PushMatrixFunc_t)PushMatrix;
        t->PopMatrix = (PopMatrixFunc_t)PopMatrix;
        t->MultMatrixf = (MultMatrixfFunc_t)MultMatrixf;
        t->MultMatrixd = (MultMatrixdFunc_t)MultMatrixd;
        t->Rotatef = (RotatefFunc_t)Rotatef;
  t->Rotated = (RotatedFunc_t)Rotated;
        t->Translatef = (TranslatefFunc_t)Translatef;
        t->Translated = (TranslatedFunc_t)Translated;
        t->Scalef = (ScalefFunc_t)Scalef;
        t->Scaled = (ScaledFunc_t)Scaled;
        t->Vertex2f = (Vertex2fFunc_t)Vertex2f;
        t->Vertex2fv = (Vertex2fvFunc_t)Vertex2fv;
        t->Vertex3f = (Vertex3fFunc_t)Vertex3f;
        t->Vertex3fv = (Vertex3fvFunc_t)Vertex3fv;
        t->Vertex4f = (Vertex4fFunc_t)Vertex4f;
        t->Vertex4fv = (Vertex4fvFunc_t)Vertex4fv;
        t->VertexAttrib3fARB = (VertexAttrib3fARBFunc_t)VertexAttrib3fARB;
}


void
crDLMComputeBoundingBox(unsigned long listId)
{
        static GLboolean tableInitialized = GL_FALSE;
        static SPUDispatchTable t;
        CRDLMContextState *listState = CURRENT_STATE();
        CRDLM *dlm = listState->dlm;
        DLMListInfo *listInfo
                = (DLMListInfo *) crHashtableSearch(dlm->displayLists, listId);

        if (!tableInitialized) {
                InitDispatchTable(&t);
                crStateInitMatrixStack(&ModelViewStack, CR_MAX_MODELVIEW_STACK_DEPTH);
                crStateInitMatrixStack(&DummyStack, CR_MAX_MODELVIEW_STACK_DEPTH);
                tableInitialized = GL_TRUE;
        }

        CurrentStack = &ModelViewStack;

        Xmin = Ymin = Zmin = FLT_MAX;
        Xmax = Ymax = Zmax = -FLT_MAX;
        
        crDLMReplayDLMList(listState->dlm, listId, &t);

        if (Xmin == FLT_MAX) {
                /* XXX review this choice of default bounds */
                /*
                crDebug("Warning: no bounding box!");
                */
                Xmin = -100;
                Xmax =  100;
                Ymin = -100;
                Ymax =  100;
                Zmin = -100;
                Zmax =  100;
        }
        /*
        crDebug("List %d bbox: %f, %f, %f .. %f, %f, %f", (int) listId,
                                        Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
        */

        listInfo->bbox.xmin = Xmin;
        listInfo->bbox.ymin = Ymin;
        listInfo->bbox.zmin = Zmin;
        listInfo->bbox.xmax = Xmax;
        listInfo->bbox.ymax = Ymax;
        listInfo->bbox.zmax = Zmax;
}