123

RenderDll/Common/RendElements/CRE2DQuad.cpp

@@ -0,0 +1,18 @@
+#include "RenderPCH.h"
+#include "RendElement.h"
+#include "CRE2DQuad.h"
+
+
+void *CRE2DQuad::mfGetPointer(ESrcPointer ePT, int *Stride, int Type, ESrcPointer Dst, int Flags)
+{
+  *Stride = sizeof(m_arrVerts[0]);
+
+  switch(ePT) 
+  {
+    case eSrcPointer_Vert:
+      return &m_arrVerts[0].xyz.x;
+    case eSrcPointer_Tex:
+      return &m_arrVerts[0].st[0];
+  }
+  return NULL;
+}

RenderDll/Common/RendElements/CREBeam.cpp

@@ -0,0 +1,243 @@
+#include "RenderPCH.h"
+#include "RendElement.h"
+#include "I3dengine.h"
+
+void CREBeam::mfPrepare(void)
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+
+  int Features = gRenDev->GetFeatures();
+
+  if (!m_pBuffer)
+  {
+    I3DEngine *eng = (I3DEngine *)iSystem->GetI3DEngine();
+    IStatObj *pObj = eng->MakeObject(m_ModelName.c_str(), NULL, evs_ShareAndSortForCache, false, false);	
+    m_pBuffer = pObj->GetLeafBuffer();
+    if (!m_pBuffer)
+    {
+      gRenDev->m_RP.m_pRE = NULL;
+      gRenDev->m_RP.m_RendNumIndices = 0;
+      gRenDev->m_RP.m_RendNumVerts = 0;
+      return;
+    }
+    Vec3d Mins = m_pBuffer->m_vBoxMin;
+    Vec3d Maxs = m_pBuffer->m_vBoxMax;
+
+    m_fLengthScale = Maxs.x;
+    m_fWidthScale  = Maxs.z;
+  }
+
+  CLeafBuffer *lb = m_pBuffer;
+  CMatInfo *mi = &(*lb->m_pMats)[0];
+
+  gRenDev->m_RP.m_pShader = (SShader *)mi->shaderItem.m_pShader->GetTemplate(-1);
+  gRenDev->m_RP.m_pShaderResources = mi->shaderItem.m_pShaderResources;
+  gRenDev->m_RP.m_pRE = mi->pRE;
+
+  // Choose appropriate shader technique depend on some input parameters
+  if (gRenDev->m_RP.m_pShader->m_HWTechniques.Num())
+  {
+    int nHW = gRenDev->EF_SelectHWTechnique(gRenDev->m_RP.m_pShader);
+    if (nHW >= 0)
+      gRenDev->m_RP.m_pCurTechnique = gRenDev->m_RP.m_pShader->m_HWTechniques[nHW];
+    else
+      gRenDev->m_RP.m_pCurTechnique = NULL;
+  }
+  else
+    gRenDev->m_RP.m_pCurTechnique = NULL;
+
+  CCObject *obj = gRenDev->m_RP.m_pCurObject;
+  obj->m_RE = this;
+  UParamVal pv;
+  pv.m_Float = m_fLengthScale;
+  SShaderParam::SetParam("origlength", &gRenDev->m_RP.m_pShader->m_PublicParams, pv, -1);
+
+  pv.m_Float = m_fWidthScale;
+  SShaderParam::SetParam("origwidth", &gRenDev->m_RP.m_pShader->m_PublicParams, pv, -1);
+
+  pv.m_Float = m_fLength;
+  SShaderParam::SetParam("length", &gRenDev->m_RP.m_pShader->m_PublicParams, pv, -1);
+
+  pv.m_Float = m_fStartRadius;
+  SShaderParam::SetParam("startradius", &gRenDev->m_RP.m_pShader->m_PublicParams, pv, -1);
+
+  pv.m_Float = m_fEndRadius;
+  SShaderParam::SetParam("endradius", &gRenDev->m_RP.m_pShader->m_PublicParams, pv, -1);
+
+  pv.m_Color[0] = m_StartColor[0];
+  pv.m_Color[1] = m_StartColor[1];
+  pv.m_Color[2] = m_StartColor[2];
+  pv.m_Color[3] = m_StartColor[3];
+  if (m_LightStyle == 0)
+  {
+    pv.m_Color[0] = obj->m_Color[0];
+    pv.m_Color[1] = obj->m_Color[1];
+    pv.m_Color[2] = obj->m_Color[2];
+  }
+  SShaderParam::SetParam("startcolor", &gRenDev->m_RP.m_pShader->m_PublicParams, pv, -1);
+
+  pv.m_Color[0] = m_EndColor[0];
+  pv.m_Color[1] = m_EndColor[1];
+  pv.m_Color[2] = m_EndColor[2];
+  pv.m_Color[3] = m_EndColor[3];
+  if (m_LightStyle == 0)
+  {
+    pv.m_Color[0] = obj->m_Color[0];
+    pv.m_Color[1] = obj->m_Color[1];
+    pv.m_Color[2] = obj->m_Color[2];
+  }
+  SShaderParam::SetParam("endcolor", &gRenDev->m_RP.m_pShader->m_PublicParams, pv, -1);
+
+  obj->m_ShaderParams = &gRenDev->m_RP.m_pShader->m_PublicParams;
+
+  gRenDev->m_RP.m_FirstVertex = mi->nFirstVertId;
+  gRenDev->m_RP.m_RendNumIndices = mi->nNumIndices;
+  gRenDev->m_RP.m_RendNumVerts = mi->nNumVerts;
+  gRenDev->m_RP.m_FirstIndex = mi->nFirstIndexId;
+}
+
+bool CREBeam::mfCompile(SShader *ef, char *scr)
+{
+  char* name;
+  long cmd;
+  char *params;
+  char *data;
+  
+  enum {eModel = 1, eLength, eStartRadius, eEndRadius, eStartColor, eEndColor, eLightStyle};
+  static tokenDesc commands[] =
+  {
+    {eModel, "Model"},
+    {eStartRadius, "StartRadius"},
+    {eEndRadius, "EndRadius"},
+    {eStartColor, "StartColor"},
+    {eEndColor, "EndColor"},
+    {eLightStyle, "LightStyle"},
+    {eLength, "Length"},
+    {0, 0},
+  };
+
+  I3DEngine *eng = (I3DEngine *)iSystem->GetI3DEngine();
+
+  while ((cmd = shGetObject (&scr, commands, &name, &params)) > 0)
+  {
+    data = NULL;
+    if (name)
+      data = name;
+    else
+    if (params)
+      data = params;
+      
+    switch (cmd)
+    {
+      case eModel: 
+        {
+          m_ModelName = data;
+          //IStatObj *pObj = eng->MakeObject(data, NULL, 0, false, false);	
+          //m_pBuffer = pObj->GetLeafBuffer();
+        }
+        break;
+
+      case eStartRadius:
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing StartRadius argument for Beam Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        m_fStartRadius = shGetFloat(data);
+        break;
+
+      case eEndRadius:
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing EndRadius argument for Beam Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        m_fEndRadius = shGetFloat(data);
+        break;
+
+      case eLightStyle:
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing LightStyle argument for Beam Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        m_LightStyle = shGetInt(data);
+        break;
+
+      case eLength:
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing Length argument for Beam Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        m_fLength = shGetFloat(data);
+        break;
+
+      case eStartColor:
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing StartColor argument for Beam Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        shGetColor(data, m_StartColor);
+        break;
+
+      case eEndColor:
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing EndColor argument for Beam Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        shGetColor(data, m_EndColor);
+        break;
+    }
+  }
+
+  if (!m_ModelName.c_str()[0])
+    return false;
+  SShaderParam *sp;
+
+  sp = new SShaderParam;
+  strcpy(sp->m_Name, "origlength");
+  sp->m_Type = eType_FLOAT;
+  sp->m_Value.m_Float = 10.0f;
+  m_ShaderParams.AddElem(sp);
+
+  sp = new SShaderParam;
+  strcpy(sp->m_Name, "origwidth");
+  sp->m_Type = eType_FLOAT;
+  sp->m_Value.m_Float = 1.0f;
+  m_ShaderParams.AddElem(sp);
+
+  sp = new SShaderParam;
+  strcpy(sp->m_Name, "startradius");
+  sp->m_Type = eType_FLOAT;
+  sp->m_Value.m_Float = 0.1f;
+  m_ShaderParams.AddElem(sp);
+
+  sp = new SShaderParam;
+  strcpy(sp->m_Name, "endradius");
+  sp->m_Type = eType_FLOAT;
+  sp->m_Value.m_Float = 1.0f;
+  m_ShaderParams.AddElem(sp);
+
+  sp = new SShaderParam;
+  strcpy(sp->m_Name, "startcolor");
+  sp->m_Type = eType_FCOLOR;
+  sp->m_Value.m_Color[0] = 1.0f;
+  sp->m_Value.m_Color[1] = 1.0f;
+  sp->m_Value.m_Color[2] = 1.0f;
+  sp->m_Value.m_Color[3] = 1.0f;
+  m_ShaderParams.AddElem(sp);
+
+  sp = new SShaderParam;
+  strcpy(sp->m_Name, "endcolor");
+  sp->m_Type = eType_FCOLOR;
+  sp->m_Value.m_Color[0] = 1.0f;
+  sp->m_Value.m_Color[1] = 1.0f;
+  sp->m_Value.m_Color[2] = 1.0f;
+  sp->m_Value.m_Color[3] = 0.1f;
+  m_ShaderParams.AddElem(sp);
+
+  return true;
+}

RenderDll/Common/RendElements/CREBeam.h

@@ -0,0 +1,50 @@
+
+#ifndef __CREBEAM_H__
+#define __CREBEAM_H__
+
+//=============================================================
+
+
+class CREBeam : public CRendElement
+{
+public:
+  struct CLeafBuffer * m_pBuffer;
+  float m_fFogScale;
+  TArray<SShaderParam *> m_ShaderParams;
+
+  CFColor m_StartColor;
+  CFColor m_EndColor;
+  float m_fStartRadius;
+  float m_fEndRadius;
+  int m_LightStyle;
+  float m_fLength;
+  float m_fLengthScale;
+  float m_fWidthScale;
+  string m_ModelName;
+
+public:
+  CREBeam()
+  {
+    mfSetType(eDATA_Beam);
+    m_fFogScale = 0;
+    m_pBuffer = NULL;
+    m_LightStyle = 0;
+    m_fLength = 1.0f;
+    mfUpdateFlags(FCEF_TRANSFORM);
+  }
+
+  virtual ~CREBeam()
+  {
+    for (int i=0; i<m_ShaderParams.Num(); i++)
+    {
+      SShaderParam *pr = m_ShaderParams[i];
+      SAFE_DELETE(pr);
+    }
+    m_ShaderParams.Free();
+  }
+
+  virtual void mfPrepare();
+  virtual bool mfCompile(SShader *ef, char *scr);
+};
+
+#endif  // __CREBEAM_H__

RenderDll/Common/RendElements/CREClientPoly.cpp

@@ -0,0 +1,157 @@
+/*=============================================================================
+	CClientPoly.cpp : implementation of Client polygons RE.
+	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 "RendElement.h"
+
+
+//===============================================================
+
+
+TArray<CREClientPoly *> CREClientPoly::mPolysStorage[4];
+
+CRendElement *CREClientPoly::mfCopyConstruct(void)
+{
+  CREClientPoly *cp = new CREClientPoly;
+  *cp = *this;
+  return cp;
+}
+
+float CREClientPoly::mfDistanceToCameraSquared(const CCObject & thisObject)
+{
+  CRenderer *rd = gRenDev;
+
+  if (m_fDistance >= 0)
+    return m_fDistance;
+
+  Vec3d vMid;
+  vMid.Set(0,0,0);
+  SColorVert *tv = mVerts;
+  for (int i=0; i<mNumVerts; i++, tv++)
+  {
+    vMid += tv->vert;
+  }
+  vMid /= (float)mNumVerts;
+
+  vMid += thisObject.GetTranslation();
+
+  Vec3d Delta = rd->m_RP.m_ViewOrg - vMid;
+  float fDist = GetLengthSquared(Delta);
+  m_fDistance = fDist;
+
+  return fDist;
+}
+
+void CREClientPoly::mfPrepare(void)
+{
+  CRenderer *rd = gRenDev;
+  SShader *ef = rd->m_RP.m_pShader;
+  byte *inds;
+  int i, n;
+  SColorVert *tv;
+
+  CREClientPoly::mRS.NumRendPolys++;
+
+  {
+    //PROFILE_FRAME_TOTAL(Mesh_REPrepare_Flush3DPoly);
+    rd->EF_CheckOverflow(mNumVerts, mNumIndices, this);
+  }
+
+  {
+    //PROFILE_FRAME_TOTAL(Mesh_REPrepare_3DPoly);
+
+    int savev = rd->m_RP.m_RendNumVerts;
+    int savei = rd->m_RP.m_RendNumIndices;
+
+    inds = mIndices;
+    n = rd->m_RP.m_RendNumVerts;
+    ushort *dinds = &rd->m_RP.m_RendIndices[rd->m_RP.m_RendNumIndices];
+    for (i=0; i<mNumIndices; i++, dinds++, inds++)
+    {
+      *dinds = *inds+n;
+    }
+    rd->m_RP.m_RendNumIndices += i;
+
+    byte *OffsT, *OffsD;
+    tv = mVerts;
+    UPipeVertex ptr = rd->m_RP.m_NextPtr;
+    switch(rd->m_RP.m_CurVFormat)
+    {
+      case VERTEX_FORMAT_P3F_COL4UB_TEX2F:
+        OffsT = rd->m_RP.m_OffsT + ptr.PtrB;
+        OffsD = rd->m_RP.m_OffsD + ptr.PtrB;
+        for (i=0; i<mNumVerts; i++, tv++, ptr.PtrB+=rd->m_RP.m_Stride, OffsT+=rd->m_RP.m_Stride, OffsD+=rd->m_RP.m_Stride)
+        {
+          *(Vec3 *)ptr.PtrB = tv->vert;
+          *(float *)(OffsT) = tv->dTC[0];
+          *(float *)(OffsT+4) = tv->dTC[1];
+          *(uint *)OffsD = tv->color.dcolor;
+        }
+    	  break;
+      default:
+        assert(false);
+    }
+    if (rd->m_RP.m_OffsD && gbRgb)
+    {
+      OffsD = rd->m_RP.m_OffsD + rd->m_RP.m_NextPtr.PtrB;
+      for (i=0; i<mNumVerts; i++, OffsD+=rd->m_RP.m_Stride)
+      {
+        *(uint *)(OffsD) = COLCONV(*(uint *)(OffsD));
+      }
+    }
+
+    gRenDev->m_RP.m_NextPtr = ptr;
+    gRenDev->m_RP.m_RendNumVerts += mNumVerts;
+
+    CREClientPoly::mRS.NumVerts += gRenDev->m_RP.m_RendNumVerts - savev; 
+    CREClientPoly::mRS.NumIndices += gRenDev->m_RP.m_RendNumIndices - savei; 
+  }
+}
+
+bool CREClientPoly::mfCullBox(Vec3d& vmin, Vec3d& vmax)
+{
+  CREClientPoly::mRS.NumOccPolys++;
+
+  //if(gfCullBox(vmin, vmax))
+  //  return true;
+
+  return false;
+}
+
+
+//=======================================================================
+
+SClientPolyStat CREClientPoly::mRS;
+
+void CREClientPoly::mfPrintStat()
+{
+/*  char str[1024];
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Indices: %i\n", mRS.NumIndices);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Verts: %i\n", mRS.NumVerts);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Render Client Polys: %i\n", mRS.NumRendPolys);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Occluded Client Polys: %i\n", mRS.NumOccPolys);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  gRenDev->mfPrintString ("\nClient Polygons status info:\n", PS_TRANSPARENT | PS_UP);*/
+}

RenderDll/Common/RendElements/CREClientPoly.h

@@ -0,0 +1,54 @@
+
+#ifndef __CRECLIENTPOLY_H__
+#define __CRECLIENTPOLY_H__
+
+//=============================================================
+
+struct SClientPolyStat
+{
+  int NumOccPolys;
+  int NumRendPolys;
+  int NumVerts;
+  int NumIndices;
+};
+
+//#define MAX_CLIENTPOLY_VERTS 16
+#define MAX_CLIENTPOLY_VERTS 32
+
+class CREClientPoly : public CRendElement
+{
+public:
+  SShader *mEf;
+  int m_nFogID;
+  short mNumVerts;
+  short mNumIndices;
+  CCObject *m_pObject;
+  SColorVert mVerts[MAX_CLIENTPOLY_VERTS];
+  byte mIndices[(MAX_CLIENTPOLY_VERTS-2)*3];
+  float m_fDistance;
+
+  static SClientPolyStat mRS;
+  static void mfPrintStat();
+
+public:
+  CREClientPoly()
+  {
+    mfSetType(eDATA_ClientPoly);
+    mNumVerts = 0;
+    mEf = NULL;
+    m_pObject = NULL;
+    mfSetFlags(FCEF_TRANSFORM | FCEF_NEEDFILLBUF);
+  }
+
+  virtual ~CREClientPoly() {};
+
+  virtual void mfPrepare();
+
+  bool mfCullBox(Vec3d& vmin, Vec3d& vmax);
+  float mfDistanceToCameraSquared(const CCObject & thisObject);
+  virtual CRendElement *mfCopyConstruct(void);
+
+  static TArray<CREClientPoly *> mPolysStorage[4];
+};
+
+#endif  // __CRECLIENTPOLY_H__

RenderDll/Common/RendElements/CREClientPoly2D.cpp

@@ -0,0 +1,120 @@
+/*=============================================================================
+	CClientPoly2D.cpp : implementation of 2D Client polygons RE.
+	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"
+
+
+//===============================================================
+
+
+TArray<CREClientPoly2D *> CREClientPoly2D::mPolysStorage;
+
+CRendElement *CREClientPoly2D::mfCopyConstruct(void)
+{
+  CREClientPoly2D *cp = new CREClientPoly2D;
+  *cp = *this;
+  return cp;
+}
+
+void CREClientPoly2D::mfPrepare(void)
+{
+  CRenderer *rd = gRenDev;
+  SShader *ef = rd->m_RP.m_pShader;
+  byte *inds;
+  int i, n;
+  SColorVert2D *tv;
+
+  CREClientPoly2D::mRS.NumRendPolys++;
+
+  int savev = rd->m_RP.m_RendNumVerts;
+  int savei = rd->m_RP.m_RendNumIndices;
+
+  rd->EF_CheckOverflow(mNumVerts, mNumIndices/3, this);
+  
+  rd->m_RP.m_FlagsPerFlush |= RBSI_DRAWAS2D;
+
+  inds = mIndices;
+  n = rd->m_RP.m_RendNumVerts;
+  ushort *dinds = &rd->m_RP.m_RendIndices[gRenDev->m_RP.m_RendNumIndices];
+  for (i=0; i<mNumIndices; i++, dinds++, inds++)
+  {
+    *dinds = *inds+n;
+  }
+  rd->m_RP.m_RendNumIndices += i;
+
+  tv = mVerts;
+  UPipeVertex ptr = rd->m_RP.m_NextPtr;
+  byte *OffsT, *OffsD;
+  switch(rd->m_RP.m_CurVFormat)
+  {
+    case VERTEX_FORMAT_TRP3F_COL4UB_TEX2F:
+      OffsT = rd->m_RP.m_OffsT + ptr.PtrB;
+      OffsD = rd->m_RP.m_OffsD + ptr.PtrB;
+      for (i=0; i<mNumVerts; i++, tv++, ptr.PtrB+=rd->m_RP.m_Stride, OffsT+=rd->m_RP.m_Stride, OffsD+=rd->m_RP.m_Stride)
+      {
+        *(float *)(ptr.PtrB+0) = tv->vert[0];
+        *(float *)(ptr.PtrB+4) = tv->vert[1];
+        *(float *)(ptr.PtrB+8) = 0.0f;
+        *(float *)(ptr.PtrB+12) = 1.0f;
+        *(float *)(OffsT) = tv->dTC[0];
+        *(float *)(OffsT+4) = tv->dTC[1];
+        *(uint *)OffsD = tv->color.dcolor;
+      }
+    	break;
+    default:
+      assert(false);
+  }
+
+  if (rd->m_RP.m_OffsD && gbRgb)
+  {
+    OffsD = rd->m_RP.m_OffsD + rd->m_RP.m_NextPtr.PtrB;
+    for (i=0; i<mNumVerts; i++, OffsD+=rd->m_RP.m_Stride)
+    {
+      *(uint *)(OffsD) = COLCONV(*(uint *)(OffsD));
+    }
+  }
+
+  rd->m_RP.m_NextPtr = ptr;
+  rd->m_RP.m_RendNumVerts += mNumVerts;
+
+  CREClientPoly2D::mRS.NumVerts += rd->m_RP.m_RendNumVerts - savev; 
+  CREClientPoly2D::mRS.NumIndices += rd->m_RP.m_RendNumIndices - savei; 
+}
+
+
+//=======================================================================
+
+SClientPolyStat2D CREClientPoly2D::mRS;
+
+void CREClientPoly2D::mfPrintStat()
+{
+/*  char str[1024];
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Indices: %i\n", mRS.NumIndices);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Verts: %i\n", mRS.NumVerts);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Render Client Polys: %i\n", mRS.NumRendPolys);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Occluded Client Polys: %i\n", mRS.NumOccPolys);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  gRenDev->mfPrintString ("\nClient Polygons status info:\n", PS_TRANSPARENT | PS_UP);*/
+}

RenderDll/Common/RendElements/CREClientPoly2D.h

@@ -0,0 +1,47 @@
+
+#ifndef __CRECLIENTPOLY2D_H__
+#define __CRECLIENTPOLY2D_H__
+
+//=============================================================
+
+struct SClientPolyStat2D
+{
+  int NumOccPolys;
+  int NumRendPolys;
+  int NumVerts;
+  int NumIndices;
+};
+
+
+class CREClientPoly2D : public CRendElement
+{
+public:
+  SShader *mEf;
+  SRenderShaderResources *m_pShaderResources;
+  short mNumVerts;
+  short mNumIndices;
+  SColorVert2D mVerts[16];
+  byte mIndices[(16-2)*3];
+
+  static SClientPolyStat2D mRS;
+  static void mfPrintStat();
+
+public:
+  CREClientPoly2D()
+  {
+    mfSetType(eDATA_ClientPoly2D);
+    mNumVerts = 0;
+    mEf = NULL;
+    m_pShaderResources = NULL;
+    mfUpdateFlags(FCEF_TRANSFORM | FCEF_NEEDFILLBUF);
+  }
+
+  virtual ~CREClientPoly2D() {};
+
+  virtual void mfPrepare();
+  virtual CRendElement *mfCopyConstruct(void);
+
+  static TArray<CREClientPoly2D *> mPolysStorage;
+};
+
+#endif  // __CRECLIENTPOLY2D_H__

RenderDll/Common/RendElements/CREDummy.cpp

@@ -0,0 +1,17 @@
+#include "RenderPCH.h"
+#include "RendElement.h"
+
+void CREDummy::mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_RendNumVerts = 0;
+}
+
+bool CREDummy::mfDraw(SShader *ef, SShaderPass *sfm)
+{    
+  return true;
+}
+

RenderDll/Common/RendElements/CREFlares.cpp

