123

RenderDll/XRenderNULL/NULL_Font.cpp

@@ -0,0 +1,54 @@
+/*=============================================================================
+  NULL_Font.cpp : NULL font functions.
+  Copyright (c) 2001 Crytek Studios. All Rights Reserved.
+
+  Revision history:
+    * Created by Honitch Andrey
+
+=============================================================================*/
+
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+
+
+#include "RenderPCH.h"
+#include "NULL_Renderer.h"
+
+#include "../CryFont/FBitmap.h"
+
+bool CNULLRenderer::FontUpdateTexture(int nTexId, int X, int Y, int USize, int VSize, byte *pData)
+{
+  return true;
+}
+
+bool CNULLRenderer::FontUploadTexture(class CFBitmap* pBmp, ETEX_Format eTF) 
+{
+  return true;
+}
+void CNULLRenderer::FontReleaseTexture(class CFBitmap *pBmp)
+{
+}
+
+void CNULLRenderer::FontSetTexture(class CFBitmap* pBmp, int nTexFiltMode)
+{
+}
+
+void CNULLRenderer::FontSetRenderingState(unsigned long nVPWidth, unsigned long nVPHeight)
+{
+}
+
+void CNULLRenderer::FontSetBlending(int blendSrc, int blendDest)
+{
+}
+
+void CNULLRenderer::FontRestoreRenderingState()
+{
+}
+
+void CNULLRenderer::FontSetState(bool bRestore)
+{
+}
+
+void CNULLRenderer::PrintToScreen(float x, float y, float size, const char *buf)
+{
+}

RenderDll/XRenderNULL/NULL_REOcean.cpp

@@ -0,0 +1,104 @@
+/*=============================================================================
+  PS2_REOcean.cpp : implementation of the Ocean Rendering.
+  Copyright (c) 2001 Crytek Studios. All Rights Reserved.
+
+  Revision history:
+    * Created by Honitch Andrey
+
+=============================================================================*/
+
+#include "RenderPCH.h"
+#include "NULL_Renderer.h"
+#include "I3dengine.h"
+
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+
+//=======================================================================
+
+void CREOcean::mfReset()
+{
+}
+
+bool CREOcean::mfPreDraw(SShaderPass *sl)
+{
+  return true;
+}
+
+void CREOcean::UpdateTexture()
+{
+}
+
+void CREOcean::DrawOceanSector(SOceanIndicies *oi)
+{
+}
+
+static _inline int Compare(SOceanSector *& p1, SOceanSector *& p2)
+{
+  if(p1->m_Flags > p2->m_Flags)
+    return 1;
+  else
+  if(p1->m_Flags < p2->m_Flags)
+    return -1;
+  
+  return 0;
+}
+
+static _inline float sCalcSplash(SSplash *spl, float fX, float fY)
+{
+  CNULLRenderer *r = gcpNULL;
+
+  float fDeltaTime = r->m_RP.m_RealTime - spl->m_fStartTime;
+  float fScaleFactor = 1.0f / (r->m_RP.m_RealTime - spl->m_fLastTime + 1.0f);
+
+  float vDelt[2];
+
+  // Calculate 2D distance
+  vDelt[0] = spl->m_Pos[0] - fX; vDelt[1] = spl->m_Pos[1] - fY;
+  float fSqDist = vDelt[0]*vDelt[0] + vDelt[1]*vDelt[1];
+
+  // Inverse square root
+  unsigned int *n1 = (unsigned int *)&fSqDist;
+  unsigned int nn = 0x5f3759df - (*n1 >> 1);
+  float *n2 = (float *)&nn;
+  float fDistSplash = 1.0f / ((1.5f - (fSqDist * 0.5f) * *n2 * *n2) * *n2);
+
+  // Emulate sin waves
+  float fDistFactor = fDeltaTime*10.0f - fDistSplash + 4.0f;
+  fDistFactor = CLAMP(fDistFactor, 0.0f, 1.0f);
+  float fRad = (fDistSplash - fDeltaTime*10) * 0.4f / 3.1416f * 1024.0f;
+  float fSin = gRenDev->m_RP.m_tSinTable[QRound(fRad)&0x3ff] * fDistFactor;
+
+  return fSin * fScaleFactor * spl->m_fForce;
+}
+
+float *CREOcean::mfFillAdditionalBuffer(SOceanSector *os, int nSplashes, SSplash *pSplashes[], int& nCurSize, int nLod, float fSize)
+{
+  return NULL;
+}
+
+void CREOcean::mfDrawOceanSectors()
+{ 
+}
+
+
+void CREOcean::mfDrawOceanScreenLod()
+{ 
+}
+
+bool CREOcean::mfDraw(SShader *ef, SShaderPass *sfm)
+{ 
+  double time0 = 0;
+  ticks(time0);
+
+  if (CRenderer::CV_r_oceanrendtype == 0)
+    mfDrawOceanSectors();
+  else
+    mfDrawOceanScreenLod();
+  unticks(time0);
+  m_RS.m_StatsTimeRendOcean = (float)(time0*1000.0*g_SecondsPerCycle);
+
+  return true;
+}
+
+

RenderDll/XRenderNULL/NULL_RERender.cpp

@@ -0,0 +1,140 @@
+/*=============================================================================
+  PS2_RERender.cpp : implementation of the Rendering RenderElements pipeline.
+  Copyright (c) 2001 Crytek Studios. All Rights Reserved.
+
+  Revision history:
+    * Created by Honitch Andrey
+
+=============================================================================*/
+
+#include "RenderPCH.h"
+#include "NULL_Renderer.h"
+#include "I3dengine.h"
+
+//#include "../cry3dengine/StatObj.h"
+
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+
+//=======================================================================
+
+void CREFlareGeom::mfCheckVis(CFColor &col, CCObject *obj)
+{
+}
+
+//#include "..\common\shadow_renderer.h"
+
+///////////////////////////////////////////////////////////////////
+
+CREOcclusionQuery::~CREOcclusionQuery()
+{
+}
+
+void CREOcclusionQuery::mfReset()
+{
+}
+
+bool CREScreenProcess::mfDrawLowSpec(SShader *ef, SShaderPass *sfm)
+{
+  return 1;
+}
+
+bool CREOcclusionQuery::mfDraw(SShader *ef, SShaderPass *sfm)
+{ 
+  return true;
+}
+
+bool CREOcLeaf::mfPreDraw(SShaderPass *sl)
+{
+  return true;
+}
+
+bool CREGlare::mfDraw(SShader *ef, SShaderPass *sfm)
+{ 
+  return true;
+}
+
+bool CREOcLeaf::mfDraw(SShader *ef, SShaderPass *sl)
+{
+  return (true);
+}
+
+///////////////////////////////////////////////////////////////////
+void CREOcLeaf::mfEndFlush(void)
+{
+}
+
+//===============================================================================
+
+void CRE2DQuad::mfPrepare()
+{
+}
+
+bool CRE2DQuad::mfDraw(SShader *ef, SShaderPass *sfm)
+{ 
+  return 1;
+}
+//===============================================================================
+
+bool CRETempMesh::mfDraw(SShader *ef, SShaderPass *sl)
+{
+  return true;
+}
+bool CRETempMesh::mfPreDraw(SShaderPass *sl)
+{
+  return true;
+}
+void CRETempMesh::mfReset()
+{
+}
+
+//=========================================================================================
+
+bool CREFlare::mfCheckVis(CCObject *obj)
+{
+  return false;
+}
+
+void CREFlare::mfDrawFlares(SShader *ef, CFColor &col)
+{
+}
+
+void CREFlare::mfDrawCorona(SShader *ef, CFColor &col)
+{
+}
+
+bool CREFlare::mfDraw(SShader *ef, SShaderPass *sfm)
+{
+  return true;
+}
+
+bool CREFlashBang::mfDraw(SShader *ef, SShaderPass *sfm)
+{   
+  return true;
+}
+void CREFlashBang::mfPrepare()
+{   
+}
+
+// screen process 
+bool CREScreenProcess:: mfDraw(SShader *ef, SShaderPass *sfm)
+{
+  return 1;
+}
+
+//=====================================================================================
+
+bool CREClearStencil::mfDraw(SShader *ef, SShaderPass *sfm)
+{    
+  return true;
+}
+
+bool CRETriMeshShadow::mfDraw(SShader *ef, SShaderPass *sfm)
+{    
+  return true;
+}
+
+bool CREHDRProcess::mfDraw(SShader *ef, SShaderPass *sfm)
+{
+  return true;
+}

RenderDll/XRenderNULL/NULL_RendPipeline.cpp

