/*=============================================================================
  GLCGVPrograms.cpp : OpenGL cg vertex programs support.
  Copyright (c) 2001 Crytek Studios. All Rights Reserved.

  Revision history:
    * Created by Honitch Andrey

=============================================================================*/

#include "RenderPCH.h"
#include "GL_Renderer.h"
#include "GLCGVProgram.h"

#undef THIS_FILE
static char THIS_FILE[] = __FILE__;

#ifdef WIN64
#pragma warning( push )									//AMD Port
#pragma warning( disable : 4267 )
#endif

TArray<CVProgram *> CVProgram::m_VPrograms;

vec4_t CCGVProgram_GL::m_CurParams[96];
vec4_t CCGVProgram_GL::m_CurParamsARB[96];
bool CCGVProgram_GL::m_bCreateNoise = false;

//=======================================================================

CVProgram *CVProgram::mfForName(const char *name, std::vector<SFXStruct>& Structs, std::vector<SPair>& Macros, char *entryFunc, EShaderVersion eSHV, uint64 nMaskGen)
{
  assert(0);
  return 0;
}

//=======================================================================

CVProgram *CVProgram::mfForName(const char *name, uint64 nMask)
{
  int i;

  if (!name || !name[0])
    return NULL;

  if (!(gRenDev->GetFeatures() & (RFT_HW_VS)))
    return NULL;

  for (i=0; i<m_VPrograms.Num(); i++)
  {
    if (!m_VPrograms[i])
      continue;
    if (!stricmp(name, m_VPrograms[i]->m_Name.c_str()) && m_VPrograms[i]->m_nMaskGen == nMask)
    {
      m_VPrograms[i]->m_nRefCounter++;
      return m_VPrograms[i];
    }
  }

  char scrname[128];
  char dir[128];
  sprintf(dir, "%sDeclarations/CGVShaders/", gRenDev->m_cEF.m_HWPath);
  sprintf(scrname, "%s%s.crycg", dir, name);
  FILE *fp = iSystem->GetIPak()->FOpen(scrname, "r");
  if (!fp)
  {
    iLog->Log("WARNING: Couldn't find vertex shader '%s'", name);
    return NULL;
  }
  iSystem->GetIPak()->FSeek(fp, 0, SEEK_END);
  int len = iSystem->GetIPak()->FTell(fp);
  char *buf = new char [len+1];
  iSystem->GetIPak()->FSeek(fp, 0, SEEK_SET);
  len = iSystem->GetIPak()->FRead(buf, 1, len, fp);
  iSystem->GetIPak()->FClose(fp);
  buf[len] = 0;
  buf = gRenDev->m_cEF.mfScriptPreprocessor(buf, dir, scrname);

  CVProgram *p = NULL;
  {
    CVProgram *pr;
    pr = new CCGVProgram_GL;
    FILE *handle = iSystem->GetIPak()->FOpen(scrname, "rb");
    if (handle)
    {
      pr->m_WriteTime = iSystem->GetIPak()->GetModificationTime(handle);
      iSystem->GetIPak()->FClose(handle);
    }
    pr->m_Name = name;
    pr->m_Id = i;
    m_VPrograms.AddElem(pr);
    pr->m_nRefCounter = 1;
    pr->m_nMaskGen = nMask;
    p = pr;
  }

  p->mfCompile(buf);
  delete [] buf;
  if (CRenderer::CV_r_shadersprecache==1)
    p->mfPrecache();

  return p;
}

//=======================================================================


TArray<SCGScript *> CCGVProgram_GL::m_CGScripts;

void SCGScript::mfRemoveFromList()
{
  int i;

  for (i=0; i<CCGVProgram_GL::m_CGScripts.Num(); i++)
  {
    SCGScript *scr = CCGVProgram_GL::m_CGScripts[i];
    if (scr == this)
      CCGVProgram_GL::m_CGScripts[i] = NULL;
  }
}

void CCGVProgram_GL::mfPrecache()
{
  bool bPrevFog = gRenDev->m_FS.m_bEnable;
  gRenDev->m_FS.m_bEnable = true;

  int Mask;
  if ((m_Flags & VPFI_NOFOG) || !(gRenDev->m_Features & RFT_FOGVP) || !gRenDev->m_FS.m_bEnable)
    Mask = VPVST_NOFOG;
  else
    Mask = VPVST_FOGGLOBAL;

  CVProgram *pPosVP = this;
  int Id = mfGetCGInstanceID(Mask, pPosVP);
  mfActivate(pPosVP);

  Mask |= VPVST_CLIPPLANES3;
  Id = mfGetCGInstanceID(Mask, pPosVP);
  mfActivate(pPosVP);

  gRenDev->m_FS.m_bEnable = bPrevFog;
}

void CCGVProgram_GL::mfReset()
{
  for (int i=0; i<m_Insts.Num(); i++)
  {
    m_CurInst = i;
    mfDel();
  }
  m_Insts.Free();
  m_dwFrame++;
}

void CCGVProgram_GL::mfFree()
{
  m_Flags = 0;

  if (m_Script && !m_Script->m_Name.GetIndex())
    SAFE_RELEASE(m_Script);
  if (m_CoreScript && !m_CoreScript->m_Name.GetIndex())
    SAFE_RELEASE(m_CoreScript);
  if (m_SubroutinesScript && !m_SubroutinesScript->m_Name.GetIndex())
    SAFE_RELEASE(m_SubroutinesScript);
  if (m_DeclarationsScript && !m_DeclarationsScript->m_Name.GetIndex())
    SAFE_RELEASE(m_DeclarationsScript);
  if (m_InputParmsScript && !m_InputParmsScript->m_Name.GetIndex())
    SAFE_RELEASE(m_InputParmsScript);
  if (m_PosScript && !m_PosScript->m_Name.GetIndex())
    SAFE_RELEASE(m_PosScript);

  m_Pointers.Free();
  m_ParamsNoObj.Free();
  m_ParamsObj.Free();
  m_MatrixObj.Free();

  mfReset();
}

CCGVProgram_GL::~CCGVProgram_GL()
{
  mfFree();
  CVProgram::m_VPrograms[m_Id] = NULL;
}

void CCGVProgram_GL::Release()
{
  m_nRefCounter--;
  if (!m_nRefCounter)
    delete this;
}

bool CCGVProgram_GL::mfHasPointer(ESrcPointer ePtr)
{
  for (int i=0; i<m_Pointers.Num(); i++)
  {
    if (m_Pointers[i]->ePT == ePtr)
      return true;
  }
  return false;
}

static char *sAdditionalVP[] = 
{
  {
    "return OUT;\n"
    "}\n"
  },
  {
    "OUT.FogC = dot(ModelViewProj._31_32_33_34, vPos);\n"
    "return OUT;\n"
    "}\n"
  },
  {
    "OUT.Tex3.z = dot(vPos, ClipPlane);\n"
    "return OUT;\n"
    "}\n"
  },
  {
    "OUT.FogC = dot(ModelViewProj._31_32_33_34, vPos);\n"
    "OUT.Tex3.z = dot(vPos, ClipPlane);\n"
    "return OUT;\n"
    "}\n"
  },

  {
    "return OUT;\n"
    "}\n"
  },
  {
    "return OUT;\n"
    "}\n"
  },
  {
    "OUT.Tex3.z = dot(vPos, ClipPlane);\n"
    "return OUT;\n"
    "}\n"
  },
  {
    "OUT.Tex3.z = dot(vPos, ClipPlane);\n"
    "return OUT;\n"
    "}\n"
  }
};