@@ -0,0 +1,240 @@
+/*=============================================================================
+	CFlare.cpp : implementation of light coronas and flares RE.
+	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"
+
+void CopyLightStyle(int dest, int src);
+
+//===============================================================
+
+CRendElement *CREFlareProp::mfCreateWorldRE(SShader *ef, SInpData *ds)
+{
+  return NULL;
+}
+
+
+bool CREFlareGeom::mfCullFlare(CCObject *obj, CREFlareProp *fp)
+{
+  return false;
+}
+
+//========================================================================================
+
+// Parsing
+
+bool CREFlareProp::mfCompile(SShader *ef, char *scr)
+{
+  return false;
+}
+
+bool CREFlare::mfCompile(SShader *ef, char *scr)
+{
+  char* name;
+  long cmd;
+  char *params;
+  char *data;
+  
+  enum {eMap = 1, eScale, eRGBStyle, eBlind, eColor, eDistFactor, eDistIntensityFactor, eMinLight, eSizeBlindScale, eSizeBlindBias, eIntensBlindScale, eIntensBlindBias, eLayer, eImportance, eFadeTime, eVisAreaScale};
+  static tokenDesc commands[] =
+  {
+    {eRGBStyle, "RGBStyle"},
+    {eScale, "Scale"},
+    {eBlind, "Blind"},
+    {eSizeBlindScale, "SizeBlindScale"},
+    {eSizeBlindBias, "SizeBlindBias"},
+    {eIntensBlindScale, "IntensBlindScale"},
+    {eIntensBlindBias, "IntensBlindBias"},    
+    {eMinLight, "MinLight"},
+    {eDistFactor, "DistFactor"},
+    {eDistIntensityFactor, "DistIntensityFactor"},
+    {eMap, "Map"},
+    {eFadeTime, "FadeTime"},
+    {eColor, "Color"},
+    {eLayer, "Layer"},
+    {eImportance, "Importance"},
+    {eVisAreaScale, "VisAreaScale"},
+    {0, 0},
+  };
+
+  CFColor col;
+  while ((cmd = shGetObject (&scr, commands, &name, &params)) > 0)
+  {
+    data = NULL;
+    if (name)
+      data = name;
+    else
+    if (params)
+      data = params;
+      
+    switch (cmd)
+    {
+      case eMap: 
+        m_Map = (STexPic *)gRenDev->EF_LoadTexture(data, FT_NORESIZE, 0, eTT_Base);
+        break;
+
+      case eColor:
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing Color argument for Light Stage in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        shGetColor(data, m_fColor);
+        break;
+
+      case eRGBStyle:
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing RgbStyle argument for Light Stage in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        if (!stricmp(data, "Poly"))
+          m_eLightRGB = eLIGHT_Poly;
+        else
+        if (!stricmp(data, "Identity"))
+          m_eLightRGB = eLIGHT_Identity;
+        else
+        if (!strnicmp(data, "FromObj", 7) || !stricmp(data, "FromLight"))
+          m_eLightRGB = eLIGHT_Object;
+        else
+        if (!stricmp(data, "LightStyle"))
+        {
+          m_eLightRGB = eLIGHT_Style;
+          m_Color = CFColor(1.0f);
+          if (!params || !params[0])
+          {
+            Warning( 0,0,"missing RgbStyle LightStyle value in Shader '%s' (use 0)\n", ef->m_Name.c_str());
+            m_LightStyle = 0;
+          }
+          else
+            m_LightStyle = shGetInt(params);
+        }
+        else
+        if (!stricmp(data, "Fixed"))
+        {
+          m_eLightRGB = eLIGHT_Fixed;
+          if (!params || !params[0])
+          {
+            Warning( 0,0,"missing RgbStyle Fixed value in Shader '%s' (use 1.0)\n", ef->m_Name.c_str());
+            m_Color = CFColor(1.0f);
+          }
+          else
+          {
+            CFColor col;
+            shGetColor(params, col);
+            m_Color = col;
+          }
+        }
+        else
+          m_eLightRGB = eLIGHT_Identity;
+        break;
+
+      case eScale:
+        if (!name)
+          m_fScaleCorona = shGetFloat(data);
+        else
+        {
+          TArray<SParam> Params;
+          gRenDev->m_cEF.mfCompileParam(params, ef, &Params);
+          if (Params.Num())
+            m_pScaleCoronaParams = Params[0].m_Comps[0];
+        }
+        break;
+
+      case eBlind:
+        m_bBlind = true;
+        break;
+
+      case eImportance:
+        m_Importance = shGetInt(data);
+        break;
+
+      case eFadeTime:
+        m_fFadeTime = shGetFloat(data);
+        break;
+
+      case eSizeBlindScale:
+        m_fSizeBlindScale = shGetFloat(data);
+        break;
+
+      case eSizeBlindBias:
+        m_fSizeBlindBias = shGetFloat(data);
+        break;
+
+      case eIntensBlindScale:
+        m_fIntensBlindScale = shGetFloat(data);
+        break;
+
+      case eIntensBlindBias:
+        m_fIntensBlindBias = shGetFloat(data);
+        break;
+
+      case eMinLight:
+        m_fMinLight = shGetFloat(data);
+        break;
+
+      case eDistFactor:
+        m_fDistSizeFactor = shGetFloat(data);
+        break;
+
+      case eVisAreaScale:
+        m_fVisAreaScale = shGetFloat(data);
+        break;
+
+      case eDistIntensityFactor:
+        m_fDistIntensityFactor = shGetFloat(data);
+        break;
+
+      case eLayer:
+        {
+          if (!m_Pass)
+            m_Pass = new SShaderPassHW;
+          gRenDev->m_cEF.mfCompileLayer(ef, 0, params, m_Pass);
+        }
+        break;
+
+    }
+  }
+
+  return true;
+}
+
+void CREFlare::mfPrepare(void)
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+  
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_RendNumVerts = 0;
+
+  switch(m_eLightRGB)
+  {
+    case eLIGHT_Identity:
+      m_Color = CFColor(1.0f);
+      break;
+    case eLIGHT_Style:
+      {
+        if (m_LightStyle>=0 && m_LightStyle<CLightStyle::m_LStyles.Num() && CLightStyle::m_LStyles[m_LightStyle])
+        {
+          CLightStyle *ls = CLightStyle::m_LStyles[m_LightStyle];
+          ls->mfUpdate(gRenDev->m_RP.m_RealTime);
+          m_Color = m_fColor * ls->m_fIntensity;
+        }
+      }
+      break;
+    case eLIGHT_Object:
+      if (gRenDev->m_RP.m_pCurObject)
+        m_Color = gRenDev->m_RP.m_pCurObject->m_Color;
+      else
+        m_Color = CFColor(1.0f);
+      break;
+  }
+}

RenderDll/Common/RendElements/CREFlares.h

@@ -0,0 +1,190 @@
+
+#ifndef __CREFLARES_H__
+#define __CREFLARES_H__
+
+//=================================================
+// Flares
+
+struct SFlareFrame
+{
+  int mFrame;
+  float mDecayTime;
+  bool mbVis;
+  int mX;
+  int mY;
+  float mDepth;
+  CFColor mColor;
+  float mScale;
+};
+
+class CREFlareProp;
+
+class CREFlareGeom : public CRendElement
+{
+  friend class CRender3D;
+
+public:
+  SFlareFrame mFlareFr[8];
+  CFColor mColor;
+  Vec3d mNormal;
+  int mLightStyle;
+  int mDLightStyle;
+  float mBreakTime;
+  float mEndBreakTime;
+
+  float mfGetScale(float rtime)
+  {
+    float scale = 1.0f;
+
+    if (mBreakTime && rtime+0.01>=mBreakTime && mEndBreakTime>rtime)
+    {
+      float time = rtime - mBreakTime;
+
+      if (time<0.25)
+      {
+        scale = 1 - time*4;
+      }
+      else
+      {
+        time = mEndBreakTime - rtime;
+        if (time<1)
+          scale= 1 - time;
+        else
+          scale = 0;
+      }
+      return scale;
+    }
+    return -1;
+  }
+
+  CREFlareGeom()
+  {
+    mfSetType(eDATA_FlareGeom);
+    mfUpdateFlags(FCEF_TRANSFORM);
+  }
+  virtual ~CREFlareGeom()
+  {
+  }
+
+  void mfCheckVis(CFColor &col, CCObject *obj);
+  bool mfCullFlare(CCObject *obj, CREFlareProp *fp);
+};
+
+enum ELightRGB
+{
+  eLIGHT_Identity,
+  eLIGHT_Fixed,
+  eLIGHT_Poly,
+  eLIGHT_Style,
+  eLIGHT_Object,
+};
+
+enum EEmitLight
+{
+  eEMIT_Poly,
+  eEMIT_Point,
+};
+
+
+class CREFlareProp : public CRendElement
+{
+  friend class CRender3D;
+
+public:
+  SShader *FlareShader;
+  ELightRGB eLightRGB;
+  float LightColorScale;
+  CFColor LightColor;
+  int LightStyle;
+  float offsLight;
+  EEmitLight eLightEmit;
+
+  CREFlareProp()
+  {
+    mfSetType(eDATA_FlareProp);
+    mfUpdateFlags(FCEF_TRANSFORM);
+    LightColorScale = 1;
+    eLightEmit = eEMIT_Point;
+    LightStyle = 0;
+    FlareShader = 0;
+	  eLightRGB = eLIGHT_Identity;
+  }
+  virtual ~CREFlareProp()
+  {
+  }
+  virtual bool mfCompile(SShader *ef, char *scr);
+  virtual CRendElement *mfCreateWorldRE(SShader *ef, SInpData *ds);
+};
+
+
+class CREFlare : public CRendElement
+{
+  friend class CRender3D;
+  friend class CGLRenderer;
+
+public:
+  Vec3d mNormal;
+  float m_fScaleCorona;
+  SParamComp *m_pScaleCoronaParams;
+  float m_fMinLight;
+  float m_fDistSizeFactor;
+  float m_fDistIntensityFactor;
+  bool  m_bBlind;
+  float m_fSizeBlindBias;
+  float m_fSizeBlindScale;
+  float m_fIntensBlindBias;
+  float m_fIntensBlindScale;
+  float m_fFadeTime;
+  float m_fVisAreaScale;
+  STexPic *m_Map;
+  ELightRGB m_eLightRGB;
+  int m_LightStyle;
+  CFColor m_fColor;
+  int m_UpdateFrame;
+  int m_nFrameQuery;
+  SShaderPassHW *m_Pass;
+  int m_Importance;
+
+  CREFlare()
+  {
+    mfSetType(eDATA_Flare);
+    mfUpdateFlags(FCEF_TRANSFORM);
+    m_Map = NULL;
+    m_fMinLight = 0.0f;
+    m_eLightRGB = eLIGHT_Identity;
+    m_fColor = Col_White;
+    m_UpdateFrame = -1;
+    m_fDistSizeFactor = 1.0f;
+    m_fDistIntensityFactor = 1.0f;
+    m_fSizeBlindBias = 0;
+    m_nFrameQuery = -1;
+    m_fSizeBlindScale = 1.0f;
+    m_fIntensBlindBias = 0;
+    m_fIntensBlindScale = 1.0f;
+    m_fVisAreaScale = 1.0f;
+    m_fFadeTime = -1.0f;
+    m_bBlind = false;
+    m_fScaleCorona = 0.6f;
+    m_pScaleCoronaParams = NULL;
+    m_Pass = NULL;
+    m_Importance = 1;
+  }
+  virtual ~CREFlare()
+  {
+    if (m_Map)
+    {
+      m_Map->Release(false);
+      m_Map = NULL;
+    }
+    SAFE_DELETE(m_Pass);
+  }
+  virtual bool mfCompile(SShader *ef, char *scr);
+  virtual void mfPrepare(void);
+  virtual bool mfDraw(SShader *ef, SShaderPass *sfm);
+
+  void mfDrawCorona(SShader *ef, CFColor &col);
+  void mfDrawFlares(SShader *ef, CFColor &col);
+  bool mfCheckVis(CCObject *obj);
+};
+
+#endif  // __CREFLARES_H__

RenderDll/Common/RendElements/CREFlashBang.cpp

@@ -0,0 +1,17 @@
+#include "RenderPCH.h"
+#include "RendElement.h"
+
+#if !defined(LINUX)
+
+void CREFlashBang::mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+
+  gRenDev->m_RP.m_FlagsPerFlush |= RBSI_DRAWAS2D;
+
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_RendNumVerts = 0;
+}
+
+#endif // !defined(LINUX)

RenderDll/Common/RendElements/CREGlare.cpp

@@ -0,0 +1,24 @@
+#include "RenderPCH.h"
+#include "RendElement.h"
+
+void CREGlare:: mfInit()
+{
+  m_GlareWidth = 128;
+  m_GlareHeight = 128; 
+  m_fGlareAmount=0;
+
+  mfSetType(eDATA_Glare);
+  mfUpdateFlags(FCEF_TRANSFORM);
+}
+
+
+void CREGlare::mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_RendNumVerts = 4;
+  gRenDev->m_RP.m_FirstVertex = 0;
+}
+

RenderDll/Common/RendElements/CREGlare.h

@@ -0,0 +1,39 @@
+
+#ifndef __CREGLARE_H__
+#define __CREGLARE_H__
+
+//=============================================================
+
+struct SByteColor
+{
+  byte r,g,b,a;
+};
+
+struct SLongColor
+{
+  unsigned long r,g,b,a;
+};
+
+class CREGlare : public CRendElement
+{
+public:
+  int m_GlareWidth;
+  int m_GlareHeight;
+  float m_fGlareAmount;
+
+public:
+  CREGlare()
+  {
+    mfInit();
+  }
+  void mfInit();
+
+  virtual ~CREGlare()
+  {
+  }
+
+  virtual void mfPrepare();
+  virtual bool mfDraw(SShader *ef, SShaderPass *sfm);
+};
+
+#endif  // __CREGLARE_H__

RenderDll/Common/RendElements/CREHDRProcess.cpp

@@ -0,0 +1,43 @@
+/*
+=======================================================================
+FILE : CREHDRProcess.cpp
+DESC : HDR processing render element
+PROJ : Crytek Engine
+CODER: Andrey Honich
+
+=======================================================================
+*/
+
+#include "RenderPCH.h"
+
+
+// constructor/destructor
+CREHDRProcess::CREHDRProcess()
+{
+  // setup screen process renderer type
+  mfSetType(eDATA_HDRProcess);
+  mfUpdateFlags(FCEF_TRANSFORM);
+}
+
+CREHDRProcess::~CREHDRProcess()
+{  
+};
+
+// prepare screen processing
+void CREHDRProcess:: mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_FlagsPerFlush |= RBSI_DRAWAS2D;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_RendNumVerts = 0;
+}
+
+void CREHDRProcess::mfReset()
+{
+}
+
+void CREHDRProcess::mfActivate(int iProcess)
+{
+}

RenderDll/Common/RendElements/CREHDRProcess.h

@@ -0,0 +1,39 @@
+/*
+=====================================================================
+FILE : CREHDRProcess.h
+DESC : HDR processing render element
+PROJ : Crytek Engine
+CODER: Andrey Honich
+
+=====================================================================
+*/
+
+#ifndef __CREHDRPROCESS_H__
+#define __CREHDRPROCESS_H__
+
+
+// screen processing render element
+class CREHDRProcess : public CRendElement
+{
+  friend class CD3D9Renderer;
+  friend class CGLRenderer;
+
+public:
+
+  // constructor/destructor
+  CREHDRProcess();
+
+  virtual ~CREHDRProcess();
+
+  // prepare screen processing
+  virtual void mfPrepare();
+  // render screen processing
+  virtual bool mfDraw(SShader *ef, SShaderPass *sfm);
+
+  // begin screen processing
+  virtual void mfActivate(int iProcess);
+  // reset 
+  virtual void mfReset(void);
+};
+
+#endif

RenderDll/Common/RendElements/CREHeat.h

@@ -0,0 +1,31 @@
+
+#ifndef __CREHEAT_H__
+#define __CREHEAT_H__
+
+//=============================================================
+
+
+class CREHeat : public CRendElement
+{
+public:
+  int m_HeatWidth;
+  int m_HeatHeight;
+
+public:
+  CREHeat()
+  {
+    m_HeatWidth = CRenderer::CV_r_heatsize;
+    m_HeatHeight = CRenderer::CV_r_heatsize;
+    mfSetType(eDATA_Heat);
+    mfUpdateFlags(FCEF_TRANSFORM);
+  }
+
+  virtual ~CREHeat()
+  {
+  }
+
+  virtual void mfPrepare();
+  virtual bool mfDraw(SShader *ef, SShadeLayer *sfm);
+};
+
+#endif  // __CREHEAT_H__

RenderDll/Common/RendElements/CREMotionBlur.cpp

@@ -0,0 +1,96 @@
+#if !defined(LINUX)
+
+#include "stdafx.h"
+#include "RendElement.h"
+#include "CREMotionBlur.h"
+
+#ifdef OPENGL
+#include "..\..\XRenderOGL\GL_Renderer.h"
+#endif
+
+void CREMotionBlur::mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+
+  gRenDev->m_RP.m_DynLMask |= m_DynMask;
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_RendNumVerts = 0;
+}
+
+bool CREMotionBlur::mfDraw(SShader *ef, SShaderPass *sfm)
+{
+  gRenDev->ResetToDefault();
+
+  static int counter=0;
+
+  gRenDev->EnableBlend(true);
+  gRenDev->SetBlendMode();
+  gRenDev->Set2DMode(true,100,100);
+  gRenDev->EnableDepthWrites(false);
+  gRenDev->EnableDepthTest(false);
+
+  for(int pass=-1; pass>-16 ; pass--)
+  {
+    if(!sfm->m_TUnits[0]->mfSetTexture(counter+pass))
+      break;
+
+    gRenDev->SetEnviMode(R_MODE_MODULATE);
+    gRenDev->SetMaterialColor(1,1,1,1.f/(float)fabs(pass+1));
+
+    struct_VERTEX_FORMAT_P3F_TEX2F data[] =
+    {
+      100,   100, 0, 1,1.f-1,
+      100,     0, 0, 1,1.f-0,
+        0,   100, 0, 0,1.f-1,
+        0,     0, 0, 0,1.f-0,
+    };
+
+    gRenDev->PushMatrix();
+    gRenDev->TranslateMatrix(Vec3d(50,50,0));
+
+    // scale
+    if(m_nEffectType == 1)
+    {
+      float scale = 1.0f-(float)fabs(pass/16.f)/3.0f;
+      gRenDev->ScaleMatrix(scale,scale,0);
+    }
+    if(m_nEffectType == 2)
+    {
+      float scale = 1.f+(float)fabs(pass/16.f)/3;
+      gRenDev->ScaleMatrix(scale,scale,0);
+    }
+    // rotation
+    else if(m_nEffectType == 3)
+    {
+      gRenDev->RotateMatrix(Vec3d(0,0,pass&1 ? (float)fabs(pass/16.f)*4.0f : -(float)fabs(pass/16.f)*4.0f));
+    }
+    else if(m_nEffectType == 4)
+    {
+      gRenDev->RotateMatrix(Vec3d(0,0,pass&1 ? (float)fabs(pass/16.f)*40 : -(float)fabs(pass/16.f)*40));
+    }
+    // translation
+    else if(m_nEffectType == 5)
+    {
+      gRenDev->TranslateMatrix(Vec3d(pass&1 ? (float)fabs(pass/16.f)*4.0f : -(float)fabs(pass/16.f)*4.0f,0,0));
+    }
+    else if(m_nEffectType == 6)
+    {
+      gRenDev->TranslateMatrix(Vec3d(0,pass&1 ? (float)fabs(pass/16.f)*4.0f : -(float)fabs(pass/16.f)*4.0f,0));
+    }
+
+    gRenDev->TranslateMatrix(Vec3d(-50,-50,0));
+    gRenDev->DrawTriStrip(&(CVertexBuffer (data,VERTEX_FORMAT_P3F_TEX2F)),4);
+    gRenDev->PopMatrix();
+  }
+
+  counter++;
+
+  gRenDev->Set2DMode(false,100,100);
+  gRenDev->ResetToDefault();
+
+
+  return true;
+}
+
+#endif // !defined(LINUX)

RenderDll/Common/RendElements/CREOcean.cpp

@@ -0,0 +1,756 @@
+#include "RenderPCH.h"
+#include "RendElement.h"
+#include "CREOcean.h"
+#include "../NvTriStrip/NVTriStrip.h"
+#include "I3dengine.h"
+
+SREOceanStats CREOcean::m_RS;
+CREOcean *CREOcean::m_pStaticOcean = NULL;
+
+DEFINE_ALIGNED_DATA( float, CREOcean::m_HX[OCEANGRID][OCEANGRID], 16 ); 
+DEFINE_ALIGNED_DATA( float, CREOcean::m_HY[OCEANGRID][OCEANGRID], 16 ); 
+
+DEFINE_ALIGNED_DATA( float, CREOcean::m_NX[OCEANGRID][OCEANGRID], 16 ); 
+DEFINE_ALIGNED_DATA( float, CREOcean::m_NY[OCEANGRID][OCEANGRID], 16 ); 
+
+DEFINE_ALIGNED_DATA( float, CREOcean::m_DX[OCEANGRID][OCEANGRID], 16 ); 
+DEFINE_ALIGNED_DATA( float, CREOcean::m_DY[OCEANGRID][OCEANGRID], 16 ); 
+
+CREOcean::~CREOcean()
+{
+  m_pStaticOcean = NULL;
+  if (m_pBuffer)
+  {
+    gRenDev->ReleaseBuffer(m_pBuffer);
+    m_pBuffer = NULL;
+  }
+  SAFE_DELETE_ARRAY(m_HMap);
+  for (int i=0; i<NUM_LODS; i++)
+  {
+    m_pIndices[i].Free();
+  }
+}
+
+float CREOcean::GetWaterZElevation(float fX, float fY)
+{
+  if (!m_HMap)
+    return 0;
+  CRenderer *r = gRenDev;
+  I3DEngine *eng = (I3DEngine *)iSystem->GetI3DEngine();
+  float fSize = (float)CRenderer::CV_r_oceansectorsize;
+  float fHeightScale = (float)CRenderer::CV_r_oceanheightscale;
+  float fWaterLevel = eng->GetWaterLevel();
+  float fHScale = fabsf(gRenDev->m_RP.m_ViewOrg.z-fWaterLevel);
+  float fMaxDist = eng->GetMaxViewDistance() / 1.0f;
+  float fGrid = (float)OCEANGRID;
+
+  float fZH = GetHMap(fX, fY);
+  if (fZH >= fWaterLevel)
+    return fWaterLevel;
+
+  float fXPart = fX / fSize;
+  float fYPart = fY / fSize;
+  float fXLerp = (fXPart - (int)fXPart) * fGrid;
+  float fYLerp = (fYPart - (int)fYPart) * fGrid;
+  int nXMin = (int)fXLerp;
+  int nXMax = nXMin+1;
+  int nYMin = (int)fYLerp;
+  int nYMax = nYMin+1;
+  fXLerp = fXLerp - (int)fXLerp;
+  fYLerp = fYLerp - (int)fYLerp;
+
+  if (fHScale < 5.0f)
+    fHScale = LERP(0.1f, 0.5f, fHScale/5.0f);
+  else
+  if (fHScale < 20)
+    fHScale = LERP(0.5f, 1.0f, (fHScale-5.0f)/15.0f);
+  else
+    fHScale = 1.0f;
+
+  float fZ00 = -m_HX[nYMin][nXMin] * fHScale;
+  float fZ01 = -m_HX[nYMin][nXMax] * fHScale;
+  float fZ10 = -m_HX[nYMax][nXMin] * fHScale;
+  float fZ11 = -m_HX[nYMax][nXMax] * fHScale;
+  float fZ0 = LERP(fZ00, fZ01, fXLerp);
+  float fZ1 = LERP(fZ10, fZ11, fXLerp);
+  float fZ = LERP(fZ0, fZ1, fYLerp);
+  //fZ *= fHeightScale;
+
+  float fHeightDelta = fWaterLevel - fZH;
+  fHeightScale *= CLAMP(fHeightDelta * 0.066f, 0, 1);
+
+  return fZ * fHeightScale + fWaterLevel;
+}
+
+void CREOcean::PrepareHMap()
+{
+  int nDim=0;
+
+  I3DEngine *eng = (I3DEngine *)iSystem->GetI3DEngine();
+  m_nHMUnitSize = eng->GetHeightMapUnitSize();
+  int nExp = 8;
+  m_fExpandHMap = (float)nExp;
+  m_fExpandHM = (float)m_nHMUnitSize * (float)nExp;
+  m_fInvHMUnitSize = 1.0f / (float)m_nHMUnitSize;
+  m_fTerrainSize = (float)eng->GetTerrainSize();
+  eng->MakeUnderWaterSmoothHMap(m_nHMUnitSize);
+  ushort *shm = eng->GetUnderWaterSmoothHMap(nDim);
+
+	if(!nDim)
+		return; // terrain not present
+
+  float fWaterLevel = eng->GetWaterLevel();
+
+  if (m_HMap)
+    delete [] m_HMap;
+  int nDimO = nDim+nExp*2;
+  m_nHMapSize = nDimO;
+  m_HMap = new float [nDimO*nDimO];
+  float f;
+  for (int y=-nExp; y<nDim+nExp; y++)
+  {
+    for (int x=-nExp; x<nDim+nExp; x++)
+    {
+      if (x>0 && x<nDim-1 && y>0 && y<nDim-1)
+        m_HMap[(y+nExp)*nDimO+x+nExp] = (float)shm[y*nDim+x] / 256.0f;
+      else
+      {
+        int nX = x;
+        int nY = y;
+        float fLerpX = -1.0f;
+        float fLerpY = -1.0f;
+        
+        if (nX<=0)
+          nX = 1;
+        else
+        if (nX>=nDim-1)
+          nX = nDim-2;
+
+        if (nY<=0)
+          nY = 1;
+        else
+        if (nY>=nDim-1)
+          nY = nDim-2;
+
+        f = (float)shm[nY*nDim+nX] / 256.0f;
+
+        if (nX != x)
+          fLerpX = 1.0f - fabsf((float)(nX-x)) / (float)(nExp+1);
+        if (nY != y)
+          fLerpY = 1.0f - fabsf((float)(nY-y)) / (float)(nExp+1);
+
+        float fX, fY;
+
+        if (fLerpX >= 0)
+          fX = LERP(fWaterLevel/2.0f, f, fLerpX);
+        if (fLerpY >= 0)
+          fY = LERP(fWaterLevel/2.0f, f, fLerpY);
+        if (fLerpX >= 0 && fLerpY >= 0)
+          m_HMap[(y+nExp)*nDimO+x+nExp] = (fX + fY) / 2.0f;
+        else
+        if (fLerpX >= 0)
+          m_HMap[(y+nExp)*nDimO+x+nExp] = fX;
+        else
+        if (fLerpY >= 0)
+          m_HMap[(y+nExp)*nDimO+x+nExp] = fY;
+        else
+          m_HMap[(y+nExp)*nDimO+x+nExp] = f;
+      }
+    }
+  }
+}
+
+void CREOcean::mfPrepare()
+{
+  CRenderer *rd = gRenDev;
+
+  if (m_nFrameLoad != rd->m_nFrameLoad)
+  {
+    m_nFrameLoad = rd->m_nFrameLoad;
+    PrepareHMap();
+  }
+
+  rd->EF_CheckOverflow(0, 0, this);
+
+  Update(rd->m_RP.m_RealTime * m_fSpeed);
+
+  double time0 = 0;
+  ticks(time0);
+
+  I3DEngine *eng = (I3DEngine *)iSystem->GetI3DEngine();
+  float fWaterLevel = eng->GetWaterLevel();
+  float fHScale = fabsf(gRenDev->m_RP.m_ViewOrg.z-fWaterLevel);
+  if (fHScale < 5.0f)
+    fHScale = LERP(0.1f, 0.5f, fHScale/5.0f);
+  else
+  if (fHScale < 20)
+    fHScale = LERP(0.5f, 1.0f, (fHScale-5.0f)/15.0f);
+  else
+    fHScale = 1.0f;
+  m_MinBound.Set(9999.0f, 9999.0f, 9999.0f);
+  m_MaxBound.Set(-9999.0f, -9999.0f, -9999.0f);
+
+  if (!m_pBuffer)
+    m_pBuffer = gRenDev->CreateBuffer((OCEANGRID+1)*(OCEANGRID+1), VERTEX_FORMAT_P3F_N, "Ocean", true);
+  rd->UpdateBuffer(m_pBuffer, NULL, 0, 0, 0, 1);
+
+  static const float fScale = 1.0f / (float)OCEANGRID;
+
+  struct_VERTEX_FORMAT_P3F_N *pVertices = (struct_VERTEX_FORMAT_P3F_N *)m_pBuffer->m_VS[VSF_GENERAL].m_VData;
+  for(int vy=0; vy<OCEANGRID+1; vy++)
+  {
+    int y = vy & (OCEANGRID-1);
+    for(int vx=0; vx<(OCEANGRID+1); vx++)
+    {
+      int x = vx & (OCEANGRID-1);
+      m_Pos[vy][vx][0] = vx * fScale + m_DX[y][x] * m_fChoppyWaveFactor;
+      m_Pos[vy][vx][1] = vy * fScale + m_DY[y][x] * m_fChoppyWaveFactor;
+      pVertices->xyz.x = m_Pos[vy][vx][0];
+      pVertices->xyz.y = m_Pos[vy][vx][1];
+      float fZ = -m_HX[y][x] * fHScale;
+      pVertices->xyz.z = fZ;
+      m_MinBound.x = min(m_Pos[vy][vx][0], m_MinBound.x);
+      m_MinBound.y = min(m_Pos[vy][vx][1], m_MinBound.y);
+      m_MinBound.z = min(fZ, m_MinBound.z);
+
+      m_MaxBound.x = max(m_Pos[vy][vx][0], m_MaxBound.x);
+      m_MaxBound.y = max(m_Pos[vy][vx][1], m_MaxBound.y);
+      m_MaxBound.z = max(fZ, m_MaxBound.z);
+
+      m_Normals[vy][vx] = Vec3d(m_NX[y][x], m_NY[y][x], 64.0f);
+      pVertices->normal = m_Normals[vy][vx];
+      m_Normals[vy][vx].NormalizeFast();
+
+      pVertices++;
+    }       
+  }
+  unticks(time0);
+  m_RS.m_StatsTimeUpdateVerts = (float)(time0*1000.0*g_SecondsPerCycle);
+
+  UpdateTexture();
+
+  rd->m_RP.m_pRE = this;
+  rd->m_RP.m_RendNumIndices = 0;
+  rd->m_RP.m_RendNumVerts = (OCEANGRID+1)*(OCEANGRID+1);
+  rd->m_RP.m_FirstVertex = 0;
+}
+
+int CREOcean::GetLOD(Vec3d camera, Vec3d pos)
+{
+  float dist = (pos-camera).GetLength();
+  dist /= CRenderer::CV_r_oceanloddist;
+
+  return (int)CLAMP(dist, 0.0f, (float)(NUM_LODS-1));
+}
+
+void *CREOcean::mfGetPointer(ESrcPointer ePT, int *Stride, int Type, ESrcPointer Dst, int Flags)
+{
+
+  switch(ePT) 
+  {
+    case eSrcPointer_Vert:
+      {
+        struct_VERTEX_FORMAT_P3F_N *pVertices = (struct_VERTEX_FORMAT_P3F_N *)m_pBuffer->m_VS[VSF_GENERAL].m_VData;
+        *Stride = sizeof(struct_VERTEX_FORMAT_P3F_N);
+        return &pVertices->xyz.x;
+      }
+    case eSrcPointer_Normal:
+      {
+        struct_VERTEX_FORMAT_P3F_N *pVertices = (struct_VERTEX_FORMAT_P3F_N *)m_pBuffer->m_VS[VSF_GENERAL].m_VData;
+        *Stride = sizeof(struct_VERTEX_FORMAT_P3F_N);
+        return &pVertices->normal.x;
+      }
+  }
+  return NULL;
+}
+
+
+void CREOcean::GenerateGeometry()
+{
+  m_pBuffer = gRenDev->CreateBuffer((OCEANGRID+1)*(OCEANGRID+1), VERTEX_FORMAT_P3F_N, "Ocean", true);
+
+  for (int lod=0; lod<NUM_LODS; lod++)
+  {
+    int nl = 1<<lod;
+    // set indices
+    int iIndex = 0;
+    int yStep = (OCEANGRID+1) * nl;
+    for(int a=0; a<(OCEANGRID+1)-1; a+=nl )
+    {
+      for(int i=0; i<(OCEANGRID+1); i+=nl, iIndex+=nl )
+      {
+        m_pIndices[lod].AddElem(iIndex);
+        m_pIndices[lod].AddElem(iIndex + yStep);
+      }
+
+      int iNextIndex = (a+nl) * (OCEANGRID+1);
+
+      if(a < (OCEANGRID+1)-1-nl)
+      {
+        m_pIndices[lod].AddElem(iIndex + yStep - nl);
+        m_pIndices[lod].AddElem(iNextIndex);
+      }
+      iIndex = iNextIndex;
+    }
+    m_pIndices[lod].Shrink();
+  }
+}
+
+void CREOcean::SmoothLods_r(SOceanSector *os, float fSize, int minLod)
+{
+  if (os->m_Frame != gRenDev->m_cEF.m_Frame)
+    return;
+  if (os->nLod > minLod+1)
+  {
+    os->nLod = minLod+1;
+    SOceanSector *osLeft;
+    SOceanSector *osRight;
+    SOceanSector *osTop;
+    SOceanSector *osBottom;
+
+    // Left
+    osLeft = GetSectorByPos(os->x-fSize, os->y, false);
+    // Right
+    osRight = GetSectorByPos(os->x+fSize, os->y, false);
+    // Top
+    osTop = GetSectorByPos(os->x, os->y-fSize, false);
+    // Bottom
+    osBottom = GetSectorByPos(os->x, os->y+fSize, false);
+    if (osLeft)
+      SmoothLods_r(osLeft, fSize, os->nLod);
+    if (osRight)
+      SmoothLods_r(osRight, fSize, os->nLod);
+    if (osTop)
+      SmoothLods_r(osTop, fSize, os->nLod);
+    if (osBottom)
+      SmoothLods_r(osBottom, fSize, os->nLod);
+  }
+}
+
+void CREOcean::LinkVisSectors(float fSize)
+{
+  for (int i=0; i<m_VisOceanSectors.Num(); i++)
+  {
+    SOceanSector *os = m_VisOceanSectors[i];
+    SOceanSector *osLeft;
+    SOceanSector *osRight;
+    SOceanSector *osTop;
+    SOceanSector *osBottom;
+
+    // Left
+    osLeft = GetSectorByPos(os->x-fSize, os->y, false);
+    // Right
+    osRight = GetSectorByPos(os->x+fSize, os->y, false);
+    // Top
+    osTop = GetSectorByPos(os->x, os->y-fSize, false);
+    // Bottom
+    osBottom = GetSectorByPos(os->x, os->y+fSize, false);
+    if (osLeft)
+      SmoothLods_r(osLeft, fSize, os->nLod);
+    if (osRight)
+      SmoothLods_r(osRight, fSize, os->nLod);
+    if (osTop)
+      SmoothLods_r(osTop, fSize, os->nLod);
+    if (osBottom)
+      SmoothLods_r(osBottom, fSize, os->nLod);
+  }
+}
+
+void CREOcean::PostLoad(unsigned long ulSeed, float fWindDirection, float fWindSpeed, float fWaveHeight, float fDirectionalDependence, float fChoppyWavesFactor, float fSuppressSmallWavesFactor)
+{
+  m_fWindX                    = cry_cosf( fWindDirection );    
+  m_fWindY                    = cry_sinf( fWindDirection );
+  m_fWindSpeed                = fWindSpeed;
+  m_fWaveHeight               = fWaveHeight;
+  m_fDirectionalDependence    = fDirectionalDependence;
+  m_fChoppyWaveFactor         = fChoppyWavesFactor;
+  m_fSuppressSmallWavesFactor = fSuppressSmallWavesFactor;
+
+  m_fLargestPossibleWave =  m_fWindSpeed * m_fWindSpeed / m_fGravity;   
+  m_fSuppressSmallWaves  = m_fLargestPossibleWave * m_fSuppressSmallWavesFactor;
+
+  // init H0
+  CRERandom kRnd( ulSeed );
+  float fOneBySqrtTwo = 1.0f / cry_sqrtf(2.0f);
+  int i, j;
+  for(j=-OCEANGRID/2; j<=OCEANGRID/2; j++)
+  {
+    int y = j + OCEANGRID/2;
+    for(i=-OCEANGRID/2; i<=OCEANGRID/2; i++)
+    {
+      int x = i + OCEANGRID/2;
+      float rndX = (float)kRnd.GetGauss();
+      float rndY = (float)kRnd.GetGauss();
+      rndX *= fOneBySqrtTwo * cry_sqrtf(PhillipsSpectrum(2.0f*PI*i, 2.0f*PI*j));
+      rndY *= fOneBySqrtTwo * cry_sqrtf(PhillipsSpectrum(2.0f*PI*i, 2.0f*PI*j));
+
+      m_H0X[y][x] = rndX;
+      m_H0Y[y][x] = rndY;
+    }
+  } 
+
+  // precalc length of K
+  for(j=-OCEANGRID/2; j<OCEANGRID/2; j++)
+  {
+    int y = j + OCEANGRID/2;
+    for(i=-OCEANGRID/2; i<OCEANGRID/2; i++)
+    {
+      int x = i + OCEANGRID/2;
+      float fKLength = cry_sqrtf(sqrf(2.0f*PI*i) + sqrf(2.0f*PI*j));
+      if( fKLength < 1e-8f )
+        fKLength = 1e-8f;
+      m_aKScale[y][x] = 1.0f / fKLength;
+    }
+  }
+
+  // init angular frequencies
+  for(j=-OCEANGRID/2; j<OCEANGRID/2; j++)
+  {
+    int y = j + OCEANGRID/2;
+    for(i=-OCEANGRID/2; i<OCEANGRID/2; i++)
+    {
+      int x = i + OCEANGRID/2;
+      float fKLength = cry_sqrtf(sqrf(2.0f*PI*i) + sqrf(2.0f*PI*j));
+      m_aAngularFreq[y][x] = cry_sqrtf(m_fGravity * fKLength) * cry_tanhf(fKLength * m_fDepth);
+    }
+  }
+}
+
+void CREOcean::FFT( int iDir, float* real, float* imag )
+{
+  long nn,i,i1,j,k,i2,l,l1,l2;
+  float c1,c2,treal,timag,t1,t2,u1,u2,z;
+  
+  nn = OCEANGRID;
+  
+  // Do the bit reversal
+  i2 = nn >> 1;
+  j = 0;
+  for( i = 0; i < nn - 1; ++i )
+  {
+    if( i < j )
+    {
+      treal = real[ i ];
+      timag = imag[ i ];
+      real[ i ] = real[ j ];
+      imag[ i ] = imag[ j ];
+      real[ j ] = treal;
+      imag[ j ] = timag;
+    }
+
+    k = i2;
+    while( k <= j )
+    {
+      j -= k;
+      k >>= 1;
+    }
+
+    j += k;
+  }
+  
+  // Compute the FFT
+  c1 = -1.0f;
+  c2 = 0.0f;
+  l2 = 1;
+  for(l=0; l<LOG_OCEANGRID; l++)
+  {
+    l1 = l2;
+    l2 <<= 1;
+    u1 = 1.0;
+    u2 = 0.0;
+    for( j = 0; j < l1; ++j )
+    {
+      for( i = j; i < nn; i += l2 )
+      {
+        i1 = i + l1;
+        t1 = u1 * real[i1] - u2 * imag[i1];
+        t2 = u1 * imag[i1] + u2 * real[i1];
+        real[i1] = real[i] - t1;
+        imag[i1] = imag[i] - t2;
+        real[i] += t1;
+        imag[i] += t2;
+      }
+
+      z =  u1 * c1 - u2 * c2;
+      u2 = u1 * c2 + u2 * c1;
+      u1 = z;
+    }
+
+    c2 = crySqrtf(( 1.0f - c1 ) / 2.0f);
+    
+    if( 1 == iDir )
+    {
+      c2 = -c2;
+    }
+
+    c1 = crySqrtf(( 1.0f + c1 ) / 2.0f);
+  }
+  
+  // Scaling for forward transform
+  if( 1 == iDir )
+  {
+    for(i=0; i<nn; ++i)
+    {
+      real[i] /= (float) nn;
+      imag[i] /= (float) nn;
+    }
+  }
+}
+
+void FFTSSE_64(float* ar, float* ai);
+
+void CREOcean::FFT2D(int iDir, float cmpX[OCEANGRID][OCEANGRID], float cmpY[OCEANGRID][OCEANGRID])
+{
+  float real[OCEANGRID];
+  float imag[OCEANGRID];
+
+
+#if !defined(_XBOX) && !defined(WIN64) && !defined(LINUX)
+	// NOTE: AMD64 port: implement
+  if ((g_CpuFlags & CPUF_SSE) && CRenderer::CV_r_sse && !(((int)&cmpX[0][0]) & 0xf) && !(((int)&cmpY[0][0]) & 0xf) && OCEANGRID == 64)
+  {
+    FFTSSE_64(&cmpY[0][0], &cmpX[0][0]);
+    return;
+  }
+#endif
+  
+  int i, j;
+
+  // Transform the rows
+  for(j=0; j<OCEANGRID; j++)
+  {
+    for(i=0; i<OCEANGRID; i++)
+    {
+      real[i] = cmpX[j][i];
+      imag[i] = cmpY[j][i];
+    }
+
+    FFT( iDir, real, imag );
+    
+    for(i=0; i<OCEANGRID; i++)
+    {
+      cmpX[j][i] = real[i];
+      cmpY[j][i] = imag[i];
+    }
+  }
+  
+  // Transform the columns
+  for(i=0; i<OCEANGRID; i++)
+  {
+    for(j=0; j<OCEANGRID; j++)
+    {
+      real[j] = cmpX[j][i];
+      imag[j] = cmpY[j][i];
+    }
+
+    FFT( iDir, real, imag );
+
+    for(j=0; j<OCEANGRID; j++)
+    {
+      cmpX[j][i] = real[j];
+      cmpY[j][i] = imag[j];
+    }
+  }
+}
+
+void CREOcean::Update( float fTime )
+{
+  double time0 = 0;
+  ticks(time0);
+
+  float fK = 2.0f * PI;
+  for(int j=-OCEANGRID/2; j<OCEANGRID/2; j++)
+  {
+    int jn = j & (OCEANGRID-1);
+    for(int i=-OCEANGRID/2; i<OCEANGRID/2; i++)
+    {
+      int x = i + OCEANGRID/2;
+      int y = j + OCEANGRID/2;
+      unsigned int val = (int)(m_aAngularFreq[y][x] * 1024.0f / (PI*2) * fTime);
+      float fSin = gRenDev->m_RP.m_tSinTable[val&0x3ff];
+      float fCos = gRenDev->m_RP.m_tSinTable[(val+512)&0x3ff];
+
+      int x1 = -i + OCEANGRID/2;
+      int y1 = -j + OCEANGRID/2;
+
+      float hx = (m_H0X[y][x] + m_H0X[y1][x1]) * fCos -
+                 (m_H0Y[y][x] + m_H0Y[y1][x1]) * fSin;
+
+      float hy = (m_H0X[y][x] - m_H0X[y1][x1]) * fSin + 
+                 (m_H0Y[y][x] - m_H0Y[y1][x1]) * fCos;
+
+      int in = i & (OCEANGRID-1);
+
+      // update height
+      m_HX[jn][in] = hx;
+      m_HY[jn][in] = hy;
+
+      // update normal
+      float fKx = fK * i;
+      float fKy = fK * j;
+      m_NX[jn][in] = (-hy * fKx - hx * fKy);
+      m_NY[jn][in] = ( hx * fKx - hy * fKy);
+
+      // update displacement vector for choppy waves 
+      fKx *= m_aKScale[y][x];
+      fKy *= m_aKScale[y][x];
+      m_DX[jn][in] = ( hy * fKx + hx * fKy);
+      m_DY[jn][in] = (-hx * fKx + hy * fKy);
+    }
+  }
+  unticks(time0);
+  m_RS.m_StatsTimeFFTTable = (float)(time0*1000.0*g_SecondsPerCycle);
+
+  ticks(time0);
+  FFT2D(-1, m_HX, m_HY);    
+  FFT2D(-1, m_NX, m_NY);    
+  FFT2D(-1, m_DX, m_DY);    
+  unticks(time0);
+  m_RS.m_StatsTimeFFT = (float)(time0*1000.0*g_SecondsPerCycle);
+}
+
+bool CREOcean::mfCompile(SShader *ef, char *scr)
+{
+  char* name;
+  long cmd;
+  char *params;
+  char *data;
+  
+  enum {eSeed = 1, eSpeed, eGravity, eDepth, eWindSpeed, eWindDirection, eWaveHeight, eDirectionalDependence, eChoppyWaveFactor, eSuppressSmallWavesFactor};
+  static tokenDesc commands[] =
+  {
+    {eSpeed, "Speed"},
+    {eGravity, "Gravity"},
+    {eDepth, "Depth"},
+    {eWindDirection, "WindDirection"},
+    {eWindSpeed, "WindSpeed"},
+    {eWaveHeight, "WaveHeight"},
+    {eDirectionalDependence, "DirectionalDependence"},
+    {eChoppyWaveFactor, "ChoppyWaveFactor"},
+    {eSuppressSmallWavesFactor, "SuppressSmallWavesFactor"},
+    {0, 0},
+  };
+
+  float fWindDirection = 90.0f;
+  float fWindSpeed = m_fWindSpeed;
+  float fWaveHeight = m_fWaveHeight;
+  float fDirectionalDependence = m_fDirectionalDependence;
+  float fChoppyWaveFactor = m_fChoppyWaveFactor;
+  float fSuppressSmallWavesFactor = m_fSuppressSmallWavesFactor;
+  m_fSpeed = 1.0f;
+  m_fGravity = 9.81f;
+  m_fDepth = 10;
+
+  while ((cmd = shGetObject (&scr, commands, &name, &params)) > 0)
+  {
+    data = NULL;
+    if (name)
+      data = name;
+    else
+    if (params)
+      data = params;
+      
+    switch (cmd)
+    {
+      case eGravity: 
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing Gravity argument for Ocean Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        m_fGravity = shGetFloat(data);
+        break;
+
+      case eDepth: 
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing Depth argument for Ocean Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        m_fDepth = shGetFloat(data);
+        break;
+
+      case eSpeed: 
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing Speed argument for Ocean Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        m_fSpeed = shGetFloat(data);
+        break;
+
+      case eWindDirection: 
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing WindDirection argument for Ocean Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        fWindDirection = shGetFloat(data);
+        break;
+
+      case eWindSpeed: 
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing WindSpeed argument for Ocean Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        fWindSpeed = shGetFloat(data);
+        break;
+
+      case eWaveHeight: 
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing WaveHeight argument for Ocean Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        fWaveHeight = shGetFloat(data);
+        break;
+
+      case eDirectionalDependence: 
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing DirectionalDependence argument for Ocean Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        fDirectionalDependence = shGetFloat(data);
+        break;
+
+      case eChoppyWaveFactor: 
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing ChoppyWaveFactor argument for Ocean Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        fChoppyWaveFactor = shGetFloat(data);
+        break;
+
+      case eSuppressSmallWavesFactor: 
+        if (!data || !data[0])
+        {
+          Warning( 0,0,"missing SuppressSmallWavesFactor argument for Ocean Effect in Shader '%s'\n", ef->m_Name.c_str());
+          break;
+        }
+        fSuppressSmallWavesFactor = shGetFloat(data);
+        break;
+    }
+  }
+
+  PostLoad(4357, fWindDirection, fWindSpeed, fWaveHeight, fDirectionalDependence, fChoppyWaveFactor, fSuppressSmallWavesFactor);
+  m_CustomTexBind[0] = 0;
+
+#if !defined(PS2) && !defined (GC) && !defined (NULL_RENDERER)
+  if (!m_VPs[OVP_NOHEIGHT])
+  {
+    m_VPs[OVP_NOHEIGHT]      = CVProgram::mfForName("CGVProgOcean_NoHeight");
+    m_VPs[OVP_NOHEIGHT_SPL] = CVProgram::mfForName("CGVProgOcean_NoHeight_Splash");
+
+    m_VPs[OVP_HEIGHT]      = CVProgram::mfForName("CGVProgOcean");
+    m_VPs[OVP_HEIGHT_SPL] = CVProgram::mfForName("CGVProgOcean_Splash");
+  }
+  if (!m_VPQ)
+    m_VPQ = CVProgram::mfForName("CGVProgOcean_SL");
+#endif
+
+  return true;
+}
+