@@ -0,0 +1,328 @@
+/*=============================================================================
+  PS2_RendPipeline.cpp : PS2 specific rendering using shaders pipeline.
+  Copyright (c) 2001 Crytek Studios. All Rights Reserved.
+
+    Revision history:
+  		* Created by Honich Andrey
+    
+=============================================================================*/
+
+#include "RenderPCH.h"
+#include "NULL_Renderer.h"
+#include "I3dengine.h"
+
+#include "Platform.h"
+
+//============================================================================================
+// Shaders rendering
+//============================================================================================
+
+//============================================================================================
+// Init Shaders rendering
+
+void CNULLRenderer::EF_InitRandTables()
+{
+}
+
+void CNULLRenderer::EF_InitWaveTables()
+{  
+}
+
+void CNULLRenderer::EF_InitEvalFuncs(int num)
+{
+}
+
+int CNULLRenderer::EF_RegisterFogVolume(float fMaxFogDist, float fFogLayerZ, CFColor color, int nIndex, bool bCaustics)
+{
+  if (nIndex < 0)
+  {
+    SMFog Fog;
+    memset(&Fog,0,sizeof(Fog));
+
+    Fog.m_fMaxDist = fMaxFogDist;
+    Fog.m_FogInfo.m_FogColor = color;
+    Fog.m_Dist = fFogLayerZ;
+    Fog.m_Color = color;
+    Fog.m_Color.a = 1.0f;
+    Fog.bCaustics = bCaustics;
+    //Fog.m_FogInfo.m_FogColor = m_FogColor;
+    Fog.m_Normal = Vec3d(0,0,1);
+
+    m_RP.m_FogVolumes.AddElem(Fog);
+    return m_RP.m_FogVolumes.Num()-1;
+  }
+  else
+  {
+    assert (nIndex < m_RP.m_FogVolumes.Num());
+    SMFog *pFog = &m_RP.m_FogVolumes[nIndex];
+    pFog->m_fMaxDist = fMaxFogDist;
+    pFog->m_FogInfo.m_FogColor = color;
+    pFog->m_Dist = fFogLayerZ;
+    pFog->m_Color = color;
+    pFog->m_Color.a = 1.0f;
+    pFog->bCaustics = bCaustics;
+    return nIndex;
+  }
+}
+
+void CNULLRenderer::EF_PipelineInit()
+{
+  bool nv = 0;
+
+  m_RP.m_MaxVerts = 600;
+  m_RP.m_MaxTris = 300;
+
+  EF_InitWaveTables();
+  EF_InitRandTables();
+  EF_InitEvalFuncs(0);
+  EF_InitFogVolumes();
+
+//==================================================
+
+  SAFE_DELETE_ARRAY(m_RP.m_VisObjects);
+
+  CCObject::m_Waves.Create(32);
+  m_RP.m_VisObjects = new CCObject *[MAX_REND_OBJECTS];
+
+  if (!m_RP.m_TempObjects.Num())
+    m_RP.m_TempObjects.Reserve(MAX_REND_OBJECTS);
+  if (!m_RP.m_Objects.Num())
+  {
+    m_RP.m_Objects.Reserve(MAX_REND_OBJECTS);
+    m_RP.m_Objects.SetUse(1);
+    SAFE_DELETE_ARRAY(m_RP.m_ObjectsPool);
+    m_RP.m_nNumObjectsInPool = 384;
+    m_RP.m_ObjectsPool = new CCObject[m_RP.m_nNumObjectsInPool];
+    for (int i=0; i<m_RP.m_nNumObjectsInPool; i++)
+    {
+      m_RP.m_TempObjects[i] = &m_RP.m_ObjectsPool[i];
+      m_RP.m_TempObjects[i]->Init();
+      m_RP.m_TempObjects[i]->m_Color = Col_White;
+      m_RP.m_TempObjects[i]->m_ObjFlags = 0;
+      m_RP.m_TempObjects[i]->m_Matrix.SetIdentity();
+      m_RP.m_TempObjects[i]->m_RenderState = 0;
+    }
+    m_RP.m_VisObjects[0] = &m_RP.m_ObjectsPool[0];
+  }
+
+  //m_RP.m_DLights.Create(64);
+  //m_RP.m_DLights.SetUse(0);
+
+  m_RP.m_pREGlare = (CREGlare *)EF_CreateRE(eDATA_Glare);
+
+  for (int i=0; i<VERTEX_FORMAT_NUMS; i++)
+  {
+    for (int j=0; j<VERTEX_FORMAT_NUMS; j++)
+    {
+      SVertBufComps Cps[2];
+      GetVertBufComps(&Cps[0], i);
+      GetVertBufComps(&Cps[1], j);
+
+      bool bNeedTC = Cps[1].m_bHasTC | Cps[0].m_bHasTC;
+      bool bNeedCol = Cps[1].m_bHasColors | Cps[0].m_bHasColors;
+      bool bNeedSecCol = Cps[1].m_bHasSecColors | Cps[0].m_bHasSecColors;
+      bool bNeedNormals = Cps[1].m_bHasNormals | Cps[0].m_bHasNormals;
+      m_RP.m_VFormatsMerge[i][j] = VertFormatForComponents(bNeedCol, bNeedSecCol, bNeedNormals, bNeedTC);
+    }
+  }
+}
+
+void CNULLRenderer::EF_ClearBuffers(bool bForce, float *Colors)
+{
+}
+
+void CNULLRenderer::EF_SetClipPlane (bool bEnable, float *pPlane, bool bRefract)
+{
+}
+
+void CNULLRenderer::EF_PipelineShutdown()
+{
+  int i, j;
+
+  CCObject::m_Waves.Free();
+  SAFE_DELETE_ARRAY(m_RP.m_VisObjects);
+
+  //m_RP.m_DLights.Free();
+  m_RP.m_FogVolumes.Free();
+  SAFE_RELEASE(m_RP.m_pREGlare);
+  
+  for (i=0; i<CREClientPoly2D::mPolysStorage.GetSize(); i++)
+  {
+    SAFE_RELEASE(CREClientPoly2D::mPolysStorage[i]);
+  }
+  CREClientPoly2D::mPolysStorage.Free();
+
+  for (j=0; j<4; j++)
+  {
+    for (i=0; i<CREClientPoly::mPolysStorage[j].GetSize(); i++)
+    {
+      SAFE_RELEASE(CREClientPoly::mPolysStorage[j][i]);
+    }
+    CREClientPoly::mPolysStorage[j].Free();
+  }
+}
+
+void CNULLRenderer::EF_Release(int nFlags)
+{
+}
+
+//==========================================================================
+
+void CNULLRenderer::EF_SetCameraInfo()
+{
+}
+
+void CNULLRenderer::EF_CalcObjectMatrix(CCObject *obj)
+{
+}
+
+void CNULLRenderer::EF_SetObjectTransform(CCObject *obj)
+{
+}
+
+void CNULLRenderer::EF_PreRender(int Stage)
+{
+}
+
+//=======================================================================
+
+
+void CNULLRenderer::EF_Eval_DeformVerts(TArray<SDeform>* Defs)
+{
+}
+
+void CNULLRenderer::EF_Eval_TexGen(SShaderPass *sfm)
+{
+}
+
+void CNULLRenderer::EF_Eval_RGBAGen(SShaderPass *sfm)
+{
+}
+
+void CNULLRenderer::EF_EvalNormalsRB(SShader *ef)
+{
+}
+
+//=================================================================================
+
+void CNULLRenderer::PS2SetCull(ECull eCull)
+{ 
+  m_RP.m_eCull = eCull;
+}
+
+
+void CRenderer::EF_SetState(int st)
+{
+  m_CurState = st;
+}
+
+void CNULLRenderer::EF_SetColorOp(byte co)
+{
+}
+
+//=================================================================================
+
+DEFINE_ALIGNED_DATA_STATIC( Matrix44, sIdentityMatrix( 1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1 ), 16 ); 
+
+// Get inverted matrix of the object matrix
+// All matrices are 16 bytes alligned to speedup matrix calculations using SSE instructions
+Matrix44 &CCObject::GetInvMatrix()
+{
+  return sIdentityMatrix;
+}
+
+
+bool CNULLRenderer::EF_ObjectChange(SShader *Shader, int nObject, CRendElement *pRE)
+{
+  return true;
+}
+
+
+// Initialize of the new shader pipeline (only 2d)
+void CNULLRenderer::EF_Start(SShader *ef, SShader *efState, SRenderShaderResources *Res, CRendElement *re) 
+{
+  m_RP.m_Frame++;
+}
+
+// Initialize of the new shader pipeline
+void CNULLRenderer::EF_Start(SShader *ef, SShader *efState, SRenderShaderResources *Res, int numFog, CRendElement *re)
+{
+  m_RP.m_Frame++;
+}
+
+void CNULLRenderer::EF_CheckOverflow(int nVerts, int nInds, CRendElement *re)
+{
+}
+
+//========================================================================================
+
+void CNULLRenderer::EF_LightMaterial(SLightMaterial *lm, int Flags)
+{
+}
+
+//===================================================================================================
+
+// Used for HW effectors for rendering of tri mesh (vertex array)
+void CNULLRenderer::EF_DrawIndexedMesh (int nPrimType)
+{
+}
+
+
+void CNULLRenderer::EF_FlushShader()
+{
+}
+
+void CNULLRenderer::EF_Flush()
+{
+}
+
+void CNULLRenderer::EF_EndEf3D(int nFlags)
+{
+  m_RP.m_RealTime = iTimer->GetCurrTime();
+  EF_RemovePolysFromScene();
+  SRendItem::m_RecurseLevel--;
+}
+
+void CNULLRenderer::EF_RenderPipeLine(void (*RenderFunc)())
+{
+}
+
+void CNULLRenderer::EF_PipeLine(int nums, int nume, int nList, int nSortType, void (*RenderFunc)())
+{
+}
+
+void CNULLRenderer::EF_DrawWire()
+{
+}
+
+void CNULLRenderer::EF_DrawNormals()
+{
+}
+
+void CNULLRenderer::EF_DrawTangents()
+{
+}
+
+void CNULLRenderer::EF_DrawDebugLights()
+{
+}
+
+void CNULLRenderer::EF_DrawDebugTools()
+{
+}
+
+
+void CNULLRenderer::EF_PrintProfileInfo()
+{
+}
+
+int CNULLRenderer::EF_Preprocess(SRendItemPre *ri, int nums, int nume)
+{
+  return 0;
+}
+
+//double timeFtoI, timeFtoL, timeQRound;
+//int sSome;
+void CNULLRenderer::EF_EndEf2D(bool bSort)
+{
+}

RenderDll/XRenderNULL/NULL_Renderer.cpp