SCGScript *CCGVProgram_GL::mfGenerateScriptVP(CVProgram *pPosVP)
{
  TArray<char> newScr;

  if (m_DeclarationsScript)
    newScr.Copy(m_DeclarationsScript->m_Script, strlen(m_DeclarationsScript->m_Script));

  char *szInputParms = "";
  if (m_InputParmsScript)
    szInputParms = m_InputParmsScript->m_Script;
  if (m_PosScript && m_PosScript->m_Name != m_Insts[m_CurInst].m_PosScriptName)
  {
    char str[1024];
    strcpy(str, szInputParms);
    szInputParms = str;
    if (pPosVP && pPosVP->m_bCGType)
    {
      CCGVProgram_GL *pVPGL = (CCGVProgram_GL *)pPosVP;
      for (int i=0; i<pVPGL->m_ParamsNoObj.Num(); i++)
      {
        if (!strstr(str, pVPGL->m_ParamsNoObj[i].m_Name.c_str()))
        {
          strcat(str, ", uniform float4 ");
          strcat(str, pVPGL->m_ParamsNoObj[i].m_Name.c_str());
        }
      }
      for (int i=0; i<pVPGL->m_ParamsObj.Num(); i++)
      {
        if (!strstr(str, pVPGL->m_ParamsObj[i].m_Name.c_str()))
        {
          strcat(str, ", uniform float4 ");
          strcat(str, pVPGL->m_ParamsObj[i].m_Name.c_str());
        }
      }
    }
  }

  if (m_SubroutinesScript)
    newScr.Copy(m_SubroutinesScript->m_Script, strlen(m_SubroutinesScript->m_Script));

  char str[1024];
  sprintf(str, "vertout main(appin IN, %s)\n{\n  vertout OUT;\n", szInputParms);
  newScr.Copy(str, strlen(str));

  if (pPosVP)
  {
    CCGVProgram_GL *pVP = (CCGVProgram_GL *)pPosVP;
    SCGScript *pScr = pVP->m_PosScript;
    if (CName(pPosVP->m_Name.c_str(), eFN_Find) != m_Insts[m_CurInst].m_PosScriptName)
    {
      SCGScript *pS = mfAddNewScript(m_Insts[m_CurInst].m_PosScriptName.c_str(), NULL);
      if (pS)
        pScr = pS;
    }
    if (pScr)
      newScr.Copy(pScr->m_Script, strlen(pScr->m_Script));
  }
  if (m_CoreScript)
    newScr.Copy(m_CoreScript->m_Script, strlen(m_CoreScript->m_Script));

  char *pExit = "return OUT;\n}";
  newScr.Copy(pExit, strlen(pExit));
  newScr.AddElem(0);

  if (m_Flags & VPFI_AUTOENUMTC)
  {
    int n = 0;
    char *s = &newScr[0];
    while (true)
    {
      s = strstr(s, "TEXCOORDN");
      if (!s)
        break;
      s[8] = 0x30 + n;
      n++;
    }

    char *sNewStr = strstr(&newScr[0], "main");
    int nDepth = 0;
    if (sNewStr)
    {
      n = 0;
      while (true)
      {
        if (sNewStr[n] == '(')
        {
          nDepth++;
        }
        else
        if (sNewStr[n] == ')')
        {
          if (nDepth == 1)
          {
            n--;
            while (sNewStr[n] == 0x20 || sNewStr[n] == 9 || sNewStr[n] == 0xa) {n--;}
            if (sNewStr[n] == ',')
              sNewStr[n] = 0x20;
            break;
          }
          nDepth--;
        }
        n++;
      }
    }
  }

  SCGScript *cgs = mfAddNewScript(NULL, &newScr[0]);

  return cgs;
}

//===============================================================================
// TexGen / TexTransform modifications

static char *sEyeSpaceCamVecVP = 
{
  "float4 tcEPos = mul(ModelView, vPos);\n"
  "float3 tcCamVec = normalize(tcEPos.xyz);\n"
};
static char *sEyeSpaceNormal = 
{
  "float3 tcNormal = normalize(mul((float3x3)ModelViewIT, IN.TNormal.xyz));\n"
};
static char *sReflectVec = 
{
  "float3 tcRef = reflect(tcCamVec, tcNormal.xyz);\n"
};
static char *sSphereMapGenScriptVP[] = 
{
  sEyeSpaceCamVecVP,
  sEyeSpaceNormal,
  sReflectVec,
  {
    "float3 tcEm = tcRef + float3(0,0,1);\n"
    "tcEm.x = 2 * sqrt(dot(tcEm, tcEm));\n"
    "float4 tcSM = {0,0,0,1};\n"
    "tcSM.xy = tcRef.xy/tcEm.x + 0.5;\n"
  },
  NULL
};
static char *sReflectionMapGenScriptVP[] = 
{
  sEyeSpaceCamVecVP,
  sEyeSpaceNormal,
  sReflectVec,
  {
    "float4 tcRM;\n"
    "tcRM.xyz = tcRef.xyz;\n"
    "tcRM.w = vPos.w;\n"
  },
  NULL
};
static char *sNormalMapGenScriptVP[] = 
{
  sEyeSpaceNormal,
  {
    "float4 tcNM;\n"
    "tcNM.xyz = tcNormal.xyz;\n"
    "tcNM.w = vPos.w;\n"
  },
  NULL
};

