gmanager.cpp

/*    Copyright (C) 2000,2001,2002  Sony Computer Entertainment America
 
          This file is subject to the terms and conditions of the GNU Lesser
      General Public License Version 2.1. See the file "COPYING" in the
      main directory of this archive for more details.                             */
 
#include <stdio.h>
 
#include "GL/ps2gl.h"
 
#include "ps2s/cpu_matrix.h"
#include "ps2s/displayenv.h"
#include "ps2s/math.h"
#include "ps2s/packet.h"
 
#include "ps2gl/clear.h"
#include "ps2gl/debug.h"
#include "ps2gl/dlist.h"
#include "ps2gl/glcontext.h"
#include "ps2gl/gmanager.h"
#include "ps2gl/matrix.h"
 
/********************************************
 * class CVertArray
 */
 
CVertArray::CVertArray()
{
    Vertices = Normals = TexCoords = Colors = NULL;
    VerticesAreValid = NormalsAreValid = TexCoordsAreValid = ColorsAreValid = false;
    WordsPerVertex = WordsPerTexCoord = WordsPerColor = 0;
    WordsPerNormal                                    = 3; // not set by NormalPointer
}
 
/********************************************
 * class CGeomManager
 */
 
// static members
 
CVertArray* CGeomManager::VertArray;
 
tUserPrimEntry CGeomManager::UserPrimTypes[kMaxUserPrimTypes];
 
bool CGeomManager::DoNormalize = false;
 
CGeomManager::CGeomManager(CGLContext& context)
    : GLContext(context)
    , CurNormal(0.0f, 0.0f, 1.0f)
    , Prim(GL_INVALID_VALUE)
    , InsideBeginEnd(false)
    , LastArrayAccessWasIndexed(false)
    , LastArrayAccessIsValid(false)
    , UserRenderContextChanged(false)
{
    for (unsigned int i               = 0; i < kMaxUserPrimTypes; i++)
        UserPrimTypes[i].requirements = 0xffffffff;
}
 
/********************************************
 * gl api
 */
 
void glVertexPointer(GLint size, GLenum type,
    GLsizei stride, const GLvoid* ptr)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    if (stride != 0) {
        mNotImplemented("stride must be 0");
        return;
    }
    if (type != GL_FLOAT) {
        mNotImplemented("type must be float");
        return;
    }
 
    CVertArray& vertArray = pGLContext->GetGeomManager().GetVertArray();
    vertArray.SetVertices((void*)ptr);
    vertArray.SetWordsPerVertex(size);
}
 
void glNormalPointer(GLenum type, GLsizei stride,
    const GLvoid* ptr)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    pglNormalPointer(3, type, stride, ptr);
}
 
void glTexCoordPointer(GLint size, GLenum type,
    GLsizei stride, const GLvoid* ptr)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    if (stride != 0) {
        mNotImplemented("stride must be 0");
        return;
    }
    if (type != GL_FLOAT) {
        mNotImplemented("type must be float");
        return;
    }
 
    CVertArray& vertArray = pGLContext->GetGeomManager().GetVertArray();
    vertArray.SetTexCoords((void*)ptr);
    vertArray.SetWordsPerTexCoord(size);
}
 
void glColorPointer(GLint size, GLenum type,
    GLsizei stride, const GLvoid* ptr)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    if (stride != 0) {
        mNotImplemented("stride must be 0");
        return;
    }
    if (type != GL_FLOAT) {
        mNotImplemented("type must be float");
        return;
    }
 
    CVertArray& vertArray = pGLContext->GetGeomManager().GetVertArray();
    vertArray.SetColors((void*)ptr);
    vertArray.SetWordsPerColor(size);
}
 
void glDrawArrays(GLenum mode, GLint first, GLsizei count)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    CGeomManager& gmanager = pGLContext->GetGeomManager();
    gmanager.DrawArrays(mode, first, count);
}
 
void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    mError("glDrawElements is a placeholder ATM and should not be called");
}
 
void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid* pointer)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    mError("glInterleavedArrays is a placeholder ATM and should not be called");
}
 
void glArrayElement(GLint i)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    mError("glArrayElement is a placeholder ATM and should not be called");
}
 
void glFlush(void)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    CGeomManager& gmanager = pGLContext->GetGeomManager();
    gmanager.Flush();
}
 
 
void glEnableClientState(GLenum cap)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    CGeomManager& gmanager = pGLContext->GetGeomManager();
    CVertArray& vertArray  = gmanager.GetVertArray();
 
    switch (cap) {
    case GL_NORMAL_ARRAY:
        vertArray.SetNormalsValid(true);
        break;
    case GL_VERTEX_ARRAY:
        vertArray.SetVerticesValid(true);
        break;
    case GL_COLOR_ARRAY:
        vertArray.SetColorsValid(true);
        break;
    case GL_TEXTURE_COORD_ARRAY:
        vertArray.SetTexCoordsValid(true);
        break;
 
    case GL_INDEX_ARRAY:
    case GL_EDGE_FLAG_ARRAY:
        mNotImplemented("capability = %d", cap);
        break;
    }
}
 