RenderDll/Common/RendElements/CREOcean.h

@@ -0,0 +1,471 @@
+#ifndef _CREOCEAN_H_
+#define _CREOCEAN_H_
+
+#include "../nvTriStrip/nvTriStrip.h"
+
+struct SREOceanStats
+{
+  float m_StatsTimeFFTTable;
+  float m_StatsTimeFFT;
+  float m_StatsTimeUpdateVerts;
+  float m_StatsTimeTexUpdate;
+  float m_StatsTimeRendOcean;
+  int m_StatsAllocatedSectors;
+  int m_StatsNumRendOceanSectors;
+};
+
+#define OCEANPI         3.141592654f
+#define OCEANGRID       64
+#define LOG_OCEANGRID   6
+
+#define NUM_LODS        5
+#define LOD_MASK        7
+#define LOD_LEFTSHIFT   3
+#define LOD_RIGHTSHIFT  4
+#define LOD_TOPSHIFT    5
+#define LOD_BOTTOMSHIFT 6
+
+#define OSF_VISIBLE     1
+#define OSF_FIRSTTIME   2
+#define OSF_NEEDHEIGHTS 4
+#define OSF_LODUPDATED  8
+#define OSF_BLEND       0x10
+
+#define OVP_NOHEIGHT      0
+#define OVP_NOHEIGHT_SPL  1
+#define OVP_HEIGHT        2
+#define OVP_HEIGHT_SPL    3
+#define NUM_OVP           4
+
+#define NUM_OCEANVBS      8
+
+struct SOceanSector
+{
+  float x, y;
+  int RenderState;
+  int nLod;
+  int m_Frame;
+  int m_Flags;
+
+  SOceanSector ()
+  {
+    m_Flags = OSF_FIRSTTIME;
+    m_Frame = -1;
+  }
+};
+
+struct SOceanIndicies
+{
+  float m_fLastAccess;
+  int m_nInds;
+  ushort *m_pIndicies;
+  TArray<SPrimitiveGroup> m_Groups;
+};
+
+/**
+* A random number class. It implements the <em>mersenne twister</em> algorithm to produce 
+* "high quality" pseudo random numbers.
+*/
+class CRERandom  
+{
+public:
+  enum EMersenneTwisterInitialSeed
+  {
+    INITIAL_SEED = 4357U
+  };
+
+public:
+  CRERandom( unsigned long ulSeed = INITIAL_SEED ) : m_ulIndex( 0 )
+  {
+    SetSeed( ulSeed );
+  }
+
+  ~CRERandom() {};
+
+  void SetSeed( unsigned long ulSeed )
+  {
+    m_ulState[ 0 ] = ( ulSeed | 1 ) & 0xFFFFFFFFU;
+    for( m_ulIndex = 1; m_ulIndex < N; ++m_ulIndex )
+    {
+        m_ulState[ m_ulIndex ] = ( m_ulState[ m_ulIndex - 1 ] * GENERATOR ) & 0xFFFFFFFFU;
+    }
+  }
+
+  unsigned long GetInteger()
+  {
+    if( N == m_ulIndex )
+    {
+      Reload();
+    }
+
+    unsigned long ulY = m_ulState[ m_ulIndex++ ];
+    ulY ^= TemperingShiftU( ulY );
+    ulY ^= TemperingShiftS( ulY ) & TEMPERING_MASK_B;
+    ulY ^= TemperingShiftT( ulY ) & TEMPERING_MASK_C;
+    ulY ^= TemperingShiftL( ulY );
+
+    return( ulY ); 
+  }
+
+  double Get()
+  {
+    return( GetInteger() * (double) 2.3283064365386963e-10 ); // i.e. GetInteger() / 2^32
+  }
+
+  double GetInRange( double dLower = 0.0, double dUpper = 1.0 )
+  {
+    return( dLower + Get() * ( dUpper - dLower ) );
+  }
+
+  double GetGauss( double dMean = 0.0, double dStdDeviation = 1.0 )
+  {
+    double dX1; 
+    double dX2;
+    double dW;
+
+    // perform box muller test
+    do
+    {
+      dX1 = 2.0 * Get() - 1.0;
+      dX2 = 2.0 * Get() - 1.0;
+      dW  = dX1 * dX1 + dX2 * dX2;
+    } while( dW >= 1.0 );
+    
+    dW = sqrt_tpl( -2.0f * log_tpl( dW ) / dW );
+    dX1 *= dW;
+
+    return( dMean + dX1 * dStdDeviation );
+  }
+
+private:
+  enum EMersenneTwisterConstants
+  {
+      GENERATOR   = 69069U,
+
+      N = 624U,
+      M = 397U,
+
+      MATRIX_A   = 0x9908B0DFU,
+      UPPER_MASK = 0x80000000U,
+      LOWER_MASK = 0x7FFFFFFFU,
+
+      TEMPERING_MASK_B = 0x9D2C5680U,
+      TEMPERING_MASK_C = 0xEFC60000U
+  };
+
+  void Reload()
+  {
+    const unsigned long c_ulMag01[ 2 ] = { 0x0, MATRIX_A };
+
+    unsigned long ulY;
+    for( m_ulIndex = 0; m_ulIndex < N - M; ++m_ulIndex ) 
+    {
+        ulY = ( m_ulState[ m_ulIndex     ] & UPPER_MASK ) |
+              ( m_ulState[ m_ulIndex + 1 ] & LOWER_MASK );
+        
+        m_ulState[ m_ulIndex ] = m_ulState[ m_ulIndex + M ] ^ ( ulY >> 1 ) ^ c_ulMag01[ ulY & 0x1 ];
+    }
+    
+    for( ; m_ulIndex < N  - 1; ++m_ulIndex)
+    {
+        ulY = ( m_ulState[ m_ulIndex     ] & UPPER_MASK ) | 
+              ( m_ulState[ m_ulIndex + 1 ] & LOWER_MASK );
+
+        m_ulState[ m_ulIndex ] = m_ulState[ m_ulIndex + ( M - N ) ] ^ ( ulY >> 1 ) ^ c_ulMag01[ ulY & 0x1 ];
+    }
+
+    ulY = ( m_ulState[ N - 1 ] & UPPER_MASK ) | ( m_ulState[ 0 ] & LOWER_MASK );
+    m_ulState[ N - 1 ] = m_ulState[ M - 1 ] ^ ( ulY >> 1 ) ^ c_ulMag01[ ulY & 0x1 ];
+    
+    m_ulIndex = 0;
+  }
+
+  unsigned long TemperingShiftU( unsigned long ulX )
+  {
+    return( ulX >> 11 );
+  }
+
+  unsigned long TemperingShiftS( unsigned long ulX )
+  {
+    return( ulX << 7 );
+  }
+
+  unsigned long TemperingShiftT( unsigned long ulX )
+  {
+    return( ulX << 15 );
+  }
+
+  unsigned long TemperingShiftL( unsigned long ulX )
+  {
+    return( ulX >> 18 );
+  }
+
+private:
+  unsigned long m_ulIndex;
+
+  unsigned long m_ulState[ N ];
+};
+
+//=============================================================================
+
+class CREOcean : public CRendElement
+{
+  friend class CRender3D;
+  friend class CGLRenderer;
+  friend class CD3D9Renderer;
+
+public:
+
+  static CREOcean *m_pStaticOcean;
+  CREOcean()
+  {
+    m_nFrameLoad = 0;
+    m_pBuffer = NULL;
+    mfSetType(eDATA_Ocean);
+    mfUpdateFlags(FCEF_TRANSFORM);
+    GenerateGeometry();
+    m_pStaticOcean = this;
+  }
+
+  virtual ~CREOcean();
+
+public:
+
+  void GenerateGeometry();
+  void GenerateIndices(int nLodCode);
+  void DrawOceanSector(SOceanIndicies *oi);
+  void SmoothLods_r(SOceanSector *os, float fSize, int minLod);
+  void LinkVisSectors(float fSize);
+  float GetWaterZElevation(float fX, float fY);
+
+  void PostLoad( unsigned long ulSeed, float fWindDirection, float fWindSpeed, float fWaveHeight, float fDirectionalDependence, float fChoppyWavesFactor, float fSuppressSmallWavesFactor );
+  void Update( float fTime );
+  void UpdateTexture(void);
+  void PrepareHMap();
+
+private:
+  int m_nFrameLoad;
+  float m_fGravity;
+  float m_fDepth;
+
+  TArray <unsigned short> m_pIndices[NUM_LODS];
+
+private:
+  float *mfFillAdditionalBuffer(SOceanSector *os, int nSplashes, SSplash *pSplashes[], int& nCurSize, int nLod, float fSize);
+
+  void FFT(int iDir, float* real, float* imag);
+  void FFT2DReal(float cmpX[OCEANGRID][OCEANGRID]);
+  void FFT2D(int iDir, float cmpX[OCEANGRID][OCEANGRID], float cmpY[OCEANGRID][OCEANGRID] );
+  _inline float sqrf( float x )
+  {
+    return (x * x);
+  }
+
+  _inline float PhillipsSpectrum( float fKx, float fKy )
+  {
+    float fKLength = cry_sqrtf(sqrf(fKx) + sqrf(fKy));
+
+    if( fKLength < 1e-8f )
+      fKLength = 1e-8f;
+
+    float fScale = 1.0f / fKLength;
+    fKx *= fScale;
+    fKy *= fScale;
+
+    return (m_fWaveHeight * cry_expf(-1.0f / sqrf(fKLength * m_fLargestPossibleWave) - sqrf(fKLength * m_fSuppressSmallWaves)) * cry_powf(fKx*m_fWindX + fKy*m_fWindY, m_fDirectionalDependence) / cry_powf(fKLength, 4.0f));
+  }
+
+  _inline int GetHash(float x, float y)
+  {
+    return (int)(x*0.133f+y*0.356f) & 255;
+  }
+
+  _inline SOceanSector *GetSectorByPos(float x, float y, bool bCreate=true)
+  {
+    int i;
+
+    int hash = GetHash(x, y);
+    for (i=0; i<m_OceanSectorsHash[hash].Num(); i++)
+    {
+      SOceanSector *os = &m_OceanSectorsHash[hash][i];
+      if (os->x == x && os->y == y)
+        return os;
+    }
+    m_RS.m_StatsAllocatedSectors++;
+    SOceanSector os;
+    os.x = x;
+    os.y = y;
+    os.m_Flags |= OSF_FIRSTTIME;
+    os.nLod = NUM_LODS-1;
+    int n = m_OceanSectorsHash[hash].Num();
+    m_OceanSectorsHash[hash].AddElem(os);
+    return &m_OceanSectorsHash[hash][n];
+  }
+  int GetLOD(Vec3d camera, Vec3d pos);
+
+private:
+
+  TArray<SOceanSector> m_OceanSectorsHash[256];
+  SOceanIndicies *m_OceanIndicies[1<<(LOD_BOTTOMSHIFT+1)];
+  TArray<SOceanSector *> m_VisOceanSectors;
+  float m_fSectorSize;
+
+  TArray<unsigned short> m_DWQIndices;
+  TArray<struct_VERTEX_FORMAT_P3F_COL4UB> m_DWQVertices;
+
+  float m_H0X[OCEANGRID+1][OCEANGRID+1];
+  float m_H0Y[OCEANGRID+1][OCEANGRID+1];
+
+  //static _declspec(align(16)) float m_HX[OCEANGRID][OCEANGRID];
+  //static _declspec(align(16)) float m_HY[OCEANGRID][OCEANGRID];
+
+  //static _declspec(align(16)) float m_NX[OCEANGRID][OCEANGRID];
+  //static _declspec(align(16)) float m_NY[OCEANGRID][OCEANGRID];
+
+  //static _declspec(align(16)) float m_DX[OCEANGRID][OCEANGRID];
+  //static _declspec(align(16)) float m_DY[OCEANGRID][OCEANGRID];
+	DEFINE_ALIGNED_DATA_STATIC( float, m_HX[OCEANGRID][OCEANGRID], 16 );
+	DEFINE_ALIGNED_DATA_STATIC( float, m_HY[OCEANGRID][OCEANGRID], 16 );
+
+	DEFINE_ALIGNED_DATA_STATIC( float, m_NX[OCEANGRID][OCEANGRID], 16 );
+	DEFINE_ALIGNED_DATA_STATIC( float, m_NY[OCEANGRID][OCEANGRID], 16 );
+
+	DEFINE_ALIGNED_DATA_STATIC( float, m_DX[OCEANGRID][OCEANGRID], 16 );
+	DEFINE_ALIGNED_DATA_STATIC( float, m_DY[OCEANGRID][OCEANGRID], 16 );
+
+  vec2_t m_Pos[OCEANGRID+1][OCEANGRID+1];
+  Vec3d m_Normals[OCEANGRID+1][OCEANGRID+1];
+
+  float m_aAngularFreq[OCEANGRID][OCEANGRID];
+  float m_aKScale[OCEANGRID][OCEANGRID];
+
+  float m_fWindX;    
+  float m_fWindY;
+  float m_fWindSpeed;
+  float m_fSpeed;
+  float m_fLargestPossibleWave;
+  float m_fSuppressSmallWaves;
+  float m_fWaveHeight;
+  float m_fDirectionalDependence;
+  float m_fChoppyWaveFactor;
+  float m_fSuppressSmallWavesFactor;
+
+  CVertexBuffer *m_pBuffer;
+
+  Vec3d m_MinBound;
+  Vec3d m_MaxBound;
+
+  //===========================================================================
+
+  _inline float GetHMap(float x, float y)
+  {
+    float dDownLandZ;
+
+    if( x<-m_fExpandHM || y<-m_fExpandHM || x>=m_fTerrainSize+m_fExpandHM || y>=m_fTerrainSize+m_fExpandHM)
+      dDownLandZ = 0;
+    else
+    {
+      // convert into hmap space
+      x *= m_fInvHMUnitSize;
+      y *= m_fInvHMUnitSize;
+
+      x += m_fExpandHMap;
+      y += m_fExpandHMap;
+
+      long nX = QInt(x);
+      long nY = QInt(y);
+      long nX1 = (nX+1 >= m_nHMapSize) ? nX : nX+1;
+      long nY1 = (nY+1 >= m_nHMapSize) ? nY : nY+1;
+
+      float dx = x - nX;
+      float dy = y - nY;
+
+      float dDownLandZ0 = (1.0f-dx) * m_HMap[nX*m_nHMapSize+nY]  + dx * m_HMap[nX1*m_nHMapSize+nY];
+      float dDownLandZ1 = (1.0f-dx) * m_HMap[nX*m_nHMapSize+nY1] + dx * m_HMap[nX1*m_nHMapSize+nY1];
+      dDownLandZ = (1-dy) * dDownLandZ0 + dy * dDownLandZ1;
+    }
+    return dDownLandZ;
+  }
+
+public:
+#if !defined(PS2) && !defined (GC)
+  CVProgram * m_VPs[NUM_OVP];
+  CVProgram * m_VPQ;
+#endif
+  void *m_pVertsPool[NUM_OCEANVBS];
+  void *m_VertDecl;
+  void *m_VertDeclHeightSplash;
+  int m_nCurVB;
+  int m_nNumVertsInPool;
+  bool m_bLockedVB;
+
+  float *m_HMap;
+  int    m_nHMUnitSize;
+  float  m_fExpandHM;
+  float  m_fExpandHMap;
+  int    m_nHMapSize;
+  float  m_fInvHMUnitSize;
+  float  m_fTerrainSize;
+
+  void InitVB();
+  struct_VERTEX_FORMAT_TEX2F *GetVBPtr(int nVerts);
+  void UnlockVBPtr();
+
+  void mfDrawOceanSectors();
+  void mfDrawOceanScreenLod();
+
+public:
+  virtual void mfPrepare();
+  virtual bool mfDraw(SShader *ef, SShaderPass *sfm);
+  virtual bool mfCompile(SShader *ef, char *scr);
+  virtual void *mfGetPointer(ESrcPointer ePT, int *Stride, int Type, ESrcPointer Dst, int Flags);
+  virtual bool mfPreDraw(SShaderPass *sl);
+  virtual void mfReset();
+  virtual int Size()
+  {
+    int i;
+    int nSize = sizeof(*this);
+    nSize += m_DWQVertices.GetMemoryUsage();
+    nSize += m_DWQIndices.GetMemoryUsage();
+
+    nSize += sizeof(m_Pos);
+    nSize += sizeof(m_Normals);
+    nSize += m_VisOceanSectors.GetMemoryUsage() + 12;
+    for (i=0; i<(1<<(LOD_BOTTOMSHIFT+1)); i++)
+    {
+      SOceanIndicies *oi = m_OceanIndicies[i];
+      if (!oi)
+        continue;
+
+      nSize += sizeof(SOceanIndicies);
+      nSize += oi->m_nInds * sizeof(short);
+      nSize += oi->m_Groups.GetMemoryUsage();
+    }
+    for (i=0; i<256; i++)
+    {
+      nSize += m_OceanSectorsHash[i].GetMemoryUsage()+12;
+    }
+    // CREOcean::m_HMap array
+    nSize += m_nHMapSize * m_nHMapSize * sizeof(float);
+
+    return nSize;
+  }
+
+  static SREOceanStats m_RS;
+
+#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 // _CREOCEAN_H_

RenderDll/Common/RendElements/CREOclusionQuery.cpp

@@ -0,0 +1,13 @@
+#include "RenderPCH.h"
+#include "RendElement.h"
+
+void CREOcclusionQuery::mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_FirstVertex = 0;
+  gRenDev->m_RP.m_RendNumVerts = 4;
+}
+

