renderermanager.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 "ps2s/packet.h"
 
#include "ps2gl/glcontext.h"
#include "ps2gl/metrics.h"
#include "ps2gl/renderermanager.h"
 
#include "ps2gl/indexed_renderer.h"
#include "ps2gl/linear_renderer.h"
 
#include "vu1_mem_linear.h"
#include "vu1renderers.h"
 
using namespace RendererProps;
 
/********************************************
 * methods
 */
 
CRendererManager::CRendererManager(CGLContext& context)
    : GLContext(context)
    , RendererReqsHaveChanged(false)
    , CurUserPrimReqs(0)
    , CurUserPrimReqMask(~0)
    , NumDefaultRenderers(0)
    , NumUserRenderers(0)
    , CurrentRenderer(NULL)
    , NewRenderer(NULL)
{
    RendererRequirements.PrimType         = 0;
    RendererRequirements.Lighting         = 0;
    RendererRequirements.NumDirLights     = 0;
    RendererRequirements.NumPtLights      = 0;
    RendererRequirements.Texture          = 0;
    RendererRequirements.Specular         = 0;
    RendererRequirements.PerVtxMaterial   = kNoMaterial;
    RendererRequirements.Clipping         = kClipped;
    RendererRequirements.CullFace         = 0;
    RendererRequirements.TwoSidedLighting = 0;
    RendererRequirements.ArrayAccess      = 0;
    RendererRequirements.UserProps        = 0;
 
    CRendererProps no_reqs;
    no_reqs = (tU64)0;
 
    // indexed array renderer
    {
        CRendererProps capabilities = {
            PrimType : kPtsLinesStripsFans,
            Lighting : 1,
            NumDirLights : k3DirLights | k8DirLights,
            NumPtLights : k1PtLight | k2PtLights | k8PtLights,
            Texture : 1,
            Specular : 1,
            PerVtxMaterial : kNoMaterial,
            Clipping : kNonClipped | kClipped,
            CullFace : 1,
            TwoSidedLighting : 0,
            ArrayAccess : kIndexed
        };
 
        RegisterDefaultRenderer(new CIndexedRenderer(mVsmAddr(Indexed), mVsmSize(Indexed), capabilities, no_reqs, 3, 3,
            "indexed"));
    }
 
    // fast, no lights renderer
    {
        CRendererProps capabilities = {
            PrimType : kPtsLinesStripsFans,
            Lighting : 0,
            NumDirLights : k3DirLights,
            NumPtLights : 0,
            Texture : 1,
            Specular : 0,
            PerVtxMaterial : kNoMaterial,
            Clipping : kNonClipped,
            CullFace : 0,
            TwoSidedLighting : 0,
            ArrayAccess : kLinear
        };
 
        RegisterDefaultRenderer(new CLinearRenderer(mVsmAddr(FastNoLights), mVsmSize(FastNoLights), capabilities, no_reqs, 3, 3,
            kInputStart, kInputBufSize - kInputStart,
            "fast, no lights"));
    }
    // fast renderer
    {
        CRendererProps capabilities = {
            PrimType : kPtsLinesStripsFans,
            Lighting : 1,
            NumDirLights : k3DirLights,
            NumPtLights : 0,
            Texture : 1,
            Specular : 0,
            PerVtxMaterial : kNoMaterial,
            Clipping : kNonClipped,
            CullFace : 0,
            TwoSidedLighting : 0,
            ArrayAccess : kLinear
        };
 
        RegisterDefaultRenderer(new CLinearRenderer(mVsmAddr(Fast), mVsmSize(Fast), capabilities, no_reqs, 3, 3,
            kInputStart, kInputBufSize - kInputStart,
            "fast"));
    }
 
    // SCEI renderer
    {
        CRendererProps capabilities = {
            PrimType : kPtsLinesStripsFans,
            Lighting : 1,
            NumDirLights : k3DirLights,
            NumPtLights : 0,
            Texture : 1,
            Specular : 0,
            PerVtxMaterial : kNoMaterial,
            Clipping : kClipped,
            CullFace : 0,
            TwoSidedLighting : 0,
            ArrayAccess : kLinear
        };
 
        RegisterDefaultRenderer(new CLinearRenderer(mVsmAddr(SCEI), mVsmSize(SCEI), capabilities, no_reqs, 3, 3,
            kInputStart, kInputBufSize - kInputStart,
            "scei"));
    }
 
    // linear, no specular renderers
 
    {
        CRendererProps capabilities = {
            PrimType : kPtsLinesStripsFans,
            Lighting : 1,
            NumDirLights : k3DirLights | k8DirLights,
            NumPtLights : k1PtLight | k2PtLights | k8PtLights,
            Texture : 1,
            Specular : 0,
            PerVtxMaterial : kNoMaterial,
            Clipping : kNonClipped | kClipped,
            CullFace : 1,
            TwoSidedLighting : 0,
            ArrayAccess : kLinear
        };
 
        RegisterDefaultRenderer(new CLinearRenderer(mVsmAddr(GeneralNoSpec), mVsmSize(GeneralNoSpec), capabilities, no_reqs, 3, 3,
            kInputStart, kInputBufSize - kInputStart,
            "linear, no specular"));
    }
    {
        CRendererProps capabilities = {
            PrimType : kTriangles,
            Lighting : 1,
            NumDirLights : k3DirLights | k8DirLights,
            NumPtLights : k1PtLight | k2PtLights | k8PtLights,
            Texture : 1,
            Specular : 0,
            PerVtxMaterial : kNoMaterial,
            Clipping : kNonClipped | kClipped,
            CullFace : 1,
            TwoSidedLighting : 0,
            ArrayAccess : kLinear
        };
 
        RegisterDefaultRenderer(new CLinearRenderer(mVsmAddr(GeneralNoSpecTri), mVsmSize(GeneralNoSpecTri), capabilities, no_reqs, 3, 3,
            kInputStart, kInputBufSize - kInputStart,
            "linear, tris, no specular"));
    }
    {
        CRendererProps capabilities = {
            PrimType : kQuads,
            Lighting : 1,
            NumDirLights : k3DirLights | k8DirLights,
            NumPtLights : k1PtLight | k2PtLights | k8PtLights,
            Texture : 1,
            Specular : 0,
            PerVtxMaterial : kNoMaterial,
            Clipping : kNonClipped | kClipped,
            CullFace : 1,
            TwoSidedLighting : 0,
            ArrayAccess : kLinear
        };
 
        RegisterDefaultRenderer(new CLinearRenderer(mVsmAddr(GeneralNoSpecQuad), mVsmSize(GeneralNoSpecQuad), capabilities, no_reqs, 3, 3,
            kInputStart, kInputBufSize - kInputStart,
            "linear, quads, no specular"));
    }
 
    // linear renderers
 
    {
        CRendererProps capabilities = {
            PrimType : kPtsLinesStripsFans,
            Lighting : 1,
            NumDirLights : k3DirLights | k8DirLights,
            NumPtLights : k1PtLight | k2PtLights | k8PtLights,
            Texture : 1,
            Specular : 1,
            PerVtxMaterial : kNoMaterial,
            Clipping : kNonClipped | kClipped,
            CullFace : 1,
            TwoSidedLighting : 0,
            ArrayAccess : kLinear
        };
 
        RegisterDefaultRenderer(new CLinearRenderer(mVsmAddr(General), mVsmSize(General), capabilities, no_reqs, 3, 3,
            kInputStart, kInputBufSize - kInputStart,
            "linear"));
    }
    {
        CRendererProps capabilities = {
            PrimType : kQuads,
            Lighting : 1,
            NumDirLights : k3DirLights | k8DirLights,
            NumPtLights : k1PtLight | k2PtLights | k8PtLights,
            Texture : 1,
            Specular : 1,
            PerVtxMaterial : kNoMaterial,
            Clipping : kNonClipped | kClipped,
            CullFace : 1,
            TwoSidedLighting : 0,
            ArrayAccess : kLinear
        };
 
        RegisterDefaultRenderer(new CLinearRenderer(mVsmAddr(GeneralQuad), mVsmSize(GeneralQuad), capabilities, no_reqs, 3, 3,
            kInputStart, kInputBufSize - kInputStart,
            "linear, quads"));
    }
    {
        CRendererProps capabilities = {
            PrimType : kTriangles,
            Lighting : 1,
            NumDirLights : k3DirLights | k8DirLights,
            NumPtLights : k1PtLight | k2PtLights | k8PtLights,
            Texture : 1,
            Specular : 1,
            PerVtxMaterial : kNoMaterial,
            Clipping : kNonClipped | kClipped,
            CullFace : 1,
            TwoSidedLighting : 0,
            ArrayAccess : kLinear
        };
 
        RegisterDefaultRenderer(new CLinearRenderer(mVsmAddr(GeneralTri), mVsmSize(GeneralTri), capabilities, no_reqs, 3, 3,
            kInputStart, kInputBufSize - kInputStart,
            "linear, tris"));
    }
 
    // linear, per-vertex color renderers
 
    {
        CRendererProps capabilities = {
            PrimType : kPtsLinesStripsFans,
            Lighting : 1,
            NumDirLights : k3DirLights | k8DirLights,
            NumPtLights : k1PtLight | k2PtLights | k8PtLights,
            Texture : 1,
            Specular : 1,
            PerVtxMaterial : kDiffuse,
            Clipping : kNonClipped | kClipped,
            CullFace : 1,
            TwoSidedLighting : 0,
            ArrayAccess : kLinear
        };
 
        RegisterDefaultRenderer(new CLinearRenderer(mVsmAddr(GeneralPVDiff), mVsmSize(GeneralPVDiff), capabilities, no_reqs, 4, 3,
            kInputStart, kInputBufSize - kInputStart,
            "linear, pvc"));
    }
    {
        CRendererProps capabilities = {
            PrimType : kTriangles,
            Lighting : 1,
            NumDirLights : k3DirLights | k8DirLights,
            NumPtLights : k1PtLight | k2PtLights | k8PtLights,
            Texture : 1,
            Specular : 1,
            PerVtxMaterial : kDiffuse,
            Clipping : kNonClipped | kClipped,
            CullFace : 1,
            TwoSidedLighting : 0,
            ArrayAccess : kLinear
        };
 
        RegisterDefaultRenderer(new CLinearRenderer(mVsmAddr(GeneralPVDiffTri), mVsmSize(GeneralPVDiffTri), capabilities, no_reqs, 4, 3,
            kInputStart, kInputBufSize - kInputStart,
            "linear, pvc, tris"));
    }
    {
        CRendererProps capabilities = {
            PrimType : kQuads,
            Lighting : 1,
            NumDirLights : k3DirLights | k8DirLights,
            NumPtLights : k1PtLight | k2PtLights | k8PtLights,
            Texture : 1,
            Specular : 1,
            PerVtxMaterial : kDiffuse,
            Clipping : kNonClipped | kClipped,
            CullFace : 1,
            TwoSidedLighting : 0,
            ArrayAccess : kLinear
        };
 
        RegisterDefaultRenderer(new CLinearRenderer(mVsmAddr(GeneralPVDiffQuad), mVsmSize(GeneralPVDiffQuad), capabilities, no_reqs, 4, 3,
            kInputStart, kInputBufSize - kInputStart,
            "linear, pvc, quads"));
    }
 
    // if we don't do this pglGetCurRendererName() will crash if called before rendering
    // any geometry
    CurrentRenderer = &DefaultRenderers[0];
}
 