char *CCGVProgram_GL::mfGenerateTCScript(char *Script, int nt)
{
  int tcGOLMask = VPVST_TCGOL0<<nt;
  int tcGRMMask = VPVST_TCGRM0<<nt;
  int tcGNMMask = VPVST_TCGNM0<<nt;
  int tcGSMMask = VPVST_TCGSM0<<nt;
  int tcMMask = VPVST_TCM0<<nt;
  int n, m;
  if (m_Insts[m_CurInst].m_Mask & (tcGOLMask | tcGRMMask | tcGNMMask | tcGSMMask | tcMMask))
  {
    if (!strstr(Script, "IN.TexCoord0") && !strstr(Script, "IN.baseTC"))
    {
      if (!(m_Insts[m_CurInst].m_Mask & (tcGOLMask | tcGRMMask | tcGNMMask | tcGSMMask)))
        return Script;
    }
    char sOTex[64];
    char sMTCG[64];
    char sMTCM[64];
    char sStr1[512];
    char sStr[512];
    sprintf(sOTex, "OUT.Tex%d", nt);
    char *svo;
    if (svo=strstr(Script, "vertout"))
    {
      char TC[32];
      sprintf(TC, "TEXCOORD%d", nt);
      n = 0;
      if (svo=strstr(svo, TC))
      {
        n--;
        while (svo[n]==0x20 || svo[n]==8 || svo[n]==':')
        {
          if (svo[n]==0xa)
            break;
          n--;
        }
        if (svo[n] != 0xa)
        {
          while (svo[n]!=0x20 && svo[n]!=8) { n--; }
          n++;
          m = 4;
          while (svo[n]!=0x20 && svo[n]!=8 && svo[n]!=':')
          {
            sOTex[m++] = svo[n];
            n++;
          }
          sOTex[m] = 0;
        }
      }
    }

    sprintf(sMTCG, "MatrixTCG%d", nt);
    sprintf(sMTCM, "MatrixTCM%d", nt);
    char *sNewStr = strstr(Script, sOTex);
    if (sNewStr)
    {
      bool bCamPos = false;
      bool bModV = false;
      bool bModVIT = false;
      if (m_Insts[m_CurInst].m_Mask & (tcGRMMask | tcGSMMask))
      {
        if (strstr(Script, "CameraPos"))
          bCamPos = true;
      }
      if (strstr(Script, "ModelViewIT"))
        bModVIT = true;
      char *sss = strstr(Script, "ModelView");
      while (sss)
      {
        if (sss[9]==',' || sss[9]==' ' || sss[9]==')' || sss[9]==0x9 || sss[9]==0xa)
        {
          bModV = true;
          break;
        }
        sss = strstr(sss+1, "ModelView");
      }

      char *sNStr = sNewStr;
      char sINTex[64];
      strcpy(sINTex, "IN.TexCoord0");
      while (sNStr = strstr(sNStr, sOTex))
      {
        n = 0;
        while (sNStr[n]!=0xa && sNStr[n]!=0)
        {
          if (sNStr[n] == '=')
          {
            sNStr[n] = 0x20;
            n++;
            while (sNStr[n]==0x20 || sNStr[n]==8) { n++; }
            m = 0;
            while (sNStr[n]!=';')
            {
              sINTex[m++] = sNStr[n];
              sINTex[m] = 0;
              sNStr[n++] = 0x20;
              if (sNStr[n]=='.' && m > 3)
                break;
            }
            while (sNStr[n]!=0xa && sNStr[n]!=0) {sNStr[n]=0x20; n++;}
            break;
          }
          sNStr[n]=0x20;
          n++;
        }
      }
      n = 0;
      while (sNewStr[n]!=0xa && sNewStr[n]!=0) {sNewStr[n]=0x20; n++;}

      // Add texgen code to the final VP
      char **pNewScripts = NULL;
      sStr1[0] = 0;
      if (m_Insts[m_CurInst].m_Mask & tcGOLMask)
        sprintf(sStr1,  "float4 tcOL = mul(%s, vPos);\n", sMTCG);
      else
      if (m_Insts[m_CurInst].m_Mask & tcGRMMask)
        pNewScripts = sReflectionMapGenScriptVP;
      else
      if (m_Insts[m_CurInst].m_Mask & tcGSMMask)
        pNewScripts = sSphereMapGenScriptVP;
      else
      if (m_Insts[m_CurInst].m_Mask & tcGNMMask)
        pNewScripts = sNormalMapGenScriptVP;
      if (pNewScripts)
      {
        n = 0;
        while(pNewScripts[n])
        {
          if (!strstr(Script, pNewScripts[n]))
          {
            strcat(sStr1, pNewScripts[n]);
          }
          n++;
        }
      }

      if (m_Insts[m_CurInst].m_Mask & tcMMask)
      {
        if (m_Insts[m_CurInst].m_Mask & tcGOLMask)
          sprintf(sStr, "%s %s = mul(%s, tcOL);\n", sStr1, sOTex, sMTCM);
        else
        if (m_Insts[m_CurInst].m_Mask & tcGRMMask)
          sprintf(sStr, "%s %s = mul(%s, tcRM);\n", sStr1, sOTex, sMTCM);
        else
        if (m_Insts[m_CurInst].m_Mask & tcGSMMask)
          sprintf(sStr, "%s %s = mul(%s, tcSM);\n", sStr1, sOTex, sMTCM);
        else
        if (m_Insts[m_CurInst].m_Mask & tcGNMMask)
          sprintf(sStr, "%s %s = mul(%s, tcNM);\n", sStr1, sOTex, sMTCM);
        else
          sprintf(sStr, "%s = mul(%s, %s);\n", sOTex, sMTCM, sINTex);
      }
      else
      {
        if (m_Insts[m_CurInst].m_Mask & tcGOLMask)
          sprintf(sStr, "%s %s = tcOL;\n", sStr1, sOTex);
        else
        if (m_Insts[m_CurInst].m_Mask & tcGRMMask)
          sprintf(sStr, "%s %s = tcRM;\n", sStr1, sOTex);
        else
        if (m_Insts[m_CurInst].m_Mask & tcGSMMask)
          sprintf(sStr, "%s %s = tcSM;\n", sStr1, sOTex);
        else
        if (m_Insts[m_CurInst].m_Mask & tcGNMMask)
          sprintf(sStr, "%s %s = tcNM;\n", sStr1, sOTex);
      }
      size_t len = strlen(sStr);
      size_t len2 = strlen(Script)+1;
      char *newScr2 = new char[len+len2];
      n = sNewStr-Script;
      strncpy(newScr2, Script, n);
      strcpy(&newScr2[n], sStr);
      strcpy(&newScr2[n+len], &Script[n]);
      delete [] Script;
      Script = newScr2;

      if (m_Insts[m_CurInst].m_Mask & (tcGOLMask | tcMMask | tcGRMMask | tcGSMMask | tcGNMMask))
      {
        sNewStr = strstr(Script, "main");
        if (sNewStr)
        {
          n = 0;
          while (sNewStr[n]!=0x20 && sNewStr[n]!=8 && sNewStr[n]!=0xa && sNewStr[n] != '(') {n++;}
          while (sNewStr[n]==0x20 || sNewStr[n]==8 || sNewStr[n]==0xa) {n++;}
          if (sNewStr[n] == '(')
          {
            int m = 0;
            n++;
            while (true)
            {
              if (sNewStr[n]==')')
              {
                if (!m)
                  break;
                m--;
              }
              if (sNewStr[n]=='(')
                m++;
              n++;
            }
            sStr[0] = 0;
            if (m_Insts[m_CurInst].m_Mask & tcMMask)
              sprintf(sStr,  ", uniform float4x4 %s\n", sMTCM);
            if (m_Insts[m_CurInst].m_Mask & tcGOLMask)
            {
              sprintf(sStr1,  ", uniform float4x4 %s\n", sMTCG);
              strcat(sStr, sStr1);
            }
            if (m_Insts[m_CurInst].m_Mask & (tcGRMMask | tcGSMMask))
            {
              if (!bCamPos)
              {
                sprintf(sStr1,  ", uniform float4 CameraPos\n");
                strcat(sStr, sStr1);
              }
              if (!bModV)
              {
                sprintf(sStr1,  ", uniform float4x4 ModelView\n");
                strcat(sStr, sStr1);
              }
              if (!bModVIT)
              {
                sprintf(sStr1,  ", uniform float4x4 ModelViewIT\n");
                strcat(sStr, sStr1);
              }
            }
            if (m_Insts[m_CurInst].m_Mask & tcGNMMask)
            {
              if (!bModVIT)
              {
                sprintf(sStr1,  ", uniform float4x4 ModelViewIT\n");
                strcat(sStr, sStr1);
              }
            }
            len = strlen(sStr);
            size_t len2 = strlen(Script)+1;
            char *newScr2 = new char[len+len2];
            n = sNewStr-Script+n;
            strncpy(newScr2, Script, n);
            strcpy(&newScr2[n], sStr);
            strcpy(&newScr2[n+len], &Script[n]);
            delete [] Script;
            Script = newScr2;
          }
        }
      }

      if (m_Insts[m_CurInst].m_Mask & (tcGRMMask | tcGNMMask | tcGSMMask))
      {
        if (!strstr(Script, ": NORMAL"))
        {
          while (true)
          {
            sNewStr = strstr(Script, "appin");
            if (!sNewStr)
              break;
            n = 0;
            while (sNewStr[n]!=0x20 && sNewStr[n]!=8 && sNewStr[n]!=0xa && sNewStr[n] != '{') {n++;}
            while (sNewStr[n]==0x20 || sNewStr[n]==8 || sNewStr[n]==0xa) {n++;}
            if (sNewStr[n] == '{')
            {
              n++;
              while (sNewStr[n]==0x20 || sNewStr[n]==8 || sNewStr[n]==0xa) {n++;}
              len = strlen("float3 TNormal : NORMAL;\n");
              size_t len2 = strlen(Script)+1;
              char *newScr2 = new char[len+len2];
              n = sNewStr-Script+n;
              strncpy(newScr2, Script, n);
              strcpy(&newScr2[n], "float3 TNormal : NORMAL;\n");
              strcpy(&newScr2[n+len], &Script[n]);
              delete [] Script;
              Script = newScr2;
              break;
            }
          }
        }
      }
    }
  }
  return Script;
}