RenderDll/Common/RendElements/CREParticleSpray.h

@@ -0,0 +1,210 @@
+
+#ifndef __CREPARTICLESPRAY_H__
+#define __CREPARTICLESPRAY_H__
+
+//=============================================================
+
+struct SParticle
+{
+  SParticle *prev,*next;       // LINK
+  Vec3d      pos;              // CURRENT POSITION
+  Vec3d      prevPos[8];       // PREVIOUS POSITION
+  Vec3d      realPos;          // CURRENT RENDER POSITION
+  Vec3d      dir;              // CURRENT DIRECTION WITH SPEED
+  Vec3d      moveDir;          // CURRENT CHANGE DIRECTION
+  int        life;             // HOW LONG IT WILL LAST
+  int        startLife;
+  
+  CFColor    color;            // CURRENT COLOR OF PARTICLE
+  CFColor    prevColor;        // LAST COLOR OF PARTICLE
+  CFColor    deltaColor;       // CHANGE OF COLOR
+
+  bool bSpark;
+
+  float curSize;
+  float deltaSize;
+};
+
+//================================================
+
+#define MAX_PART_MOVE_STAGES 4
+
+enum EMoveType
+{
+  eMTWave,
+  eMTWhirl,
+  eMTSqueeze,
+};
+
+struct SPartMoveStage
+{
+  EMoveType eMoveType;
+  SWaveForm WaveMove;
+};
+
+//================================================
+
+enum EParticleType
+{
+  ePTPoint,
+  ePTLine,
+  ePTPolySegs,
+  ePTPoly,
+  ePTBeam,
+};
+
+enum EParticleCollision
+{
+  ePCollision_None,
+  ePCollision_True,
+  ePCollision_Plane
+};
+
+struct SParticleInfo
+{
+  // TRANSFORMATION INFO
+  float   yaw, yawVar;        // YAW AND VARIATION
+  float   pitch, pitchVar;    // PITCH AND VARIATION
+  float   speed,speedVar;
+
+  int     life, lifeVar;              // LIFE COUNT AND VARIATION
+  CFColor    startColor, startColorVar;  // CURRENT COLOR OF PARTICLE
+  CFColor    endColor, endColorVar;      // CURRENT COLOR OF PARTICLE
+
+  // Physics
+  Vec3d      force;
+
+  EParticleType ePT;
+  int Flags;
+
+  // Move info
+  SPartMoveStage mMoves[MAX_PART_MOVE_STAGES];
+  int mNumMoves;
+
+  Vec3d moveDir;
+  Vec3d moveDirVar;
+
+  // Geometry info
+  float startSize, startSizeVar;
+  float endSize, endSizeVar;
+
+  float segmOffs;
+  int segmMax;
+
+  int StackSize;
+  float Squeeze;
+};
+
+struct SEmitter
+{
+  SParticleInfo pi;
+
+  Vec3d    startPos;           // XYZ POSITION
+  Vec3d    startPosVar;        // XYZ POSITION VARIATION
+
+  // Particle
+  SParticle *particle;               // NULL TERMINATED LINKED LIST
+  int       totalParticles[2];       // TOTAL EMITTED AT ANY TIME
+  int       particleCount[2];        // TOTAL EMITTED RIGHT NOW
+  int       emitsPerFrame, emitVar;  // EMITS PER FRAME AND VARIATION
+
+  EParticleCollision eCollisionType;
+  Vec3d PlaneAxis;
+  Vec3d PlaneOffs;
+
+  SParticleInfo Spark;
+  int NumSparks;
+
+  float Life;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// Particle Definitions //////////////////////////////////////////////////////
+#define MAX_PARTICLES   4096    // MAXIMUM NUMBER OF PARTICLES
+///////////////////////////////////////////////////////////////////////////////
+
+#define FP_ANTIALIAS 0x1
+
+struct SParticleStat
+{
+  int NumSprays;
+  int NumRendSprays;
+  int NumParticles;
+  int NumVerts;
+  int NumIndices;
+};
+
+class CREParticleSpray : public CRendElement
+{
+public:
+  SEmitter mEmitter;
+  SParticle *mParticlePool[2];
+  SParticle *mParticlePntr[2];
+  int mFrame;
+
+private:
+/// Support Function Definitions //////////////////////////////////////////////
+  bool mfInitParticleSystem();
+  bool mfSetDefaultEmitter(SEmitter *emitter);
+  bool mfInitEmitter(SEmitter *emitter);
+
+  bool mfAddParticle(SEmitter *emitter, SParticleInfo *pi);
+  bool mfUpdateParticle(SParticle *particle,SEmitter *emitter);
+  void mfEmitSparks(SParticle *p, SEmitter *em);
+
+  bool mfUpdateEmitter(SEmitter *emitter);    // DRAW THE SYSTEM FOR A FRAME
+  SEmitter *mfGetEmitter(void) { return &mEmitter; }
+
+  // Parsing
+  void mfCompileParticleInfo(SShader *ef, SParticleInfo *pi, char *scr);
+  void mfCompileCollision(SShader *ef, SEmitter *em, char *scr, char *Collision);
+  bool mfCompileMove(SShader *ef, SPartMoveStage *pm, SParticleInfo *pi, char *scr);
+  bool mfCompileMoveTypeSqueeze(SShader *ef, SPartMoveStage *pm, char *scr);
+  bool mfCompileMoveTypeWhirl(SShader *ef, SPartMoveStage *pm, char *scr);
+  bool mfCompileMoveTypeWave(SShader *ef, SPartMoveStage *pm, char *scr);
+
+public:
+  CREParticleSpray()
+  {
+    mfSetType(eDATA_ParticleSpray);
+    mfUpdateFlags(FCEF_TRANSFORM | FCEF_NEEDFILLBUF);
+    mfInitEmitter(&mEmitter);
+  }
+  virtual ~CREParticleSpray();
+  //CREParticleSpray(CREParticleSpray *Orig);
+  CREParticleSpray& operator = (const CREParticleSpray& src);
+
+  // CRendElement interface
+  virtual void mfPrepare();
+  virtual bool mfCull(CCObject *obj);
+
+  virtual CRendElement *mfCopyConstruct(void)
+  {
+    //CREParticleSpray *ps = new CREParticleSpray;
+    //*ps = this;
+    return this;
+  }
+
+  virtual bool mfIsValidTime(SShader *ef, CCObject *obj, float curtime);
+  virtual bool mfCompile(SShader *ef, char *scr);
+
+  static SParticleStat mRS;
+  static void mfPrintStat();
+
+#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  // __RENDELEMENT_H__

RenderDll/Common/RendElements/CREPolyBlend.cpp

@@ -0,0 +1,651 @@
+/*=============================================================================
+	CPolyBlend.cpp : implementation of blended polygons RE.
+	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"
+
+//===============================================================
+
+bool CREPolyBlend::mfCull(CCObject *obj)
+{
+  CREPolyBlend::mRS.NumPolys++;
+
+  if ((obj->m_ObjFlags & FOB_NEAREST))
+    return false;
+
+  return false;
+}
+
+bool CREPolyBlend_Base::mfPrepareRB(CCObject *obj, Vec3d& orgo, CFColor& col)
+{
+  if (obj->m_ObjFlags & FOB_DRSUN)
+  {
+    orgo = gRenDev->m_RP.m_ViewOrg + 2000.0f * gRenDev->m_RP.m_SunDir;
+  }
+  /*else
+  if (obj->m_ObjFlags & FOB_DRPLANET)
+  {
+    orgo = obj->m_Trans + gRenDev->m_RP.m_ViewOrg;
+    orgo[2] += 2000;
+  }*/
+  else
+  {
+    orgo = obj->GetTranslation();
+  }
+
+  col = obj->m_Color;
+
+  if (col[0]+col[1]+col[2] == 0)
+    col = CFColor(1.0f);
+
+  if (obj->m_ObjFlags & FOB_DRSUN)
+  {
+    CREFlareGeom *fl = (CREFlareGeom *)obj->m_RE;
+    fl->mfCheckVis(col, obj);
+    if (!col.a)
+      return false; // Flare not visible
+    col.ScaleCol(col.a);
+    col.a = 1;
+  }
+  else
+  if (eColStyle || eAlphaStyle)
+  {
+    float frac;
+    if (eColStyle)
+    {
+      col = Col_White;
+      if (eColStyle == ePBCS_Decay)
+      {
+        frac = (gRenDev->m_RP.m_RealTime-obj->m_StartTime)/LiveTime;
+        col.ScaleCol(frac);
+      }
+    }
+    if (eAlphaStyle)
+    {
+      if (eAlphaStyle == ePBCS_Decay)
+      {
+        if (obj->m_StartTime+LiveTimeA < gRenDev->m_RP.m_RealTime-0.001)
+          frac = 1;
+        else
+          frac = (gRenDev->m_RP.m_RealTime-obj->m_StartTime)/LiveTimeA;
+        col[3] = ValA0 + frac * (ValA1-ValA0);
+      }
+    }
+  }
+  else
+  {
+    CLightStyle *ls = CLightStyle::m_LStyles[obj->m_LightStyle];
+    ls->mfUpdate(gRenDev->m_RP.m_RealTime);
+    col = ls->m_Color;
+    col[3] = 1.0f;
+  }
+  return true;
+}
+
+void CREPolyBlend_Base::mfSetVerts(CCObject *obj, Vec3d& orgo, uint c, SOrient *ori)
+{
+  Vec3d VecX, VecY, v;
+  Vec3d org;
+  float distX, distY;
+  float *verts[4];
+  Vec3d norm;
+  bvec4 *cols;
+  int i;
+  static int inds[] = {3, 0, 2, 2, 0, 1};
+  static float tverts[4][2] = 
+  {
+    {0, 0},
+    {1, 0},
+    {1, 1},
+    {0, 1}
+  };
+
+  int n = gRenDev->m_RP.m_RendNumVerts;
+  byte *p = gRenDev->m_RP.m_Ptr.PtrB + n*gRenDev->m_RP.m_Stride;
+  verts[0] = (float *)p;
+  p += gRenDev->m_RP.m_Stride;
+  verts[1] = (float *)p;
+  p += gRenDev->m_RP.m_Stride;
+  verts[2] = (float *)p;
+  p += gRenDev->m_RP.m_Stride;
+  verts[3] = (float *)p;
+
+  org = orgo;
+
+  if (ori->m_Flags & FOR_ORTHO)
+  {
+    VecX = gRenDev->m_RP.m_CamVecs[1];
+    VecY = gRenDev->m_RP.m_CamVecs[2];
+
+    org += ori->m_Coord.m_Org;
+
+    v = org - gRenDev->m_RP.m_ViewOrg;
+    distX = v.GetLength();
+    norm = -gRenDev->m_RP.m_CamVecs[0];
+  }
+  else
+  {
+    VecX = ori->m_Coord.m_Vecs[1];
+    VecY = ori->m_Coord.m_Vecs[2];
+
+    org += ori->m_Coord.m_Org;
+
+    v = org - gRenDev->m_RP.m_ViewOrg;
+    distX = v.GetLength();
+    norm = -ori->m_Coord.m_Vecs[0];
+  }
+  if (gRenDev->m_RP.m_PersFlags & RBPF_DRAWMIRROR)
+  {
+    VecY = -VecY;
+  }
+
+  distY = distX;
+  if (ScaleX > 0)
+  {
+    distX = ScaleX;
+    distY = ScaleY;
+  }
+  else
+  if (ScaleX < 0)
+  {
+    distX *= -ScaleX * 0.1f;
+    distY *= -ScaleY * 0.1f;
+  }
+  else
+    distX = distY = 10.0f;
+
+  VecX *= distX;
+  VecY *= distY;
+
+  verts[0][0] = org[0]+VecX[0]+VecY[0];
+  verts[0][1] = org[1]+VecX[1]+VecY[1];
+  verts[0][2] = org[2]+VecX[2]+VecY[2];
+
+  verts[1][0] = org[0]-VecX[0]+VecY[0];
+  verts[1][1] = org[1]-VecX[1]+VecY[1];
+  verts[1][2] = org[2]-VecX[2]+VecY[2];
+
+  verts[2][0] = org[0]-VecX[0]-VecY[0];
+  verts[2][1] = org[1]-VecX[1]-VecY[1];
+  verts[2][2] = org[2]-VecX[2]-VecY[2];
+
+  verts[3][0] = org[0]+VecX[0]-VecY[0];
+  verts[3][1] = org[1]+VecX[1]-VecY[1];
+  verts[3][2] = org[2]+VecX[2]-VecY[2];
+
+  UPipeVertex ptr = gRenDev->m_RP.m_NextPtr;
+  byte *OffsT, *OffsD;
+  SMRendTexVert *rtvb;
+  byte *OffsN;
+  switch (gRenDev->m_RP.m_FT)
+  {
+    case FLT_BASE:
+      cols = &gRenDev->m_RP.m_pClientColors[n];
+      OffsT = gRenDev->m_RP.m_OffsT + ptr.PtrB;
+      for (i=0; i<4; i++, cols++, OffsT+=gRenDev->m_RP.m_Stride)
+      {
+        *(float *)(OffsT) = tverts[i][0];
+        *(float *)(OffsT+4) = tverts[i][1];
+        *(uint *)cols = c;
+      }
+      break;
+
+    case FLT_BASE + FLT_COL:
+      OffsD = gRenDev->m_RP.m_OffsD + ptr.PtrB;
+      OffsT = gRenDev->m_RP.m_OffsT + ptr.PtrB;
+      for (i=0; i<4; i++, OffsT+=gRenDev->m_RP.m_Stride, OffsD+=gRenDev->m_RP.m_Stride)
+      {
+        *(float *)(OffsT) = tverts[i][0];
+        *(float *)(OffsT+4) = tverts[i][1];
+        *(uint *)OffsD = c;
+      }
+      break;
+
+    case FLT_COL:
+      OffsD = gRenDev->m_RP.m_OffsD + ptr.PtrB;
+      for (i=0; i<4; i++, OffsD+=gRenDev->m_RP.m_Stride)
+      {
+        *(uint *)OffsD = c;
+      }
+      break;
+
+    case FLT_COL + FLT_SYSBASE:
+      OffsD = gRenDev->m_RP.m_OffsD + ptr.PtrB;
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      for (i=0; i<4; i++, OffsD+=gRenDev->m_RP.m_Stride)
+      {
+        Vector2Copy(tverts[i], rtvb[i].vert);
+        *(uint *)OffsD = c;
+      }
+      break;
+
+    case 0:
+      cols = &gRenDev->m_RP.m_pClientColors[n];
+      for (i=0; i<4; i++, cols++)
+      {
+        *(uint *)cols = c;
+      }
+      break;
+
+    case FLT_SYSBASE:
+      cols = &gRenDev->m_RP.m_pClientColors[n];
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      for (i=0; i<4; i++, cols++)
+      {
+        Vector2Copy(tverts[i], rtvb[i].vert);
+        *(uint *)cols = c;
+      }
+      break;
+
+
+    case FLT_BASE + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      cols = &gRenDev->m_RP.m_pClientColors[n];
+      OffsT = gRenDev->m_RP.m_OffsT + ptr.PtrB;
+      for (i=0; i<4; i++, cols++, OffsT+=gRenDev->m_RP.m_Stride)
+      {
+        *(float *)(OffsN) = norm.x;
+        *(float *)(OffsN+4) = norm.y;
+        *(float *)(OffsN+8) = norm.z;
+        *(float *)(OffsT) = tverts[i][0];
+        *(float *)(OffsT+4) = tverts[i][1];
+        *(uint *)cols = c;
+      }
+      break;
+
+    case FLT_BASE + FLT_COL + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      OffsD = gRenDev->m_RP.m_OffsD + ptr.PtrB;
+      OffsT = gRenDev->m_RP.m_OffsT + ptr.PtrB;
+      for (i=0; i<4; i++, OffsT+=gRenDev->m_RP.m_Stride, OffsD+=gRenDev->m_RP.m_Stride)
+      {
+        *(float *)(OffsN) = norm.x;
+        *(float *)(OffsN+4) = norm.y;
+        *(float *)(OffsN+8) = norm.z;
+        *(float *)(OffsT) = tverts[i][0];
+        *(float *)(OffsT+4) = tverts[i][1];
+        *(uint *)OffsD = c;
+      }
+      break;
+
+    case FLT_COL + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      OffsD = gRenDev->m_RP.m_OffsD + ptr.PtrB;
+      for (i=0; i<4; i++, OffsD+=gRenDev->m_RP.m_Stride)
+      {
+        *(float *)(OffsN) = norm.x;
+        *(float *)(OffsN+4) = norm.y;
+        *(float *)(OffsN+8) = norm.z;
+        *(uint *)OffsD = c;
+      }
+      break;
+
+    case FLT_COL + FLT_SYSBASE + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      OffsD = gRenDev->m_RP.m_OffsD + ptr.PtrB;
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      for (i=0; i<4; i++, OffsD+=gRenDev->m_RP.m_Stride)
+      {
+        *(float *)(OffsN) = norm.x;
+        *(float *)(OffsN+4) = norm.y;
+        *(float *)(OffsN+8) = norm.z;
+        Vector2Copy(tverts[i], rtvb[i].vert);
+        *(uint *)OffsD = c;
+      }
+      break;
+
+    case 0 + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      cols = &gRenDev->m_RP.m_pClientColors[n];
+      for (i=0; i<4; i++, cols++)
+      {
+        *(float *)(OffsN) = norm.x;
+        *(float *)(OffsN+4) = norm.y;
+        *(float *)(OffsN+8) = norm.z;
+        *(uint *)cols = c;
+      }
+      break;
+
+    case FLT_SYSBASE + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      cols = &gRenDev->m_RP.m_pClientColors[n];
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      for (i=0; i<4; i++, cols++)
+      {
+        *(float *)(OffsN) = norm.x;
+        *(float *)(OffsN+4) = norm.y;
+        *(float *)(OffsN+8) = norm.z;
+        Vector2Copy(tverts[i], rtvb[i].vert);
+        *(uint *)cols = c;
+      }
+      break;
+
+    default:
+      break;
+  }
+  if ((gRenDev->m_RP.m_FT & FLT_COL) && gbRgb)
+  {
+    OffsD = gRenDev->m_RP.m_OffsD + gRenDev->m_RP.m_NextPtr.PtrB;
+    for (i=0; i<4; i++, OffsD+=gRenDev->m_RP.m_Stride)
+    {
+      *(uint *)(OffsD) = COLCONV(*(uint *)(OffsD));
+    }
+  }
+
+  ptr.PtrB += gRenDev->m_RP.m_Stride*4;
+  gRenDev->m_RP.m_NextPtr = ptr;
+
+  ushort *dinds = &gRenDev->m_RP.m_RendIndices[gRenDev->m_RP.m_RendNumIndices];
+  for (i=0; i<6; i++)
+  {
+    *dinds++ = inds[i]+n;
+  }
+}
+
+void CREPolyBlend::mfPrepare(void)
+{
+  CCObject *obj = gRenDev->m_RP.m_pCurObject;
+  if (!obj)
+    return;
+
+  int savev = gRenDev->m_RP.m_RendNumVerts;
+  int savei = gRenDev->m_RP.m_RendNumIndices;
+
+  CREPolyBlend::mRS.NumRendPolys++;
+
+  SShader *ef = gRenDev->m_RP.m_pShader;
+  CFColor col;
+  Vec3d orgo;
+
+  if (!mfPrepareRB(obj, orgo, col))
+    return;
+
+  uint c = col.GetTrue();
+
+  for (int o=0; o<NumOrients; o++)
+  {
+    gRenDev->EF_CheckOverflow(4, 6, this);
+
+    mfSetVerts(obj, orgo, c, Orients[o]);
+
+    gRenDev->m_RP.m_RendNumVerts += 4;
+    gRenDev->m_RP.m_RendNumIndices += 6;
+  }
+
+  CREPolyBlend::mRS.NumVerts += gRenDev->m_RP.m_RendNumVerts - savev; 
+  CREPolyBlend::mRS.NumIndices += gRenDev->m_RP.m_RendNumIndices - savei; 
+}
+
+//=====================================================================
+
+bool CREAnimPolyBlend::mfCull(CCObject *obj)
+{
+  CREPolyBlend::mRS.NumAnimPolys++;
+
+  //if(gfCullSphere(obj->m_Trans, 100)==2)
+  //  return true;
+
+  return false;
+}
+
+bool CREPolyBlend::mfIsValidTime(SShader *ef, CCObject *obj, float curtime)
+{
+  if (!LiveTime)
+    return true;
+
+  if (curtime > LiveTime+obj->m_StartTime)
+    return false;
+  return true;
+}
+
+bool CREAnimPolyBlend::mfIsValidTime(SShader *ef, CCObject *obj, float curtime)
+{
+  int i, j;
+  SShaderTexUnit *shm;
+  SShaderPass *sfm;
+
+  for (i=0; i<ef->m_Passes.Num(); i++)
+  {
+    sfm = &ef->m_Passes[i];
+
+    for (j=0; j<sfm->m_TUnits.Num(); j++)
+    {
+      shm = &sfm->m_TUnits[j];
+      if (!shm->m_AnimInfo)
+        continue;
+      if (shm->m_AnimInfo->m_Time && shm->m_AnimInfo->m_TexPics.Num())
+      {
+        float t = curtime - obj->m_StartTime;
+        int m = (int)(t / shm->m_AnimInfo->m_Time);
+        if (m >= shm->m_AnimInfo->m_TexPics.Num())
+          return false;
+      }
+    }
+  }
+  return true;
+}
+
+void CREAnimPolyBlend::mfPrepare(void)
+{
+  CCObject *obj = gRenDev->m_RP.m_pCurObject;
+  if (!obj)
+    return;
+  
+  int savev = gRenDev->m_RP.m_RendNumVerts;
+  int savei = gRenDev->m_RP.m_RendNumIndices;
+  
+  CREPolyBlend::mRS.NumRendPolys++;
+  
+  SShader *ef = gRenDev->m_RP.m_pShader;
+  CFColor col;
+  Vec3d orgo;
+  
+  if (!mfPrepareRB(obj, orgo, col))
+    return;
+  
+  uint c = col.GetTrue();
+  
+  for (int o=0; o<NumOrients; o++)
+  {
+    gRenDev->EF_CheckOverflow(4, 6, this);
+    
+    mfSetVerts(obj, orgo, c, Orients[o]);
+    
+    gRenDev->m_RP.m_RendNumVerts += 4;
+    gRenDev->m_RP.m_RendNumIndices += 6;
+  }
+  
+  CREPolyBlend::mRS.NumVerts += gRenDev->m_RP.m_RendNumVerts - savev; 
+  CREPolyBlend::mRS.NumIndices += gRenDev->m_RP.m_RendNumIndices - savei; 
+}
+
+
+//=======================================================================
+
+SPolyBlendStat CREPolyBlend::mRS;
+
+void CREPolyBlend::mfPrintStat()
+{
+/*  char str[1024];
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Indices: %i\n", mRS.NumIndices);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Verts: %i\n", mRS.NumVerts);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Render AnimPolys: %i\n", mRS.NumAnimRendPolys);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Occluding AnimPolys: %i\n", mRS.NumAnimPolys);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Render Polys: %i\n", mRS.NumRendPolys);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Occluding Polys: %i\n", mRS.NumPolys);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  gRenDev->mfPrintString ("\nBlended Polygons status info:\n", PS_TRANSPARENT | PS_UP);*/
+}
+
+//===================================================================================================
+
+// Parsing
+
+void CREPolyBlend_Base::mfCompileOrients(SShader *ef, int *nums, SOrient *Orients[], char *scr)
+{
+  if (!scr || !scr[0])
+  {
+    Warning( 0,0,"Can't declare orient for effector '%s'\n", ef->m_Name.c_str());
+    *nums = 1;
+    Orients[0] = &gRenDev->m_cEF.m_Orients[0];
+  }
+  else
+  {
+    int ors[16];
+    *nums = sscanf(scr, "%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i", &ors[0], &ors[1], &ors[2], &ors[3], &ors[4], &ors[5], &ors[6], &ors[7], &ors[8], &ors[9], &ors[10], &ors[11], &ors[12], &ors[13], &ors[14], &ors[15]);
+    if (!(*nums))
+    {
+      Warning( 0,0,"Can't declare orient for effector '%s'\n", ef->m_Name.c_str());
+      *nums = 1;
+      Orients[0] = &gRenDev->m_cEF.m_Orients[0];
+    }
+    else
+    {
+      for (int i=0; i<*nums; i++)
+      {
+        if (ors[i] >= gRenDev->m_cEF.m_NumOrients)
+        {
+          Warning( 0,0,"Can't declare %d orient (Use Ortho mode)\n", ors[i]);
+          *nums = 1;
+          Orients[0] = &gRenDev->m_cEF.m_Orients[0];
+          return;
+        }
+        Orients[i] = &gRenDev->m_cEF.m_Orients[ors[i]];
+      }
+    }
+  }
+}
+
+
+bool CREPolyBlend_Base::mfCompile(SShader *ef, char *scr)
+{
+  char* name;
+  long cmd;
+  char *params;
+  char *data;
+
+  enum {eTrace=1, eType, eScale, eScalX, eScalY, eOrients, eRGBStyle, eAlphaStyle};
+  static tokenDesc commands[] =
+  {
+    {eTrace, "Trace"},
+    {eType, "Type"},
+    {eScale, "Scale"},
+    {eScalX, "ScalX"},
+    {eScalY, "ScalY"},
+    {eOrients, "Orients"},
+    {eRGBStyle, "RGBStyle"},
+    {eAlphaStyle, "AlphaStyle"},
+
+    {0,0}
+  };
+
+  while ((cmd = shGetObject (&scr, commands, &name, &params)) > 0)
+  {
+    data = NULL;
+    if (name)
+      data = name;
+    else
+    if (params)
+      data = params;
+
+    switch (cmd)
+    {
+      case eTrace:
+        mfUpdateFlags(FCEFPB_TRACE);
+        break;
+
+      case eType:
+        if (!stricmp(data, "Beam"))
+          this->eType = ePBT_Beam;
+        else
+          Warning( 0,0,"unknown Type parameter '%s' in Shader '%s' (CREPolyBlend)\n", data, ef->m_Name.c_str());
+        break;
+
+      case eScale:
+        ScaleX = ScaleY = shGetFloat(data);
+        break;
+
+      case eScalX:
+        ScaleX = shGetFloat(data);
+        break;
+
+      case eScalY:
+        ScaleY = shGetFloat(data);
+        break;
+
+      case eRGBStyle:
+        if (!stricmp(data, "Decay"))
+        {
+          eColStyle = ePBCS_Decay;
+          if (!params || !params[0])
+          {
+            Warning( 0,0,"missing RgbStyle Decay value in Shader '%s' (skipped) (CREPolyBlend)\n", ef->m_Name.c_str());
+            Val0 = 1;
+            Val1 = 0;
+            LiveTime = 1;
+          }
+          else
+          {
+            sscanf(params, "%f %f %f", &Val0, &Val1, &LiveTime);
+          }
+        }
+        else
+          Warning( 0,0,"unknown RgbStyle parameter '%s' in Shader '%s' (CREPolyBlend)\n", data, ef->m_Name.c_str());
+
+      case eAlphaStyle:
+        if (!stricmp(data, "Decay"))
+        {
+          this->eAlphaStyle = ePBCS_Decay;
+          if (!params || !params[0])
+          {
+            Warning( 0,0,"missing RgbStyle Decay value in Shader '%s' (skipped) (CREPolyBlend)\n", ef->m_Name.c_str());
+            ValA0 = 1;
+            ValA1 = 0;
+            LiveTimeA = 1;
+          }
+          else
+          {
+            sscanf(params, "%f %f %f", &ValA0, &ValA1, &LiveTimeA);
+          }
+        }
+        else
+          Warning( 0,0,"unknown RgbStyle parameter '%s' in Shader '%s' (CREPolyBlend)\n", data, ef->m_Name.c_str());
+
+
+      case eOrients:
+        mfCompileOrients(ef, &NumOrients, Orients, params);
+        if (Orients[0] == &gRenDev->m_cEF.m_Orients[0])
+          mfUpdateFlags(FCEFPB_ORTHO);
+        break;
+    }
+  }
+
+  return true;
+}

RenderDll/Common/RendElements/CREPolyBlend.h

@@ -0,0 +1,121 @@
+
+#ifndef __CREPOLYBLEND_H__
+#define __CREPOLYBLEND_H__
+
+//=============================================================
+
+#define FCEFPB_TRACE  0x10000
+#define FCEFPB_ORTHO  0x20000
+#define FCEFPB_SCALE  0x40000
+#define FCEFPB_PLANET 0x80000
+
+enum ePBColStyle
+{
+  ePBCS_None,
+  ePBCS_Decay,
+};
+
+enum ePBType
+{
+  ePBT_Sprite,
+  ePBT_Beam,
+};
+
+struct SPolyBlendStat
+{
+  int NumPolys;
+  int NumRendPolys;
+  int NumAnimPolys;
+  int NumAnimRendPolys;
+  int NumVerts;
+  int NumIndices;
+};
+
+class CREPolyBlend_Base : public CRendElement
+{
+public:
+  float ScaleX, ScaleY;
+  int NumOrients;
+  SOrient *Orients[16];
+  ePBColStyle eColStyle;
+  ePBColStyle eAlphaStyle;
+  ePBType eType; 
+  float LiveTime;
+  float LiveTimeA;
+  float Val0;
+  float Val1;
+  float ValA0;
+  float ValA1;
+
+public:
+  CREPolyBlend_Base()
+  {
+    ScaleX = ScaleY = 0;
+    eColStyle = ePBCS_None;
+    eType = ePBT_Sprite;
+    LiveTime = 0;
+  }
+
+  virtual bool mfCompile(SShader *ef, char *scr);
+
+protected:
+  bool mfPrepareRB(CCObject *obj, Vec3d& orgo, CFColor& col);
+  void mfSetVerts(CCObject *obj, Vec3d& orgo, uint c, SOrient *ori);
+
+  void mfCompileOrients(SShader *ef, int *nums, SOrient *Orients[], char *scr);
+};
+
+class CREPolyBlend : public CREPolyBlend_Base
+{
+public:
+
+  static SPolyBlendStat mRS;
+  static void mfPrintStat();
+
+public:
+  CREPolyBlend()
+  {
+    mfSetType(eDATA_PolyBlend);
+    Val0 = Val1 = 0;
+    mfSetFlags(FCEF_NEEDFILLBUF);
+  }
+
+  virtual ~CREPolyBlend() {};
+
+  virtual void mfPrepare();
+  virtual bool mfCull(CCObject *obj);
+  virtual CRendElement *mfCopyConstruct(void)
+  {
+    CREPolyBlend *pb = new CREPolyBlend;
+    *pb = *this;
+    return pb;
+  }
+  virtual bool mfIsValidTime(SShader *ef, CCObject *obj, float curtime);
+};
+
+
+class CREAnimPolyBlend : public CREPolyBlend_Base
+{
+public:
+  int curNum;
+
+public:
+  CREAnimPolyBlend() : CREPolyBlend_Base()
+  {
+    mfSetType(eDATA_AnimPolyBlend);
+    mfSetFlags(FCEF_NEEDFILLBUF);
+  }
+  virtual ~CREAnimPolyBlend() {};
+
+  virtual void mfPrepare();
+  virtual bool mfCull(CCObject *obj);
+  virtual CRendElement *mfCopyConstruct(void)
+  {
+    CREAnimPolyBlend *apb = new CREAnimPolyBlend;
+    *apb = *this;
+    return apb;
+  }
+  virtual bool mfIsValidTime(SShader *ef, CCObject *obj, float curtime);
+};
+
+#endif  // __CREPOLYBLEND_H__

RenderDll/Common/RendElements/CREPolyMesh.cpp

@@ -0,0 +1,485 @@
+/*=============================================================================
+	CREPolyMesh.cpp : implementation of mesh polygons RE.
+	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 <CREPolyMesh.h>
+
+
+//===============================================================
+
+SPolyStat CREPolyMesh::mRS;
+
+CREPolyMesh::~CREPolyMesh()
+{
+  if (TriVerts)
+    delete [] TriVerts;
+  if (Indices)
+    delete [] Indices;
+  if (bNoDeform)
+    delete [] bNoDeform;
+}
+
+void CREPolyMesh::mfGetPlane(Plane& pl)
+{
+  pl.n = m_Plane.n;
+  pl.d = m_Plane.d;
+}
+
+CRendElement *CREPolyMesh::mfCopyConstruct(void)
+{
+  CREPolyMesh *pm = new CREPolyMesh;
+  *pm = *this;
+  return pm;
+}
+
+bool CREPolyMesh::mfCullFace(ECull cl)
+{
+  CREPolyMesh::mRS.NumOccPolys++;
+
+  if (cl != eCULL_None)
+  {
+    float d = m_Plane.n * gRenDev->m_RP.m_ViewOrg;
+    if (cl == eCULL_Front)
+    {
+      if (d < m_Plane.d-8.0f)
+        return true;
+    }
+    else
+    {
+      if (d > m_Plane.d+8.0f)
+        return true;
+    }
+  }
+
+  CREPolyMesh::mRS.NumRendPolys++;
+
+  return false;
+}
+
+void CREPolyMesh::mfCenter(Vec3d& centr, CCObject *pObj)
+{
+  int i;
+
+  centr(0,0,0);
+  for (i=0; i<NumVerts; i++)
+  {
+    centr += TriVerts[i].vert;
+  }
+  float s = 1.0f / NumVerts;
+  centr *= s;
+  if (pObj)
+    centr += pObj->GetTranslation();
+}
+
+int CREPolyMesh::mfTransform(Matrix44& ViewMatr, Matrix44& ProjMatr, vec4_t *verts, vec4_t *vertsp, int Num)
+{
+  int i, j;
+
+  for (i=0; i<NumVerts; i++)
+  {
+    if (i == Num)
+      break;
+    for (j=0; j<4; j++)
+    {
+      verts[i][j] = TriVerts[i].vert[0]*ViewMatr(0,j) + TriVerts[i].vert[1]*ViewMatr(1,j) + TriVerts[i].vert[2]*ViewMatr(2,j) + ViewMatr(3,j);
+    }
+  }
+  
+  for (i=0; i<NumVerts; i++)
+  {
+    if (i == Num)
+      break;
+    for (j=0; j<4; j++)
+    {
+      vertsp[i][j] = verts[i][0]*ProjMatr(0,j) + verts[i][1]*ProjMatr(1,j) + verts[i][2]*ProjMatr(2,j) + verts[i][3]*ProjMatr(3,j);
+    }
+  }
+  return NumVerts;
+}
+
+void CREPolyMesh::mfPrepare(void)
+{
+  ushort *inds;
+  int i, n;
+  SShader *ef = gRenDev->m_RP.m_pShader;
+
+  CREPolyMesh::mRS.NumVerts += NumVerts;
+  CREPolyMesh::mRS.NumIndices += NumIndices;
+
+  // Check overflow
+  gRenDev->EF_CheckOverflow(NumVerts, NumIndices, this);
+
+  inds = Indices;
+  n = gRenDev->m_RP.m_RendNumVerts;
+#ifdef OPENGL
+  ushort *dinds = &gRenDev->m_RP.m_RendIndices[gRenDev->m_RP.m_RendNumIndices];
+#else
+  ushort *dinds = &gRenDev->m_RP.m_RendIndices[gRenDev->m_RP.m_RendNumIndices];
+#endif
+  i = NumIndices;
+  gRenDev->m_RP.m_RendNumIndices += i;
+  while(i--)
+  {
+    *dinds++ = *inds++ + n;
+  }
+
+  UPipeVertex ptr = gRenDev->m_RP.m_NextPtr;
+  //SMRendTexVert *rtvb, *rtvl;
+  SMTriVert *tv = TriVerts;
+  //byte *OffsN;
+  int m = NumVerts;
+
+  /*switch (gRenDev->m_RP.mFT)
+  {
+    case FLT_BASE:
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        Vector2Copy(tv[i].dTC, ptr.Ptr_D_1T->st);
+      }
+      break;
+
+    case FLT_BASE + FLT_COL:
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_1T->color.dcolor = -1;
+        Vector2Copy(tv[i].dTC, ptr.Ptr_D_1T->st);
+      }
+      break;
+
+    case FLT_SYSBASE:
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride, rtvb++)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        Vector2Copy(tv[i].dTC, rtvb->vert);
+      }
+      break;
+
+    case FLT_SYSBASE + FLT_COL:
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride, rtvb++)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_1T->color.dcolor = -1;
+        Vector2Copy(tv[i].dTC, rtvb->vert);
+      }
+      break;
+
+    case FLT_BASE + FLT_LM:
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        Vector2Copy(tv[i].dTC, ptr.Ptr_D_2T->st[0]);
+        Vector2Copy(tv[i].lmTC, ptr.Ptr_D_2T->st[1]);
+      }
+      break;
+
+    case FLT_BASE + FLT_LM + FLT_COL:
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_2T->color.dcolor = -1;
+        Vector2Copy(tv[i].dTC, ptr.Ptr_D_2T->st[0]);
+        Vector2Copy(tv[i].lmTC, ptr.Ptr_D_2T->st[1]);
+      }
+      break;
+
+    case FLT_SYSBASE + FLT_LM:
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride, rtvb++)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        Vector2Copy(tv[i].lmTC, ptr.Ptr_D_2T->st[1]);
+        Vector2Copy(tv[i].dTC, rtvb->vert);
+      }
+      break;
+
+    case FLT_SYSBASE + FLT_LM + FLT_COL:
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride, rtvb++)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_2T->color.dcolor = -1;
+        Vector2Copy(tv[i].lmTC, ptr.Ptr_D_2T->st[1]);
+        Vector2Copy(tv[i].dTC, rtvb->vert);
+      }
+      break;
+
+    case FLT_SYSBASE + FLT_SYSLM:
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      rtvl = &gRenDev->m_RP.m_pLMTexCoordPointer[n];
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride, rtvb++, rtvl++)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        Vector2Copy(tv[i].lmTC, rtvl->vert);
+        Vector2Copy(tv[i].dTC, rtvb->vert);
+      }
+      break;
+
+    case FLT_SYSBASE + FLT_SYSLM + FLT_COL:
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      rtvl = &gRenDev->m_RP.m_pLMTexCoordPointer[n];
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride, rtvb++, rtvl++)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_2T->color.dcolor = -1;
+        Vector2Copy(tv[i].lmTC, rtvl->vert);
+        Vector2Copy(tv[i].dTC, rtvb->vert);
+      }
+      break;
+
+
+    case FLT_BASE + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        Vector2Copy(tv[i].dTC, ptr.Ptr_D_1T->st);
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case FLT_BASE + FLT_COL + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_1T->color.dcolor = -1;
+        Vector2Copy(tv[i].dTC, ptr.Ptr_D_1T->st);
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case FLT_SYSBASE + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        Vector2Copy(tv[i].dTC, rtvb[i].vert);
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case FLT_SYSBASE + FLT_COL + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_1T->color.dcolor = -1;
+        Vector2Copy(tv[i].dTC, rtvb[i].vert);
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case FLT_BASE + FLT_LM + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        Vector2Copy(tv[i].dTC, ptr.Ptr_D_2T->st[0]);
+        Vector2Copy(tv[i].lmTC, ptr.Ptr_D_2T->st[1]);
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case FLT_BASE + FLT_LM + FLT_COL + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_2T->color.dcolor = -1;
+        Vector2Copy(tv[i].dTC, ptr.Ptr_D_2T->st[0]);
+        Vector2Copy(tv[i].lmTC, ptr.Ptr_D_2T->st[1]);
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case FLT_SYSBASE + FLT_LM + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        Vector2Copy(tv[i].lmTC, ptr.Ptr_D_2T->st[1]);
+        Vector2Copy(tv[i].dTC, rtvb[i].vert);
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case FLT_SYSBASE + FLT_LM + FLT_COL + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_2T->color.dcolor = -1;
+        Vector2Copy(tv[i].lmTC, ptr.Ptr_D_2T->st[1]);
+        Vector2Copy(tv[i].dTC, rtvb[i].vert);
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case FLT_SYSBASE + FLT_SYSLM + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      rtvl = &gRenDev->m_RP.m_pLMTexCoordPointer[n];
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        Vector2Copy(tv[i].lmTC, rtvl[i].vert);
+        Vector2Copy(tv[i].dTC, rtvb[i].vert);
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case FLT_SYSBASE + FLT_SYSLM + FLT_COL + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      rtvb = &gRenDev->m_RP.m_pBaseTexCoordPointer[n];
+      rtvl = &gRenDev->m_RP.m_pLMTexCoordPointer[n];
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_2T->color.dcolor = -1;
+        Vector2Copy(tv[i].lmTC, rtvl[i].vert);
+        Vector2Copy(tv[i].dTC, rtvb[i].vert);
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case FLT_COL + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_2T->color.dcolor = -1;
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case FLT_LM + FLT_COL + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_2T->color.dcolor = -1;
+        Vector2Copy(tv[i].lmTC, ptr.Ptr_D_2T->st[1]);
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case FLT_SYSLM + FLT_COL + FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      rtvl = &gRenDev->m_RP.m_pLMTexCoordPointer[n];
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_2T->color.dcolor = -1;
+        Vector2Copy(tv[i].lmTC, rtvl[i].vert);
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case FLT_COL:
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        ptr.Ptr_D_2T->color.dcolor = -1;
+      }
+      break;
+
+    case FLT_N:
+      OffsN = gRenDev->m_RP.m_OffsN + ptr.PtrB;
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+        *(float *)(OffsN) = m_Plane.n.x;
+        *(float *)(OffsN+4) = m_Plane.n.y;
+        *(float *)(OffsN+8) = m_Plane.n.z;
+      }
+      break;
+
+    case 0:
+      for (i=0; i<m; i++, ptr.PtrB+=gRenDev->m_RP.m_Stride)
+      {
+        ptr.Ptr_D_1T->xyz = tv[i].vert;
+      }
+      break;
+
+    default:
+      break;
+  }*/
+
+  gRenDev->m_RP.m_NextPtr = ptr;
+  gRenDev->m_RP.m_RendNumVerts += NumVerts;
+}
+
+void CREPolyMesh::mfPrintStat()
+{
+//  char str[1024];
+
+/*  *gpCurPrX = 4;
+  sprintf(str, "Num Indices: %i\n", mRS.NumIndices);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Verts: %i\n", mRS.NumVerts);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Rend. Details: %i\n", mRS.NumRendDetails);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Calc. Details: %i\n", mRS.NumDetails);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num Rend Polys: %i\n", mRS.NumRendPolys);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  sprintf(str, "Num BSP Occluded Polys: %i\n", mRS.NumOccPolys);
+  gRenDev->mfPrintString (str, PS_TRANSPARENT | PS_UP);
+
+  *gpCurPrX = 4;
+  gRenDev->mfPrintString ("\nPolys status info:\n", PS_TRANSPARENT | PS_UP);*/
+}