void CRendererManager::RegisterDefaultRenderer(CRenderer* renderer)
{
    mErrorIf(NumDefaultRenderers == kMaxDefaultRenderers,
        "Trying to register too many renderers; adjust the limit");
 
    tRenderer newEntry                      = { renderer->GetCapabilities(), renderer->GetRequirements(), renderer };
    DefaultRenderers[NumDefaultRenderers++] = newEntry;
}
 
void CRendererManager::RegisterUserRenderer(CRenderer* renderer)
{
    mErrorIf(renderer == NULL,
        "Trying to register a null renderer is not playing fair...");
 
    mErrorIf(NumUserRenderers == kMaxUserRenderers,
        "Trying to register too many renderers; adjust the limit");
 
    tRenderer newEntry                = { renderer->GetCapabilities(), renderer->GetRequirements(), renderer };
    UserRenderers[NumUserRenderers++] = newEntry;
}
 
// state updates
 
void CRendererManager::EnableCustom(tU64 flag)
{
    tU64 newState = RendererRequirements;
    newState |= flag;
 
    if (newState != (tU64)RendererRequirements)
        RendererReqsHaveChanged = true;
 
    RendererRequirements = newState;
}
 
void CRendererManager::DisableCustom(tU64 flag)
{
    tU64 newState = RendererRequirements;
    newState &= ~flag;
 
    if (newState != (tU64)RendererRequirements)
        RendererReqsHaveChanged = true;
 
    RendererRequirements = newState;
}
 