@@ -0,0 +1,415 @@
+//////////////////////////////////////////////////////////////////////
+//
+//  Crytek CryENGINE Source code
+//  
+//  File:NULL_Renderer.cpp
+//  Description: Implementation of the NULL renderer API
+//
+//  History:
+//  -Jan 31,2001:Originally created by Marco Corbetta
+//	-: taken over by Andrey Khonich
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "RenderPCH.h"
+#include "NULL_Renderer.h"
+
+// init memory pool usage
+#ifndef PS2
+#ifndef _XBOX
+//#if !defined(LINUX)
+_ACCESS_POOL;
+//#endif
+#endif
+#endif
+
+#include "limits.h"
+
+CNULLRenderer *gcpNULL = NULL;
+
+//////////////////////////////////////////////////////////////////////
+CNULLRenderer::CNULLRenderer()
+{
+  gcpNULL = this;
+
+#ifdef DEBUGALLOC
+#undef new
+#endif
+  m_TexMan = new CNULLTexMan;
+#ifdef DEBUGALLOC
+#define new DEBUG_CLIENTBLOCK
+#endif
+  
+}
+
+
+#include <stdio.h>
+//////////////////////////////////////////////////////////////////////
+CNULLRenderer::~CNULLRenderer()
+{ 
+  ShutDown(); 
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::EnableTMU(bool enable)
+{ 
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::CheckError(const char *comment)
+{
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::BeginFrame()
+{
+}
+
+//////////////////////////////////////////////////////////////////////
+bool CNULLRenderer::ChangeDisplay(unsigned int width,unsigned int height,unsigned int bpp)
+{
+  return false;
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::ChangeViewport(unsigned int x,unsigned int y,unsigned int width,unsigned int height)
+{
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::Update()
+{
+  m_TexMan->Update();    
+}
+
+void CNULLRenderer::GetMemoryUsage(ICrySizer* Sizer)
+{
+}
+
+WIN_HWND CNULLRenderer::GetHWND()
+{
+  return NULL;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+//IMAGES DRAWING
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::Draw2dImage(float xpos,float ypos,float w,float h,int texture_id,float s0,float t0,float s1,float t1,float angle,float r,float g,float b,float a, float z)
+{ 
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::DrawImage(float xpos,float ypos,float w,float h,int texture_id,float s0,float t0,float s1,float t1,float r,float g,float b,float a)
+{ 
+}
+
+///////////////////////////////////////////
+void CNULLRenderer::SetCullMode(int mode)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+//ENVI/BLEND MODES
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+//FOG
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////
+void CNULLRenderer::SetFog(float density,float fogstart,float fogend,const float *color,int fogmode)
+{
+}
+
+///////////////////////////////////////////
+bool CNULLRenderer::EnableFog(bool enable)
+{
+  return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TEXGEN 
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////
+void CNULLRenderer::EnableTexGen(bool enable)
+{
+}
+
+///////////////////////////////////////////
+void CNULLRenderer::SetTexgen(float scaleX,float scaleY,float translateX,float translateY)
+{        
+}
+
+void CNULLRenderer::SetTexgen3D(float x1, float y1, float z1, float x2, float y2, float z2)
+{        
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+//MISC EXTENSIONS
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////
+void CNULLRenderer::SetLodBias(float value)
+{  
+}
+
+///////////////////////////////////////////
+void CNULLRenderer::EnableVSync(bool enable)
+{
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::SelectTMU(int tnum)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+//MATRIX FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////
+void CNULLRenderer::PushMatrix()
+{
+}
+
+///////////////////////////////////////////
+void CNULLRenderer::RotateMatrix(float a,float x,float y,float z)
+{
+}
+
+void CNULLRenderer::RotateMatrix(const Vec3d & angles)
+{
+}
+
+///////////////////////////////////////////
+void CNULLRenderer::TranslateMatrix(float x,float y,float z)
+{
+}
+
+void CNULLRenderer::MultMatrix(float * mat)
+{
+}
+
+void CNULLRenderer::TranslateMatrix(const Vec3d &pos)
+{
+}
+
+///////////////////////////////////////////
+void CNULLRenderer::ScaleMatrix(float x,float y,float z)
+{
+}
+
+///////////////////////////////////////////
+void CNULLRenderer::PopMatrix()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+void CNULLRenderer::LoadMatrix(const Matrix44 *src)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+//MISC
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void CNULLRenderer::Flush3dBBox(const Vec3d &mins,const Vec3d &maxs,const bool bSolid)
+{
+}
+
+///////////////////////////////////////////
+void CNULLRenderer::Draw3dBBox(const Vec3d &mins,const Vec3d &maxs, int nPrimType)
+{
+}
+
+
+///////////////////////////////////////////
+int CNULLRenderer::SetPolygonMode(int mode)
+{
+  return 0;
+}
+
+
+///////////////////////////////////////////
+void CNULLRenderer::SetPerspective(const CCamera &cam)
+{
+}
+
+///////////////////////////////////////////
+void CNULLRenderer::SetCamera(const CCamera &cam)
+{
+  m_cam=cam;
+}
+
+void CNULLRenderer::SetViewport(int x, int y, int width, int height)
+{
+}
+
+void CNULLRenderer::SetScissor(int x, int y, int width, int height)
+{
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::GetModelViewMatrix(float * mat)
+{
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::GetModelViewMatrix(double *mat)
+{
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::GetProjectionMatrix(double *mat)
+{
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::GetProjectionMatrix(float *mat)
+{
+}
+
+//////////////////////////////////////////////////////////////////////
+Vec3d CNULLRenderer::GetUnProject(const Vec3d &WindowCoords,const CCamera &cam)
+{
+  return (Vec3d(0,0,0));
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::DrawQuad(const Vec3d &right, const Vec3d &up, const Vec3d &origin,int nFlipmode/*=0*/)
+{
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::ProjectToScreen( float ptx, float pty, float ptz, float *sx, float *sy, float *sz )
+{
+}
+
+int CNULLRenderer::UnProject(float sx, float sy, float sz, 
+              float *px, float *py, float *pz,
+              const float modelMatrix[16], 
+              const float projMatrix[16], 
+              const int    viewport[4])
+{
+  return 0;
+}
+
+//////////////////////////////////////////////////////////////////////
+int CNULLRenderer::UnProjectFromScreen( float  sx, float  sy, float  sz, 
+                                      float *px, float *py, float *pz)
+{
+  return 0;
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::Draw2dLine	(float x1,float y1,float x2,float y2)
+{
+}
+
+void CNULLRenderer::DrawLine(const Vec3d & vPos1, const Vec3d & vPos2)
+{
+}
+
+void CNULLRenderer::DrawLineColor(const Vec3d & vPos1, const CFColor & vColor1, const Vec3d & vPos2, const CFColor & vColor2)
+{
+}
+
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::ScreenShot(const char *filename)
+{
+}
+
+int CNULLRenderer::ScreenToTexture()
+{ // for death effects
+  return 0;
+}
+
+void CNULLRenderer::ResetToDefault()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+//FONT RENDERING
+////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////
+void CNULLRenderer::WriteXY(CXFont *currfont,int x, int y, float xscale,float yscale,float r,float g,float b,float a,const char *message, ...)
+{	
+}
+
+void CNULLRenderer::SetMaterialColor(float r, float g, float b, float a)
+{
+}
+
+char * CNULLRenderer::GetStatusText(ERendStats type)
+{
+  return NULL;
+}
+
+void CNULLRenderer::DrawBall(float x, float y, float z, float radius )
+{
+}
+
+void CNULLRenderer::DrawBall(const Vec3d & pos, float radius )
+{
+}
+
+void CNULLRenderer::DrawPoint(float x, float y, float z, float fSize)
+{
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::ClearDepthBuffer()
+{
+}
+
+void CNULLRenderer::ClearColorBuffer(const Vec3d vColor)
+{
+}
+
+void CNULLRenderer::ReadFrameBuffer(unsigned char * pRGB, int nSizeX, int nSizeY, bool bBackBuffer, bool bRGBA, int nScaledX, int nScaledY)
+{
+}
+
+void CNULLRenderer::SetFogColor(float * color)
+{
+}
+
+void CNULLRenderer::TransformTextureMatrix(float x, float y, float angle, float scale)
+{
+}
+
+void CNULLRenderer::ResetTextureMatrix()
+{
+}
+
+
+void CNULLRenderer::SetClipPlane( int id, float * params )
+{
+}
+
+void CNULLRenderer::DrawQuad(float dy,float dx, float dz, float x, float y, float z)
+{
+}
+
+void CNULLRenderer::EnableAALines(bool bEnable)
+{
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::Set2DMode(bool enable, int ortox, int ortoy)
+{ 
+}
+
+// ps2 to create matrix
+void CNULLRenderer::MakeMatrix(const Vec3d & pos, const Vec3d & angles,const Vec3d & scale, Matrix44 * mat)
+{
+}
+
+//=========================================================================================
+

RenderDll/XRenderNULL/NULL_Renderer.h

@@ -0,0 +1,398 @@
+
+//////////////////////////////////////////////////////////////////////
+//
+//  Crytek CryENGINE Source code
+//  
+//  File:PS2_Renderer.h - PS2 API 
+//
+//  History:
+//  -Jan 31,2001:Originally created by Marco Corbetta
+//  -: taken over by Andrey Khonich
+//
+//////////////////////////////////////////////////////////////////////
+
+#ifndef PS2_RENDERER_H
+#define PS2_RENDERER_H
+
+#if _MSC_VER > 1000
+# pragma once
+#endif
+
+/*
+===========================================
+The NULLRenderer interface Class
+===========================================
+*/
+
+#define MAX_TEXTURE_STAGES 4
+
+#include "list2.h"
+
+typedef std::map<int,STexPic*> TTextureMap;
+typedef TTextureMap::iterator TTextureMapItor;
+
+
+//////////////////////////////////////////////////////////////////////
+class CNULLRenderer : public CRenderer
+{
+  friend class CNULLTexMan;
+
+public: 
+
+  CNULLRenderer();
+  ~CNULLRenderer();
+  
+#ifndef PS2 
+  virtual WIN_HWND Init(int x,int y,int width,int height,unsigned int cbpp, int zbpp, int sbits, bool fullscreen,WIN_HINSTANCE hinst, WIN_HWND Glhwnd=0, WIN_HDC Glhdc=0, WIN_HGLRC hGLrc=0, bool bReInit=false);
+#else //PS2
+  virtual bool Init(int x,int y,int width,int height,unsigned int cbpp, int zbpp, int sbits, bool fullscreen, bool bReInit=false);
+#endif  //endif 
+  virtual WIN_HWND GetHWND();
+  virtual bool SetCurrentContext(WIN_HWND hWnd);
+  virtual bool CreateContext(WIN_HWND hWnd, bool bAllowFSAA=false);
+  virtual bool DeleteContext(WIN_HWND hWnd);
+
+  virtual int  CreateRenderTarget (int nWidth, int nHeight, ETEX_Format eTF=eTF_8888) {return 0;}
+  virtual bool DestroyRenderTarget (int nHandle) {return true;}
+  virtual bool SetRenderTarget (int nHandle) {return true;}
+
+  virtual void  ShareResources( IRenderer *renderer );
+
+  virtual void  MakeCurrent();
+
+  virtual void  ShutDown(bool bReInit=false);
+
+  virtual bool  SetGammaDelta(const float fGamma);
+
+  virtual void  BeginFrame(void);
+  virtual void  Update(void); 
+  virtual void  GetMemoryUsage(ICrySizer* Sizer);
+  virtual void  RefreshResources(int nFlags);
+  virtual int   EnumDisplayFormats(TArray<SDispFormat>& Formats, bool bReset);
+  //! Return all supported by video card video AA formats
+  virtual int	EnumAAFormats(TArray<SAAFormat>& Formats, bool bReset) { return 0; }
+
+  virtual bool	ChangeResolution(int nNewWidth, int nNewHeight, int nNewColDepth, int nNewRefreshHZ, bool bFullScreen);
+  virtual void	Reset (void) {};
+  virtual	void	CheckError(const char *comment);
+
+  virtual void *GetDynVBPtr(int nVerts, int &nOffs, int Pool);
+  virtual void DrawDynVB(int nOffs, int Pool, int nVerts);
+  virtual void DrawDynVB(struct_VERTEX_FORMAT_P3F_COL4UB_TEX2F *pBuf, ushort *pInds, int nVerts, int nInds, int nPrimType);
+  virtual CVertexBuffer	*CreateBuffer(int  buffersize,int vertexformat, const char *szSource, bool bDynamic=false);
+  virtual void  CreateBuffer(int size, int vertexformat, CVertexBuffer *buf, int Type, const char *szSource);
+  virtual void	ReleaseBuffer(CVertexBuffer *bufptr);
+  virtual void	DrawBuffer(CVertexBuffer *src,SVertexStream *indicies,int numindices, int offsindex, int prmode,int vert_start=0,int vert_stop=0, CMatInfo *mi=NULL);
+  virtual void	UpdateBuffer(CVertexBuffer *dest,const void *src,int size, bool bUnlock, int offs=0, int Type=0);
+  virtual void  DrawTriStrip(CVertexBuffer *src, int vert_num);
+
+  virtual void  CreateIndexBuffer(SVertexStream *dest,const void *src,int indexcount);
+  virtual void  UpdateIndexBuffer(SVertexStream *dest,const void *src,int indexcount, bool bUnLock=true);
+  virtual void  ReleaseIndexBuffer(SVertexStream *dest);
+
+  virtual void  SetFenceCompleted(CVertexBuffer * buffer);
+
+  // low-level Render-states
+  virtual void  SetCullMode (int mode=R_CULL_BACK);
+  virtual void  EnableTexGen(bool enable); 
+  virtual void  SetTexgen(float scaleX,float scaleY,float translateX,float translateY);
+  virtual void  SetTexgen3D(float x1, float y1, float z1, float x2, float y2, float z2);
+  virtual void  SetLodBias(float value);
+  virtual void  EnableVSync(bool enable);
+  virtual void  EnableAALines(bool bEnable);
+  virtual int   SetPolygonMode(int mode);
+  virtual void  SetClipPlane(int id, float * params);
+
+  // global fog 
+  virtual void  SetFogColor(float * color);
+  virtual bool  EnableFog (bool enable);
+  virtual void  SetFog(float density,float fogstart,float fogend,const float *color,int fogmode);
+
+  // matrix/camera/viewport manipulations
+  virtual void  PushMatrix();
+  virtual void  RotateMatrix(float a,float x,float y,float z);
+  virtual void  RotateMatrix(const Vec3d & angels);
+  virtual void  TranslateMatrix(float x,float y,float z);
+  virtual void  ScaleMatrix(float x,float y,float z);
+  virtual void  TranslateMatrix(const Vec3d &pos);
+  virtual void  MultMatrix(float * mat);
+  virtual void  PopMatrix();
+  virtual void  LoadMatrix(const Matrix44 *src);
+  virtual void  ProjectToScreen(float ptx, float pty, float ptz, float *sx, float *sy, float *sz );
+  virtual int   UnProject(float sx, float sy, float sz, float *px, float *py, float *pz, const float modelMatrix[16], const float projMatrix[16], const int viewport[4]);
+  virtual int   UnProjectFromScreen( float  sx, float  sy, float  sz, float *px, float *py, float *pz);
+  virtual void  GetModelViewMatrix(float *mat);
+  virtual void  GetModelViewMatrix(double *mat);
+  virtual void  GetProjectionMatrix(double *mat);
+  virtual void  GetProjectionMatrix(float *mat);
+  virtual Vec3d GetUnProject(const Vec3d &WindowCoords,const CCamera &cam);
+  virtual void  Set2DMode(bool enable, int ortox, int ortoy);
+  virtual void  SetCamera(const CCamera &cam);
+  virtual void  SetViewport(int x=0, int y=0, int width=0, int height=0);
+  virtual void  SetScissor(int x=0, int y=0, int width=0, int height=0);
+  virtual bool  ChangeDisplay(unsigned int width,unsigned int height,unsigned int cbpp);
+  virtual void  ChangeViewport(unsigned int x,unsigned int y,unsigned int width,unsigned int height);
+  virtual void  SetPerspective(const CCamera &cam);
+
+  // draw helper functions
+  virtual void  DrawObjSprites (list2<CStatObjInst*> *pList, float fMaxViewDist, CObjManager *pObjMan);
+  virtual void  DrawQuad(const Vec3d &right, const Vec3d &up, const Vec3d &origin,int nFlipMode=0);
+  virtual void  DrawQuad(float dy,float dx, float dz, float x, float y, float z);
+  virtual void  Draw3dBBox(const Vec3d &mins,const Vec3d &maxs, int nPrimType);
+  virtual void  Flush3dBBox(const Vec3d &mins,const Vec3d &maxs,const bool bSolid);
+  virtual void  WriteXY(CXFont *currfont,int x,int y, float xscale,float yscale,float r,float g,float b,float a,const char *message, ...);  
+  virtual void	Draw2dImage(float xpos,float ypos,float w,float h,int textureid,float s0=0,float t0=0,float s1=1,float t1=1,float angle=0,float r=1,float g=1,float b=1,float a=1,float z=1);
+  virtual void  DrawImage(float xpos,float ypos,float w,float h,int texture_id,float s0,float t0,float s1,float t1,float r,float g,float b,float a);
+  virtual void  Draw2dLine  (float x1,float y1,float x2,float y2);
+  virtual void  DrawLine(const Vec3d & vPos1, const Vec3d & vPos2);
+  virtual void  DrawLineColor(const Vec3d & vPos1, const CFColor & vColor1, const Vec3d & vPos2, const CFColor & vColor2);
+  virtual void  DrawBall(float x, float y, float z, float radius);
+  virtual void  DrawBall(const Vec3d & pos, float radius );
+  virtual void  DrawPoint(float x, float y, float z, float fSize = 0.0f);
+
+  virtual char*	GetVertexProfile(bool bSupported) {return "NONE";}
+  virtual char*	GetPixelProfile(bool bSupported) {return "NONE";}
+
+  // basic textures operations
+  virtual unsigned int DownLoadToVideoMemory(unsigned char *data,int w, int h, ETEX_Format eTFSrc, ETEX_Format eTFDst, int nummipmap, bool repeat=true, int filter=FILTER_BILINEAR, int Id=0, char *szCacheName=NULL, int flags=0);
+  virtual void  UpdateTextureInVideoMemory(uint tid, unsigned char *data,int posx,int posy,int w,int h,ETEX_Format eTF=eTF_0888);
+  virtual void  RemoveTexture(unsigned int TextureId);
+  virtual void  RemoveTexture(ITexPic * pTexPic);
+  virtual uint  LoadTexture(const char * filename,int *tex_type=NULL,unsigned int def_tid=0,bool compresstodisk=true,bool bWarn=true);
+  virtual void  SetTexture(int tnum, ETexType eTT=eTT_Base);  
+  virtual void  SetTexture3D(int tid3d);
+  virtual int   LoadAnimatedTexture(const char * format,const int nCount);
+  virtual int   GenerateAlphaGlowTexture(float k);
+  virtual uint  MakeSprite(float object_scale, int tex_size, float angle, IStatObj * pStatObj, uchar * pTmpBuffer, uint def_tid);
+  virtual uint  Make3DSprite(int nTexSize, float fAngleStep, IStatObj * pStatObj);
+  virtual void  TransformTextureMatrix(float x, float y, float angle, float scale);
+  virtual void  ResetTextureMatrix();
+  virtual int   ScreenToTexture();
+  virtual void  SetTexClampMode(bool clamp);
+  virtual void  MakeMatrix(const Vec3d & pos, const Vec3d & angles,const Vec3d & scale, Matrix44 * mat);
+
+  virtual void DrawPoints(Vec3d v[], int nump, CFColor& col, int flags) {}
+  virtual void DrawLines(Vec3d v[], int nump, CFColor& col, int flags, float fGround) {}
+
+  // texture unit manupulations
+  virtual void  EnableTMU(bool enable); 
+  virtual void  SelectTMU(int tnum);
+
+  // misc functions
+  virtual void  ResetToDefault();
+  virtual void  ScreenShot(const char *filename=NULL);
+  virtual void  ClearDepthBuffer();
+  virtual void  ClearColorBuffer(const Vec3d vColor);
+  virtual void  ReadFrameBuffer(unsigned char * pRGB, int nSizeX, int nSizeY, bool bBackBuffer, bool bRGBA, int nScaledX=-1, int nScaledY=-1);  
+  virtual void  SetMaterialColor(float r, float g, float b, float a);
+  virtual char *GetStatusText(ERendStats type);
+  
+  // font functions
+  virtual bool  FontUploadTexture(class CFBitmap*, ETEX_Format eTF=eTF_8888);
+  virtual	int   FontCreateTexture(int Width, int Height, byte *pData, ETEX_Format eTF=eTF_8888) { return -1; };
+  virtual	bool  FontUpdateTexture(int nTexId, int X, int Y, int USize, int VSize, byte *pData);
+  virtual void  FontReleaseTexture(class CFBitmap *pBmp);
+  virtual void  FontSetTexture(class CFBitmap*, int nFilterMode);
+  virtual void  FontSetTexture(int nTexId, int nFilterMode) {};
+  virtual void  FontSetRenderingState(unsigned long nVirtualScreenWidth, unsigned long nVirtualScreenHeight);
+  virtual void  FontSetBlending(int src, int dst);
+  virtual void  FontRestoreRenderingState();
+  virtual void  FontSetState(bool bRestore);
+  virtual void  PrintToScreen(float x, float y, float size, const char *buf);
+  virtual void  DrawString(int x, int y,bool bIgnoreColor,const char *message, ...) {};
+
+  void PrepareDepthMap(ShadowMapFrustum * lof, bool make_new_tid);
+  virtual void SetupShadowOnlyPass(int Num, ShadowMapFrustum * pFrustum, Vec3d * vShadowTrans, const float fShadowScale, Vec3d vObjTrans=Vec3d(0,0,0), float fObjScale=1.f, const Vec3d vObjAngles=Vec3d(0,0,0), Matrix44 * pObjMat=0);
+	virtual void OnEntityDeleted(IEntityRender * pEntityRender);
+	void DrawAllShadowsOnTheScreen();
+
+  virtual void EF_PolygonOffset(bool bEnable, float fFactor, float fUnits) {};
+
+private:
+  void PS2SetDefaultState();
+  void SetGamma(float fGamma);
+
+  //========================================================================
+  // Shaders pipeline
+
+  void PS2SetCull(ECull eCull);
+
+  void EF_InitWaveTables();
+  void EF_InitRandTables();
+  void EF_InitEvalFuncs(int nums);
+  void EF_ClearBuffers(bool bForce=false, float *Colors=NULL);
+  void EF_SetCameraInfo();
+  void EF_SetObjectTransform(CCObject *obj);
+  bool EF_ObjectChange(SShader *Shader, int nObject, CRendElement *re);
+  void EF_PreRender(int Stage);
+
+  void EF_Eval_DeformVerts(TArray<SDeform>* Defs);
+  void EF_Eval_TexGen(SShaderPass *sfm);
+  void EF_Eval_RGBAGen(SShaderPass *sfm);
+  void EF_EvalNormalsRB(SShader *ef);
+
+  void EF_DrawIndexedMesh (int nPrimType);
+  void EF_FlushShader();
+  void EF_RenderPipeLine(void (*RenderFunc)());
+  void EF_PipeLine(int nums, int nume, int nList, int nSortType, void (*RenderFunc)());
+  int  EF_Preprocess(SRendItemPre *ri, int First, int End);
+  void EF_PrintProfileInfo();
+
+  void EF_DrawDebugLights();
+  void EF_DrawDebugTools();
+  void EF_DrawFogOverlay();
+  void EF_DrawDetailOverlay();
+  void EF_DrawDecalOverlay();
+
+  static void EF_Flush();
+  static void EF_DrawWire();
+  static void EF_DrawNormals();
+  static void EF_DrawTangents();
+
+  _inline void EF_Draw(SShader *sh, SShaderPass *sl)
+  {
+    if (!CV_r_nodrawshaders)
+    {
+      if (m_RP.m_pRE)
+        m_RP.m_pRE->mfDraw(sh, sl);
+      else
+        EF_DrawIndexedMesh(R_PRIMV_TRIANGLES);
+    }
+  }
+
+  // init render pipeline
+  void EF_PipelineInit();
+
+  // shutdown render pipeline
+  void EF_PipelineShutdown();
+
+public:
+  void EF_SetClipPlane (bool bEnable, float *pPlane, bool bRefract);
+  void EF_SetColorOp(byte eCO);
+  void EF_CalcObjectMatrix(CCObject *obj);
+
+public:
+  virtual STexPic *EF_MakePhongTexture(int Exp);
+  virtual void EF_CheckOverflow(int nVerts, int nTris, CRendElement *re);
+  virtual void EF_Start(SShader *ef, SShader *efState, SRenderShaderResources *Res, int nFog, CRendElement *re);
+  virtual void EF_Start(SShader *ef, SShader *efState, SRenderShaderResources *Res, CRendElement *re);
+  virtual bool EF_SetLightHole(Vec3d vPos, Vec3d vNormal, int idTex, float fScale=1.0f, bool bAdditive=true);
+  virtual void EF_Release(int nFlags);
+  virtual int  EF_RegisterFogVolume(float fMaxFogDist, float fFogLayerZ, CFColor color, int nIndex=-1, bool bCaustics=false);
+  virtual void EF_LightMaterial(SLightMaterial *lm, int Flags);
+	virtual void SetColorOp(byte eCo, byte eAo, byte eCa, byte eAa){};
+
+  // Draw all shaded Render items
+  virtual void EF_EndEf3D (int nFlags);
+
+  /////////////////////////////////////////////////////////////////////////////////
+  // 2d interface for the shaders
+  /////////////////////////////////////////////////////////////////////////////////
+  virtual void EF_EndEf2D(bool bSort);
+
+};
+
+//=============================================================================
+
+extern CNULLRenderer *gcpNULL;
+
+struct CNULLTexUnit
+{
+  int m_Bind;
+  int m_Target;
+  float m_fTexFilterLodBias;
+};
+
+class CNULLTexMan : public CTexMan
+{
+
+protected:
+  virtual STexPic *CreateTexture(const char *name, int wdt, int hgt, int Depth, uint flags, uint flags2, byte *dst, ETexType eTT, float fAmount1=-1.0f, float fAmount2=-1.0f, int DXTSize=0, STexPic *ti=NULL, int bind=0, ETEX_Format eTF=eTF_8888, const char *szSourceName=NULL);
+  virtual STexPic *CopyTexture(const char *name, STexPic *ti, int CubeSide=-1);
+
+public:  
+  static int TexSize(int wdt, int hgt, int mode);
+  static int GetTexSrcFormat(ETEX_Format eTF);
+  static int GetTexDstFormat(ETEX_Format eTF);
+  static void CalcMipsAndSize(STexPic *ti);
+  static ETEX_Format GetTexFormat(int GLFormat);
+  static void BindNULL(int From)
+  {
+  }
+
+  static _inline void SetTextureTarget(int Stage, int Target)
+  {
+  }
+
+  static _inline void ResetTextureTarget(int Stage)
+  {
+  }
+
+  CNULLTexMan() : CTexMan()
+  {
+  }
+  virtual ~CNULLTexMan();
+  
+  virtual byte *GenerateDXT_HW(STexPic *ti, EImFormat eF, byte *dst, int *numMips, int *DXTSize, bool bMips=true);
+  virtual void SetTexture(int Id, ETexType eTT);
+  virtual bool SetFilter(char *filt);
+  virtual void UpdateTextureData(STexPic *pic, byte *data, int USize, int VSize, bool bProc, int State, bool bPal);
+  virtual void UpdateTextureRegion(STexPic *pic, byte *data, int X, int Y, int USize, int VSize) {};
+  virtual STexPic *CreateTexture();
+  virtual void GetAverageColor(SEnvTexture *cm, int nSide) {}
+  virtual bool ScanEnvironmentCM (const char *name, int size, Vec3d& Pos) {return true;}
+  virtual void ScanEnvironmentCube(SEnvTexture *cm, int RendFlags, int Size, bool bLightCube) {}
+  virtual void ScanEnvironmentTexture(SEnvTexture *cm, SShader *pSH, SRenderShaderResources *pRes, int RendFlags, bool bUseExistingREs) {}
+  virtual void EndCubeSide(CCObject *obj, bool bNeedClear) {}
+  virtual void StartCubeSide(CCObject *obj) {}
+  virtual void DrawToTexture(Plane& Pl, STexPic *Tex, int RendFlags) {}
+  virtual void DrawToTextureForDof(int Id) {};
+  virtual void DrawToTextureForGlare(int Id) {}
+  virtual void DrawToTextureForRainMap(int Id) {}
+  virtual void StartHeatMap(int Id) {}
+  virtual void EndHeatMap() {}
+  virtual void StartRefractMap(int Id) {};
+  virtual void EndRefractMap() {};
+  virtual void StartNightMap(int Id) {}
+  virtual void EndNightMap() {}
+  virtual void Update() {}
+  virtual void GenerateFuncTextures() {}
+
+  virtual void DrawFlashBangMap(int Id, int RendFlags, CREFlashBang *pRE) {}
+  // tiago: added
+  virtual void DrawMotionMap(void) {}
+  virtual void DrawScreenContrastMap(void) {}
+  virtual void DrawScreenColorTransferMap(void) {}    
+  virtual void StartScreenTexMap(int Id) {}
+  virtual void EndScreenTexMap() {}
+  virtual bool PreloadScreenFxMaps(void)  { return 0; }
+
+  virtual void StartScreenMap(int Id) {}
+  virtual void EndScreenMap() {}
+
+  virtual STexPic *AddToHash(int Id, STexPic *ti);
+  virtual void RemoveFromHash(int Id, STexPic *ti);
+  virtual STexPic *GetByID(int Id);
+
+  static TTextureMap m_RefTexs;
+
+  static int m_Format;
+
+  static CNULLTexUnit m_TUState[8];
+
+#ifdef DEBUGALLOC
+#undef new
+#endif
+  void* operator new( size_t Size )
+  {
+    void *ptr = malloc(Size);
+    memset(ptr, 0, Size);
+    return ptr;
+  }
+#ifdef DEBUGALLOC
+#define new DEBUG_CLIENTBLOCK
+#endif
+};
+
+
+#endif //ps2_renderer

RenderDll/XRenderNULL/NULL_Shaders.cpp

@@ -0,0 +1,249 @@
+/*=============================================================================
+  PS2_Shaders.cpp : PS2 specific effectors/shaders functions implementation.
+  Copyright 2001 Crytek Studios. All Rights Reserved.
+
+  Revision history:
+    * Created by Honitch Andrey
+
+=============================================================================*/
+
+#include "RenderPCH.h"
+#include "NULL_Renderer.h"
+#include "I3dengine.h"
+
+
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+
+//============================================================================
+
+
+void CShader::mfCompileVarsPak(char *scr, TArray<CVarCond>& Vars, SShader *ef)
+{
+  char *var;
+  char *val;
+
+  while ((shGetVar (&scr, &var, &val)) >= 0)
+  {
+    if (!var)
+      continue;
+
+    ICVar *vr = iConsole->GetCVar(var);
+    if (!vr)
+    {
+      iLog->Log("Warning: Couldn't find console variable '%s' in shader '%s'\n", var, ef->m_Name.c_str());
+      continue;
+    }
+    float v = shGetFloat(val);
+    CVarCond vc;
+    vc.m_Var = vr;
+    vc.m_Val = v;
+    Vars.AddElem(vc);
+  }
+}
+
+bool CShader::mfCompileHWShadeLayer(SShader *ef, char *scr, TArray<SShaderPassHW>& Layers)
+{
+  return true;
+}
+
+void CShader::mfCompileLayers(SShader *ef, char *scr, TArray<SShaderPassHW>& Layers, EShaderPassType eType)
+{
+}
+
+void CShader::mfCompileHWConditions(SShader *ef, char *scr, SShaderTechnique *hs, int Id)
+{
+}
+
+SShaderTechnique *CShader::mfCompileHW(SShader *ef, char *scr, int Id)
+{
+  return NULL;
+}
+
+//===================================================================
+
+//====================================================================
+
+SGenTC *SGenTC_NormalMap::mfCopy()
+{
+  return NULL;
+}
+
+bool SGenTC_NormalMap::mfSet(bool bEnable)
+{
+  return true;
+}
+
+
+void SGenTC_NormalMap::mfCompile(char *params, SShader *ef)
+{
+}
+
+SGenTC *SGenTC_ReflectionMap::mfCopy()
+{
+  return NULL;
+}
+
+bool SGenTC_ReflectionMap::mfSet(bool bEnable)
+{
+  return true;
+}
+
+void SGenTC_ReflectionMap::mfCompile(char *params, SShader *ef)
+{
+}
+
+SGenTC *SGenTC_ObjectLinear::mfCopy()
+{
+  return NULL;
+}
+
+bool SGenTC_ObjectLinear::mfSet(bool bEnable)
+{
+  return true;
+}
+
+void SGenTC_ObjectLinear::mfCompile(char *scr, SShader *ef)
+{
+}
+
+SGenTC *SGenTC_EyeLinear::mfCopy()
+{
+  return NULL;
+}
+
+bool SGenTC_EyeLinear::mfSet(bool bEnable)
+{
+  return true;
+}
+
+void SGenTC_EyeLinear::mfCompile(char *scr, SShader *ef)
+{
+}
+
+SGenTC *SGenTC_SphereMap::mfCopy()
+{
+  return NULL;
+}
+
+bool SGenTC_SphereMap::mfSet(bool bEnable)
+{
+  return true;
+}
+
+void SGenTC_SphereMap::mfCompile(char *params, SShader *ef)
+{
+}
+
+
+SGenTC *SGenTC_EmbossMap::mfCopy()
+{
+  return NULL;
+}
+
+
+bool SGenTC_EmbossMap::mfSet(bool bEnable)
+{
+  return true;
+}
+
+void SGenTC_EmbossMap::mfCompile(char *params, SShader *ef)
+{
+}
+
+bool CShader::mfCompileTexGen(char *name, char *params, SShader *ef, SShaderTexUnit *ml)
+{
+  return true;
+}
+
+//====================================================================
+// Matrix operations
+
+
+void CShader::mfCompileMatrixOp(TArray<SMatrixTransform>* List, char *scr, char *nmMat, SShader *ef)
+{
+}
+
+void SMatrixTransform_LightCMProject::mfSet(bool bSet)
+{
+}
+void SMatrixTransform_LightCMProject::mfSet(Matrix44& matr)
+{
+}
+
+
+void SMatrixTransform_Identity::mfSet(bool bSet)
+{
+}
+void SMatrixTransform_Identity::mfSet(Matrix44& matr)
+{
+  matr.SetIdentity();
+}
+
+void SMatrixTransform_Translate::mfSet(bool bSet)
+{
+}
+void SMatrixTransform_Translate::mfSet(Matrix44& matr)
+{
+}
+
+void SMatrixTransform_Scale::mfSet(bool bSet)
+{
+}
+void SMatrixTransform_Scale::mfSet(Matrix44& matr)
+{
+}
+
+void SMatrixTransform_Matrix::mfSet(bool bSet)
+{
+}
+void SMatrixTransform_Matrix::mfSet(Matrix44& matr)
+{
+}
+
+void SMatrixTransform_Rotate::mfSet(bool bSet)
+{
+}
+void SMatrixTransform_Rotate::mfSet(Matrix44& matr)
+{
+}
+
+//====================================================================
+// Array pointers for PS2
+//================================================================
+
+void SArrayPointer_Vertex::mfSet(int Id)
+{
+}
+
+//=========================================================================================
+
+void SArrayPointer_Normal::mfSet(int Id)
+{
+}
+
+//=========================================================================================
+
+void SArrayPointer_Texture::mfSet(int Id)
+{
+}
+
+//=========================================================================================
+
+void SArrayPointer_Color::mfSet(int Id)
+{
+}
+
+//=========================================================================================
+
+void SArrayPointer_SecColor::mfSet(int Id)
+{
+}
+
+//=========================================================================================
+
+float SParamComp_Fog::mfGet()
+{
+  return 0;
+}
+

RenderDll/XRenderNULL/NULL_Shadows.cpp

@@ -0,0 +1,35 @@
+//////////////////////////////////////////////////////////////////////
+//
+//  Crytek CryENGINE Source code
+//  
+//  File: PS2_Shadows.cpp
+//  Description: Implementation of the shadow maps using PS2 renderer API
+//  shadow map calculations
+//
+//  History:
+//  -Jan 31,2001:Created by Vladimir Kajain
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "RenderPCH.h"
+#include "NULL_Renderer.h"
+#include "../Common/shadow_renderer.h"
+
+#include "I3dengine.h"
+
+// render depth/shadow map into texture from light source position
+void CNULLRenderer::PrepareDepthMap(ShadowMapFrustum * lof, bool make_new_tid)
+{
+}
+
+void CNULLRenderer::SetupShadowOnlyPass(int Num, ShadowMapFrustum * pFrustum, Vec3d * vShadowTrans, const float fShadowScale, Vec3d vObjTrans, float fObjScale, const Vec3d vObjAngles, Matrix44 * pObjMat)
+{
+}
+
+void CNULLRenderer::OnEntityDeleted(IEntityRender * pEntityRender)
+{
+}
+
+void CNULLRenderer::DrawAllShadowsOnTheScreen()
+{
+}

RenderDll/XRenderNULL/NULL_System.cpp

@@ -0,0 +1,170 @@
+/*=============================================================================
+  PS2_System.cpp : HW depended PS2 functions and extensions handling.
+  Copyright (c) 2001 Crytek Studios. All Rights Reserved.
+
+  Revision history:
+    * Created by Honitch Andrey
+
+=============================================================================*/
+
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+
+
+#include "RenderPCH.h"
+#include "NULL_Renderer.h"
+
+
+bool CNULLRenderer::SetGammaDelta(const float fGamma)
+{
+  m_fDeltaGamma = fGamma;
+  return true;
+}
+
+void CNULLRenderer::SetGamma(float fGamma)
+{
+}
+
+void CNULLRenderer::MakeCurrent()
+{
+}
+
+void CNULLRenderer::ShareResources( IRenderer *renderer )
+{
+}
+
+
+int CNULLRenderer::EnumDisplayFormats(TArray<SDispFormat>& Formats, bool bReset)
+{
+  return 0;
+}
+
+bool CNULLRenderer::ChangeResolution(int nNewWidth, int nNewHeight, int nNewColDepth, int nNewRefreshHZ, bool bFullScreen)
+{
+  return false;
+}
+
+void CNULLRenderer::PS2SetDefaultState()
+{
+}
+
+WIN_HWND CNULLRenderer::Init(int x,int y,int width,int height,unsigned int cbpp, int zbpp, int sbits, bool fullscreen,WIN_HINSTANCE hinst, WIN_HWND Glhwnd, WIN_HDC Glhdc, WIN_HGLRC hGLrc, bool bReInit)
+{
+  //=======================================
+  // Add init code here
+  //=======================================
+
+  PS2SetDefaultState();
+
+  SetPolygonMode(R_SOLID_MODE);
+
+  SetGamma(CV_r_gamma+m_fDeltaGamma);
+
+  m_width = width;
+  m_height = height;
+  
+  if (bReInit)
+  {
+    iLog->Log("Reload textures\n");
+    RefreshResources(0);
+  }
+
+  iLog->Log("Init Shaders\n");
+
+  gRenDev->m_cEF.mfInit();
+  EF_PipelineInit();
+
+#if defined(LINUX)
+	return (WIN_HWND)this;//it just get checked against NULL anyway
+#else
+  return (WIN_HWND)GetDesktopWindow();
+#endif
+}
+
+
+bool CNULLRenderer::SetCurrentContext(WIN_HWND hWnd)
+{
+  return true;
+}
+
+bool CNULLRenderer::CreateContext(WIN_HWND hWnd, bool bAllowFSAA)
+{
+  return true;
+}
+
+bool CNULLRenderer::DeleteContext(WIN_HWND hWnd)
+{
+  return true;
+}
+
+void CNULLRenderer::RefreshResources(int nFlags)
+{
+  if (nFlags & FRO_TEXTURES)
+    m_TexMan->ReloadAll(nFlags);
+  if (nFlags & (FRO_SHADERS | FRO_SHADERTEXTURES))
+    gRenDev->m_cEF.mfReloadAllShaders(nFlags);
+}
+
+void CNULLRenderer::ShutDown(bool bReInit)
+{
+  FreeResources(FRR_ALL);
+  EF_PipelineShutdown();
+  CName::mfExitSubsystem();
+}
+
+
+//=======================================================================
+
+ILog     *iLog;
+IConsole *iConsole;
+ITimer   *iTimer;
+ISystem  *iSystem;
+//CVars    *cVars;
+int *pTest_int;
+//CryCharManager *pCharMan;
+IPhysicalWorld *pIPhysicalWorld;
+
+ISystem* GetISystem()
+{
+	return iSystem;
+}
+
+extern "C" DLL_EXPORT IRenderer* PackageRenderConstructor(int argc, char* argv[], SCryRenderInterface *sp);
+DLL_EXPORT IRenderer* PackageRenderConstructor(int argc, char* argv[], SCryRenderInterface *sp)
+{
+  gbRgb = false;
+
+  iConsole  = sp->ipConsole;
+  iLog      = sp->ipLog;
+  iTimer    = sp->ipTimer;
+  iSystem   = sp->ipSystem;
+//  cVars     = sp->ipVars;
+  pTest_int = sp->ipTest_int;
+	pIPhysicalWorld = sp->pIPhysicalWorld;
+//  pCharMan = sp->ipCharMan;
+
+#ifdef DEBUGALLOC
+#undef new
+#endif
+  CRenderer *rd = (CRenderer *) (new CNULLRenderer());
+#ifdef DEBUGALLOC
+#define new DEBUG_CLIENTBLOCK
+#endif
+
+#ifdef LINUX
+	srand( clock() );
+#else
+  srand( GetTickCount() );
+#endif
+
+  return rd;
+}
+
+void *gGet_D3DDevice()
+{
+  return NULL;
+}
+void *gGet_glReadPixels()
+{
+  return NULL;
+}

RenderDll/XRenderNULL/NULL_Textures.cpp

@@ -0,0 +1,299 @@
+/*=============================================================================
+  PS2_Textures.cpp : PS2 specific texture manager implementation.
+  Copyright (c) 2001 Crytek Studios. All Rights Reserved.
+
+  Revision history:
+    * Created by Honitch Andrey
+
+=============================================================================*/
+
+#include "RenderPCH.h"
+#include "NULL_Renderer.h"
+
+TTextureMap CNULLTexMan::m_RefTexs;
+CNULLTexUnit CNULLTexMan::m_TUState[8];
+int nTexSize=0;
+int nFrameTexSize=0;
+int BindSizes[TX_LASTBIND];
+int BindFrame[TX_LASTBIND];
+
+//=================================================================================
+
+byte *STexPic::GetData32()
+{
+  return NULL;
+}
+
+bool STexPic::SetFilter(int nFilter)
+{
+  return true;
+}
+
+void STexPic::SaveJPG(const char *nam, bool bMips)
+{
+}
+
+void STexPic::SaveTGA(const char *nam, bool bMips)
+{
+}
+
+void STexPic::ReleaseDriverTexture()
+{
+}
+
+void STexPic::SetWrapping()
+{
+}
+
+void STexPic::SetFilter()
+{
+}
+
+STexPic *CNULLTexMan::GetByID(int Id)
+{
+  if (Id >= TX_FIRSTBIND)
+  {
+    int n = Id - TX_FIRSTBIND;
+    if (n < m_Textures.Num())
+    {
+      STexPic *tp = m_Textures[n];
+      if (tp && tp->m_Bind == Id)
+        return tp;
+    }
+  }
+  TTextureMapItor it = m_RefTexs.find(Id);
+  if (it != m_RefTexs.end())
+    return it->second;
+  return NULL;
+}
+
+void CNULLTexMan::RemoveFromHash(int Id, STexPic *ti)
+{
+  TTextureMapItor it = m_RefTexs.find(Id);
+  if (it != m_RefTexs.end())
+  {
+    if (ti)
+      assert(ti == it->second);
+    m_RefTexs.erase(Id);
+  }
+}
+
+STexPic *CNULLTexMan::AddToHash(int Id, STexPic *ti)
+{
+  TTextureMapItor it = m_RefTexs.find(Id);
+  if (it == m_RefTexs.end())
+    m_RefTexs.insert(TTextureMapItor::value_type(Id, ti));
+  else
+    assert(ti == it->second);
+  return ti;
+}
+
+void STexPic::SetClamp(bool bEnable)
+{
+}
+
+void CNULLTexMan::SetTexture(int Id, ETexType eTT)
+{
+}
+
+void STexPic::Set(int nTexSlot)
+{
+}
+
+int STexPic::DstFormatFromTexFormat(ETEX_Format eTF)
+{
+  return 0;
+}
+int STexPic::TexSize(int Width, int Height, int DstFormat)
+{
+  return 0;
+}
+
+int SShaderTexUnit::mfSetTexture(int nt)
+{
+  return 1;
+}
+
+bool SShaderPass::mfSetTextures()
+{
+  return true;
+}
+void SShaderPass::mfResetTextures()
+{
+}
+
+
+CNULLTexMan::~CNULLTexMan()
+{
+}
+
+
+STexPic *CNULLTexMan::CreateTexture()
+{
+#ifdef DEBUGALLOC
+#undef new
+#endif
+  return new STexPic;
+#ifdef DEBUGALLOC
+#define new DEBUG_CLIENTBLOCK
+#endif
+}
+
+bool CNULLTexMan::SetFilter(char *tex)  
+{
+  return true;
+}
+
+void CNULLTexMan::CalcMipsAndSize(STexPic *ti)
+{
+}
+
+ETEX_Format CNULLTexMan::GetTexFormat(int PS2Format)
+{
+  return eTF_Unknown;
+}
+
+int CNULLTexMan::GetTexDstFormat(ETEX_Format eTF)
+{
+  return 0;
+}
+
+int CNULLTexMan::GetTexSrcFormat(ETEX_Format eTF)
+{
+  return 0;
+}
+
+int CNULLTexMan::TexSize(int wdt, int hgt, int mode)
+{
+  return 0;
+}
+
+//==================================================================================
+extern int nTexSize;
+extern int nFrameTexSize;
+
+int TexCallback( const void* arg1, const void* arg2 )
+{
+  STexPic **pi1 = (STexPic **)arg1;
+  STexPic **pi2 = (STexPic **)arg2;
+  STexPic *ti1 = *pi1;
+  STexPic *ti2 = *pi2;
+  if (ti1->m_Size > ti2->m_Size)
+    return -1;
+  if (ti1->m_Size < ti2->m_Size)
+    return 1;
+  return 0;
+}
+
+STexPic *CNULLTexMan::CopyTexture(const char *name, STexPic *tiSrc, int CubeSide)
+{
+  return NULL;
+}
+
+STexPic *CNULLTexMan::CreateTexture(const char *name, int wdt, int hgt, int Depth, uint flags, uint flags2, byte *dst, ETexType eTT, float fAmount1, float fAmount2, int DXTSize, STexPic *ti, int bind, ETEX_Format eTF, const char *szSourceName)
+{
+  return NULL;
+}
+
+
+
+byte *CNULLTexMan::GenerateDXT_HW(STexPic *ti, EImFormat eF, byte *dst, int *numMips, int *DXTSize, bool bMips)
+{
+  return NULL;
+}
+
+void CNULLTexMan::UpdateTextureData(STexPic *pic, byte *data, int USize, int VSize, bool bProc, int State, bool bPal)
+{
+}
+
+//=========================================================================
+// Offscreen drawing functions
+
+//=========================================================================
+// Renderer interface functions
+
+void CNULLRenderer::SetTexture(int tnum, ETexType Type)
+{
+}
+
+void CNULLRenderer::SetTexture3D(int tid3d)
+{
+}
+
+uint CNULLRenderer::DownLoadToVideoMemory(unsigned char *data,int w, int h, ETEX_Format eTFSrc, ETEX_Format eTFDst, int nummipmap, bool repeat, int filter, int Id, char *szCacheName, int flags)
+{
+  return 0;
+}
+
+//////////////////////////////////////////////////////////////////////
+void CNULLRenderer::UpdateTextureInVideoMemory(uint tnum, unsigned char *newdata,int posx,int posy,int w,int h,ETEX_Format eTF)
+{
+}
+
+void CNULLRenderer::RemoveTexture(ITexPic * pTexPic)
+{
+  if(!pTexPic)
+    return;
+
+  STexPic * pSTexPic = (STexPic *)pTexPic;
+  pSTexPic->Release(false);
+}
+
+void CNULLRenderer::RemoveTexture(unsigned int nTextureId)
+{
+  if(nTextureId)
+  {
+    STexPic *tp = m_TexMan->GetByID(nTextureId);
+    if (tp)
+      tp->Release(false);
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////////
+uint CNULLRenderer::LoadTexture(const char * _filename,int *tex_type,unsigned int def_tid,bool compresstodisk,bool bWarn)
+{
+  return m_TexMan->m_Text_NoTexture->GetTextureID();
+}
+
+int CNULLRenderer::LoadAnimatedTexture(const char * szFileNameFormat,const int nCount)
+{
+  return 0;
+}
+
+
+void CNULLRenderer::SetTexClampMode(bool clamp)
+{
+}
+
+void CNULLRenderer::DrawObjSprites (list2<CStatObjInst*> *pList, float fMaxViewDist, CObjManager *pObjMan)
+{
+}
+
+uint CNULLRenderer::MakeSprite(float _object_scale, int nTexSize, float angle, IStatObj * pStatObj, uchar * _pTmpBuffer, uint def_tid)
+{
+  return 0;
+}
+
+uint CNULLRenderer::Make3DSprite(int nTexSize, float fAngleStep, IStatObj * pStatObj)
+{
+  return 0;
+}
+
+int CNULLRenderer::GenerateAlphaGlowTexture(float k)
+{
+  return 0;
+}
+
+bool CNULLRenderer::EF_SetLightHole(Vec3d vPos, Vec3d vNormal, int idTex, float fScale, bool bAdditive)
+{
+  return false;
+}
+
+STexPic *CNULLRenderer::EF_MakePhongTexture(int Exp)
+{
+  return NULL;
+}
+
+void STexPic::Preload (int Flags)
+{
+}

RenderDll/XRenderNULL/NULL_TexturesStreaming.cpp

@@ -0,0 +1,39 @@
+/*=============================================================================
+  PS2_TexturesStreaming.cpp : PS2 specific texture streaming technology.
+  Copyright (c) 2001 Crytek Studios. All Rights Reserved.
+
+  Revision history:
+    * Created by Honitch Andrey
+
+=============================================================================*/
+
+#include "RenderPCH.h"
+#include "NULL_Renderer.h"
+
+//===============================================================================
+
+void STexPic::BuildMips()
+{
+}
+
+bool STexPic::UploadMips(int nStartMip, int nEndMip)
+{
+  return true;
+}
+
+void STexPic::RemoveFromPool()
+{
+}
+
+void CTexMan::UnloadOldTextures(STexPic *pExclude)
+{
+}
+
+void CTexMan::CheckTexLimits(STexPic *pExclude)
+{
+}
+
+void STexPic::PrecacheAsynchronously(float fDist, int Flags)
+{
+}
+

RenderDll/XRenderNULL/NULL_VertBuffer.cpp

@@ -0,0 +1,160 @@
+//////////////////////////////////////////////////////////////////////
+//
+//  Crytek CryENGINE Source code
+//  
+//  File: PS2_VertBuffer.cpp
+//  Description: Implementation of the vertex buffer management
+//
+//  History:
+//  -Jan 31,2001:Created by Vladimir Kajalin
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "RenderPCH.h"
+#include "NULL_Renderer.h"
+
+void *CVertexBuffer::GetStream(int nStream, int *nOffs)
+{
+  return NULL;
+}
+
+void *CNULLRenderer::GetDynVBPtr(int nVerts, int &nOffs, int Pool)
+{
+  return m_DynVB;
+}
+
+void CNULLRenderer::DrawDynVB(int nOffs, int Pool, int nVerts)
+{
+}
+
+void CNULLRenderer::DrawDynVB(struct_VERTEX_FORMAT_P3F_COL4UB_TEX2F *pBuf, ushort *pInds, int nVerts, int nInds, int nPrimType)
+{
+}
+
+// allocates vertex buffer
+void CNULLRenderer::CreateBuffer(int size, int vertexformat, CVertexBuffer *buf, int Type, const char *szSource)
+{
+  assert(Type >= 0 && Type <= 3);
+
+  void *data;
+
+  // System buffer 
+  data=new unsigned char [size];
+  buf->m_VS[Type].m_VData = data;
+}
+
+CVertexBuffer *CNULLRenderer::CreateBuffer(int vertexcount,int vertexformat, const char *szSource, bool bDynamic)
+{
+  CVertexBuffer * vtemp = new CVertexBuffer;
+
+  vtemp->m_bDynamic = bDynamic;
+
+  int size = m_VertexSize[vertexformat]*vertexcount;
+  // System buffer 
+  vtemp->m_VS[VSF_GENERAL].m_VData = new unsigned char [size];
+  vtemp->m_fence = 0;
+
+  vtemp->m_vertexformat=vertexformat;
+  vtemp->m_NumVerts = vertexcount;
+
+  return (vtemp);
+}
+
+
+///////////////////////////////////////////
+void CNULLRenderer::DrawBuffer(CVertexBuffer *src,SVertexStream *indicies,int numindices, int offsindex, int prmode,int vert_start,int vert_stop, CMatInfo *mi)
+{
+}
+
+
+void CNULLRenderer::SetFenceCompleted(CVertexBuffer * buffer)
+{ 
+}
+
+///////////////////////////////////////////
+// Updates the vertex buffer dest with the data from src
+// NOTE: src may be NULL, in which case the data will not be copied
+void CNULLRenderer::UpdateBuffer(CVertexBuffer *dest,const void *src,int vertexcount, bool bUnlock, int offs, int Type)
+{
+  assert (Type >= 0 && Type <= 2);
+
+  // NOTE: some subsystems need to initialize the system buffer without actually intializing its values;
+	// for that purpose, src may sometimes be NULL
+  if(src && vertexcount)
+  {
+    assert(vertexcount<=dest->m_NumVerts);
+    if(vertexcount>dest->m_NumVerts)
+    {
+      iLog->Log("CNULLRenderer::UpdateBuffer: vertexcount>dest->m_NumVerts");
+      return;
+    }
+
+    byte *dst = (byte *)dest->m_VS[Type].m_VData;
+    if (dst)
+    {
+      if (Type == VSF_GENERAL)
+        memcpy(&dst[m_VertexSize[dest->m_vertexformat]*offs],src,m_VertexSize[dest->m_vertexformat]*vertexcount);
+      else
+      if (Type == VSF_TANGENTS)
+        memcpy(&dst[sizeof(SPipTangents)*offs],src,sizeof(SPipTangents)*vertexcount);
+    }
+  }
+}
+
+///////////////////////////////////////////
+void CNULLRenderer::ReleaseBuffer(CVertexBuffer *bufptr)
+{
+  if (bufptr)
+  {
+    SAFE_DELETE_ARRAY(bufptr->m_VS[VSF_GENERAL].m_VData);
+    SAFE_DELETE_ARRAY(bufptr->m_VS[VSF_TANGENTS].m_VData);
+
+    delete bufptr;
+  } 
+}
+
+///////////////////////////////////////////
+void CNULLRenderer::DrawTriStrip(CVertexBuffer *src, int vert_num)
+{ 
+}
+
+
+void CLeafBuffer::DrawImmediately()
+{						
+}
+
+void CNULLRenderer::CreateIndexBuffer(SVertexStream *dest,const void *src,int indexcount)
+{
+  SAFE_DELETE_ARRAY(dest->m_VData);
+  dest->m_nItems = 0;
+  if (indexcount)
+  {
+    dest->m_VData = new ushort[indexcount];
+    dest->m_nItems = indexcount;
+  }
+  if (src && indexcount)
+  {
+    cryMemcpy(dest->m_VData, src, indexcount*sizeof(ushort));
+    m_RP.m_PS.m_MeshUpdateBytes += indexcount*sizeof(ushort);
+  }
+}
+void CNULLRenderer::UpdateIndexBuffer(SVertexStream *dest,const void *src,int indexcount, bool bUnLock)
+{
+  PROFILE_FRAME(Mesh_UpdateIBuffers);
+  if (src && indexcount)
+  {
+    if (dest->m_nItems < indexcount)
+    {
+      delete [] dest->m_VData;
+      dest->m_VData = new ushort[indexcount];
+      dest->m_nItems = indexcount;
+    }
+    cryMemcpy(dest->m_VData, src, indexcount*sizeof(ushort));
+    m_RP.m_PS.m_MeshUpdateBytes += indexcount*sizeof(ushort);
+  }
+}
+void CNULLRenderer::ReleaseIndexBuffer(SVertexStream *dest)
+{
+  SAFE_DELETE_ARRAY(dest->m_VData);
+  dest->Reset();
+}

RenderDll/XRenderNULL/XRenderNULL.vcproj

@@ -0,0 +1,820 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="XRenderNULL"
+	ProjectGUID="{1EE58697-2D3E-454A-BA80-2455F7EA14A0}"
+	SccProjectName="Perforce Project"
+	SccAuxPath=""
+	SccLocalPath=".."
+	SccProvider="MSSCCI:Perforce SCM"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="D:\Games\FC\Bin32"
+			IntermediateDirectory="Debug"
+			ConfigurationType="2"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="0"
+				AdditionalIncludeDirectories="..\..\CryCommon"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;NULL_RENDERER;DO_ASM"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="3"
+				PrecompiledHeaderThrough="RenderPCH.h"
+				AssemblerListingLocation=""
+				ObjectFile="$(IntDir)/"
+				ProgramDataBaseFileName="$(IntDir)/vc70.pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="TRUE"
+				SubSystem="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="D:\Games\FC\Bin32"
+			IntermediateDirectory="Release"
+			ConfigurationType="2"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				FavorSizeOrSpeed="2"
+				OmitFramePointers="TRUE"
+				EnableFiberSafeOptimizations="FALSE"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="..\..\CryCommon"
+				PreprocessorDefinitions="_RELEASE;WIN32;NDEBUG;_WINDOWS;NULL_RENDERER;DO_ASM"
+				StringPooling="TRUE"
+				RuntimeLibrary="2"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="FALSE"
+				EnableEnhancedInstructionSet="0"
+				UsePrecompiledHeader="3"
+				PrecompiledHeaderThrough="RenderPCH.h"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="TRUE"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Profile|Win32"
+			OutputDirectory="D:\Games\FC\Bin32"
+			IntermediateDirectory="Profile"
+			ConfigurationType="2"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				FavorSizeOrSpeed="2"
+				OmitFramePointers="TRUE"
+				EnableFiberSafeOptimizations="FALSE"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="..\..\CryCommon"
+				PreprocessorDefinitions="_RELEASE;WIN32;NDEBUG;_WINDOWS;NULL_RENDERER;DO_ASM"
+				StringPooling="TRUE"
+				RuntimeLibrary="4"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="FALSE"
+				EnableEnhancedInstructionSet="0"
+				UsePrecompiledHeader="3"
+				PrecompiledHeaderThrough="RenderPCH.h"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				GenerateDebugInformation="TRUE"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				BaseAddress="0x38000000"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug64|Win32"
+			OutputDirectory="D:\Games\FC\Bin32"
+			IntermediateDirectory="Debug64"
+			ConfigurationType="2"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\..\CryCommon"
+				PreprocessorDefinitions="_AMD64_;WIN64;WIN32;_DEBUG;_WINDOWS;NULL_RENDERER"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="0"
+				RuntimeLibrary="3"
+				BufferSecurityCheck="FALSE"
+				UsePrecompiledHeader="3"
+				PrecompiledHeaderThrough="RenderPCH.h"
+				AssemblerListingLocation="$(IntDir)/"
+				ObjectFile="$(IntDir)/"
+				ProgramDataBaseFileName="$(IntDir)/$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:AMD64"
+				AdditionalDependencies="../../CryCommon/fSinCos64.lib"
+				OutputFile="$(OutDir)/$(ProjectName).dll"
+				LinkIncremental="2"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/$(ProjectName).pdb"
+				SubSystem="2"
+				LargeAddressAware="2"
+				ImportLibrary="$(OutDir)/$(ProjectName).lib"
+				TargetMachine="0"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release64|Win32"
+			OutputDirectory="D:\Games\FC\Bin32"
+			IntermediateDirectory="Release64"
+			ConfigurationType="2"
+			CharacterSet="2"
+			WholeProgramOptimization="TRUE">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				AdditionalIncludeDirectories="..\..\CryCommon"
+				PreprocessorDefinitions="_RELEASE;NDEBUG;WIN64;WIN32;_AMD64_;_WINDOWS;NULL_RENDERER"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="0"
+				RuntimeLibrary="2"
+				BufferSecurityCheck="FALSE"
+				UsePrecompiledHeader="3"
+				PrecompiledHeaderThrough="RenderPCH.h"
+				AssemblerListingLocation="$(IntDir)/"
+				ObjectFile="$(IntDir)/"
+				ProgramDataBaseFileName="$(IntDir)/$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:AMD64"
+				AdditionalDependencies="../../CryCommon/fSinCos64.lib"
+				OutputFile="$(OutDir)/$(ProjectName).dll"
+				LinkIncremental="1"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/$(ProjectName).pdb"
+				SubSystem="2"
+				ImportLibrary="$(OutDir)/$(ProjectName).lib"
+				TargetMachine="0"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm">
+			<File
+				RelativePath="NULL_Font.cpp">
+			</File>
+			<File
+				RelativePath="NULL_Renderer.cpp">
+			</File>
+			<File
+				RelativePath="NULL_RendPipeline.cpp">
+			</File>
+			<File
+				RelativePath="NULL_REOcean.cpp">
+			</File>
+			<File
+				RelativePath="NULL_RERender.cpp">
+			</File>
+			<File
+				RelativePath="NULL_Shaders.cpp">
+			</File>
+			<File
+				RelativePath="NULL_Shadows.cpp">
+			</File>
+			<File
+				RelativePath="NULL_System.cpp">
+			</File>
+			<File
+				RelativePath="NULL_Textures.cpp">
+			</File>
+			<File
+				RelativePath="NULL_TexturesStreaming.cpp">
+			</File>
+			<File
+				RelativePath="NULL_VertBuffer.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc">
+			<File
+				RelativePath="NULL_Renderer.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Common">
+			<File
+				RelativePath="..\Common\3DUtils.cpp">
+			</File>
+			<File
+				RelativePath="..\Common\CRT.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Profile|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\Common\EvalFuncs_C.cpp">
+			</File>
+			<File
+				RelativePath="..\Common\EvalFuncs_RE.cpp">
+			</File>
+			<File
+				RelativePath="..\Common\LightMaterial.cpp">
+			</File>
+			<File
+				RelativePath="..\Common\Names.cpp">
+			</File>
+			<File
+				RelativePath="..\Common\Renderer.cpp">
+			</File>
+			<File
+				RelativePath="..\Common\ResFile.cpp">
+			</File>
+			<File
+				RelativePath="..\Common\SimpleFrameProfiler.h">
+			</File>
+			<Filter
+				Name="Common_h">
+				<File
+					RelativePath="..\Common\3DUtils.h">
+				</File>
+				<File
+					RelativePath="..\Common\CommonRender.h">
+				</File>
+				<File
+					RelativePath="..\Common\Defs.h">
+				</File>
+				<File
+					RelativePath="..\Common\EvalFuncs.h">
+				</File>
+				<File
+					RelativePath="..\Common\LZSS.H">
+				</File>
+				<File
+					RelativePath="..\Common\Names.int">
+				</File>
+				<File
+					RelativePath="..\Common\Renderer.h">
+				</File>
+				<File
+					RelativePath="..\Common\RenderPipeline.h">
+				</File>
+				<File
+					RelativePath="..\Common\ResFile.h">
+				</File>
+				<File
+					RelativePath="..\Common\Shadow_Renderer.h">
+				</File>
+			</Filter>
+			<Filter
+				Name="RendElements">
+				<File
+					RelativePath="..\Common\RendElements\CRE2DQuad.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREBeam.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREClientPoly.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREClientPoly2D.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREDummy.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREFlares.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREGlare.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREHDRProcess.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREOcean.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREOcLeaf.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREOclusionQuery.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREParticleSpray.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREPolyBlend.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREPolyMesh.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREPrefabGeom.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREScreenProcess.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CREShadowMap.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CRESky.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CRETempMesh.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CRETerrainSector.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CRETriMeshAdditionalShadow.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\CRETriMeshShadow.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\FFT_SSE.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\RendElements\RendElement.cpp">
+				</File>
+				<Filter
+					Name="RendElements_h">
+					<File
+						RelativePath="..\Common\RendElements\CREBeam.h">
+					</File>
+					<File
+						RelativePath="..\Common\RendElements\CREClientPoly.h">
+					</File>
+					<File
+						RelativePath="..\Common\RendElements\CREClientPoly2D.h">
+					</File>
+					<File
+						RelativePath="..\Common\RendElements\CREFlares.h">
+					</File>
+					<File
+						RelativePath="..\Common\RendElements\CREGlare.h">
+					</File>
+					<File
+						RelativePath="..\Common\RendElements\CREHDRProcess.h">
+					</File>
+					<File
+						RelativePath="..\Common\RendElements\CREHeat.h">
+					</File>
+					<File
+						RelativePath="..\Common\RendElements\CREOcean.h">
+					</File>
+					<File
+						RelativePath="..\Common\RendElements\CREParticleSpray.h">
+					</File>
+					<File
+						RelativePath="..\Common\RendElements\CREPolyBlend.h">
+					</File>
+					<File
+						RelativePath="..\Common\RendElements\CREPrefabGeom.h">
+					</File>
+					<File
+						RelativePath="..\Common\RendElements\CRESkyZone.h">
+					</File>
+					<File
+						RelativePath="..\Common\RendElements\CRETempMesh.h">
+					</File>
+				</Filter>
+			</Filter>
+			<Filter
+				Name="Textures">
+				<File
+					RelativePath="..\Common\Textures\dxtlib.h">
+				</File>
+				<File
+					RelativePath="..\Common\Textures\TexMan.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\Textures\TexMan.h">
+				</File>
+				<File
+					RelativePath="..\Common\Textures\TexManShadows.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\Textures\TexManStreaming.cpp">
+				</File>
+				<Filter
+					Name="Image">
+					<File
+						RelativePath="..\Common\Textures\Image\BmpImage.cpp">
+					</File>
+					<File
+						RelativePath="..\Common\Textures\Image\CImage.cpp">
+					</File>
+					<File
+						RelativePath="..\Common\Textures\Image\DDSImage.cpp">
+					</File>
+					<File
+						RelativePath="..\Common\Textures\Image\inv_cmap.cpp">
+					</File>
+					<File
+						RelativePath="..\Common\Textures\Image\JpgImage.cpp">
+						<FileConfiguration
+							Name="Debug64|Win32"
+							ExcludedFromBuild="TRUE">
+							<Tool
+								Name="VCCLCompilerTool"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release64|Win32"
+							ExcludedFromBuild="TRUE">
+							<Tool
+								Name="VCCLCompilerTool"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath="..\Common\Textures\Image\PcxImage.cpp">
+					</File>
+					<File
+						RelativePath="..\Common\Textures\Image\Quantize.cpp">
+					</File>
+					<File
+						RelativePath="..\Common\Textures\Image\TgaImage.cpp">
+					</File>
+					<Filter
+						Name="Image_h">
+						<File
+							RelativePath="..\Common\Textures\Image\BmpImage.h">
+						</File>
+						<File
+							RelativePath="..\Common\Textures\Image\CImage.h">
+						</File>
+						<File
+							RelativePath="..\Common\Textures\Image\dds.h">
+						</File>
+						<File
+							RelativePath="..\Common\Textures\Image\DDSImage.h">
+						</File>
+						<File
+							RelativePath="..\Common\Textures\Image\GifImage.h">
+						</File>
+						<File
+							RelativePath="..\Common\Textures\Image\inv_cmap.h">
+						</File>
+						<File
+							RelativePath="..\Common\Textures\Image\JpgImage.h">
+						</File>
+						<File
+							RelativePath="..\Common\Textures\Image\PcxImage.h">
+						</File>
+						<File
+							RelativePath="..\Common\Textures\Image\Quantize.h">
+						</File>
+						<File
+							RelativePath="..\Common\Textures\Image\SHendian.h">
+						</File>
+						<File
+							RelativePath="..\Common\Textures\Image\TgaImage.h">
+						</File>
+					</Filter>
+				</Filter>
+			</Filter>
+			<Filter
+				Name="LeafBuffer">
+				<File
+					RelativePath="..\Common\LeafBufferCreate.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\LeafBufferRender.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\LeafBufferSerialize.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\pip_addons.cpp">
+				</File>
+			</Filter>
+			<Filter
+				Name="NvTriStrip">
+				<File
+					RelativePath="..\Common\NvTriStrip\NvTriStrip.cpp">
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Profile|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug64|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release64|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath="..\Common\NvTriStrip\NvTriStrip.h">
+				</File>
+				<File
+					RelativePath="..\Common\NvTriStrip\NvTriStripObjects.cpp">
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Profile|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug64|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release64|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath="..\Common\NvTriStrip\NvTriStripObjects.h">
+				</File>
+				<File
+					RelativePath="..\Common\NvTriStrip\VertexCache.h">
+				</File>
+			</Filter>
+			<Filter
+				Name="Shaders"
+				Filter="">
+				<File
+					RelativePath="..\Common\Shaders\CShader.h">
+				</File>
+				<File
+					RelativePath="..\Common\Shaders\Parser.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\Shaders\Parser.h">
+				</File>
+				<File
+					RelativePath="..\Common\Shaders\Shader.h">
+				</File>
+				<File
+					RelativePath="..\Common\Shaders\ShaderComponents.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\Shaders\ShaderCore.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\Shaders\ShaderParse.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\Shaders\ShaderScript.cpp">
+				</File>
+				<File
+					RelativePath="..\Common\Shaders\ShaderTemplate.cpp">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Libraries"
+			Filter="">
+			<File
+				RelativePath="Libraries\ijl15.lib">
+			</File>
+			<File
+				RelativePath=".\Libraries\nvDXTlib.lib">
+			</File>
+			<File
+				RelativePath="Libraries\NvTriStrip.lib">
+			</File>
+		</Filter>
+		<File
+			RelativePath="..\CrtOverrides.h">
+		</File>
+		<File
+			RelativePath="..\RenderPCH.cpp">
+			<FileConfiguration
+				Name="Debug|Win32">
+				<Tool
+					Name="VCCLCompilerTool"
+					UsePrecompiledHeader="1"/>
+			</FileConfiguration>
+			<FileConfiguration
+				Name="Release|Win32">
+				<Tool
+					Name="VCCLCompilerTool"
+					UsePrecompiledHeader="1"/>
+			</FileConfiguration>
+			<FileConfiguration
+				Name="Profile|Win32">
+				<Tool
+					Name="VCCLCompilerTool"
+					UsePrecompiledHeader="1"/>
+			</FileConfiguration>
+			<FileConfiguration
+				Name="Debug64|Win32">
+				<Tool
+					Name="VCCLCompilerTool"
+					UsePrecompiledHeader="1"/>
+			</FileConfiguration>
+			<FileConfiguration
+				Name="Release64|Win32">
+				<Tool
+					Name="VCCLCompilerTool"
+					UsePrecompiledHeader="1"/>
+			</FileConfiguration>
+		</File>
+		<File
+			RelativePath="..\RenderPCH.h">
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

RenderDll/XRenderNULL/XRenderNULL.vcproj.vspscc

@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = "relative:xrenderNULL"
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT"
+}