RenderDll/Common/RendElements/CREPrefabGeom.cpp

@@ -0,0 +1,76 @@
+/*=============================================================================
+	CREPrefabGeom.cpp : implementation of wall geometry RE for the editor.
+  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 "RendElement.h"
+
+//===============================================================
+
+CRendElement *CREPrefabGeom::mfCopyConstruct(void)
+{
+  CREPrefabGeom *cp = new CREPrefabGeom;
+  *cp = *this;
+  return cp;
+}
+
+bool CREPrefabGeom::mfCompile(SShader *ef, char *scr)
+{
+  char* name;
+  long cmd;
+  char *params;
+  char *data;
+
+  enum {eModel=1};
+  static tokenDesc commands[] =
+  {
+    {eModel, "Model"},
+
+    {0,0}
+  };
+
+  while ((cmd = shGetObject (&scr, commands, &name, &params)) > 0)
+  {
+    data = NULL;
+    if (name)
+      data = name;
+    else
+    if (params)
+      data = params;
+
+    switch (cmd)
+    {
+      case eModel:
+        mModel = NULL;//(CModelCgf *)CComModel::mfForName(data);
+        break;
+    }
+  }
+
+  if (mModel)
+    return true;
+  return false;
+}
+
+void CREPrefabGeom::mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+  
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_RendNumVerts = 0;
+}
+
+bool CREPrefabGeom::mfDraw(SShader *ef, SShaderPass *sl)
+{
+  //if (mModel)
+  //  mModel->mfDraw(ef, bCamera);
+  return true;
+}

RenderDll/Common/RendElements/CREPrefabGeom.h

@@ -0,0 +1,41 @@
+ 
+#ifndef __CREPREFABGEOM_H__
+#define __CREPREFABGEOM_H__
+
+//=============================================================
+
+struct SREPrefabStat
+{
+  int NumRendPolys;
+  int NumVerts;
+  int NumIndices;
+};
+
+class CModelCgf;
+
+class CREPrefabGeom : public CRendElement
+{
+public:
+  void *mModel;
+
+  static SREPrefabStat mRS;
+  static void mfPrintStat();
+
+public:
+  CREPrefabGeom()
+  {
+    mfSetType(eDATA_Prefab);
+    mModel = 0;
+    mfSetFlags(FCEF_TRANSFORM);
+  }
+
+  virtual ~CREPrefabGeom() {};
+
+  bool mfCullBox(Vec3d vmin, Vec3d vmax);
+  virtual CRendElement *mfCopyConstruct(void);
+  virtual bool mfCompile(SShader *ef, char *scr);
+  virtual void mfPrepare();
+  virtual bool mfDraw(SShader *ef, SShaderPass *sl);
+};
+
+#endif  // __CREPREFABGEOM_H__

RenderDll/Common/RendElements/CREScreenCommon.h

@@ -0,0 +1,381 @@
+/*
+=========================================================================
+FILE : CRECommon.h
+DESC : render elements common stuff
+PROJ : Crytek Engine
+CODER: Tiago Sousa
+
+NOTE/TODO/FIX:
+
+. All shaders, specialized textures used, should be initialized/destroyed
+in CScreenVars class
+
+. All data should be fx/name independent, accessible trought data index
+  
+. Give better data organization..
+
+Last Update: 13/10/2003
+=========================================================================
+*/
+
+#ifndef _CRECOMMON_H_
+#define _CRECOMMON_H_
+
+//-------------------------------------------------------------------------------------------------
+// screen processing types parameter
+
+
+enum EProcessType
+{
+  SCREENPROCESS_FADE,
+  SCREENPROCESS_BLUR,
+  SCREENPROCESS_COLORTRANSFER,
+  SCREENPROCESS_CONTRAST,
+  SCREENPROCESS_MOTIONBLUR,
+  SCREENPROCESS_GLARE,
+  SCREENPROCESS_NIGHTVISION,
+  SCREENPROCESS_HEATVISION,  
+  SCREENPROCESS_FLASHBANG,
+  SCREENPROCESS_CARTOON,
+  SCREENPROCESS_DOF,
+  
+  // special case, to get screen texture, after all post-processing
+  SCREENPROCESS_SCREENTEX,
+};
+
+//-------------------------------------------------------------------------------------------------
+// screen processing types parameters
+
+enum EProcessParameter
+{
+  SCREENPROCESS_FADECOLOR,
+
+  SCREENPROCESS_BLURAMOUNT,
+  SCREENPROCESS_BLURCOLORRED,
+  SCREENPROCESS_BLURCOLORGREEN,
+  SCREENPROCESS_BLURCOLORBLUE,
+
+  SCREENPROCESS_COLORTRANSFERCOLOR,
+  SCREENPROCESS_COLORTRANSFERAMOUNT,
+
+  SCREENPROCESS_CONTRASTAMOUNT,
+
+  SCREENPROCESS_MOTIONBLURTYPE,
+  SCREENPROCESS_MOTIONBLURAMOUNT,
+  SCREENPROCESS_MOTIONBLURDISPLACE,
+
+  SCREENPROCESS_GLAREAMOUNT,
+  SCREENPROCESS_GLARELUMSIZE,
+  SCREENPROCESS_GLAREMAXAMOUNT,
+  SCREENPROCESS_GLAREBOXSIZE,
+  SCREENPROCESS_GLARETHRESHOLD,
+
+  SCREENPROCESS_NIGHTVISIONCOLORRED,
+  SCREENPROCESS_NIGHTVISIONCOLORGREEN,
+  SCREENPROCESS_NIGHTVISIONCOLORBLUE,
+
+  SCREENPROCESS_FLASHBANGTIMESCALE,
+  SCREENPROCESS_FLASHBANGFLASHPOSX,
+  SCREENPROCESS_FLASHBANGFLASHPOSY,
+  SCREENPROCESS_FLASHBANGFLASHSIZEX,
+  SCREENPROCESS_FLASHBANGFLASHSIZEY,
+  SCREENPROCESS_FLASHBANGTIMEOUT,
+  SCREENPROCESS_FLASHBANGFORCEAFTERIMAGE,
+
+  SCREENPROCESS_DOFFOCALDISTANCE,  
+  SCREENPROCESS_DOFBLURAMOUNT,
+
+  SCREENPROCESS_TRANSITIONTIME,  
+  SCREENPROCESS_PRETRANSITIONTIME,  
+  SCREENPROCESS_ACTIVE
+};
+
+#define SHADERSCHECK !defined(PS2) && !defined (GC) && !defined (NULL_RENDERER)
+
+//-------------------------------------------------------------------------------------------------
+// screen processing vars class
+
+class CScreenVars 
+{
+public:
+
+  CScreenVars()
+  {
+    // initialize members
+
+    // set shaders to null...
+    m_pRCColorTransfer=0;
+    m_pVPColorTransfer=0;
+    m_pRCMotion=0;
+    m_pRCMotionAmount=0;
+    m_pVPMotion=0;
+    m_pRCBluryScreen=0;
+    m_pVPBluryScreen=0;
+    m_pRCGlareMap=0;
+    m_pRCGlareAmountMap=0;
+    m_pRCGlare=0;
+    m_pRCRenderModeCold=0;
+    m_pRCRenderModeAdv=0;
+    m_pVPGlare=0;
+    m_pRCNightVision=0;
+    m_pVPNightVision=0;
+    m_pRCHeatVision=0;
+    m_pRCHeatSourceDecode=0;
+    m_pRCFlashBang=0;
+    m_pVPFlashBang=0;
+    m_pRCFlashBang=0;
+    m_pVPFlashBang=0;
+    m_pRCBlur=0;
+    m_pVPBlur=0;
+    m_pRCReplRgbToAlpha=0;
+    m_pVPCartoon=0;
+    m_pRCCartoon=0;
+    m_pRCCartoonSilhouette=0;
+    m_pRCDof=0;
+
+    // fade process vars
+    m_bFadeActive=0;
+    m_fFadeTime=0;
+    m_fFadePreTime=0;
+    m_fFadeCurrPreTime=0;
+    m_fFadeCurrTime=0;
+    m_pFadeColor.set(0,0,0,0);
+    m_pFadeCurrColor.set(0,0,0,0);
+
+    // color transfer vars
+    m_bColorTransferActive=0;
+    m_pColorTransferColor.set(0,0,0,0);
+    m_fColorTransferAmount=1;
+
+    // motion blur vars
+    m_bMotionBlurActive=0;
+    m_fMotionBlurAmount=0.9f;
+    m_iMotionBlurType=1;
+    m_iMotionBlurDisplace=0;
+
+    // blury screen vars
+    m_bBlurActive=0;
+    m_fBlurAmount=1.0f;
+    m_pBlurColor.set(1,1,1,1);
+
+    // glare vars
+    m_bGlareActive=0;
+    m_fGlareThreshold=75;
+    m_iGlareBox=2;
+    m_iGlareLumSize=2;
+    m_iGlareSize=128;
+    m_fGlareAmount=1.0f;
+    m_fGlareAmountDynamic=1.0f;
+    m_fGlareMaxAmount=4.0f;
+    m_pCurrGlareMapConst.set(0.2f, 0.2f, 0.2f, 1.0f);
+    m_pCurrSaturation.set(0.0f, 0.0f, 0.0f, 0.2f);
+    m_pCurrContrast.set(0.0f, 0.0f, 0.85f, 0.15f);
+
+    // nightvision vars
+    m_iNightVisionActive=0;
+    m_pNightVisionColor.set(-0.1f, 0.2f, 0.11f, 1.0f);
+	      
+    // heatvision vars
+    m_iHeatVisionActive=0;
+	  m_pCVHeatVision=0;
+        
+    // flashbang vars
+    m_bFlashBangActive=0;  
+    m_iFlashBangForce=0;
+    m_fFlashBangTimeScale=1.0f;
+    m_fFlashBangTimeOut=1.0f;
+    m_fFlashBangFlashPosX=200;
+    m_fFlashBangFlashPosY=100;
+    m_fFlashBangFlashSizeX=400;
+    m_fFlashBangFlashSizeY=400;
+    
+    // cartoon vars
+    m_bCartoonActive=0;
+
+    // depth of field vars
+    m_bDofActive=0;
+    m_fDofFocalDistance=0;
+
+    // screentex vars
+    m_bScreenTexActive=0;
+
+    // console vars
+    m_pCVDisableSfx=0; //GET_CVAR("r_DisableSfx");
+    m_pCVResetSfx=0; //GET_CVAR("r_ResetScreenFx");
+    m_pCVNormalGlare=0; //GET_CVAR("r_Glare"); 
+    m_pCVMotionBlur=0; //GET_CVAR("r_MotionBlur");    
+    m_pCVScreenColorTransfer=0; //GET_CVAR("r_ScreenColorTransfer");  
+    m_pCVMotionBlurAmount=0; //GET_CVAR("r_MotionBlurAmount");
+    m_pCVMotionBlurDisplace=0; //GET_CVAR("r_MotionBlurDisplace");
+    m_pCVRenderMode=0; //GET_CVAR("r_RenderMode");
+
+    // note: these are used for correct cryvision functioning  
+    m_pCVStencilShadows=0; //GET_CVAR("e_stencil_shadows")
+    m_iPrevStencilShadows=0;
+
+    m_pCVShadowMaps=0; //GET_CVAR("e_shadow_maps");
+    m_iPrevShadowMaps=0;
+
+    m_pCVVolFog=0; //GET_CVAR("r_volumetricfog");
+    m_iPrevVolFog=0;
+
+    m_pCVFog=0; //GET_CVAR("e_fog");
+    m_iPrevFog=0;
+  };
+
+  ~CScreenVars()
+  {
+    Release();
+  };
+
+  // shaders used:
+
+  // color transfer shaders
+  void     *m_pRCColorTransfer;
+  void     *m_pVPColorTransfer;
+  
+  // motion blur shaders
+  void     *m_pRCMotion,
+           *m_pRCMotionAmount;
+  void     *m_pVPMotion;
+
+  // blury screen shaders
+  void      *m_pRCBluryScreen;
+  void      *m_pVPBluryScreen;
+
+  // image enhancement shaders
+  void      *m_pRCGlareMap,
+            *m_pRCGlareAmountMap,
+            *m_pRCGlare,
+            *m_pRCRenderModeCold,  
+            *m_pRCRenderModeAdv;
+
+  void      *m_pVPGlare;
+
+  // nightvision shaders
+  void      *m_pRCNightVision;
+  void      *m_pVPNightVision;
+
+  // heatvision shaders
+  void      *m_pRCHeatVision,
+            *m_pRCHeatSourceDecode;
+
+  // flashbang shaders
+  void      *m_pRCFlashBang;
+  void      *m_pVPFlashBang;
+
+  // cartoon shaders
+  void      *m_pRCCartoon,
+            *m_pRCCartoonSilhouette;
+  void      *m_pVPCartoon;
+
+  // depth of field shaders
+  void      *m_pRCDof;
+
+  // shared shaders
+  void      *m_pRCBlur;
+  void      *m_pRCBlurRECT;
+  void      *m_pVPBlur;
+  void      *m_pRCReplRgbToAlpha;
+
+  // fade process vars
+  bool          m_bFadeActive;
+  float         m_fFadeTime,
+                m_fFadeCurrTime,
+                m_fFadePreTime,
+                m_fFadeCurrPreTime;
+
+  color4f				m_pFadeColor,
+                m_pFadeCurrColor;
+
+  // color transfer vars
+  bool          m_bColorTransferActive;
+  color4f				m_pColorTransferColor;
+  float         m_fColorTransferAmount;
+
+  // motion blur vars
+  bool          m_bMotionBlurActive;
+  float         m_fMotionBlurAmount;
+  int           m_iMotionBlurType,
+                m_iMotionBlurDisplace;
+
+  // blury screen vars
+  bool          m_bBlurActive;
+  float         m_fBlurAmount;
+  float         m_iBlurWidth,
+                m_iBlurHeight;
+  color4f				m_pBlurColor;
+
+  // image enhancement vars
+  bool          m_bGlareActive;
+  int           m_iGlareBox,
+                m_iGlareLumSize,
+                m_iGlareSize;
+  float         m_fGlareAmount,
+                m_fGlareThreshold,
+                m_fGlareAmountDynamic,
+                m_fGlareMaxAmount;
+  color4f				m_pCurrGlareMapConst,
+                m_pCurrSaturation,
+                m_pCurrContrast;
+  // nightvision vars
+  int           m_iNightVisionActive;
+  color4f				m_pNightVisionColor;
+
+
+  // heatvision vars
+  int          m_iHeatVisionActive;
+  ICVar		    *m_pCVHeatVision; //GET_CVAR("CV_r_cryvision");
+    
+  // flashbang vars  
+  bool          m_bFlashBangActive;
+  int           m_iFlashBangForce;  
+  float         m_fFlashBangTimeScale,
+                m_fFlashBangTimeOut,
+                m_fFlashBangFlashPosX,
+                m_fFlashBangFlashPosY,
+                m_fFlashBangFlashSizeX,
+                m_fFlashBangFlashSizeY;
+
+  // cartoon rendering vars
+  bool          m_bCartoonActive;
+
+  // depth of field vars
+  bool          m_bDofActive;
+  float         m_fDofFocalDistance;
+
+  // screen texture vars
+  bool          m_bScreenTexActive;  
+  
+  // console vars
+  ICVar *m_pCVDisableSfx; //GET_CVAR("r_DisableSfx");
+  ICVar *m_pCVResetSfx; //GET_CVAR("r_ResetScreenFx");
+  ICVar *m_pCVNormalGlare; //GET_CVAR("r_Glare"); 
+  ICVar *m_pCVMotionBlur; //GET_CVAR("r_MotionBlur");    
+  ICVar *m_pCVScreenColorTransfer; //GET_CVAR("r_ScreenColorTransfer");  
+  ICVar *m_pCVMotionBlurAmount; //GET_CVAR("r_MotionBlurAmount");
+  ICVar *m_pCVMotionBlurDisplace; //GET_CVAR("r_MotionBlurDisplace");
+  ICVar *m_pCVRenderMode; //GET_CVAR("r_RenderMode");
+  
+  // note: these are used for correct cryvision functioning  
+  ICVar *m_pCVStencilShadows; //GET_CVAR("e_stencil_shadows")
+  int   m_iPrevStencilShadows;
+
+  ICVar *m_pCVShadowMaps; //GET_CVAR("e_shadow_maps");
+  int   m_iPrevShadowMaps;
+
+  ICVar *m_pCVVolFog; //GET_CVAR("r_volumetricfog");
+  int   m_iPrevVolFog;
+
+  ICVar *m_pCVFog; //GET_CVAR("e_fog");
+  int   m_iPrevFog;
+
+  ICVar *m_pCVMaxTexLodBias; //GET_CVAR("r_MaxTexLodBias");
+  float  m_fPrevMaxTexLodBias;
+
+  void Create(void);
+  void Release(void);
+  void Reset(void);
+};
+
+#endif