void CRendererManager::NumLightsChanged(tLightType type, int num)
{
    CRendererProps newState = RendererRequirements;
 
    switch (type) {
    case kDirectional:
        if (num == 0)
            newState.NumDirLights = 0;
        else if (0 < num && num <= 3)
            newState.NumDirLights = k3DirLights; // in namespace??
        else
            newState.NumDirLights = k8DirLights;
 
        if (RendererRequirements != newState) {
            RendererRequirements    = newState;
            RendererReqsHaveChanged = true;
        }
        break;
 
    case kPoint:
        if (num == 0)
            newState.NumPtLights = 0;
        else if (num == 1)
            newState.NumPtLights = k1PtLight;
        else if (num == 2)
            newState.NumPtLights = k2PtLights;
        else
            newState.NumPtLights = k8PtLights;
 
        if (RendererRequirements != newState) {
            RendererRequirements    = newState;
            RendererReqsHaveChanged = true;
        }
        break;
 
    case kSpot:
        break;
    }
}
 
void CRendererManager::PrimChanged(unsigned int prim)
{
    // is this a user-defined prim type?
    if (CGeomManager::IsUserPrimType(prim)) {
        // user-defined
 
        tU64 newState = RendererRequirements;
 
        // clear the current user prim flags (if any)
        newState &= ~CurUserPrimReqs;
 
        // clear the user-prim-type flag (bit 31)
        prim &= 0x7fffffff;
 
        CurUserPrimReqs = CGeomManager::GetUserPrimRequirements(prim);
        newState |= CurUserPrimReqs;
 
        CurUserPrimReqMask = CGeomManager::GetUserPrimReqMask(prim);
 
        if ((tU64)RendererRequirements != newState) {
            RendererRequirements    = newState;
            RendererReqsHaveChanged = true;
        }
    } else {
        // normal prim type
 
        CRendererProps newState = RendererRequirements;
 
        if (CurUserPrimReqs) {
            RendererReqsHaveChanged = true;
            // clear any requirements set by a user prim type
            newState        = (tU64)newState & ~CurUserPrimReqs;
            CurUserPrimReqs = 0;
        }
 
        CurUserPrimReqMask = ~(tU32)0;
 
        if (prim <= GL_LINE_STRIP)
            newState.PrimType = kPtsLinesStripsFans;
        else if (prim == GL_TRIANGLE_STRIP
            || prim == GL_TRIANGLE_FAN
            || prim == GL_POLYGON)
            newState.PrimType = kPtsLinesStripsFans;
        else if (prim == GL_QUAD_STRIP)
            newState.PrimType = kPtsLinesStripsFans;
        else if (prim == GL_TRIANGLES)
            newState.PrimType = kTriangles;
        else if (prim == GL_QUADS)
            newState.PrimType = kQuads;
        else {
            mError("shouldn't get here");
        }
 
        if (RendererRequirements != newState) {
            RendererRequirements    = newState;
            RendererReqsHaveChanged = true;
        }
    }
}
 