char *CCGVProgram_GL::mfCreateAdditionalVP(CVProgram *pPosVP)
{
  SCGScript *pScript = m_Script;
  if (!pScript)
    pScript = mfGenerateScriptVP(pPosVP);
  if (!pScript)
    return NULL;
  const char *scr = pScript->m_Script;
  int len, n;

  char *sNewStr = pScript->m_Script;
  int Mask = m_Insts[m_CurInst].m_Mask;
  if (Mask & VPVST_CLIPPLANES3)
  {
    char *s = strstr(sNewStr, "vertout");
    if (s && strstr(s, "TEXCOORD3"))
    {
      //m_Flags |= VPFI_NOFAKECLIPPLANE;
      Mask &= ~VPVST_CLIPPLANES3;
    }
  }
  while (true)
  {
    sNewStr = strstr(sNewStr, "return");
    if (!sNewStr)
    {
      len = strlen(pScript->m_Script)+1;
      sNewStr = new char[len];
      strcpy(sNewStr, pScript->m_Script);
      return sNewStr;
    }
    n = 0;
    while (sNewStr[n]!=0x20 && sNewStr[n]!=8 && sNewStr[n]!=0xa) {n++;}
    while (sNewStr[n]==0x20 || sNewStr[n]==8 || sNewStr[n]==0xa) {n++;}
    if (!strncmp(&sNewStr[n], "OUT", 3))
      break;
    sNewStr += n;
  }

  n = sNewStr - pScript->m_Script;
  len = strlen(pScript->m_Script)+1;
  int lenN = strlen(sAdditionalVP[Mask&7]);
  int newSize = n+1+lenN;
  char *newScr = new char [newSize];
  strncpy(newScr, scr, n);
  strcpy(&newScr[n], sAdditionalVP[Mask&7]);

  if ((Mask & VPVST_NOISE) && !strstr(newScr, "register(c30)"))
  {
    sNewStr = newScr;
    while (true)
    {
      sNewStr = strstr(sNewStr, "main");
      if (!sNewStr)
        break;
      n = 0;
      while (sNewStr[n]!=0x20 && sNewStr[n]!=8 && sNewStr[n]!=0xa && sNewStr[n] != '(') {n++;}
      while (sNewStr[n]==0x20 || sNewStr[n]==8 || sNewStr[n]==0xa) {n++;}
      if (sNewStr[n] == '(')
      {
        int m = 0;
        n++;
        while (true)
        {
          if (sNewStr[n]==')')
          {
            if (!m)
              break;
            m--;
          }
          if (sNewStr[n]=='(')
            m++;
          n++;
        }
        len = strlen(", uniform float4 pg[66] : register(c30)");
        int len2 = strlen(newScr)+1;
        char *newScr2 = new char[len+len2];
        n = sNewStr-newScr+n;
        strncpy(newScr2, newScr, n);
        strcpy(&newScr2[n], ", uniform float4 pg[66] : register(c30)");
        strcpy(&newScr2[n+len], &newScr[n]);
        delete [] newScr;
        newScr = newScr2;
        break;
      }
    }
  }

  if (!(Mask & VPVST_NOFOG))
  {
    sNewStr = newScr;
    while (true)
    {
      sNewStr = strstr(sNewStr, "vertout");
      if (!sNewStr)
        break;
      n = 0;
      while (sNewStr[n]!=0x20 && sNewStr[n]!=9 && sNewStr[n]!=8 && sNewStr[n]!=0xa && sNewStr[n] != '{') {n++;}
      while (sNewStr[n]==0x20 || sNewStr[n]==9 || sNewStr[n]==8 || sNewStr[n]==0xa) {n++;}
      if (sNewStr[n] == '{')
      {
        n++;
        while (sNewStr[n]==0x20 || sNewStr[n]==8 || sNewStr[n]==0xa) {n++;}
        len = strlen("float FogC : FOG;\n");
        int len2 = strlen(newScr)+1;
        char *newScr2 = new char[len+len2];
        n = sNewStr-newScr+n;
        strncpy(newScr2, newScr, n);
        strcpy(&newScr2[n], "float FogC : FOG;\n");
        strcpy(&newScr2[n+len], &newScr[n]);
        delete [] newScr;
        newScr = newScr2;
      }
      break;
    }
  }
  if (Mask & VPVST_CLIPPLANES3)
  {
    sNewStr = newScr;
    while (true)
    {
      sNewStr = strstr(sNewStr, "main");
      if (!sNewStr)
        break;
      n = 0;
      while (sNewStr[n]!=0x20 && sNewStr[n]!=8 && sNewStr[n]!=0xa && sNewStr[n] != '(') {n++;}
      while (sNewStr[n]==0x20 || sNewStr[n]==8 || sNewStr[n]==0xa) {n++;}
      if (sNewStr[n] == '(')
      {
        int m = 0;
        n++;
        while (true)
        {
          if (sNewStr[n]==')')
          {
            if (!m)
              break;
            m--;
          }
          if (sNewStr[n]=='(')
            m++;
          n++;
        }
        len = strlen(", uniform float4 ClipPlane");
        int len2 = strlen(newScr)+1;
        char *newScr2 = new char[len+len2];
        n = sNewStr-newScr+n;
        strncpy(newScr2, newScr, n);
        strcpy(&newScr2[n], ", uniform float4 ClipPlane");
        strcpy(&newScr2[n+len], &newScr[n]);
        delete [] newScr;
        newScr = newScr2;
        break;
      }
    }
    sNewStr = newScr;
  }
  sNewStr = newScr;
  while (true)
  {
    sNewStr = strstr(sNewStr, "main");
    if (!sNewStr)
      break;
    n = 0;
    while (sNewStr[n]!=0x20 && sNewStr[n]!=8 && sNewStr[n]!=0xa && sNewStr[n] != '(') {n++;}
    while (sNewStr[n]==0x20 || sNewStr[n]==8 || sNewStr[n]==0xa) {n++;}
    if (sNewStr[n] == '(')
    {
      int m = 0;
      n++;
      while (true)
      {
        if (sNewStr[n]==')')
        {
          if (!m)
            break;
          m--;
        }
        if (sNewStr[n]=='(')
          m++;
        n++;
      }
      len = strlen(", uniform float4 g_VSCONST_0_025_05_1 : register(c28)");
      int len2 = strlen(newScr)+1;
      char *newScr2 = new char[len+len2];
      n = sNewStr-newScr+n;
      strncpy(newScr2, newScr, n);
      strcpy(&newScr2[n], ", uniform float4 g_VSCONST_0_025_05_1 : register(c28)");
      strcpy(&newScr2[n+len], &newScr[n]);
      delete [] newScr;
      newScr = newScr2;
      break;
    }
  }

  if (Mask & VPVST_TCMASK)
  {
    for (int i=0; i<4; i++)
    {
      newScr = mfGenerateTCScript(newScr, i);
    }
  }

  if (pScript != m_Script)
    pScript->Release();

  return newScr;
}

void CCGVProgram_GL::mfCompileParam4f(char *scr, SShader *ef, TArray<SCGParam4f> *Params)
{
  gRenDev->m_cEF.mfCompileCGParam(scr, ef, Params);
}

void CCGVProgram_GL::mfCompileParamStateMatrix(char *scr, SShader *ef, TArray<SCGMatrix> *Params)
{
  char* name;
  long cmd;
  char *params;
  char *data;

  enum {eType=1, eName};
  static tokenDesc commands[] =
  {
    {eType, "Type"},
    {eName, "Name"},

    {0,0}
  };

  SCGMatrix pr;
  pr.m_dwBind = 0;
  while ((cmd = shGetObject (&scr, commands, &name, &params)) > 0)
  {
    data = NULL;
    if (name)
      data = name;
    else
    if (params)
      data = params;

    switch (cmd)
    {
      case eName:
        pr.m_Name = data;
        break;

      case eType:
        if (!stricmp(data, "ViewProj"))
          pr.m_eCGParamType = ECGP_Matr_ViewProj;
        else
        if (!stricmp(data, "View"))
          pr.m_eCGParamType = ECGP_Matr_View;
        else
        if (!stricmp(data, "View_I"))
          pr.m_eCGParamType = ECGP_Matr_View_I;
        else
        if (!stricmp(data, "View_T"))
          pr.m_eCGParamType = ECGP_Matr_View_T;
        else
        if (!stricmp(data, "View_IT"))
          pr.m_eCGParamType = ECGP_Matr_View_IT;
        else
          pr.m_eCGParamType = ECGP_Unknown;
    }
  }
  if (pr.m_eCGParamType != ECGP_Unknown && pr.m_Name.GetIndex())
    Params->AddElem(pr);
}