RenderDll/Common/RendElements/CREScreenProcess.cpp

@@ -0,0 +1,670 @@
+/*
+=======================================================================
+FILE : CREScreenProcess.cpp
+DESC : screen processing render element
+PROJ : Crytek Engine
+CODER: Tiago Sousa
+
+TODO: 
+.Convert all screen based effects into this interface
+
+Last Update: 16/06/2003
+=======================================================================
+*/
+
+#include "RenderPCH.h"
+
+// some helper macros
+#define SET_PARAMETER(pProcess, pParam, pType, pValue) \
+  case (pProcess): (pParam)=*((pType*) pValue); break; \
+
+#define RETURN_PARAMETER(pProcess, pParam) \
+  case (pProcess):  return (void*)&pParam;\
+
+// constructor/destructor
+CREScreenProcess::CREScreenProcess()
+{
+  // setup screen process renderer type
+  mfSetType(eDATA_ScreenProcess);
+  mfUpdateFlags(FCEF_TRANSFORM);
+  m_pVars=0;
+
+  // create class vars if necessary...
+  if(!m_pVars)
+  {
+    m_pVars=new CScreenVars;
+    m_pVars->Create();
+  }
+}
+
+CREScreenProcess::~CREScreenProcess()
+{  
+  SAFE_DELETE(m_pVars)
+};
+
+// prepare screen processing
+void CREScreenProcess:: mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+
+  // make sure this is not processed, when rendering to refractive texture..
+  if (gRenDev->m_RP.m_bDrawToTexture)
+  {
+    gRenDev->m_RP.m_pRE = NULL;
+  }
+  else
+  {
+    gRenDev->m_RP.m_pRE = this;
+  }
+
+  gRenDev->m_RP.m_FlagsPerFlush |= RBSI_DRAWAS2D;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_RendNumVerts = 0;
+}
+
+void CREScreenProcess::mfReset()
+{
+  if(m_pVars)
+  {
+    m_pVars->Reset();
+  }
+}
+
+// activate screen processes
+void CREScreenProcess:: mfActivate(int pProcess)
+{
+  switch(pProcess)
+  {
+  case  SCREENPROCESS_FADE:
+    if(m_pVars->m_fFadeTime)
+    {
+      m_pVars->m_bFadeActive=1;
+    }
+    else      
+    {
+      // reset fade
+      m_pVars->m_bFadeActive=0;
+      m_pVars->m_fFadePreTime=0.0f;        
+      m_pVars->m_fFadeCurrPreTime=0.0f;     
+    }
+    break;
+
+  case  SCREENPROCESS_BLUR:
+    m_pVars->m_bBlurActive=1;
+    break;
+  case  SCREENPROCESS_COLORTRANSFER:
+    m_pVars->m_bColorTransferActive=1;
+    break;
+  case  SCREENPROCESS_MOTIONBLUR:
+    m_pVars->m_bMotionBlurActive=1;
+    break;
+  case  SCREENPROCESS_GLARE:
+    m_pVars->m_bGlareActive=1;
+    break;
+  case  SCREENPROCESS_NIGHTVISION:
+//    m_pVars->m_bNightVisionActive=1;
+	  if(m_pVars->m_pCVHeatVision) 
+	  {
+		  m_pVars->m_pCVHeatVision->Set(1);
+	  }
+
+    break;
+  case  SCREENPROCESS_HEATVISION:  
+	  if(m_pVars->m_pCVHeatVision) 
+	  {
+		  m_pVars->m_pCVHeatVision->Set(1);
+	  }
+    break;
+  case  SCREENPROCESS_CARTOON:
+    m_pVars->m_bCartoonActive=1;
+    // reset fade amount    
+    if(iConsole)
+    {
+      if(m_pVars->m_pCVMaxTexLodBias)
+      {
+        if(m_pVars->m_bCartoonActive)
+        {
+          m_pVars->m_fPrevMaxTexLodBias=m_pVars->m_pCVMaxTexLodBias->GetFVal();
+          m_pVars->m_pCVMaxTexLodBias->Set(-1.5f);
+        }
+        else
+        {
+          m_pVars->m_fPrevMaxTexLodBias=m_pVars->m_pCVMaxTexLodBias->GetFVal();
+          m_pVars->m_pCVMaxTexLodBias->Set(0.0f);
+        }            
+      } 
+    }
+    break;
+  case  SCREENPROCESS_FLASHBANG:
+    m_pVars->m_bFlashBangActive=1;
+    // reset flash time out
+    m_pVars->m_fFlashBangTimeOut=1.0f;
+    break;
+  case  SCREENPROCESS_DOF:
+    m_pVars->m_bDofActive=1;
+    // reset dof focal distance plane
+    m_pVars->m_fDofFocalDistance=20.0f;
+    break;
+  default:
+    break;
+  };
+}
+
+// set screen processing parameters
+int CREScreenProcess:: mfSetParameter(int iProcess, int iParams, void *dwValue)
+{ 
+  switch(iProcess) 
+  {
+    // set screen fade parameters
+  case SCREENPROCESS_FADE:
+    switch(iParams)
+    {
+      SET_PARAMETER(SCREENPROCESS_FADECOLOR, m_pVars->m_pFadeColor, color4f, dwValue)
+      
+    case SCREENPROCESS_ACTIVE:
+      if(*((bool*) dwValue)==1)
+      {
+        m_pVars->m_bFadeActive=1;
+      }
+      else      
+      {
+        // reset fade
+        m_pVars->m_bFadeActive=0;
+        m_pVars->m_fFadePreTime=0.0f;        
+        m_pVars->m_fFadeCurrPreTime=0.0f;     
+      }
+      break; 
+
+    case SCREENPROCESS_TRANSITIONTIME:
+      m_pVars->m_fFadeTime=*((float*) dwValue);
+      m_pVars->m_fFadeCurrTime=(float) fabs(*((float*) dwValue));
+      break;
+      
+      SET_PARAMETER(SCREENPROCESS_PRETRANSITIONTIME, m_pVars->m_fFadePreTime, float, dwValue)
+    }
+    break;
+
+    // set screen blur parameters
+  case SCREENPROCESS_BLUR:
+    switch(iParams) 
+    {
+      SET_PARAMETER(SCREENPROCESS_BLURAMOUNT, m_pVars->m_fBlurAmount, float, dwValue)
+      SET_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bBlurActive, bool, dwValue)
+
+      case SCREENPROCESS_BLURCOLORRED:
+        m_pVars->m_pBlurColor.r=*(float*)dwValue;
+          break;
+      case SCREENPROCESS_BLURCOLORGREEN:
+        m_pVars->m_pBlurColor.g=*(float*)dwValue;
+        break;
+      case SCREENPROCESS_BLURCOLORBLUE:
+        m_pVars->m_pBlurColor.b=*(float*)dwValue;
+        break;
+    }
+    break;
+
+    // set color transfer parameters
+  case SCREENPROCESS_COLORTRANSFER:
+    switch(iParams) 
+    {
+      SET_PARAMETER(SCREENPROCESS_COLORTRANSFERAMOUNT, m_pVars->m_fColorTransferAmount, float, dwValue)
+      SET_PARAMETER(SCREENPROCESS_COLORTRANSFERCOLOR, m_pVars->m_pColorTransferColor, color4f, dwValue)
+      SET_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bColorTransferActive, bool, dwValue)
+    }
+    break;
+
+    // set motion blur parameters
+  case SCREENPROCESS_MOTIONBLUR:
+    switch(iParams)
+    {
+      SET_PARAMETER(SCREENPROCESS_MOTIONBLURDISPLACE, m_pVars->m_iMotionBlurDisplace, int, dwValue)
+      SET_PARAMETER(SCREENPROCESS_MOTIONBLURAMOUNT, m_pVars->m_fMotionBlurAmount, float, dwValue)
+      SET_PARAMETER(SCREENPROCESS_MOTIONBLURTYPE, m_pVars->m_iMotionBlurType, int, dwValue)
+      SET_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bMotionBlurActive, bool, dwValue)
+    }
+    break;
+
+    // set glare parameters
+  case SCREENPROCESS_GLARE:
+    switch(iParams)
+    {
+      SET_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bGlareActive, bool, dwValue)
+      SET_PARAMETER(SCREENPROCESS_GLAREAMOUNT, m_pVars->m_fGlareAmount, float, dwValue)
+      SET_PARAMETER(SCREENPROCESS_GLARELUMSIZE, m_pVars->m_iGlareLumSize, int, dwValue)
+      SET_PARAMETER(SCREENPROCESS_GLAREMAXAMOUNT, m_pVars->m_fGlareMaxAmount, float, dwValue)
+      SET_PARAMETER(SCREENPROCESS_GLAREBOXSIZE, m_pVars->m_iGlareSize, int, dwValue)
+      SET_PARAMETER(SCREENPROCESS_GLARETHRESHOLD, m_pVars->m_fGlareThreshold, float, dwValue)
+    }
+    break;
+
+    // set nightvision parameters
+  case SCREENPROCESS_NIGHTVISION:
+    switch(iParams)
+    {
+      //SET_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bNightVisionActive, bool, dwValue)
+      case SCREENPROCESS_ACTIVE:
+      //  m_pVars->m_bNightVisionActive=*(bool*)dwValue;
+	  
+		      if(m_pVars->m_pCVHeatVision) 
+		      {
+			      m_pVars->m_pCVHeatVision->Set(*((int*) dwValue));
+    			  	
+						/*
+				    // must disable some rendering in order to cryvision function properly
+				    if(m_pVars->m_pCVHeatVision->GetIVal()) 
+				    {
+					    m_pVars->m_iPrevStencilShadows=m_pVars->m_pCVStencilShadows->GetIVal();
+					    m_pVars->m_iPrevShadowMaps=m_pVars->m_pCVShadowMaps->GetIVal();
+					    m_pVars->m_iPrevVolFog=m_pVars->m_pCVVolFog->GetIVal();
+					    //m_pVars->m_iPrevFog=m_pVars->m_pCVFog->GetIVal();
+
+					    m_pVars->m_pCVStencilShadows->Set(0);         
+					    m_pVars->m_pCVShadowMaps->Set(0);         
+					    m_pVars->m_pCVVolFog->Set(0);
+					    //m_pVars->m_pCVFog->Set(0); 
+				    }
+				    else
+				    {
+					    m_pVars->m_pCVStencilShadows->Set(m_pVars->m_iPrevStencilShadows);         
+					    m_pVars->m_pCVShadowMaps->Set(m_pVars->m_iPrevShadowMaps);         
+					    m_pVars->m_pCVVolFog->Set(m_pVars->m_iPrevVolFog);                  
+					    //m_pVars->m_pCVFog->Set(m_pVars->m_iPrevFog);
+				    }*/
+		      }
+          break;
+
+      case SCREENPROCESS_NIGHTVISIONCOLORRED:
+        m_pVars->m_pNightVisionColor.r=*(float*)dwValue;
+        break;
+      case SCREENPROCESS_NIGHTVISIONCOLORGREEN:
+        m_pVars->m_pNightVisionColor.g=*(float*)dwValue;
+        break;
+      case SCREENPROCESS_NIGHTVISIONCOLORBLUE:
+        m_pVars->m_pNightVisionColor.b=*(float*)dwValue;
+        break;
+    }
+    break;
+
+    // set heatvision parameters
+  case SCREENPROCESS_HEATVISION:
+    switch(iParams)
+    {
+		case SCREENPROCESS_ACTIVE:
+			if(m_pVars->m_pCVHeatVision) 
+			{
+				m_pVars->m_pCVHeatVision->Set(*((int*) dwValue));
+			}
+			break;
+		
+      //SET_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bHeatVisionActive, bool, dwValue)
+    } 
+    break;
+
+    // set flashbang parameters
+  case SCREENPROCESS_FLASHBANG:
+    switch(iParams)
+    {
+      case SCREENPROCESS_ACTIVE:
+        m_pVars->m_bFlashBangActive= *((bool*) dwValue);
+        // reset flash time out
+        m_pVars->m_fFlashBangTimeOut=1.0f;
+        break;
+             
+      SET_PARAMETER(SCREENPROCESS_FLASHBANGTIMESCALE, m_pVars->m_fFlashBangTimeScale, float, dwValue)
+      SET_PARAMETER(SCREENPROCESS_FLASHBANGFLASHPOSX, m_pVars->m_fFlashBangFlashPosX, float, dwValue)
+      SET_PARAMETER(SCREENPROCESS_FLASHBANGFLASHPOSY, m_pVars->m_fFlashBangFlashPosY, float, dwValue)
+      SET_PARAMETER(SCREENPROCESS_FLASHBANGFLASHSIZEX, m_pVars->m_fFlashBangFlashSizeX, float, dwValue)
+      SET_PARAMETER(SCREENPROCESS_FLASHBANGFLASHSIZEY, m_pVars->m_fFlashBangFlashSizeY, float, dwValue)
+      SET_PARAMETER(SCREENPROCESS_FLASHBANGFORCEAFTERIMAGE, m_pVars->m_iFlashBangForce, int, dwValue)      
+    }
+    break;
+
+    // set cartoon parameters
+  case SCREENPROCESS_CARTOON:
+    switch(iParams)
+    {
+      //SET_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bCartoonActive, bool, dwValue)
+      case SCREENPROCESS_ACTIVE:      
+        m_pVars->m_bCartoonActive= *((bool*) dwValue);
+        break;
+    }
+    break;
+
+    // set dof parameters
+  case  SCREENPROCESS_DOF:
+    switch(iParams)
+    {
+      SET_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bDofActive, bool, dwValue)
+        SET_PARAMETER(SCREENPROCESS_DOFFOCALDISTANCE, m_pVars->m_fDofFocalDistance, float, dwValue)
+    }
+    break;
+
+    // set screentex parameters
+  case SCREENPROCESS_SCREENTEX:
+    switch(iParams)
+    {
+      SET_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bScreenTexActive, bool, dwValue)
+    }
+    break;
+
+    //default:
+    //  break;
+  }
+
+  return 0;
+}
+
+// get screen processing parameters
+void *CREScreenProcess:: mfGetParameter(int iProcess, int iParams)
+{
+  switch(iProcess)
+  {
+    // return screen fade parameters
+  case SCREENPROCESS_FADE:
+    switch(iParams)
+    {
+      RETURN_PARAMETER(SCREENPROCESS_TRANSITIONTIME, m_pVars->m_fFadeTime)
+      RETURN_PARAMETER(SCREENPROCESS_PRETRANSITIONTIME, m_pVars->m_fFadePreTime)
+      RETURN_PARAMETER(SCREENPROCESS_FADECOLOR, m_pVars->m_pFadeColor)
+      RETURN_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bFadeActive)
+    }
+    break;
+
+    // return screen blur parameters
+  case SCREENPROCESS_BLUR:
+    switch(iParams) 
+    {
+      RETURN_PARAMETER(SCREENPROCESS_BLURAMOUNT, m_pVars->m_fBlurAmount)
+      RETURN_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bBlurActive)
+      RETURN_PARAMETER(SCREENPROCESS_BLURCOLORRED, m_pVars->m_pBlurColor.r)
+      RETURN_PARAMETER(SCREENPROCESS_BLURCOLORGREEN, m_pVars->m_pBlurColor.g)
+      RETURN_PARAMETER(SCREENPROCESS_BLURCOLORBLUE, m_pVars->m_pBlurColor.b)
+    }
+    break;
+
+    // return color transfer parameters
+  case SCREENPROCESS_COLORTRANSFER:
+    switch(iParams)
+    {
+      RETURN_PARAMETER(SCREENPROCESS_COLORTRANSFERAMOUNT, m_pVars->m_fColorTransferAmount)
+      RETURN_PARAMETER(SCREENPROCESS_COLORTRANSFERCOLOR, m_pVars->m_pColorTransferColor)
+      RETURN_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bColorTransferActive)
+    }
+    break;
+
+    // return motion blur parameters
+  case SCREENPROCESS_MOTIONBLUR:
+    switch(iParams)
+    {
+      RETURN_PARAMETER(SCREENPROCESS_MOTIONBLURDISPLACE, m_pVars->m_iMotionBlurDisplace)
+      RETURN_PARAMETER(SCREENPROCESS_MOTIONBLURAMOUNT, m_pVars->m_fMotionBlurAmount)
+      RETURN_PARAMETER(SCREENPROCESS_MOTIONBLURTYPE, m_pVars->m_iMotionBlurType)
+      RETURN_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bMotionBlurActive)
+    }
+    break;
+
+    // return glare parameters
+  case SCREENPROCESS_GLARE:
+    switch(iParams)
+    {
+      RETURN_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bGlareActive)
+      RETURN_PARAMETER(SCREENPROCESS_GLAREAMOUNT, m_pVars->m_fGlareAmount)
+      RETURN_PARAMETER(SCREENPROCESS_GLARELUMSIZE, m_pVars->m_iGlareLumSize)
+      RETURN_PARAMETER(SCREENPROCESS_GLAREMAXAMOUNT, m_pVars->m_fGlareMaxAmount)
+      RETURN_PARAMETER(SCREENPROCESS_GLAREBOXSIZE, m_pVars->m_iGlareSize)
+      RETURN_PARAMETER(SCREENPROCESS_GLARETHRESHOLD, m_pVars->m_fGlareThreshold)
+    }
+    break;
+
+    // return nightvision parameters
+  case SCREENPROCESS_NIGHTVISION:
+    switch(iParams)
+    {
+		case SCREENPROCESS_ACTIVE:
+		  //RETURN_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bNightVisionActive)
+			  if(m_pVars->m_pCVHeatVision) 
+			  {
+				  m_pVars->m_iNightVisionActive=m_pVars->m_pCVHeatVision->GetIVal();
+			  }
+			  return (void*)&m_pVars->m_iNightVisionActive;		
+  		break;
+
+      RETURN_PARAMETER(SCREENPROCESS_NIGHTVISIONCOLORRED, m_pVars->m_pNightVisionColor.r)
+      RETURN_PARAMETER(SCREENPROCESS_NIGHTVISIONCOLORGREEN, m_pVars->m_pNightVisionColor.g)
+      RETURN_PARAMETER(SCREENPROCESS_NIGHTVISIONCOLORBLUE, m_pVars->m_pNightVisionColor.b)
+    }
+    break;
+
+    // return heatvision parameters
+  case SCREENPROCESS_HEATVISION:
+    switch(iParams)
+    {
+		case SCREENPROCESS_ACTIVE:
+			  if(m_pVars->m_pCVHeatVision) 
+			  {
+				  m_pVars->m_iHeatVisionActive=m_pVars->m_pCVHeatVision->GetIVal();
+			  }
+			  return (void*)&m_pVars->m_iHeatVisionActive;		
+		  break;
+		//RETURN_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bHeatVisionActive)		
+    }
+    break;
+
+    // return flashbang parameters
+  case SCREENPROCESS_FLASHBANG:
+    switch(iParams)
+    {
+      RETURN_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bFlashBangActive)
+      RETURN_PARAMETER(SCREENPROCESS_FLASHBANGTIMESCALE, m_pVars->m_fFlashBangTimeScale)
+      RETURN_PARAMETER(SCREENPROCESS_FLASHBANGTIMEOUT, m_pVars->m_fFlashBangTimeOut)
+      RETURN_PARAMETER(SCREENPROCESS_FLASHBANGFLASHPOSX, m_pVars->m_fFlashBangFlashPosX)
+      RETURN_PARAMETER(SCREENPROCESS_FLASHBANGFLASHPOSY, m_pVars->m_fFlashBangFlashPosY)
+      RETURN_PARAMETER(SCREENPROCESS_FLASHBANGFLASHSIZEX, m_pVars->m_fFlashBangFlashSizeX)
+      RETURN_PARAMETER(SCREENPROCESS_FLASHBANGFLASHSIZEY, m_pVars->m_fFlashBangFlashSizeY)
+      RETURN_PARAMETER(SCREENPROCESS_FLASHBANGFORCEAFTERIMAGE, m_pVars->m_iFlashBangForce)      
+    }
+    break;
+
+    // return cartoon parameters
+  case SCREENPROCESS_CARTOON:
+    switch(iParams)
+    {
+      RETURN_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bCartoonActive)
+    }
+    break;
+
+    // return dof parameters
+  case  SCREENPROCESS_DOF:
+    switch(iParams)
+    {
+      RETURN_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bDofActive)
+        RETURN_PARAMETER(SCREENPROCESS_DOFFOCALDISTANCE, m_pVars->m_fDofFocalDistance)
+    }
+    break;
+
+    // return screentex parameters
+  case SCREENPROCESS_SCREENTEX:
+    switch(iParams)
+    {
+    RETURN_PARAMETER(SCREENPROCESS_ACTIVE, m_pVars->m_bScreenTexActive)
+    }
+    break;
+
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+// get shaders
+void CScreenVars:: Create(void) 
+{
+#if SHADERSCHECK
+  m_pRCBlur = CPShader::mfForName("CGRCBlur");
+#ifdef OPENGL
+  m_pRCBlurRECT = CPShader::mfForName("CGRCBlurRECT");
+#else
+  m_pRCBlurRECT = NULL;
+#endif
+  m_pVPBlur = CVProgram::mfForName("CGVProgBlur");
+  m_pRCMotion = CPShader::mfForName("CGRCMotion");
+  m_pRCMotionAmount = CPShader::mfForName("CGRCMotionAmount");
+  m_pVPMotion = CVProgram::mfForName("CGVProgMotion");
+  m_pRCGlareMap = CPShader::mfForName("CGRCGlareMap"); 
+  m_pRCGlareAmountMap = CPShader::mfForName("CGRCGlareAmount"); 
+  m_pRCGlare  = CPShader::mfForName("CGRCGlare"); 
+  m_pRCRenderModeCold = CPShader::mfForName("CGRCRenderModeCold"); 
+  m_pRCRenderModeAdv= CPShader::mfForName("CGRCRenderModeAdv"); 
+  m_pVPGlare  = CVProgram::mfForName("CGVProgGlare");
+  m_pRCColorTransfer = CPShader::mfForName("CGRCColorTransfer"); 
+  m_pVPColorTransfer = CVProgram::mfForName("CGVProgColorTransfer");
+  m_pRCBluryScreen = CPShader::mfForName("CGRCBluryScreen"); 
+  m_pVPBluryScreen = CVProgram::mfForName("CGVProgBluryScreen");
+  m_pRCNightVision = CPShader::mfForName("CGRCNightVisionGlare"); 
+  m_pVPNightVision = CVProgram::mfForName("CGVProgNightVisionGlare");
+  m_pRCHeatVision = CPShader::mfForName("CGRCHeatSourcePass");
+  m_pRCHeatSourceDecode = CPShader::mfForName("CGRCHeatSourceDecode");
+  m_pVPFlashBang = CVProgram::mfForName("CGVProg_FlashBang");
+  m_pRCFlashBang = CPShader::mfForName("CGRCFlashBang");
+  m_pVPCartoon = CVProgram::mfForName("CGVProgCartoon");
+  m_pRCCartoon = CPShader::mfForName("CGRCCartoon");
+  m_pRCCartoonSilhouette = CPShader::mfForName("CGRCCartoonSilhouete");
+  m_pRCDof = CPShader::mfForName("CGRCDof");
+  m_pRCReplRgbToAlpha = CPShader::mfForName("CGRCReplRgbToAlpha");
+#endif    
+
+  if(iConsole)
+  {
+    m_pCVDisableSfx= iConsole->GetCVar("r_DisableSfx"); 
+    m_pCVResetSfx=iConsole->GetCVar("r_ResetScreenFx");
+    m_pCVNormalGlare=iConsole->GetCVar("r_Glare"); 
+    m_pCVMotionBlur=iConsole->GetCVar("r_MotionBlur");    
+    m_pCVScreenColorTransfer=iConsole->GetCVar("r_ScreenColorTransfer");  
+    m_pCVMotionBlurAmount=iConsole->GetCVar("r_MotionBlurAmount");
+    m_pCVMotionBlurDisplace=iConsole->GetCVar("r_MotionBlurDisplace");
+    m_pCVRenderMode=iConsole->GetCVar("r_RenderMode");
+
+    // note: these are used for correct cryvision functioning  
+    m_pCVStencilShadows=iConsole->GetCVar("e_stencil_shadows");
+    m_iPrevStencilShadows=m_pCVStencilShadows->GetIVal();
+
+    m_pCVShadowMaps=iConsole->GetCVar("e_shadow_maps");
+    m_iPrevShadowMaps=m_pCVShadowMaps->GetIVal();
+
+    m_pCVVolFog=iConsole->GetCVar("r_VolumetricFog");
+    m_iPrevVolFog= m_pCVVolFog->GetIVal();
+
+    m_pCVFog=iConsole->GetCVar("e_fog");
+    m_iPrevFog=m_pCVFog->GetIVal();
+
+    m_pCVMaxTexLodBias=iConsole->GetCVar("r_MaxTexLodBias");
+    m_fPrevMaxTexLodBias=m_pCVMaxTexLodBias->GetFVal();
+
+	  m_pCVHeatVision=iConsole->GetCVar("r_Cryvision");
+	  m_iHeatVisionActive=m_pCVHeatVision->GetIVal();
+
+    // reset fade amount    
+    ICVar *pHudFadeAmount=iConsole->GetCVar("hud_fadeamount");
+    if(pHudFadeAmount)
+    {
+      pHudFadeAmount->Set(1);
+    } 
+  }
+
+  // fade process vars
+  m_bFadeActive=0;
+  m_fFadeTime=0;
+  m_fFadePreTime=0;
+  m_fFadeCurrPreTime=0;
+  m_fFadeCurrTime=0;
+  m_pFadeColor.set(0,0,0,0);
+  m_pFadeCurrColor.set(0,0,0,0);
+}
+
+// release/free data..
+void CScreenVars:: Release(void) 
+{
+/*  // check if cryvision is active when exiting game, need to restore console vars..
+  if(m_pCVHeatVision)
+  {
+    if(m_pCVHeatVision->GetIVal()) 
+    {
+      if(m_pCVStencilShadows)
+      {
+        m_pCVStencilShadows->Set(m_iPrevStencilShadows);         
+      }
+
+      if(m_pCVShadowMaps->GetIVal())
+      {
+        m_pCVShadowMaps->Set(m_iPrevShadowMaps);         
+      }
+
+      if(m_pCVVolFog->GetIVal())
+      {
+        m_pCVVolFog->Set(m_iPrevVolFog);                  
+      }        
+    }
+  }
+*/
+}
+
+// reset effects state
+void CScreenVars:: Reset(void)
+{
+  // color transfer vars
+  m_bColorTransferActive=0;
+  m_pColorTransferColor.set(0,0,0,0);
+  m_fColorTransferAmount=1;
+
+  // blury screen vars
+  m_bBlurActive=0;
+  m_fBlurAmount=1.0f;
+  m_pBlurColor.set(1,1,1,1);
+
+  // nightvision vars  
+  m_iNightVisionActive=0;
+  m_pNightVisionColor.set(-0.1f, 0.2f, 0.11f, 1.0f);
+
+  // heatvision vars
+  if(m_pCVHeatVision)
+  {	
+    //	m_pHeatVision->Set(0);
+	  m_iHeatVisionActive=m_pCVHeatVision->GetIVal();
+  }
+  else
+  {
+	  m_iHeatVisionActive=0;
+  }
+  
+  // flashbang vars
+  m_bFlashBangActive=0;  
+  m_fFlashBangTimeScale=1.0f;
+  m_fFlashBangTimeOut=1.0f;
+  m_fFlashBangFlashPosX=200;
+  m_fFlashBangFlashPosY=100;
+  m_fFlashBangFlashSizeX=400;
+  m_fFlashBangFlashSizeY=400;
+
+  // screentex vars
+  m_bScreenTexActive=0;  
+  m_pCurrGlareMapConst.set(0.2f, 0.2f, 0.2f, 1.0f);
+  m_pCurrSaturation.set(0.0f, 0.0f, 0.0f, 0.2f);
+  m_pCurrContrast.set(0.0f, 0.0f, 0.85f, 0.15f);
+
+
+  // reset fade amount    
+  ICVar *pHudFadeAmount=iConsole->GetCVar("hud_fadeamount");
+  if(pHudFadeAmount)
+  {
+    pHudFadeAmount->Set(1);
+  } 
+
+  m_bFadeActive=0;
+  m_fFadeTime=0;
+  m_fFadePreTime=0;
+  m_fFadeCurrPreTime=0;
+  m_fFadeCurrTime=0;
+  m_pFadeColor.set(0,0,0,0);
+  m_pFadeCurrColor.set(0,0,0,0);
+}