void CRendererManager::TexEnabledChanged(bool enabled)
{
    CRendererProps newState = RendererRequirements;
 
    if (enabled)
        newState.Texture = 1;
    else
        newState.Texture = 0;
 
    if (RendererRequirements != newState) {
        RendererRequirements    = newState;
        RendererReqsHaveChanged = true;
    }
}
 
void CRendererManager::LightingEnabledChanged(bool enabled)
{
    CRendererProps newState = RendererRequirements;
 
    if (enabled)
        newState.Lighting = 1;
    else
        newState.Lighting = 0;
 
    if (RendererRequirements != newState) {
        RendererRequirements    = newState;
        RendererReqsHaveChanged = true;
    }
}
 
void CRendererManager::SpecularEnabledChanged(bool enabled)
{
    CRendererProps newState = RendererRequirements;
 
    if (enabled)
        newState.Specular = 1;
    else
        newState.Specular = 0;
 
    if (RendererRequirements != newState) {
        RendererRequirements    = newState;
        RendererReqsHaveChanged = true;
    }
}
 
void CRendererManager::PerVtxMaterialChanged(RendererProps::tPerVtxMaterial matType)
{
    if (RendererRequirements.PerVtxMaterial != (unsigned int)matType) {
        RendererRequirements.PerVtxMaterial = matType;
        RendererReqsHaveChanged             = true;
    }
}
 