void CCGVProgram_GL::mfCompileVertAttributes(char *scr, SShader *ef)
{
  char* name;
  long cmd;
  char *params;
  char *data;

  enum {eVertArray=1};
  static tokenDesc commands[] =
  {
    {eVertArray, "VertArray"},

    {0,0}
  };

  while ((cmd = shGetObject (&scr, commands, &name, &params)) > 0)
  {
    data = NULL;
    if (name)
      data = name;
    else
    if (params)
      data = params;

    switch (cmd)
    {
      case eVertArray:
        {
          if (!data || !data[0])
          {
            iLog->Log("Warning: Missing parameters for VertArray in Shader '%s'\n", ef->m_Name.c_str());
            break;
          }
          gRenDev->m_cEF.mfCompileArrayPointer(m_Pointers, params, ef);
        }
        break;
    }
  }
}

bool CCGVProgram_GL::mfCompile(char *scr)
{
  char* name;
  long cmd;
  char *params;
  char *data;

  enum {eScript=1, eParam4f, eParamStateMatrix, eVS20Only, eVS30Only, eAutoEnumTC, eProjected, eDefaultPos, eNoFog, eNoise, eUnifiedPosScript, eVertAttributes, eMainInput, eSubrScript, eDeclarationsScript, ePositionScript, eCoreScript, eSupportsInstancing, eSupportsMultiLights, eInst_Param4f, eNoSpecular};
  static tokenDesc commands[] =
  {
    {eScript, "Script"},
    {eAutoEnumTC, "AutoEnumTC"},
    {eParam4f, "Param4f"},
    {eParamStateMatrix, "ParamStateMatrix"},
    {eVertAttributes, "VertAttributes"},
    {eMainInput, "MainInput"},
    {eDeclarationsScript, "DeclarationsScript"},
    {ePositionScript, "PositionScript"},
    {eCoreScript, "CoreScript"},
    {eSubrScript, "SubrScript"},
    {eNoFog, "NoFog"},
    {eNoise, "Noise"},
    {eVS20Only, "VS20Only"},
    {eVS30Only, "VS30Only"},
    {eProjected, "Projected"},
    {eUnifiedPosScript, "UnifiedPosScript"},
    {eDefaultPos, "DefaultPos"},
    {eNoSpecular, "NoSpecular"},

    {eSupportsInstancing, "SupportsInstancing"},
    {eSupportsMultiLights, "SupportsMultiLights"},
    {eInst_Param4f, "Inst_Param4f"},

    {0,0}
  };

  mfFree();

  SShader *ef = gRenDev->m_cEF.m_CurShader;

  while ((cmd = shGetObject (&scr, commands, &name, &params)) > 0)
  {
    data = NULL;
    if (name)
      data = name;
    else
    if (params)
      data = params;

    switch (cmd)
    {
      case eVertAttributes:
        mfCompileVertAttributes(params, ef);
        break;

      case eMainInput:
        m_InputParmsScript = mfAddNewScript(name, params);
        break;

      case eDeclarationsScript:
        m_DeclarationsScript = mfAddNewScript(name, params);
        break;

      case ePositionScript:
        if (strchr(params, ';'))
          m_PosScript = mfAddNewScript(name, params);
        else
        {
          m_PosScript = mfAddNewScript(params, NULL);
          if (!m_PosScript)
            m_PosScript = mfAddNewScript("PosCommon", NULL);
        }
        break;

      case eCoreScript:
        m_CoreScript = mfAddNewScript(name, params);
        break;

      case eSubrScript:
        m_SubroutinesScript = mfAddNewScript(name, params);
        break;

      case eParam4f:
        mfCompileParam4f(params, ef, &m_ParamsNoObj);
        break;

      case eInst_Param4f:
        mfCompileParam4f(params, ef, &m_Params_Inst);
        break;

      case eParamStateMatrix:
        mfCompileParamStateMatrix(params, ef, &m_MatrixObj);
        break;

      case eNoFog:
        m_Flags |= VPFI_NOFOG;
        break;

      case eNoSpecular:
        m_Flags |= VPFI_NOSPECULAR;
        break;

      case eNoise:
        m_Flags |= VPFI_NOISE;
        break;

      case eAutoEnumTC:
        m_Flags |= VPFI_AUTOENUMTC;
        break;

      case eSupportsInstancing:
        m_Flags |= VPFI_SUPPORTS_INSTANCING;
        break;

      case eSupportsMultiLights:
        m_Flags |= VPFI_SUPPORTS_MULTILIGHTS;
        break;

      case eProjected:
        if (gRenDev->GetFeatures() & RFT_HW_ENVBUMPPROJECTED)
          m_Flags |= VPFI_PROJECTED;
        break;

      case eVS20Only:
        m_Flags |= VPFI_VS20ONLY;
        if (m_CGProfileType == CG_PROFILE_VP20)
        {
#ifndef WIN64
					// NOTE: AMD64 port: find the 64-bit CG runtime
          m_CGProfileType = cgGLGetLatestProfile(CG_GL_VERTEX);
#endif
          if (SUPPORTS_GL_ARB_vertex_program)
            m_CGProfileType = CG_PROFILE_ARBVP1;
        }
        break;

      case eVS30Only:
        m_Flags |= VPFI_VS20ONLY;
        break;

      case eDefaultPos:
        m_Flags |= VPFI_DEFAULTPOS;
        break;

      case eUnifiedPosScript:
        m_Flags |= VPFI_UNIFIEDPOS;
        break;

      case eScript:
        {
          SAFE_RELEASE(m_Script);
          m_Script = mfAddNewScript(NULL, data);
        }
        break;
    }
  }
  int i;
  for (i=0; i<m_MatrixObj.Num(); i++)
  {
    SCGMatrix *m = &m_MatrixObj[i];
    if (m->m_eCGParamType == ECGP_Matr_ViewProj)
      break;
  }
  if (i == m_MatrixObj.Num())
  {
    SCGMatrix m;
    m.m_eCGParamType = ECGP_Matr_ViewProj;
    m.m_Name = "ModelViewProj";
    m_MatrixObj.AddElem(m);
    m_MatrixObj.Shrink();
  }

  gRenDev->m_cEF.mfCheckObjectDependParams(&m_ParamsNoObj, &m_ParamsObj);

  return 1;
}

void CCGVProgram_GL::mfSetVariables(TArray<SCGParam4f>* Vars)
{
  int i;

  for (i=0; i<Vars->Num(); i++)
  {
    SCGParam4f *p = &Vars->Get(i);
    if (p->m_nComponents > 1)
    {
      float matr[16][4];
      int nLast = i+p->m_nComponents;
      assert(nLast <= Vars->Num());
      int n = 0;
      for (; i<nLast; i++, n++)
      {
        SCGParam4f *Param = &Vars->Get(i);
        float *v = Param->mfGet();
        matr[n][0] = v[0]; matr[n][1] = v[1]; matr[n][2] = v[2]; matr[n][3] = v[3];      	
      }
      i--;
      mfParameter(p, &matr[0][0], p->m_nComponents);
    }
    else
    {
      float *v = p->mfGet();
      mfParameter4f(p, v);
    }
  }
}