RenderDll/Common/RendElements/CREScreenProcess.h

@@ -0,0 +1,54 @@
+/*
+=====================================================================
+FILE : CREScreenProcess.h
+DESC : Screen processing render element
+PROJ : Crytek Engine
+CODER: Tiago Sousa
+
+Last Update: 13/06/2003
+=====================================================================
+*/
+
+#ifndef __CRESCREENPROCESS_H__
+#define __CRESCREENPROCESS_H__
+
+// screen processing vars class
+class CScreenVars;
+
+// screen processing render element
+class CREScreenProcess : public CRendElement
+{
+  friend class CD3D9Renderer;
+  friend class CGLRenderer;
+
+public:
+
+  // constructor/destructor
+  CREScreenProcess();
+
+  virtual ~CREScreenProcess();
+
+  // prepare screen processing
+  virtual void mfPrepare();
+  // render screen processing
+  virtual bool mfDraw(SShader *ef, SShaderPass *sfm);
+
+  // begin screen processing
+  virtual void mfActivate(int iProcess);
+  // reset 
+  virtual void mfReset(void);
+
+  // set/get methods
+  virtual int   mfSetParameter(int iProcess, int iParams, void *dwValue);
+  virtual void *mfGetParameter(int iProcess, int iParams);
+  
+  CScreenVars  *GetVars() { return m_pVars; }
+
+private:
+  virtual bool mfDrawLowSpec(SShader *ef, SShaderPass *sfm);
+
+  // screen processing vars class
+  CScreenVars *m_pVars;
+};
+
+#endif

RenderDll/Common/RendElements/CREShadowMap.cpp

@@ -0,0 +1,22 @@
+#include "RenderPCH.h"
+#include "RendElement.h"
+/*
+void CREShadowMap::mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+
+  gRenDev->m_RP.m_DynLMask |= m_DynMask;
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_RendNumVerts = 0;
+}
+
+CREShadowMap::~CREShadowMap()
+{
+  if(m_CustomData)
+  {
+    delete m_CustomData;
+    m_CustomData=0;
+  }
+}
+*/

RenderDll/Common/RendElements/CRESky.cpp

@@ -0,0 +1,326 @@
+#include "RenderPCH.h"
+#include "RendElement.h"
+#include "CRESky.h"
+#include "i3dengine.h"
+
+void CRESky::mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_RendNumVerts = 0;
+}
+
+bool CRESky::mfDraw(SShader *ef, SShaderPass *sfm)
+{   
+ 	int bPrevClipPl = gRenDev->m_RP.m_ClipPlaneEnabled;
+	if (bPrevClipPl)
+		gRenDev->EF_SetClipPlane(false, NULL, false);
+
+	if(sfm >= &ef->m_Passes[1] && ef->m_Sky)
+	{ // draw sky sphere vertices at pass 1
+		bool bPrevFog = gRenDev->EnableFog(false);
+		DrawSkySphere(ef->m_Sky->m_fSkyLayerHeight);
+		gRenDev->EnableFog(bPrevFog);
+		if (bPrevClipPl)
+			gRenDev->EF_SetClipPlane(true, &gRenDev->m_RP.m_CurClipPlane.m_Normal.x, gRenDev->m_RP.m_bClipPlaneRefract);
+		return true;
+	}
+
+	// pass 0 - skybox
+
+	if (!ef->m_Sky || !ef->m_Sky->m_SkyBox[0])
+	{
+		if (bPrevClipPl)
+			gRenDev->EF_SetClipPlane(true, &gRenDev->m_RP.m_CurClipPlane.m_Normal.x, gRenDev->m_RP.m_bClipPlaneRefract);
+		return false;
+	}
+
+	bool bPrevFog = gRenDev->EnableFog(false);
+
+	gRenDev->SetColorOp(eCO_MODULATE, eCO_MODULATE, eCA_Texture | (eCA_Constant<<3), eCA_Texture | (eCA_Constant<<3));
+
+	if (gRenDev->m_bHeatVision)
+		gRenDev->SetMaterialColor(0.3f,0.3f,0.3f,1.0f);
+	else
+		gRenDev->SetMaterialColor(1,1,1,m_fAlpha);
+	if(m_fAlpha<1.f)
+		gRenDev->EF_SetState(GS_NODEPTHTEST | GS_BLSRC_SRCALPHA | GS_BLDST_ONEMINUSSRCALPHA);
+	else
+		gRenDev->EF_SetState(GS_NODEPTHTEST);
+  gRenDev->SetCullMode(R_CULL_BACK);
+
+#if !defined(PS2) && !defined (GC) && !defined (NULL_RENDERER)
+  CPShader *fpSky = NULL;
+  if (gRenDev->m_RP.m_PersFlags & RBPF_HDR)
+  {
+    if (!(ef->m_Flags & EF_SKY_HDR))
+      fpSky = PShaderForName(gRenDev->m_RP.m_PS_HDR_SkyFake, "CGRC_HDR_SkyFake_PS20");
+    else
+      fpSky = PShaderForName(gRenDev->m_RP.m_PS_HDR_Sky, "CGRC_HDR_Sky_PS20");
+    if (fpSky)
+      fpSky->mfSet(true, 0);
+  }
+#endif
+
+	const float fSkyBoxSize = SKY_BOX_SIZE;
+
+	{ // top
+		struct_VERTEX_FORMAT_P3F_TEX2F data[] = 
+		{
+			{Vec3(fSkyBoxSize,-fSkyBoxSize, fSkyBoxSize), 1, 1.f-1},
+			{Vec3(-fSkyBoxSize,-fSkyBoxSize, fSkyBoxSize), 0, 1.f-1},
+			{Vec3(fSkyBoxSize, fSkyBoxSize, fSkyBoxSize), 1, 1.f-0},
+			{Vec3(-fSkyBoxSize, fSkyBoxSize, fSkyBoxSize), 0, 1.f-0}
+		};
+
+		gRenDev->SetTexture(ef->m_Sky->m_SkyBox[2]->m_Bind);
+		gRenDev->SetTexClampMode(true);
+		gRenDev->DrawTriStrip(&(CVertexBuffer (data,VERTEX_FORMAT_P3F_TEX2F)),4);
+	}
+
+	Vec3d camera = gRenDev->GetCamera().GetPos();
+	camera.z = max(0,camera.z);
+
+	float fWaterCamDiff = max(0,camera.z-m_fTerrainWaterLevel);
+
+	float fMaxDist = iSystem->GetI3DEngine()->GetMaxViewDist()/1024.f;
+	float P = (fWaterCamDiff)/128 + max(0,(fWaterCamDiff)*0.03f/fMaxDist);
+	float D = (fWaterCamDiff)/10.0f*fSkyBoxSize/124.0f - P + 8;
+
+	P*=m_fSkyBoxStretching;
+
+	if(m_fTerrainWaterLevel>camera.z && SRendItem::m_RecurseLevel==1)
+	{
+		P = (fWaterCamDiff);
+		D = (fWaterCamDiff);
+	}
+
+	{ // s
+		struct_VERTEX_FORMAT_P3F_TEX2F data[] = 
+		{ 
+			Vec3(-fSkyBoxSize,-fSkyBoxSize, fSkyBoxSize), 1.0, 1.f-1.0,
+			Vec3(fSkyBoxSize,-fSkyBoxSize, fSkyBoxSize), 0.0, 1.f-1.0,
+			Vec3(-fSkyBoxSize,-fSkyBoxSize,-P),           1.0, 1.f-0.5,
+			Vec3(fSkyBoxSize,-fSkyBoxSize,-P),           0.0, 1.f-0.5,
+			Vec3(-fSkyBoxSize,-fSkyBoxSize,-D),           1.0, 1.f-0.5,
+			Vec3(fSkyBoxSize,-fSkyBoxSize,-D),           0.0, 1.f-0.5
+		};
+
+		gRenDev->SetTexture(ef->m_Sky->m_SkyBox[1]->m_Bind);
+		gRenDev->SetTexClampMode(true);
+		gRenDev->DrawTriStrip(&(CVertexBuffer (data,VERTEX_FORMAT_P3F_TEX2F)),6);
+	}
+	{ // e
+		struct_VERTEX_FORMAT_P3F_TEX2F data[] = 
+		{ 
+			Vec3(-fSkyBoxSize, fSkyBoxSize, fSkyBoxSize), 1.0, 1.f-0.0,
+			Vec3(-fSkyBoxSize,-fSkyBoxSize, fSkyBoxSize), 0.0, 1.f-0.0,
+			Vec3(-fSkyBoxSize, fSkyBoxSize,-P),           1.0, 1.f-0.5,
+			Vec3(-fSkyBoxSize,-fSkyBoxSize,-P),           0.0, 1.f-0.5,
+			Vec3(-fSkyBoxSize, fSkyBoxSize,-D),           1.0, 1.f-0.5,
+			Vec3(-fSkyBoxSize,-fSkyBoxSize,-D),           0.0, 1.f-0.5
+		};
+
+		gRenDev->SetTexture(ef->m_Sky->m_SkyBox[1]->m_Bind);
+		gRenDev->SetTexClampMode(true);
+		gRenDev->DrawTriStrip(&(CVertexBuffer (data,VERTEX_FORMAT_P3F_TEX2F)),6);
+	}
+	{ // n
+		struct_VERTEX_FORMAT_P3F_TEX2F data[] = 
+		{ 
+			Vec3(fSkyBoxSize, fSkyBoxSize, fSkyBoxSize), 1.0, 1.f-1.0,
+			Vec3(-fSkyBoxSize, fSkyBoxSize, fSkyBoxSize), 0.0, 1.f-1.0,
+			Vec3(fSkyBoxSize, fSkyBoxSize,-P),           1.0, 1.f-0.5,
+			Vec3(-fSkyBoxSize, fSkyBoxSize,-P),           0.0, 1.f-0.5,
+			Vec3(fSkyBoxSize, fSkyBoxSize,-D),           1.0, 1.f-0.5,
+			Vec3(-fSkyBoxSize, fSkyBoxSize,-D),           0.0, 1.f-0.5
+		};
+
+		gRenDev->SetTexture(ef->m_Sky->m_SkyBox[0]->m_Bind);
+		gRenDev->SetTexClampMode(true);
+		gRenDev->DrawTriStrip(&(CVertexBuffer (data,VERTEX_FORMAT_P3F_TEX2F)),6);
+	}
+	{ // w
+		struct_VERTEX_FORMAT_P3F_TEX2F data[] = 
+		{ 
+			Vec3(fSkyBoxSize,-fSkyBoxSize, fSkyBoxSize), 1.0, 1.f-0.0,
+			Vec3(fSkyBoxSize, fSkyBoxSize, fSkyBoxSize), 0.0, 1.f-0.0,
+			Vec3(fSkyBoxSize,-fSkyBoxSize,-P),           1.0, 1.f-0.5,
+			Vec3(fSkyBoxSize, fSkyBoxSize,-P),           0.0, 1.f-0.5,
+			Vec3(fSkyBoxSize,-fSkyBoxSize,-D),           1.0, 1.f-0.5,
+			Vec3(fSkyBoxSize, fSkyBoxSize,-D),           0.0, 1.f-0.5
+		};
+
+		gRenDev->SetTexture(ef->m_Sky->m_SkyBox[0]->m_Bind);
+		gRenDev->SetTexClampMode(true);
+		gRenDev->DrawTriStrip(&(CVertexBuffer (data,VERTEX_FORMAT_P3F_TEX2F)),6);
+	}
+#if !defined(PS2) && !defined (GC) && !defined (NULL_RENDERER)
+  if (fpSky)
+    fpSky->mfSet(false, 0);
+#endif
+
+	DrawFogLayer();
+
+	DrawBlackPortal();
+
+	gRenDev->EnableFog(bPrevFog);
+
+	if (bPrevClipPl)
+		gRenDev->EF_SetClipPlane(true, &gRenDev->m_RP.m_CurClipPlane.m_Normal.x, gRenDev->m_RP.m_bClipPlaneRefract);
+
+	return true;
+}
+
+
+bool CRESky::DrawFogLayer()
+{   
+	if(!m_parrFogLayer)
+		m_parrFogLayer = new list2<struct_VERTEX_FORMAT_P3F_COL4UB>;
+	if(!m_parrFogLayer2)
+		m_parrFogLayer2 = new list2<struct_VERTEX_FORMAT_P3F_COL4UB>;
+
+	m_parrFogLayer->Clear();
+	m_parrFogLayer2->Clear();
+
+	const float fFogLayerRadius = SKY_BOX_SIZE;
+
+	if(gRenDev->m_FS.m_FogEnd>=256)
+		return true;
+
+	Vec3d camera = gRenDev->GetCamera().GetPos();
+	camera.z = max(0,camera.z);
+
+	float fLayerZ = -(max(0,gRenDev->m_FS.m_FogEnd-64)/(256-64))*SKY_BOX_SIZE - camera.z/35;
+
+	bool bRGB = (gRenDev->GetFeatures() & RFT_RGBA) != 0;
+
+	for(int i=0; i<=360; i+=30)
+	{
+		float rad = (i) * (gf_PI/180);
+		struct_VERTEX_FORMAT_P3F_COL4UB tmp;
+		tmp.xyz.x = cry_sinf(-rad)*fFogLayerRadius;
+		tmp.xyz.y = cry_cosf(-rad)*fFogLayerRadius;
+	
+		if(bRGB)
+		{
+			tmp.color.bcolor[0] = uchar(gRenDev->m_FS.m_FogColor.r*255);
+			tmp.color.bcolor[1] = uchar(gRenDev->m_FS.m_FogColor.g*255);
+			tmp.color.bcolor[2] = uchar(gRenDev->m_FS.m_FogColor.b*255);
+		}
+		else
+		{
+			tmp.color.bcolor[2] = uchar(gRenDev->m_FS.m_FogColor.r*255);
+			tmp.color.bcolor[1] = uchar(gRenDev->m_FS.m_FogColor.g*255);
+			tmp.color.bcolor[0] = uchar(gRenDev->m_FS.m_FogColor.b*255);
+		}
+
+		tmp.color.bcolor[3] = uchar(255.f);
+
+		tmp.xyz.z = fLayerZ-SKY_BOX_SIZE/2;
+		m_parrFogLayer2->Add(tmp);
+		tmp.xyz.z = fLayerZ+SKY_BOX_SIZE/2;
+		m_parrFogLayer2->Add(tmp);
+
+		m_parrFogLayer->Add(tmp);
+		tmp.xyz.z = fLayerZ+SKY_BOX_SIZE;
+		tmp.color.bcolor[3] = 0;
+		m_parrFogLayer->Add(tmp);
+	}
+
+#if !defined(PS2) && !defined (GC) && !defined (NULL_RENDERER)
+  CPShader *fpSky = NULL;
+  if (gRenDev->m_RP.m_PersFlags & RBPF_HDR)
+  {
+    fpSky = PShaderForName(gRenDev->m_RP.m_PS_HDR_BaseCol, "CGRC_HDR_BaseCol_PS20");
+    if (fpSky)
+      fpSky->mfSet(true);
+  }
+#endif
+
+	gRenDev->EF_SetState(GS_NODEPTHTEST | GS_BLSRC_SRCALPHA | GS_BLDST_ONEMINUSSRCALPHA);
+	gRenDev->SelectTMU(0);
+  gRenDev->m_TexMan->m_Text_White->Set();
+	gRenDev->EnableTMU(true);
+	gRenDev->DrawTriStrip(&(CVertexBuffer (m_parrFogLayer->GetElements(),VERTEX_FORMAT_P3F_COL4UB)),m_parrFogLayer->Count());
+	gRenDev->DrawTriStrip(&(CVertexBuffer (m_parrFogLayer2->GetElements(),VERTEX_FORMAT_P3F_COL4UB)),m_parrFogLayer2->Count());
+
+#if !defined(PS2) && !defined (GC) && !defined (NULL_RENDERER)
+  if (fpSky)
+    fpSky->mfSet(false);
+#endif
+
+	return true;
+}
+
+CRESky::~CRESky()
+{
+	delete m_parrFogLayer;
+	delete m_parrFogLayer2;
+}
+
+// render black occlusion volumes mostly to hide seams in indoors
+bool CRESky::DrawBlackPortal()
+{
+	if(!m_arrvPortalVerts[0][0].xyz.x)
+		return true;
+
+	gRenDev->ResetToDefault();
+
+	for(int i=0; i<MAX_SKY_OCCLAREAS_NUM; i++)
+	{
+		if(!m_arrvPortalVerts[i][0].xyz.x)
+			return true;
+
+		gRenDev->EF_SetState(GS_DEPTHWRITE);
+		gRenDev->SetCullMode(R_CULL_NONE);
+		gRenDev->SelectTMU(0);
+		gRenDev->EnableTMU(false);
+		gRenDev->DrawTriStrip(&(CVertexBuffer (m_arrvPortalVerts[i],VERTEX_FORMAT_P3F_COL4UB)),4);
+	}
+	return true;
+}
+
+void CRESky::DrawSkySphere(float fHeight)
+{
+	float nWSize = 256/16;  
+
+	float a_in  = 1, a_out = 1;
+
+	struct_VERTEX_FORMAT_P3F_COL4UB vert;
+	vert.color.bcolor[0]=255;
+	vert.color.bcolor[1]=255;
+	vert.color.bcolor[2]=255;
+
+	list2<struct_VERTEX_FORMAT_P3F_COL4UB> lstVertData;
+
+	for(float r=0; r<3; r++)
+	{
+		a_in = a_out;
+		a_out = 1.f-r/2;
+		a_out*=a_out; a_out*=a_out; a_out*=a_out;
+
+		lstVertData.Clear();
+
+		for(int i=0; i<=360; i+=40)
+		{
+			float rad = (i) * (M_PI/180);
+
+			vert.xyz.x = cry_sinf(rad)*nWSize*r;
+			vert.xyz.y = cry_cosf(rad)*nWSize*r;
+			vert.xyz.z = fHeight + 8 - (r)*8;
+			vert.color.bcolor[3] = uchar(a_in*255.0f);
+			lstVertData.Add(vert);
+
+			vert.xyz.x = cry_sinf(rad)*nWSize*(r+1);
+			vert.xyz.y = cry_cosf(rad)*nWSize*(r+1);
+			vert.xyz.z = fHeight + 8 - (r+1)*8;
+			vert.color.bcolor[3] = uchar(a_out*255.0f);
+			lstVertData.Add(vert);
+		}
+
+		gRenDev->DrawTriStrip(&CVertexBuffer(&lstVertData[0],VERTEX_FORMAT_P3F_COL4UB),lstVertData.Count());
+	}
+}

RenderDll/Common/RendElements/CRESkyZone.h

@@ -0,0 +1,32 @@
+
+#ifndef __CRESKYZONE_H__
+#define __CRESKYZONE_H__
+
+//=============================================================
+class CRESkyZone : public CRendElement
+{
+public:
+  Vec3d mViewPos;
+  Vec3d mMins;
+  Vec3d mMaxs;
+  Vec3d mCenter;
+  float mRadius;
+  byte *mPVS;
+
+  CRESkyZone()
+  {
+    mfSetType(eDATA_SkyZone);
+    mfUpdateFlags(FCEF_TRANSFORM | FCEF_NODEL);
+    mPVS = NULL;
+  }
+
+  virtual ~CRESkyZone()
+  {
+    if (mPVS)
+      delete [] mPVS;
+  }
+
+  virtual bool mfCompile(SShader *ef, char *scr);
+};
+
+#endif  // __CRESKYZONE_H__

RenderDll/Common/RendElements/CRETempMesh.cpp

@@ -0,0 +1,36 @@
+#include "RenderPCH.h"
+#include "RendElement.h"
+
+void CRETempMesh::mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_RendNumIndices = 6;
+  gRenDev->m_RP.m_RendNumVerts = 4;
+  gRenDev->m_RP.m_FirstVertex = 0;
+  gRenDev->m_RP.m_FirstIndex = 0;
+}
+
+void *CRETempMesh::mfGetPointer(ESrcPointer ePT, int *Stride, int Type, ESrcPointer Dst, int Flags)
+{
+  *Stride = sizeof(struct_VERTEX_FORMAT_P3F_COL4UB_TEX2F);
+  struct_VERTEX_FORMAT_P3F_COL4UB_TEX2F *pVertices = (struct_VERTEX_FORMAT_P3F_COL4UB_TEX2F *)m_VBuffer->m_VS[VSF_GENERAL].m_VData;
+  gRenDev->m_RP.m_nCurBufferID = m_VBuffer->m_VS[VSF_GENERAL].m_VertBuf.m_nID;
+  SBufInfoTable *pOffs = &gBufInfoTable[m_VBuffer->m_vertexformat];
+
+  switch(ePT) 
+  {
+    case eSrcPointer_Vert:
+      gRenDev->m_RP.m_nCurBufferOffset = 0;
+      return &pVertices->xyz.x;
+    case eSrcPointer_Tex:
+      gRenDev->m_RP.m_nCurBufferOffset = pOffs->OffsTC;
+      return &pVertices->st[0];
+    case eSrcPointer_Color:
+      gRenDev->m_RP.m_nCurBufferOffset = pOffs->OffsColor;
+      return &pVertices->color.dcolor;
+  }
+  return NULL;
+}
+

RenderDll/Common/RendElements/CRETempMesh.h

@@ -0,0 +1,48 @@
+
+#ifndef __CRETEMPMESH_H__
+#define __CRETEMPMESH_H__
+
+//=============================================================
+
+
+class CRETempMesh : public CRendElement
+{
+public:
+  CVertexBuffer *m_VBuffer;
+  SVertexStream m_Inds;
+
+public:
+  CRETempMesh()
+  {
+    m_VBuffer = NULL;
+    m_Inds.Reset();
+    mfSetType(eDATA_TempMesh);
+    mfUpdateFlags(FCEF_TRANSFORM);
+  }
+
+  virtual ~CRETempMesh()
+  {
+    if (m_VBuffer)
+    {
+      gRenDev->ReleaseBuffer(m_VBuffer);
+      m_VBuffer = NULL;
+    }
+    gRenDev->ReleaseIndexBuffer(&m_Inds);
+    m_Inds.Reset();
+  }
+
+  virtual void mfPrepare();
+  virtual bool mfDraw(SShader *ef, SShaderPass *sfm);
+  virtual void *mfGetPointer(ESrcPointer ePT, int *Stride, int Type, ESrcPointer Dst, int Flags);
+  virtual bool mfPreDraw(SShaderPass *sl);
+  virtual void mfReset();
+  virtual int Size()
+  {
+    int nSize = sizeof(*this);
+    if (m_VBuffer)
+      nSize += m_VBuffer->Size(0, m_VBuffer->m_NumVerts);
+    return nSize;
+  }
+};
+
+#endif  // __CRETEMPMESH_H__

RenderDll/Common/RendElements/CRETerrainSector.cpp

@@ -0,0 +1,32 @@
+#include "RenderPCH.h"
+#include "RendElement.h"
+#include "CRETerrainSector.h"
+#include "I3DEngine.h"
+
+void CRECommon::mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_RendNumVerts = 0;
+}
+
+bool CREFarTreeSprites::mfDraw(SShader *ef, SShaderPass *sfm)
+{    
+  iSystem->GetI3DEngine()->DrawFarTrees();
+  return true;
+}
+
+bool CRETerrainDetailTextureLayers::mfDraw(SShader *ef, SShaderPass *sfm)
+{    
+  iSystem->GetI3DEngine()->DrawTerrainDetailTextureLayers();
+  return true;
+}
+
+bool CRETerrainParticles::mfDraw(SShader *ef, SShaderPass *sfm)
+{    
+  iSystem->GetI3DEngine()->DrawTerrainParticles(ef);
+  return true;
+}
+

RenderDll/Common/RendElements/CRETriMeshAdditionalShadow.cpp

@@ -0,0 +1,17 @@
+
+#include "RenderPCH.h"
+/*
+#include "RendElement.h"
+#include "CRETriMeshAdditionalShadow.h"
+
+//////////////////////////////////////////////////////////////////////
+void CRETriMeshAdditionalShadow::mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+
+  gRenDev->m_RP.m_DynLMask |= m_DynMask;
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_RendNumVerts = 0;
+}
+*/

RenderDll/Common/RendElements/CRETriMeshShadow.cpp