void CRendererManager::ClippingEnabledChanged(bool enabled)
{
    tClipping clipping = (enabled) ? kClipped : kNonClipped;
    if (RendererRequirements.Clipping != (unsigned int)clipping) {
        RendererRequirements.Clipping = clipping;
        RendererReqsHaveChanged       = true;
    }
}
 
void CRendererManager::CullFaceEnabledChanged(bool enabled)
{
    if (RendererRequirements.CullFace != enabled) {
        RendererRequirements.CullFace = enabled;
        RendererReqsHaveChanged       = true;
    }
}
 
void CRendererManager::ArrayAccessChanged(RendererProps::tArrayAccess accessType)
{
    if (RendererRequirements.ArrayAccess != (unsigned int)accessType) {
        RendererRequirements.ArrayAccess = accessType;
        RendererReqsHaveChanged          = true;
    }
}
 
bool CRendererManager::UpdateNewRenderer()
{
    bool rendererChanged = false;
 
    if (RendererReqsHaveChanged) {
        // do a little fixin' up..
        CRendererProps rreqs = RendererRequirements;
        if (!rreqs.Lighting) {
            // don't care about these if there's no light
            rreqs.Specular         = 0;
            rreqs.TwoSidedLighting = 0;
        }
 
        rreqs = (tU64)rreqs & CurUserPrimReqMask;
 
        // first check the user renderers
 
        int i;
        bool userRendererFound = false;
 
        for (i = 0; i < NumUserRenderers; i++)
            if (rreqs == (rreqs & UserRenderers[i].capabilities)
                && UserRenderers[i].requirements == (rreqs & UserRenderers[i].requirements))
                break;
 
        // did we find a user renderer?
        if (i < NumUserRenderers) {
            userRendererFound = true;
 
            NewRenderer = &UserRenderers[i];
 
            if (CurrentRenderer != &UserRenderers[i]) {
                rendererChanged = true;
            }
        }
 
        // now the default renderers
 
        if (!userRendererFound) {
            for (i = 0; i < NumDefaultRenderers; i++)
                if (rreqs == (rreqs & DefaultRenderers[i].capabilities)
                    && DefaultRenderers[i].requirements == (rreqs & DefaultRenderers[i].requirements))
                    break;
 
            mErrorIf(i == NumDefaultRenderers,
                "Couldn't find a suitable renderer..\n"
                "state reqs = 0x%08x 0x%08x, mask = %08x %08x\n",
                (tU32)((tU64)rreqs >> 32),
                (tU32)((tU64)rreqs),
                (tU32)((tU64)CurUserPrimReqMask >> 32),
                (tU32)((tU64)CurUserPrimReqMask));
 
            NewRenderer = &DefaultRenderers[i];
 
            if (CurrentRenderer != &DefaultRenderers[i]) {
                // printf("vu1 renderer requirements are 0x%08x, renderer = 0x%08x i = %d\n",
                // (unsigned int)RendererRequirements, (unsigned int)CurrentRenderer->capabilities, i);
                rendererChanged = true;
            }
        }
    }
 
    RendererReqsHaveChanged = false;
 
    return rendererChanged;
}
 
void CRendererManager::MakeNewRendererCurrent()
{
    mAssert(NewRenderer != NULL);
    CurrentRenderer = NewRenderer;
    NewRenderer     = NULL;
}
 
void CRendererManager::LoadRenderer(CVifSCDmaPacket& packet)
{
    mAssert(CurrentRenderer != NULL);
 
    mDebugPrint("Loading renderer: %s\n", CurrentRenderer->renderer->GetName());
 
    CurrentRenderer->renderer->Load();
 
    pglAddToMetric(kMetricsRendererUpload);
}
 
/********************************************
 * ps2gl C api
 */
 
void pglBeginRendererDefs()
{
    // does nothing now, but a begin/end pair could come in handy later
    // if I add caches, hashes, etc..
}
 
void pglRegisterRenderer(void* renderer)
{
    CRenderer* newRenderer = reinterpret_cast<CRenderer*>(renderer);
    pGLContext->GetImmGeomManager().GetRendererManager().RegisterUserRenderer(newRenderer);
}
 
void pglEndRendererDefs()
{
    // see comment in begin
}
 
const char*
pglGetCurRendererName()
{
    return pGLContext->GetImmGeomManager().GetRendererManager().GetCurRenderer().GetName();
}