void CCGVProgram_GL::mfSetVariables(bool bObj, TArray<SCGParam4f>* Parms)
{
  if (m_Insts[m_CurInst].m_dwHandle <= 0)
    return;

  //PROFILE_FRAME(Shader_VShadersParms);

  if (!bObj)
  {
    if (m_ParamsNoObj.Num())
      mfSetVariables(&m_ParamsNoObj);

    if (m_Insts[m_CurInst].m_ParamsNoObj)
      mfSetVariables(m_Insts[m_CurInst].m_ParamsNoObj);
  }
  else
  {
    if (m_ParamsObj.Num())
      mfSetVariables(&m_ParamsObj);

    if (m_Insts[m_CurInst].m_ParamsObj)
      mfSetVariables(m_Insts[m_CurInst].m_ParamsObj);
  }

  if (Parms)
    mfSetVariables((TArray<SCGParam4f> *)Parms);
}

void CCGVProgram_GL::mfSetPointers(int nFlags)
{
  int nType = 0;
  if (nFlags & VPF_SETPOINTERSFORPASS)
    nType = 1;
  for (int i=0; i<m_Pointers.Num(); i++)
  {
    SArrayPointer *vp = m_Pointers[i];
    vp->mfSet(nType);
  }
}

/* returns a random floating point number between 0.0 and 1.0 */
static float frand()
{
    return (float) (rand() / (float) RAND_MAX);
}

/* returns a random floating point number between -1.0 and 1.0 */
static float sfrand()
{
    return (float) (rand() * 2.0f/ (float) RAND_MAX) - 1.0f;
}

void CCGVProgram_GL::mfGetSrcFileName(char *srcname, int nSize)
{
  strncpy(srcname, gRenDev->m_cEF.m_HWPath, nSize);
  strncat(srcname, "Declarations/CGVShaders/", nSize);
  strncat(srcname, m_Name.c_str(), nSize);
  strncat(srcname, ".crycg", nSize);
}

void CCGVProgram_GL::mfGetDstFileName(char *dstname, int nSize)
{
  char *type;
  if (m_Flags & VPFI_AUTOENUMTC)
    type = "GL_Auto";
  else
  if (m_CGProfileType == CG_PROFILE_VP20)
    type = "NV";
  else
  if (m_CGProfileType == CG_PROFILE_ARBVP1)
    type = "ARB";
  else
    type = "Unknown";

  char *fog;
  if (m_Insts[m_CurInst].m_Mask & VPVST_FOGGLOBAL)
    fog = "Fog";
  else
  if (m_Insts[m_CurInst].m_Mask & VPVST_NOFOG)
    fog = "NoFog";
  
  char *cp;
  if (m_Insts[m_CurInst].m_Mask & VPVST_CLIPPLANES3)
    cp = "CP";
  else
    cp = "NoCP";

  char *pr = "";
  if (m_Flags & VPFI_PROJECTED)
    pr = "Proj";

  strncpy(dstname, gRenDev->m_cEF.m_ShadersCache, nSize);
  strncat(dstname, "CGVShaders/", nSize);
  strncat(dstname, m_Name.c_str(), nSize);
  strncat(dstname, "$", nSize);
  strncat(dstname, type, nSize);
  strncat(dstname, "$", nSize);
  strncat(dstname, fog, nSize);
  strncat(dstname, "$", nSize);
  strncat(dstname, cp, nSize);
  if (pr[0])
  {
    strncat(dstname, "$", nSize);
    strncat(dstname, pr, nSize);
  }
  strncat(dstname, "#", nSize);
  strncat(dstname, m_Insts[m_CurInst].m_PosScriptName.c_str(), nSize);

  for (int i=0; i<4; i++)
  {
    char str[64];
    if (m_Insts[m_CurInst].m_Mask & (VPVST_TCM0<<i))
    {
      sprintf(str, "$TCM%d", i);
      strncat(dstname, str, nSize);
    }
    if (m_Insts[m_CurInst].m_Mask & (VPVST_TCGOL0<<i))
    {
      sprintf(str, "$TCGOL%d", i);
      strncat(dstname, str, nSize);
    }
    if (m_Insts[m_CurInst].m_Mask & (VPVST_TCGRM0<<i))
    {
      sprintf(str, "$TCGRM%d", i);
      strncat(dstname, str, nSize);
    }
    if (m_Insts[m_CurInst].m_Mask & (VPVST_TCGNM0<<i))
    {
      sprintf(str, "$TCGNM%d", i);
      strncat(dstname, str, nSize);
    }
    if (m_Insts[m_CurInst].m_Mask & (VPVST_TCGSM0<<i))
    {
      sprintf(str, "$TCGSM%d", i);
      strncat(dstname, str, nSize);
    }
  }

  if (m_nMaskGen)
  {
    char str[32];
    sprintf(str, "(%x)", m_nMaskGen);
    strncat(dstname, str, nSize);
  }

  strncat(dstname, ".cgvp", nSize);
}

static char *sGetText(char **buf)
{
  bool bBetween = false;
  SkipCharacters(buf, " ");
  if (**buf == ':')
  {
    ++*buf;
    SkipCharacters(buf, " ");
    if (**buf == ':')
      return NULL;
  }
  char *result = *buf;

  // now, we need to find the next whitespace to end the data
  char theChar;

  while ((theChar = **buf) != 0)
  {
    if (theChar <= 0x20)        // space and control chars
      break;
    ++*buf;
  }
  **buf = 0;                    // null terminate it
  if (theChar)                  // skip the terminator
    ++*buf;
  return result;
}

struct STempStr
{
  char name[128];
  int nComponents;
  int nId;
};