void glDisableClientState(GLenum cap)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    CGeomManager& gmanager = pGLContext->GetGeomManager();
    CVertArray& vertArray  = gmanager.GetVertArray();
 
    switch (cap) {
    case GL_NORMAL_ARRAY:
        vertArray.SetNormalsValid(false);
        break;
    case GL_VERTEX_ARRAY:
        vertArray.SetVerticesValid(false);
        break;
    case GL_COLOR_ARRAY:
        vertArray.SetColorsValid(false);
        break;
    case GL_TEXTURE_COORD_ARRAY:
        vertArray.SetTexCoordsValid(false);
        break;
 
    case GL_INDEX_ARRAY:
    case GL_EDGE_FLAG_ARRAY:
        mNotImplemented("capability = %d", cap);
        break;
    }
}
 
void glBegin(GLenum mode)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    CGeomManager& gmanager = pGLContext->GetGeomManager();
    gmanager.BeginGeom(mode);
}
 
void glNormal3f(GLfloat x, GLfloat y, GLfloat z)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    CGeomManager& gmanager = pGLContext->GetGeomManager();
    gmanager.Normal(cpu_vec_xyz(x, y, z));
}
 
void glNormal3fv(const GLfloat* v)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    glNormal3f(v[0], v[1], v[2]);
}
 
void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    CGeomManager& gmanager = pGLContext->GetGeomManager();
    gmanager.Vertex(cpu_vec_xyzw(x, y, z, w));
}
 
void glVertex4fv(const GLfloat* vertex)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    glVertex4f(vertex[0], vertex[1], vertex[2], vertex[3]);
}
 
void glVertex3f(GLfloat x, GLfloat y, GLfloat z)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    glVertex4f(x, y, z, 1.0f);
}
 
void glVertex3fv(const GLfloat* vertex)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    glVertex4f(vertex[0], vertex[1], vertex[2], 1.0f);
}
 
void glVertex2f(GLfloat x, GLfloat y)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    glVertex4f(x, y, 0.0f, 1.0f);
}
 
void glVertex2i(GLint x, GLint y)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    glVertex4f((GLfloat)x, (GLfloat)y, 0.0f, 1.0f);
}
 
void glVertex2fv(const GLfloat* vertex)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    glVertex4f(vertex[0], vertex[1], 0.0f, 1.0f);
}
 
void glTexCoord2f(GLfloat u, GLfloat v)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    CGeomManager& gmanager = pGLContext->GetGeomManager();
    gmanager.TexCoord(u, v);
}
 
void glTexCoord2fv(const GLfloat* texCoord)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    glTexCoord2f(texCoord[0], texCoord[1]);
}
 
void glColor3f(GLfloat red, GLfloat green, GLfloat blue)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    CGeomManager& gmanager = pGLContext->GetGeomManager();
    gmanager.Color(cpu_vec_xyzw(red, green, blue, 1.0f));
}
 
void glColor3fv(const GLfloat* color)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    glColor3f(color[0], color[1], color[2]);
}
 
void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    CGeomManager& gmanager = pGLContext->GetGeomManager();
    gmanager.Color(cpu_vec_xyzw(red, green, blue, alpha));
}
 
void glColor4fv(const GLfloat* color)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    glColor4f(color[0], color[1], color[2], color[3]);
}
 
void glEnd(void)
{
    GL_FUNC_DEBUG("%s\n", __FUNCTION__);
 
    CGeomManager& gmanager = pGLContext->GetGeomManager();
    gmanager.EndGeom();
}
 
/********************************************
 * pgl api
 */
 
void pglNormalPointer(GLint size, GLenum type,
    GLsizei stride, const GLvoid* ptr)
{
    if (stride != 0) {
        mNotImplemented("stride must be 0");
        return;
    }
    if (type != GL_FLOAT) {
        mNotImplemented("type must be float");
        return;
    }
 
    CVertArray& vertArray = pGLContext->GetGeomManager().GetVertArray();
    vertArray.SetNormals((void*)ptr);
    vertArray.SetWordsPerNormal(size);
}
 
void pglDrawIndexedArrays(GLenum primType,
    int numIndices, const unsigned char* indices,
    int numVertices)
{
    pGLContext->GetGeomManager().DrawIndexedArrays(primType, numIndices, indices, numVertices);
}
 
void pglRegisterCustomPrimType(GLenum primType,
    pglU64_t requirements, pglU64_t rendererReqMask, int mergeContiguous)
{
    mErrorIf(!CGeomManager::IsUserPrimType(primType), "custom prim types must have bit 31 set");
    CGeomManager::RegisterUserPrimType(primType, requirements, rendererReqMask, mergeContiguous);
}
 
void pglEnableCustom(pglU64_t flag)
{
    flag &= ~(tU64)0xffffffff;
    pGLContext->GetGeomManager().EnableCustom(flag);
}
 
void pglDisableCustom(pglU64_t flag)
{
    flag &= ~(tU64)0xffffffff;
    pGLContext->GetGeomManager().DisableCustom(flag);
}
 
void pglUserRenderContextChanged()
{
    pGLContext->GetGeomManager().SetUserRenderContextChanged();
}