renderer.h

/*    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.                             */
 
#ifndef renderer_h
#define renderer_h
 
#include "ps2s/packet.h"
 
#include "GL/gl.h"
 
/********************************************
 * flags describing what pieces of microcode can do/
 * need to do
 */
 
class CRendererProps {
public:
    tU64 PrimType : 3;
    tU64 Lighting : 1;
    tU64 NumDirLights : 2;
    tU64 NumPtLights : 3;
    tU64 Texture : 1;
    tU64 Specular : 1;
    tU64 PerVtxMaterial : 3;
    tU64 Clipping : 2;
    tU64 CullFace : 1;
    tU64 TwoSidedLighting : 1;
    tU64 ArrayAccess : 2;
 
    tU64 unused : 12;
 
    tU64 UserProps : 32;
 
    // convert to unsigned 64-bit value
 
    inline operator tU64() const
    {
        // this hack doesn't work on linux since the compiler thinks this is a 32-bit
        // machine..
        // asm (" ### CRendererProps to uint ### " : "=r" (value) : "0" (*this) );
 
        tU64* value = (tU64*)this;
        return *value;
    }
 
    inline void operator=(tU64 value)
    {
        // see above..
        // asm(" ### CRendererProps assign from u64 ### " : "=r" (*(tU64*)this) : "0" (value) );
 
        *this = *(CRendererProps*)&value;
    }
} __attribute__((aligned(8)));
 
namespace RendererProps {
typedef enum { kPtsLinesStripsFans = 1 << 0,
    kTriangles                     = 1 << 1,
    kQuads                         = 1 << 2 } tPrimType;
 
typedef enum { k3DirLights = 1 << 0,
    k8DirLights            = 1 << 1 } tNumDirLights;
 
typedef enum { k1PtLight = 1 << 0,
    k2PtLights           = 1 << 1,
    k8PtLights           = 1 << 2 } tNumPtLights;
 
typedef enum { kNoMaterial = 1 << 0,
    kDiffuse               = 1 << 1,
    kSpecular              = 1 << 2 } tPerVtxMaterial;
 
typedef enum { kLinear = 1 << 0,
    kIndexed           = 1 << 1 } tArrayAccess;
 
typedef enum { kNonClipped = 1 << 0,
    kClipped               = 1 << 1 } tClipping;
}
 
class CGeometryBlock;
class CVertArray;
 
class CRenderer {
protected:
    tU64 Capabilities;
    tU64 Requirements;
 
    // this class can't be instantiated
    CRenderer() {}
    CRenderer(tU64 caps, tU64 reqs)
        : Capabilities(caps)
        , Requirements(reqs)
    {
    }
 
    void SetCapabilities(tU64 caps) { Capabilities = caps; }
    void SetRequirements(tU64 reqs) { Requirements = reqs; }
 
public:
    virtual tU64 GetCapabilities() const { return Capabilities; }
    virtual tU64 GetRequirements() const { return Requirements; }
 
    virtual void InitContext(GLenum primType, tU32 rcChanges, bool userRcChanged) = 0;
 
    virtual void Load() = 0;
 
    virtual void DrawLinearArrays(CGeometryBlock& block)
    {
        mError("This renderer doesn't do linear arrays");
    }
    virtual void DrawIndexedArrays(CGeometryBlock& block)
    {
        mError("This renderer doesn't do indexed arrays");
    }
 
    virtual bool GetCachePackets(const CGeometryBlock& geometry) = 0;
 
    virtual CRendererProps GetRenderContextDeps() = 0;
 
    virtual int GetPacketQwordSize(const CGeometryBlock& geometry) = 0;
 
    virtual const char* GetName() = 0;
};
 
#endif // renderer_h