bool CCGVProgram_GL::mfActivate(CVProgram *pPosVP)
{
  if (!m_Insts[m_CurInst].m_dwHandle)
  {
    int VS20Profile = CG_PROFILE_ARBVP1;

    if (m_Flags & VPFI_VS30ONLY)
    {
      if (gRenDev->GetFeatures() & RFT_HW_PS30)
        m_CGProfileType = CG_PROFILE_ARBVP2;
      else
      if (gRenDev->GetFeatures() & RFT_HW_PS20)
        m_CGProfileType = VS20Profile;
      else
        m_CGProfileType = CG_PROFILE_VP20;
    }
    else
    if (m_Flags & VPFI_VS20ONLY)
    {
      if (gRenDev->GetFeatures() & RFT_HW_PS20)
        m_CGProfileType = VS20Profile;
      else
        m_CGProfileType = CG_PROFILE_VP20;
    }
    else
    if (SUPPORTS_GL_NV_vertex_program)
      m_CGProfileType = CG_PROFILE_VP20;
    else
    if (SUPPORTS_GL_ARB_vertex_program)
      m_CGProfileType = VS20Profile;
    if (m_CGProfileType == CG_PROFILE_VP20 && !SUPPORTS_GL_NV_vertex_program)
      return false;
    if (m_CGProfileType == CG_PROFILE_ARBVP1 && !SUPPORTS_GL_ARB_vertex_program)
      return false;

    if (m_Insts[m_CurInst].m_Mask & (VPVST_INSTANCING_NOROT | VPVST_INSTANCING_ROT))
    {
      if (m_CGProfileType < CG_PROFILE_ARBVP1)
        m_CGProfileType = VS20Profile;
    }

    char strVer[128];
    char strVer0[128];
    sprintf(strVer, "//CGVER%.1f\n", CG_VP_CACHE_VER);
    bool bCreate = false;
    char namesrc[256];
    char namedst[256];
    char namedst1[256];
    FILETIME writetimesrc,writetimedst;
    FILE *statussrc, *statusdst;
    statussrc = NULL;
    statusdst = NULL;
    mfGetSrcFileName(namesrc, 256);
    CCGVProgram_GL *pVP = (CCGVProgram_GL *)pPosVP;
    mfGetDstFileName(namedst, 256);
    StripExtension(namedst, namedst1);
    AddExtension(namedst1, ".cgasm");
    statusdst = iSystem->GetIPak()->FOpen(namedst1, "r");
    if (statusdst == NULL)
    {
      if (CRenderer::CV_r_shadersprecache == 2)
        bCreate = true;
      else
      {
        statusdst = iSystem->GetIPak()->FOpen(namedst, "r");
        if (statusdst == NULL)
          bCreate = true;
        else
        {
          statussrc = iSystem->GetIPak()->FOpen(namesrc, "r");
          writetimesrc = iSystem->GetIPak()->GetModificationTime(statussrc);
          writetimedst = iSystem->GetIPak()->GetModificationTime(statusdst);;
          if (CompareFileTime(&writetimesrc, &writetimedst) != 0)
            bCreate = true;
          iSystem->GetIPak()->FGets(strVer0, 128, statusdst);
          if (strcmp(strVer, strVer0))
            bCreate = true;
          iSystem->GetIPak()->FClose(statussrc);
        }
      }
    }
    else
      strcpy(namedst, namedst1);
create:
    if (bCreate)
    {
      char *scr;
      scr = mfCreateAdditionalVP(pPosVP);

      const char *code = mfLoadCG(scr);
      delete [] scr;
      if (m_CGProfileType == CG_PROFILE_ARBVP1)
      {
        char *cd = (char *)code;
        while (cd)
        {
          cd = (char*)strstr(code, "program.local");
          if (cd)
          {
            memcpy(cd, "  program.env", 13);
            cd += 13;
          }
        }
      }

      if (code)
      {
        FILE *fp = fopen(namedst, "wb");
        if (fp)
        {
          fputs(strVer, fp);
          fputs(code, fp);
          fclose(fp);
        }
        HANDLE hdst = CreateFile(namedst,GENERIC_WRITE,FILE_SHARE_READ, NULL,OPEN_EXISTING,FILE_FLAG_SEQUENTIAL_SCAN,NULL);
        FILE *hsrc = iSystem->GetIPak()->FOpen(namesrc, "r");
        writetimesrc = iSystem->GetIPak()->GetModificationTime(hsrc);
        SetFileTime(hdst,NULL,NULL,&writetimesrc);
        iSystem->GetIPak()->FClose(hsrc);
        CloseHandle(hdst);
        delete [] code;
      }
      else
      {
#ifdef WIN64
        iLog->LogError ("\002 Can't create CG vertex program '%s' (cache name: %s): NO CG Runtime in 64-bit version", m_Name.c_str(), namedst);
#endif
        m_Insts[m_CurInst].m_dwHandle = 0;
      }
      statusdst = iSystem->GetIPak()->FOpen(namedst, "r");
    }
    if (!statusdst)
      return false;
    else
    {
      iSystem->GetIPak()->FSeek(statusdst, 0, SEEK_END);
      int len = iSystem->GetIPak()->FTell(statusdst);
      iSystem->GetIPak()->FSeek(statusdst, 0, SEEK_SET);
      char *pbuf = new char [len+1];
      iSystem->GetIPak()->FGets(strVer0, 128, statusdst);
      len = iSystem->GetIPak()->FRead(pbuf, 1, len, statusdst);
      pbuf[len] = 0;
      iSystem->GetIPak()->FClose(statusdst);
      statusdst = NULL;

      if (!bCreate && (m_Flags & PSFI_AUTOENUMTC))
      {
        if (strstr(pbuf, "!!ARBvp1.0"))
        {
          if (!SUPPORTS_GL_ARB_vertex_program)
          {
            bCreate = true;
            goto create;
          }
          m_CGProfileType = CG_PROFILE_ARBVP1;
        }
        else
        {
          if (!SUPPORTS_GL_NV_vertex_program)
          {
            bCreate = true;
            goto create;
          }
          m_CGProfileType = CG_PROFILE_VP20;
        }
      }

      RemoveCR(pbuf);
      mfLoad(pbuf);

      // parse variables and constants from CG object code
      /*if (m_CGProfileType == CG_PROFILE_ARBVP1)
      {
        char *scr = pbuf;
        char *token = strstr(scr, "PARAM");
        while (token)
        {
          int n = 0;
          while (token[n]!=0x20 && token[n]!=8) { n++; }
          while (token[n]==0x20 || token[n]==8) { n++; }
          token += n;
          if (token[0] == 'c')
          {
            int nBind = atoi(&token[1]);
            n = 0;
            while (token[n]!=0x20 && token[n]!=8) { n++; }
            while (token[n]==0x20 || token[n]==8) { n++; }
            token += n;
            if (token[0] == '=')
            {
              n = 1;
              while (token[n]==0x20 || token[n]==8) { n++; }
              token += n;
              if (token[0] == '{')
              {
                float v[4];
                n = sscanf(&token[1], "%f, %f, %f, %f", &v[0], &v[1], &v[2], &v[3]);
                if (n == 4)
                {
                  if (!m_Insts[m_CurInst].m_BindConstants)
                    m_Insts[m_CurInst].m_BindConstants = new TArray<SCGBindConst>;
                  SCGBindConst cgp;
                  cgp.m_dwBind = nBind;
                  cgp.m_nComponents = 1;
                  cgp.m_Val[0] = v[0];
                  cgp.m_Val[1] = v[1];
                  cgp.m_Val[2] = v[2];
                  cgp.m_Val[3] = v[3];
                  m_Insts[m_CurInst].m_BindConstants->AddElem(cgp);
                }
              }
            }
          }
          token = strstr(token, "PARAM");
        }
      }*/
      int nComps = 1;
      char *scr = pbuf;
      char *token = strtok(scr, "#");
      TArray<STempStr> FoundNames;
      int i;
      while (token)
      {
        if (!strncmp(token, "const", 5))
        {
          token += 5;
          char *szhReg = sGetText(&token);
          char *szEqual = sGetText(&token);

          char *szF0 = sGetText(&token);
          char *szF1 = sGetText(&token);
          char *szF2 = sGetText(&token);
          char *szF3 = sGetText(&token);

          if (!m_Insts[m_CurInst].m_BindConstants)
            m_Insts[m_CurInst].m_BindConstants = new TArray<SCGBindConst>;
          SCGBindConst cgp;
          cgp.m_nComponents = 1;
          cgp.m_Val[0] = (float)atof(szF0);
          cgp.m_Val[1] = (float)atof(szF1);
          cgp.m_Val[2] = (float)atof(szF2);
          cgp.m_Val[3] = (float)atof(szF3);
          cgp.m_dwBind = atoi(&szhReg[2]);
          m_Insts[m_CurInst].m_BindConstants->AddElem(cgp);
        }
        else
        if (!strncmp(token, "var", 3))
        {
          token += 3;
          char *szType = sGetText(&token);
          char *szName = sGetText(&token);
          int n = 0;
          if (szName)
          {
            char *s = strchr(szName, '[');
            if (s)
              s[0] = 0;
            int i;
            for (i=0; i<FoundNames.Num(); i++)
            {
              if (!stricmp(szName, FoundNames[i].name))
              {
                FoundNames[i].nComponents = atol(&s[1])+1;
                break;
              }
            }
            if (i != FoundNames.Num())
              continue;
            STempStr name;
            strcpy(name.name, szName);
            n = FoundNames.Num();
            FoundNames.AddElem(name);
            FoundNames[n].nId = -1;
          }
          char *szvAttr = sGetText(&token);
          char *szhReg = sGetText(&token);
          int len = strlen(szhReg);
          if (szhReg[len-1] == ',')
          {
            char *sznComps = sGetText(&token);
            nComps = atoi(sznComps);
          }
          else
            nComps = 1;
          char *szVarType = sGetText(&token);
          char *sznVar = sGetText(&token);
          if (!szvAttr || szvAttr[0] != '$')
          {
            if (!m_Insts[m_CurInst].m_BindVars)
              m_Insts[m_CurInst].m_BindVars = new TArray<SCGBind>;
            SCGBind cgp;
            cgp.m_nComponents = nComps;
            cgp.m_Name = szName;
            cgp.m_dwBind = atoi(&szhReg[2]);
            FoundNames[n].nId = m_Insts[m_CurInst].m_BindVars->Num();
            FoundNames[n].nComponents = nComps;
            m_Insts[m_CurInst].m_BindVars->AddElem(cgp);
          }
        }
        token = strtok(NULL, "#");
      }
      SAFE_DELETE_ARRAY(pbuf);
      for (i=0; i<FoundNames.Num(); i++)
      {
        if (FoundNames[i].nId >= 0)
          m_Insts[m_CurInst].m_BindVars->Get(FoundNames[i].nId).m_nComponents = FoundNames[i].nComponents;
      }
    }

    mfUnbind();

    if (!m_bCreateNoise)
    {
      m_bCreateNoise = true;

      // create a perlin noise permuation table
	    vec4_t c[32*2+2];
	    int i;

	    // want reproducable behaviour for debug
	    //srand(1);

	    for(i=0; i<32; i++) 
	    {
		    c[i][3] = (float)i;
        Vec3d v;
		    v[0] = frand();
		    v[1] = frand();
		    v[2] = frand();
        v.Normalize();
        c[i][0] = v[0];
        c[i][1] = v[1];
        c[i][2] = v[2];
	    }

	    for(i=0; i<32; i++) 
	    {
		    // choose two entries at random and swap
		    int j = (rand() >> 4) & 31;		// lower bits of rand() are bogus sometimes
		    Exchange (c[j][3], c[i][3]);
        c[i+32][0] = c[i][0];
        c[i+32][1] = c[i][1];
        c[i+32][2] = c[i][2];
	    }

      if (m_CGProfileType == CG_PROFILE_ARBVP1)
      {
	      for(i=0; i<64; i++) 
	      {
          glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 30+i, &c[i][0]);
	      }
        glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 30+i,   &c[0][0]);
        glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 30+i+1, &c[1][0]);
        glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, VSCONST_0_025_05_1, 0, 0.25f, 0.5f, 1.0f);
      }
      else
      {
        for(i=0; i<64; i++) 
        {
          glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 30+i, &c[i][0]);
        }
        glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 30+i,   &c[0][0]);
        glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 30+i+1, &c[1][0]);
        glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, VSCONST_0_025_05_1, 0, 0.25f, 0.5f, 1.0f);
      }
    }
  }

  if (!m_Insts[m_CurInst].m_dwHandle)
    return false;
  return true;
}