@@ -0,0 +1,247 @@
+#include "RenderPCH.h"
+#include "RendElement.h"
+#include "CRETriMeshShadow.h"
+#include "I3DEngine.h"
+
+// shadow volumes rendering modified by vlad
+
+// shadow volumes statistics
+int CRETriMeshShadow::m_nCRETriMeshShadowRebuildsPerFrrame = 0;
+int CRETriMeshShadow::m_nCRETriMeshShadowShadowsPerFrrame = 0;
+int CRETriMeshShadow::m_nCRETriMeshShadowAloocatedShadows = 0;
+
+//////////////////////////////////////////////////////////////////////
+void CRETriMeshShadow::mfPrepare()
+{
+  gRenDev->EF_CheckOverflow(0, 0, this);
+  gRenDev->m_RP.m_pRE = this;
+  gRenDev->m_RP.m_RendNumIndices = 0;
+  gRenDev->m_RP.m_RendNumVerts = 0;
+}
+
+//////////////////////////////////////////////////////////////////////
+void *CRETriMeshShadow::mfGetPointer(ESrcPointer ePT, int *Stride, int Type, ESrcPointer Dst, int Flags)
+{
+  switch (ePT)
+  {
+    case eSrcPointer_Vert:
+			{
+        if(m_nCurrInst<0)
+       {
+//          Warning( 0,0,"Error: CRETriMeshShadow::mfGetPointer: m_nCurrInst<0");
+          return NULL;
+        }
+
+        *Stride = m_VertexSize[m_arrLBuffers[m_nCurrInst].pVB->m_pVertexBuffer->m_vertexformat];
+        if(m_arrLBuffers[m_nCurrInst].pVB->m_pVertexBuffer)
+          return m_arrLBuffers[m_nCurrInst].pVB->m_pVertexBuffer->m_VS[VSF_GENERAL].m_VData;
+				else
+					Warning( 0,0,"Error: CRETriMeshShadow::mfGetPointer: m_pBuffer->m_pVertexBuffer == 0");
+			}
+			break;
+  }
+
+  return NULL;
+}
+
+int CRETriMeshShadow::GetAndResetRebuildsPerFrrameCounter()
+{
+  int n = m_nCRETriMeshShadowRebuildsPerFrrame;
+  m_nCRETriMeshShadowRebuildsPerFrrame = 0;
+  return n;
+}
+
+int CRETriMeshShadow::GetAndResetShadowVolumesPerFrrameCounter()
+{
+  int n = m_nCRETriMeshShadowShadowsPerFrrame;
+  m_nCRETriMeshShadowShadowsPerFrrame = 0;
+  return n;
+}
+
+int CRETriMeshShadow::GetShadowVolumesAllocatedCounter()
+{
+  return m_nCRETriMeshShadowAloocatedShadows;
+}
+
+bool CRETriMeshShadow::mfCheckUpdate(int nVertFormat, int Flags)
+{  
+  if(m_bAnimatedObject)
+  { // character animation: everything already calculated, always use slot 0
+    m_nCurrInst = 0; // will be used during drawing
+    ShadVolInstanceInfo * pSVInfo = &m_arrLBuffers[0];
+    if (pSVInfo->pVB->m_pMats && pSVInfo->pVB->m_pMats->Count() && pSVInfo->pVB->m_pMats->Get(0)->pRE)
+      return pSVInfo->pVB->m_pMats->Get(0)->pRE->mfCheckUpdate(nVertFormat, Flags);
+    
+    return false;
+  }
+
+  m_nCRETriMeshShadowShadowsPerFrrame++;
+
+  assert(m_nCurrInst == -1);
+
+  // find light of this shadow
+  CDLight * pDLight = NULL;
+  if (gRenDev->m_RP.m_DynLMask)
+  {
+    for (int n=0; n<gRenDev->m_RP.m_DLights[SRendItem::m_RecurseLevel].Num(); n++)
+    {
+      if (gRenDev->m_RP.m_DynLMask & (1<<n))
+      {
+        pDLight = gRenDev->m_RP.m_DLights[SRendItem::m_RecurseLevel][n];
+        break;
+      }
+    }
+  }
+  if (!pDLight)
+    return true;
+
+  CDLight fakeLight;
+  fakeLight = *pDLight; // do not copy
+
+  // get obj space light pos
+  CCObject *pObj = gRenDev->m_RP.m_pCurObject;
+  Matrix44& tInvRot = pObj->GetInvMatrix();
+
+  fakeLight.m_vObjectSpacePos = tInvRot.TransformPointOLD(fakeLight.m_Origin);
+
+//  assert(m_nCurrInst==-1);
+
+  // todo: take radius into account
+
+  //assert(pObj->m_CustomData);
+
+  // find buffer for this case
+  ShadVolInstanceInfo * pSVInfo = 0;
+  for(int i=0; i<MAX_SV_INSTANCES; i++) // find static volume by light objspace position
+  if(m_arrLBuffers[i].pVB && IsEquivalent(m_arrLBuffers[i].vObjSpaceLightPos, fakeLight.m_vObjectSpacePos, 0.001f))
+  {
+    pSVInfo = &m_arrLBuffers[i];
+    pSVInfo->nFrameId = gRenDev->GetFrameID();
+    m_nCurrInst = i;
+    break;
+  }
+  
+  if(!pSVInfo) // if not found - select new slot
+  {
+    // now find same combination of light and shadow caster 
+    // but only if slot was not used in prev frame -
+    // outomagic double buffering of dynamic shadows
+    for(int i=0; i<MAX_SV_INSTANCES; i++)
+    if( m_arrLBuffers[i].pVB && 
+        m_arrLBuffers[i].pLightOwner == fakeLight.m_pOwner && 
+        m_arrLBuffers[i].pShadowCaster == pObj->m_CustomData &&
+        m_arrLBuffers[i].nFrameId+1 < gRenDev->GetFrameID())
+    {
+      pSVInfo = &m_arrLBuffers[i];
+      m_nCurrInst = i;
+      break;
+    }
+
+    if(!pSVInfo) // if still not found 
+    { // find empty slot or slot with smallest frame id
+      int nSmalestFrameId = gRenDev->GetFrameID()+1;
+      for(int i=0; i<MAX_SV_INSTANCES; i++)
+      {
+        if(!m_arrLBuffers[i].pVB)
+        { // search for free slot
+          pSVInfo = &m_arrLBuffers[i];
+          m_nCurrInst = i;
+          nSmalestFrameId=0;
+          break;
+        }
+
+        if(m_arrLBuffers[i].nFrameId<nSmalestFrameId)
+        { // search for oldest slot at the same time
+          nSmalestFrameId = m_arrLBuffers[i].nFrameId;
+          pSVInfo = &m_arrLBuffers[i];
+          m_nCurrInst = i;
+        }
+      }
+    }
+
+    if(pSVInfo)
+    {
+      pSVInfo->nFrameId = gRenDev->GetFrameID();
+      pSVInfo->vObjSpaceLightPos = fakeLight.m_vObjectSpacePos;
+      pSVInfo->pLightOwner = fakeLight.m_pOwner;
+      pSVInfo->pShadowCaster = (IEntityRender*)pObj->m_CustomData;
+    }
+
+    if(!pSVInfo->pVB)
+      m_nCRETriMeshShadowAloocatedShadows++; // will be created now
+
+    // pSVInfo will be used in RebuildDynamicShadowVolumeBuffer
+    m_pSvObj->RebuildShadowVolumeBuffer(fakeLight, pObj->m_TempVars[0]);
+    m_nCRETriMeshShadowRebuildsPerFrrame++;
+
+  //  if(!pSVInfo->pVB)
+//      iLog->Log("Warning: CRETriMeshShadow::mfCheckUpdate: !pSVInfo->pVB");
+
+/*
+    ICVar *pVar = iConsole->GetCVar("e_stencil_shadows");
+    if(pVar && pVar->GetIVal()==3 && pSVInfo->pVB)
+      iLog->Log("CRETriMeshShadow: Static shadow volume created: %d faces", pSVInfo->pVB->GetIndices().Count()/3);*/
+  }
+   
+  if (pSVInfo->pVB &&
+      pSVInfo->pVB->m_pMats && 
+      pSVInfo->pVB->m_pMats->Count() &&
+      pSVInfo->pVB->m_pMats->Get(0)->pRE)
+    pSVInfo->pVB->m_pMats->Get(0)->pRE->mfCheckUpdate(nVertFormat, Flags);
+  else
+    m_nCurrInst = -1;
+
+  fakeLight.m_vObjectSpacePos = Vec3d(0,0,0);
+
+#ifdef DIRECT3D8
+  assert(0); // not tested, what this line do?
+  gRenDev->m_RP.m_CurD3DVFormat = pSVInfo->pVB->m_pSecVertBuffer->m_vertexformat + 16;
+#endif
+  return true;
+}
+
+CRETriMeshShadow::~CRETriMeshShadow()
+{
+  for(int i=0; i<MAX_SV_INSTANCES; i++)
+  {
+    gRenDev->DeleteLeafBuffer(m_arrLBuffers[i].pVB);
+    m_arrLBuffers[i].pVB=0;
+  }
+}
+
+bool CRETriMeshShadow::mfCheckUnload()
+{ // remove all not used leafbuffers
+  for(int i=0; i<MAX_SV_INSTANCES; i++)
+  if(m_arrLBuffers[i].pVB)
+  {
+    if(m_arrLBuffers[i].nFrameId < gRenDev->GetFrameID()-100)
+    {
+      gRenDev->DeleteLeafBuffer(m_arrLBuffers[i].pVB);
+      m_arrLBuffers[i].pVB=0;
+      m_arrLBuffers[i].nFrameId=0;
+      m_nCRETriMeshShadowAloocatedShadows--;
+    }
+  }
+
+/*
+  if(nLastCRETriMeshShadowLogFrame != gRenDev->GetFrameID())
+  {
+    int nRebNum  = GetRETriMeshShadowRebuildsPerFrrame()/32;;
+    int nShadNum = GetRETriMeshShadowShadowsPerFrrame()/32;
+    ICVar *pVar = iConsole->GetCVar("e_stencil_shadows");
+    if(pVar && pVar->GetIVal()==3)
+      iLog->Log("CRETriMeshShadow: Allocated: %d, Used: %d, Updated: %d", 
+      nCRETriMeshShadowAloocatedShadows, nShadNum, nRebNum);
+    nLastCRETriMeshShadowLogFrame = gRenDev->GetFrameID();
+  }*/
+
+  return true;
+}
+
+void CRETriMeshShadow::PrintStats()
+{
+  gRenDev->TextToScreenColor(8,20, 0,2,0,1, "Shadow volumes stats: Rebuild: %d, Used: %d, Allocated: %d",
+    CRETriMeshShadow::GetAndResetRebuildsPerFrrameCounter(),
+    CRETriMeshShadow::GetAndResetShadowVolumesPerFrrameCounter(),
+    CRETriMeshShadow::GetShadowVolumesAllocatedCounter());
+}

RenderDll/Common/RendElements/FFT_SSE.cpp

@@ -0,0 +1,526 @@
+#include "RenderPCH.h"
+
+// Not for AMD64
+#if !defined(WIN64) && !defined(LINUX)
+
+#pragma warning(push)
+#pragma warning(disable:4731) // frame pointer register 'ebp' modified by inline assembly code
+
+struct SConstSSE
+{
+  float m_fVal0;
+  float m_fVal1;
+  float m_fVal2;
+  float m_fVal3;
+};
+
+_declspec(align(16)) SConstSSE _tabCoef64_1[4][6] =
+{
+  {
+    {1.000000f, 0.995185f, 0.980785f, 0.956940f},
+    {0.000000f, -0.098017f, -0.195090f, -0.290285f},
+    {1.000000f, 0.980785f, 0.923880f, 0.831470f},
+    {0.000000f, -0.195090f, -0.382683f, -0.555570f},
+    {1.000000f, 0.956940f, 0.831470f, 0.634393f},
+    {0.000000f, -0.290285f, -0.555570f, -0.773010f},
+  },
+  {
+    {0.923880f, 0.881921f, 0.831470f, 0.773010f},
+    {-0.382683f, -0.471397f, -0.555570f, -0.634393f},
+    {0.707107f, 0.555570f, 0.382683f, 0.195090f},
+    {-0.707107f, -0.831470f, -0.923880f, -0.980785f},
+    {0.382683f, 0.098017f, -0.195090f, -0.471397f},
+    {-0.923880f, -0.995185f, -0.980785f, -0.881921f},
+  },
+  {
+    {0.707107f, 0.634393f, 0.555570f, 0.471397f},
+    {-0.707107f, -0.773010f, -0.831470f, -0.881921f},
+    {0.000000f, -0.195090f, -0.382683f, -0.555570f},
+    {-1.000000f, -0.980785f, -0.923880f, -0.831470f},
+    {-0.707107f, -0.881921f, -0.980785f, -0.995185f},
+    {-0.707107f, -0.471397f, -0.195090f, 0.098017f},
+  },
+  {
+    {0.382683f, 0.290285f, 0.195090f, 0.098017f},
+    {-0.923880f, -0.956940f, -0.980785f, -0.995185f},
+    {-0.707107f, -0.831470f, -0.923880f, -0.980785f},
+    {-0.707107f, -0.555570f, -0.382683f, -0.195090f},
+    {-0.923880f, -0.773010f, -0.555570f, -0.290285f},
+    {0.382683f, 0.634393f, 0.831470f, 0.956940f},
+  }
+};
+
+_declspec(align(16)) SConstSSE _tabCoef64_2[4][6] =
+{
+  {
+    {1.000000f, 0.923880f, 0.707107f, 0.382683f},
+    {0.000000f, -0.382683f, -0.707107f, -0.923880f},
+    {1.000000f, 0.707107f, 0.000000f, -0.707107f},
+    {0.000000f, -0.707107f, -1.000000f, -0.707107f},
+    {1.000000f, 0.382683f, -0.707107f, -0.923880f},
+    {0.000000f, -0.923880f, -0.707107f, 0.382683f},
+  }
+};
+
+void cradix4c_64(float* ar, float* ai, int nm)
+{
+  int wdt = OCEANGRID;
+  float *arw = &ar[wdt];
+  float *aiw = &ai[wdt];
+  _asm
+  {
+    mov         eax, arw
+    mov         ebx, aiw
+    mov         edx, ai
+    mov         ecx, ar
+    sub         esp, 20h
+    mov         [esp+0ch], ebp
+    mov         [esp], ecx
+    mov         [esp+4], edx
+    mov         ebp, ecx
+    mov         [esp+10h], eax
+    mov         [esp+14h], ebx
+    mov         [esp+18h], ebp
+    mov         [esp+1ch], edx
+    lea         ebx, [ebp+40h]
+    lea         edi, _tabCoef64_1
+    mov         [esp+8], ebx
+_lAlign:
+    movaps      xmm0,xmmword ptr [ebp]
+    movaps      xmm4,xmm0
+    movaps      xmm2,xmmword ptr [ebp+80h]
+    subps       xmm0,xmm2
+    movaps      xmm1,xmmword ptr [ebp+40h]
+    addps       xmm4,xmm2
+    movaps      xmm3,xmmword ptr [ebp+0C0h]
+    movaps      xmm5,xmm1
+    movaps      xmm2,xmmword ptr [edx]
+    addps       xmm5,xmm3
+    jmp         _lCicleAlign
+align 4
+_lStartAlign:
+    movaps      xmmword ptr [edx+0B0h],xmm0
+    movaps      xmm0,xmmword ptr [ebp]
+    subps       xmm7,xmm4
+    movaps      xmm4,xmm0
+    movaps      xmmword ptr [ebp+0B0h],xmm5
+    addps       xmm3,xmm1
+    movaps      xmm2,xmmword ptr [ebp+80h]
+    movaps      xmmword ptr [ebp+30h],xmm7
+    subps       xmm0,xmm2
+    movaps      xmm1,xmmword ptr [ebp+40h]
+    addps       xmm4,xmm2
+    movaps      xmm5,xmm1
+    movaps      xmmword ptr [edx+30h],xmm3
+    movaps      xmm2,xmmword ptr [edx]
+    movaps      xmm3,xmmword ptr [ebp+0C0h]
+    addps       xmm5,xmm3
+_lCicleAlign:
+align 4
+    movaps      xmm7,xmm4
+    subps       xmm1,xmm3
+    prefetcht0  [edi]
+    addps       xmm4,xmm5
+    movaps      xmm3,xmm2
+    movaps      xmm6,xmmword ptr [edx+80h]
+    subps       xmm7,xmm5
+    prefetcht0  [edi+10h]
+    movaps      xmmword ptr [ebp],xmm4
+    addps       xmm3,xmm6
+    movaps      xmm5,xmmword ptr [edx+40h]
+    subps       xmm2,xmm6
+    prefetcht0  [edi+20h]
+    movaps      xmm4,xmmword ptr [edx+0C0h]
+    movaps      xmm6,xmm5
+    addps       xmm5,xmm4
+    prefetcht0  [edi+30h]
+    subps       xmm6,xmm4
+    movaps      xmm4,xmm5
+    addps       xmm5,xmm3
+    movaps      xmmword ptr [edx],xmm5
+    movaps      xmm5,xmm0
+    addps       xmm0,xmm6
+    prefetcht0  [edi+40h]
+    subps       xmm3,xmm4
+    movaps      xmm4,xmm2
+    subps       xmm2,xmm1
+    prefetcht0  [edi+50h]
+    addps       xmm1,xmm4
+    subps       xmm5,xmm6
+    movaps      xmm4,xmm0
+    movaps      xmm6,xmm2
+    mulps       xmm0,xmmword ptr [edi]
+    mulps       xmm2,xmmword ptr [edi+10h]
+    mulps       xmm4,xmmword ptr [edi+10h]
+    add         ebp,10h
+    add         edx,10h
+    subps       xmm0,xmm2
+    mulps       xmm6,xmmword ptr [edi]
+    movaps      xmm2,xmm1
+    movaps      xmmword ptr [ebp+70h],xmm0
+    mulps       xmm1,xmmword ptr [edi+50h]
+    movaps      xmm0,xmm5
+    addps       xmm4,xmm6
+    mulps       xmm5,xmmword ptr [edi+40h]
+    mulps       xmm2,xmmword ptr [edi+40h]
+    mulps       xmm0,xmmword ptr [edi+50h]
+    subps       xmm5,xmm1
+    movaps      xmmword ptr [edx+70h],xmm4
+    movaps      xmm1,xmm7
+    mulps       xmm7,xmmword ptr [edi+20h]
+    movaps      xmm4,xmm3
+    addps       xmm0,xmm2
+    mulps       xmm3,xmmword ptr [edi+20h]
+    mulps       xmm4,xmmword ptr [edi+30h]
+    cmp         ebp,ebx
+    mulps       xmm1,xmmword ptr [edi+30h]
+    lea         edi,[edi+60h]
+    jl          _lStartAlign
+    movaps      xmmword ptr [ebp+0B0h],xmm5
+    addps       xmm3,xmm1
+    subps       xmm7,xmm4
+    movaps      xmmword ptr [edx+0B0h],xmm0
+    movaps      xmmword ptr [edx+30h],xmm3
+    movaps      xmmword ptr [ebp+30h],xmm7
+    mov         ebp,[esp]
+    mov         edx,[esp+4]
+    add         ebp,100h
+    add         edx,100h
+    mov         [esp],ebp
+    mov         [esp+4],edx
+    cmp         ebp,[esp+10h]
+    lea         ebx,[ebp+40h]
+    mov         [esp+8],ebx
+    lea         edi,_tabCoef64_1
+    jl          _lAlign
+
+    mov         ebp, [esp+18h];
+    mov         edx, [esp+1ch];
+    mov         [esp], ebp
+    mov         [esp+4], edx
+    lea         ebx, [ebp+10h]
+    lea         edi, _tabCoef64_2
+    mov         [esp+8], ebx
+_lAlign2:
+    movaps      xmm0,xmmword ptr [ebp]
+    movaps      xmm4,xmm0
+    movaps      xmm2,xmmword ptr [ebp+20h]
+    subps       xmm0,xmm2
+    movaps      xmm1,xmmword ptr [ebp+10h]
+    addps       xmm4,xmm2
+    movaps      xmm3,xmmword ptr [ebp+30h]
+    movaps      xmm5,xmm1
+    movaps      xmm2,xmmword ptr [edx]
+    addps       xmm5,xmm3
+    jmp         _lCicleAlign2
+align 4
+_lStartAlign2:
+    movaps      xmmword ptr [edx+20h],xmm0
+    movaps      xmm0,xmmword ptr [ebp]
+    subps       xmm7,xmm4
+    movaps      xmm4,xmm0
+    movaps      xmmword ptr [ebp+20h],xmm5
+    addps       xmm3,xmm1
+    movaps      xmm2,xmmword ptr [ebp+20h]
+    movaps      xmmword ptr [ebp],xmm7
+    subps       xmm0,xmm2
+    movaps      xmm1,xmmword ptr [ebp+10h]
+    addps       xmm4,xmm2
+    movaps      xmm5,xmm1
+    movaps      xmmword ptr [edx],xmm3
+    movaps      xmm2,xmmword ptr [edx]
+    movaps      xmm3,xmmword ptr [ebp+30h]
+    addps       xmm5,xmm3
+_lCicleAlign2:
+    movaps      xmm7,xmm4
+    subps       xmm1,xmm3
+    prefetcht0  [edi]
+    addps       xmm4,xmm5
+    movaps      xmm3,xmm2
+    movaps      xmm6,xmmword ptr [edx+20h]
+    subps       xmm7,xmm5
+    prefetcht0  [edi+10h]
+    movaps      xmmword ptr [ebp],xmm4
+    addps       xmm3,xmm6
+    movaps      xmm5,xmmword ptr [edx+10h]
+    subps       xmm2,xmm6
+    prefetcht0  [edi+20h]
+    movaps      xmm4,xmmword ptr [edx+30h]
+    movaps      xmm6,xmm5
+    addps       xmm5,xmm4
+    prefetcht0  [edi+30h]
+    subps       xmm6,xmm4
+    movaps      xmm4,xmm5
+    addps       xmm5,xmm3
+    movaps      xmmword ptr [edx],xmm5
+    movaps      xmm5,xmm0
+    addps       xmm0,xmm6
+    prefetcht0  [edi+40h]
+    subps       xmm3,xmm4
+    movaps      xmm4,xmm2
+    subps       xmm2,xmm1
+    prefetcht0  [edi+50h]
+    addps       xmm1,xmm4
+    subps       xmm5,xmm6
+    movaps      xmm4,xmm0
+    movaps      xmm6,xmm2
+    mulps       xmm0,xmmword ptr [edi]
+    mulps       xmm2,xmmword ptr [edi+10h]
+    mulps       xmm4,xmmword ptr [edi+10h]
+    add         ebp,10h
+    add         edx,10h
+    subps       xmm0,xmm2
+    mulps       xmm6,xmmword ptr [edi]
+    movaps      xmm2,xmm1
+    movaps      xmmword ptr [ebp+10h],xmm0
+    mulps       xmm1,xmmword ptr [edi+50h]
+    movaps      xmm0,xmm5
+    addps       xmm4,xmm6
+    mulps       xmm5,xmmword ptr [edi+40h]
+    mulps       xmm2,xmmword ptr [edi+40h]
+    mulps       xmm0,xmmword ptr [edi+50h]
+    subps       xmm5,xmm1
+    movaps      xmmword ptr [edx+10h],xmm4
+    movaps      xmm1,xmm7
+    mulps       xmm7,xmmword ptr [edi+20h]
+    movaps      xmm4,xmm3
+    addps       xmm0,xmm2
+    mulps       xmm3,xmmword ptr [edi+20h]
+    mulps       xmm4,xmmword ptr [edi+30h]
+    cmp         ebp,ebx
+    mulps       xmm1,xmmword ptr [edi+30h]
+    lea         edi,[edi+60h]
+    jl          _lStartAlign2
+    movaps      xmmword ptr [ebp+20h],xmm5
+    addps       xmm3,xmm1
+    subps       xmm7,xmm4
+    movaps      xmmword ptr [edx+20h],xmm0
+    movaps      xmmword ptr [edx],xmm3
+    movaps      xmmword ptr [ebp],xmm7
+    mov         ebp,[esp]
+    mov         edx,[esp+4]
+    add         ebp,40h
+    add         edx,40h
+    mov         [esp],ebp
+    mov         [esp+4],edx
+    cmp         ebp,[esp+10h]
+    lea         ebx,[ebp+10h]
+    mov         [esp+8],ebx
+    lea         edi,_tabCoef64_2
+    jl          _lAlign2
+
+    mov         ebp, [esp+18h]
+    mov         edx, [esp+1ch]
+    mov         [esp], ebp
+    mov         [esp+4], edx
+    mov         ebx, [esp+10h]
+    fld         dword ptr [ebp]
+    fld         st(0)
+    fld         dword ptr [ebp+8]
+    fsub        st(1),st
+    faddp       st(2),st
+    fld         dword ptr [ebp+4]
+    fxch        st(2)
+    fld         st(2)
+    fld         dword ptr [ebp+0Ch]
+    fadd        st(1),st
+    fsubp       st(4),st
+    jmp         _lEnd3
+align 4
+_lCicle:
+    fstp        dword ptr [ebp-4]
+    fld         dword ptr [ebp]
+    fxch        st(1)
+    fstp        dword ptr [ebp-8]
+    fld         st(0)
+    fld         dword ptr [ebp+8]
+    fadd        st(2),st
+    fxch        st(3)
+    fstp        dword ptr [edx-10h]
+    fsubrp      st(2),st
+    fld         dword ptr [ebp+4]
+    fld         st(0)
+    fld         dword ptr [ebp+0Ch]
+    fadd        st(2),st
+    fxch        st(5)
+    fstp        dword ptr [edx-4]
+    fsubrp      st(4),st
+_lEnd3:
+    fld         dword ptr [edx]
+    fld         dword ptr [edx]
+    fld         st(3)
+    fadd        st,st(3)
+    fld         dword ptr [edx+8]
+    fadd        st(3),st
+    fxch        st(5)
+    fsubrp      st(4),st
+    fld         dword ptr [edx+4]
+    fxch        st(2)
+    fsubrp      st(5),st
+    fstp        dword ptr [ebp]
+    fld         st(0)
+    fld         dword ptr [edx+0Ch]
+    fadd        st(2),st
+    fxch        st(4)
+    fstp        dword ptr [ebp+4]
+    fsubrp      st(3),st
+    fst         [esp+10h]
+    fadd        st,st(1)
+    fxch        st(4)
+    fst         [esp+14h]
+    fadd        st,st(2)
+    fxch        st(3)
+    fst         [esp+18h]
+    fsub        st,st(5)
+    fld         [esp+10h]
+    fsubp       st(2),st
+    fld         [esp+14h]
+    fsubrp      st(3),st
+    fld         [esp+18h]
+    faddp       st(6),st
+    add         ebp,10h
+    add         edx,10h
+    fstp        dword ptr [edx-8]
+    cmp         ebp,ebx
+    fstp        dword ptr [edx-0Ch]
+    jl          _lCicle
+    fstp        dword ptr [ebp-4]
+    fstp        dword ptr [ebp-8]
+    fstp        dword ptr [edx-10h]
+    fstp        dword ptr [edx-4]
+    mov         ebp, [esp+0ch]
+    add         esp, 20h
+  }
+}
+
+void bittabc(int *p, int sn)
+{
+  int i2 = sn;
+  int j = 1;
+  int i, k;
+  int ind = 0;
+  i2 >>= 1;
+  for (i=1; i<=sn-1; i++)
+  {
+    if (i < j)
+    {
+      ind += 2;
+      p[ind] = i-1;
+      p[ind+1] = j-1;
+    }
+    k = i2;
+    while (j > k)
+    {
+      j -= k;
+      k >>= 1;
+    }
+    j += k;
+  }
+  p[0] = 0;
+  p[1] = ind >> 1;
+}
+
+void coef4r22c(int *ptr, int nm)
+{
+  int sn = 1<<nm;
+  bittabc(ptr, sn);
+}
+
+
+void cbitrevc(float* ar, float* ai, int *p)
+{
+  int nCount = p[1];
+  int *pInd = &p[2];
+  int nC = nCount >> 2;
+  while (nC)
+  {
+    Exchange(ar[pInd[0]], ar[pInd[1]]);
+    Exchange(ar[pInd[2]], ar[pInd[3]]);
+    Exchange(ar[pInd[4]], ar[pInd[5]]);
+    Exchange(ar[pInd[6]], ar[pInd[7]]);
+    pInd += 8;
+    nC--;
+  }
+  pInd = &p[2];
+  nC = nCount >> 2;
+  while (nC)
+  {
+    Exchange(ai[pInd[0]], ai[pInd[1]]);
+    Exchange(ai[pInd[2]], ai[pInd[3]]);
+    Exchange(ai[pInd[4]], ai[pInd[5]]);
+    Exchange(ai[pInd[6]], ai[pInd[7]]);
+    pInd += 8;
+    nC--;
+  }
+}
+
+void xcfft1dc(float* ar, float* ai, int *p, int nm)
+{
+  cradix4c_64(ar, ai, nm);
+  cbitrevc(ar, ai, p);
+}
+
+void FFTSSE_64(float* ar, float* ai)
+{
+  int i, j;
+  const int nm = 6;
+
+  _declspec(align(16)) int p0[OCEANGRID*8];
+  coef4r22c(p0, nm);
+  for (i=0; i<OCEANGRID; i++)
+  {
+    xcfft1dc(&ar[OCEANGRID*i], &ai[OCEANGRID*i], p0, nm);
+  }
+
+  coef4r22c(p0, nm);
+
+  _declspec(align(16)) float p1[4][OCEANGRID];
+  _declspec(align(16)) float p2[4][OCEANGRID];
+
+  float *src, *dst;
+  for (j=0; j<OCEANGRID; j+=4)
+  {
+    src = &ar[j];
+    for (i=0; i<OCEANGRID; i++, src+=OCEANGRID)
+    {
+      p1[0][i] = src[0];
+      p1[1][i] = src[1];
+      p1[2][i] = src[2];
+      p1[3][i] = src[3];
+    }
+    src = &ai[j];
+    for (i=0; i<OCEANGRID; i++, src+=OCEANGRID)
+    {
+      p2[0][i] = src[0];
+      p2[1][i] = src[1];
+      p2[2][i] = src[2];
+      p2[3][i] = src[3];
+    }
+
+    xcfft1dc(&p1[0][0], &p2[0][0], p0, nm);
+    xcfft1dc(&p1[1][0], &p2[1][0], p0, nm);
+    xcfft1dc(&p1[2][0], &p2[2][0], p0, nm);
+    xcfft1dc(&p1[3][0], &p2[3][0], p0, nm);
+
+    dst = &ar[j];
+    for (i=0; i<OCEANGRID; i++, dst+=OCEANGRID)
+    {
+      dst[0] = p1[0][i];
+      dst[1] = p1[1][i];
+      dst[2] = p1[2][i];
+      dst[3] = p1[3][i];
+    }
+    dst = &ai[j];
+    for (i=0; i<OCEANGRID; i++, dst+=OCEANGRID)
+    {
+      dst[0] = p2[0][i];
+      dst[1] = p2[1][i];
+      dst[2] = p2[2][i];
+      dst[3] = p2[3][i];
+    }
+  }
+}
+
+#pragma warning(pop)
+
+#endif // !defined(WIN64)