void CCGVProgram_GL::mfSetGlobalParams()
{
  vec4_t v;
  int n;
  CGLRenderer *r = gcpOGL;
  if (!(r->m_Features & RFT_HW_VS))
    return;

  v[0] = 0; v[1] = 0.25f; v[2] = 0.5f; v[3] = 1.0f;
  n = VSCONST_0_025_05_1;
  //if (m_CurParams[n][0] != v[0] || m_CurParams[n][1] != v[1] || m_CurParams[n][2] != v[2] || m_CurParams[n][3] != v[3])
  {
    m_CurParams[n][0] = v[0];
    m_CurParams[n][1] = v[1];
    m_CurParams[n][2] = v[2];
    m_CurParams[n][3] = v[3];
    if (SUPPORTS_GL_ARB_vertex_program)
      glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, n, m_CurParams[n]);
    else
      glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, n, m_CurParams[n]);
  }

  if ((gRenDev->m_Features & RFT_HW_HDR) || (r->m_Features & RFT_HW_PS30))
  {
    n = PSCONST_HDR_FOGCOLOR;
    //if (m_CurParams[n][0] != v[0] || m_CurParams[n][1] != v[1] || m_CurParams[n][2] != v[2] || m_CurParams[n][3] != v[3])
    {
      m_CurParams[n][0] = r->m_FS.m_FogColor[0];
      m_CurParams[n][1] = r->m_FS.m_FogColor[1];
      m_CurParams[n][2] = r->m_FS.m_FogColor[2];
      m_CurParams[n][3] = r->m_FS.m_FogColor[3];
      if (SUPPORTS_GL_ARB_fragment_program)
        glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, n, m_CurParams[n]);
    }
  }
}

bool CCGVProgram_GL::mfSet(bool bEnable, SShaderPassHW *slw, int nFlags)
{
  //PROFILE_FRAME(Shader_VShaders);

  int Mask;
  CGLRenderer *rd = gcpOGL;

  if (!bEnable)
  {
#ifdef DO_RENDERLOG
    if (CRenderer::CV_r_log == 4)
      rd->Logv(SRendItem::m_RecurseLevel, "--- Reset CGVProgram \"%s\"\n", m_Name.c_str());
#endif
    mfDisable();
    rd->m_RP.m_PersFlags &= ~RBPF_VSNEEDSET;
  }
  else
  {
    if ((m_Flags & VPFI_NOFOG) || !(rd->m_Features & RFT_FOGVP) || !rd->m_FS.m_bEnable || !CRenderer::CV_r_vpfog)
      Mask = VPVST_NOFOG;
    else
      Mask = VPVST_FOGGLOBAL;
    if (rd->m_RP.m_ClipPlaneEnabled == 1)
      Mask |= VPVST_CLIPPLANES3;
    Mask |= (rd->m_RP.m_FlagsModificators & VPVST_TCMASK);

    CVProgram *pPosVP = this;
    if (m_Flags & VPFI_UNIFIEDPOS)
    {
      CVProgram *pVP = NULL;
      if (rd->m_RP.m_pRE && rd->m_RP.m_pRE->m_LastVP)
        pVP = rd->m_RP.m_pRE->m_LastVP;
      else
      if (gRenDev->m_RP.m_RendPass)
        pVP = rd->m_RP.m_LastVP;
      else
      if (gRenDev->m_RP.m_pShader->m_DefaultVProgram)
        pVP = rd->m_RP.m_pShader->m_DefaultVProgram;
      if (pVP && pVP->m_bCGType)
      {
        pPosVP = pVP;
        if (pVP->m_Flags & VPFI_NOISE)
          Mask |= VPVST_NOISE;
      }
    }

    int Type = mfGetCGInstanceID(Mask, pPosVP);

#ifdef DO_RENDERLOG
  if (CRenderer::CV_r_log >= 3)
    rd->Logv(SRendItem::m_RecurseLevel, "--- Set CGVProgram \"%s\", Mask: 0x%x (%d Type)\n", m_Name.c_str(), m_nMaskGen, Mask);
#endif

    if ((int)m_Insts[Type].m_dwHandle == -1)
    {
      m_LastTypeVP = Mask;
      return false;
    }

    if (!m_Insts[Type].m_dwHandle)
    {
      rd->m_RP.m_CurVP = this;
      if (!mfActivate(pPosVP))
      {
        m_Insts[Type].m_dwHandle = -1;
        return false;
      }
      m_LastVP = NULL;
    }

    if (m_Frame != rd->m_nFrameUpdateID)
    {
      m_Frame = rd->m_nFrameUpdateID;
      rd->m_RP.m_PS.m_NumVShaders++;
    }
    if (m_LastVP != this || m_LastTypeVP != Mask)
    {
      m_LastVP = this;
      m_LastTypeVP = Mask;
      mfBind();
    }
    rd->m_RP.m_PersFlags |= RBPF_VSNEEDSET;
    if (nFlags & (VPF_SETPOINTERSFORSHADER | VPF_SETPOINTERSFORPASS))
      mfSetPointers(nFlags);

    if (!(nFlags & VPF_DONTSETMATRICES))
      mfSetStateMatrices();

    if (!(m_Flags & VPFI_UNIFIEDPOS))
      rd->m_RP.m_LastVP = this;
  }
  return true;
}

#ifdef WIN64
#pragma warning( pop )									//AMD Port
#endif