/*
 * ShaderEngine.cpp
 *
 *  Created on: Jul 18, 2008
 *      Author: pete
 */
#include <fstream>
#include "PerlinNoise.hpp"
#include "ShaderEngine.hpp"
#include "BeatDetect.hpp"


ShaderEngine::ShaderEngine()
{
#ifdef USE_CG
  SetupCg();
#endif
}

ShaderEngine::~ShaderEngine()
{
  // TODO Auto-generated destructor stub
}

#ifdef USE_CG

void
ShaderEngine::setParams (
const int           texsize,
const unsigned int  texId,
const float         aspect,
BeatDetect          *beatDetect,
TextureManager      *textureManager
)
{
  mainTextureId = texId;
  this->beatDetect = beatDetect;
  this->textureManager = textureManager;
  this->aspect = aspect;
  this->texsize = texsize;

  textureManager->setTexture("main", texId, texsize, texsize);

  glGenTextures(1, &blur1_tex);
  glBindTexture(GL_TEXTURE_2D, blur1_tex);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texsize/2, texsize/2, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

  glGenTextures(1, &blur2_tex);
  glBindTexture(GL_TEXTURE_2D, blur2_tex);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texsize / 4, texsize / 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

  glGenTextures(1, &blur3_tex);
  glBindTexture(GL_TEXTURE_2D, blur3_tex);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texsize / 8, texsize / 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

  blur1_enabled = false;
  blur2_enabled = false;
  blur3_enabled = false;

  //std::cout << "Generating Noise Textures" << std::endl;

  PerlinNoise noise;

  glGenTextures(1, &noise_texture_lq_lite);
  glBindTexture(GL_TEXTURE_2D, noise_texture_lq_lite);
  glTexImage2D(GL_TEXTURE_2D, 0, 4, 32, 32, 0, GL_LUMINANCE, GL_FLOAT, noise.noise_lq_lite);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  textureManager->setTexture("noise_lq_lite", noise_texture_lq_lite, 32, 32);

  glGenTextures(1, &noise_texture_lq);
  glBindTexture(GL_TEXTURE_2D, noise_texture_lq);
  glTexImage2D(GL_TEXTURE_2D, 0, 4, 256, 256, 0, GL_LUMINANCE, GL_FLOAT, noise.noise_lq);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  textureManager->setTexture("noise_lq", noise_texture_lq, 256, 256);

  glGenTextures(1, &noise_texture_mq);
  glBindTexture(GL_TEXTURE_2D, noise_texture_mq);
  glTexImage2D(GL_TEXTURE_2D, 0, 4, 256, 256, 0, GL_LUMINANCE, GL_FLOAT, noise.noise_mq);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  textureManager->setTexture("noise_mq", noise_texture_mq, 256, 256);

  glGenTextures(1, &noise_texture_hq);
  glBindTexture(GL_TEXTURE_2D, noise_texture_hq);
  glTexImage2D(GL_TEXTURE_2D, 0, 4, 256, 256, 0, GL_LUMINANCE, GL_FLOAT, noise.noise_hq);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  textureManager->setTexture("noise_hq", noise_texture_hq, 256, 256);

  glGenTextures(1, &noise_texture_perlin);
  glBindTexture(GL_TEXTURE_2D, noise_texture_perlin);
  glTexImage2D(GL_TEXTURE_2D, 0, 4, 512, 512, 0, GL_LUMINANCE, GL_FLOAT, noise.noise_perlin);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  textureManager->setTexture("noise_perlin", noise_texture_perlin, 512, 512);

  /*
  glGenTextures( 1, &noise_texture_lq_vol );
  glBindTexture( GL_TEXTURE_3D, noise_texture_lq_vol );
  glTexImage3D(GL_TEXTURE_3D,0,4,32,32,32,0,GL_LUMINANCE,GL_FLOAT,noise.noise_lq_vol);
  glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  textureManager->setTexture("noisevol_lq", noise_texture_lq_vol, 256, 256);

  glGenTextures( 1, &noise_texture_hq_vol );
  glBindTexture( GL_TEXTURE_3D, noise_texture_hq_vol );
  glTexImage3D(GL_TEXTURE_3D,0,4,32,32,32,0,GL_LUMINANCE,GL_FLOAT,noise.noise_hq_vol);
  glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  textureManager->setTexture("noisevol_hq", noise_texture_hq_vol, 8, 8);
  */
}

bool
ShaderEngine::LoadCgProgram(Shader &shader)
{
  //if (p != NULL) cgDestroyProgram(p);
  //  p = NULL;
  std::string program = shader.programSource;

  if (program.length() > 0)
  {
    size_t found = program.rfind('}');
    if (found != std::string::npos)
    {
      //std::cout << "last '}' found at: " << int(found) << std::endl;
      program.replace(int(found), 1, "OUT.color.xyz=ret.xyz;\nOUT.color.w=1;\nreturn OUT;\n}");
    }
    else
      return false;
    found = program.rfind('{');
    if (found != std::string::npos)
    {
      //std::cout << "first '{' found at: " << int(found) << std::endl;
      program.replace(int(found), 1, "{\nfloat rad=getrad;\nfloat ang=getang;\n");
    }
    else
      return false;
    found = program.find("shader_body");
    if (found != std::string::npos)
    {
      //std::cout << "first 'shader_body' found at: " << int(found) << std::endl;
      program.replace(int(found), 11, "outtype projectm(float2 uv : TEXCOORD0)\n");
    }
    else
      return false;

    shader.textures.clear();

    found = 0;
    found = program.find("sampler_", found);
    while (found != std::string::npos)
    {
      found += 8;
      size_t end = program.find_first_of(" ;,\n\r)", found);

      if (end != std::string::npos)
      {
        std::string sampler = program.substr((int) found, (int) end - found);
        UserTexture* texture = new UserTexture(sampler);

        texture->texID = textureManager->getTexture(texture->name);
        if (texture->texID != 0)
        {
          texture->width = textureManager->getTextureWidth(texture->name);
          texture->height = textureManager->getTextureHeight(texture->name);
        }
        else
        {
          if (sampler.substr(0, 4) == "rand")
          {
            std::string random_name = textureManager->getRandomTextureName(texture->name);

            if (random_name.size() > 0)
            {
              texture->texID = textureManager->getTexture(random_name);
              texture->width = textureManager->getTextureWidth(random_name);
              texture->height = textureManager->getTextureHeight(random_name);
            }
          }
          else
          {
            std::string extensions[6];
            extensions[0] = ".jpg";
            extensions[1] = ".dds";
            extensions[2] = ".png";
            extensions[3] = ".tga";
            extensions[4] = ".bmp";
            extensions[5] = ".dib";

            for (int x = 0; x < 6; x++)
            {
              std::string filename = texture->name + extensions[x];

              texture->texID = textureManager->getTexture(filename);
              if (texture->texID != 0)
              {
                texture->width = textureManager->getTextureWidth(filename);
                texture->height = textureManager->getTextureHeight(filename);
                break;
              }
            }
          }
        }
        if (texture->texID != 0 && shader.textures.find(texture->qname) == shader.textures.end())
          shader.textures[texture->qname] = texture;
        else
          delete (texture);
      }

      found = program.find("sampler_", found);
    }
    textureManager->clearRandomTextures();

    found = 0;
    found = program.find("texsize_", found);
    while (found != std::string::npos)
    {
      found += 8;
      size_t end = program.find_first_of(" ;.,\n\r)", found);

      if (end != std::string::npos)
      {
        std::string tex = program.substr((int) found, (int) end - found);
        if (shader.textures.find(tex) != shader.textures.end())
        {
          UserTexture* texture = shader.textures[tex];
          texture->texsizeDefined = true;
          //std::cout << "texsize_" << tex << " found" << std::endl;
        }
      }
      found = program.find("texsize_", found);
    }

    found = program.find("GetBlur3");
    if (found != std::string::npos)
      blur1_enabled = blur2_enabled = blur3_enabled = true;
    else
    {
      found = program.find("GetBlur2");
      if (found != std::string::npos)
        blur1_enabled = blur2_enabled = true;
      else
      {
        found = program.find("GetBlur1");
        if (found != std::string::npos)
          blur1_enabled = true;
      }
    }

    std::string temp;

    temp.append(cgTemplate);
    temp.append(program);

    //std::cout << "Cg: Compilation Results:" << std::endl << std::endl;
    //std::cout << program << std::endl;

    CGprogram p = cgCreateProgram(myCgContext, CG_SOURCE, temp.c_str(),//temp.c_str(),
    myCgProfile, "projectm", NULL);

    checkForCgCompileError("creating shader program");
    if (p == NULL)
      return false;

    cgGLLoadProgram(p);

    if (checkForCgCompileError("loading shader program"))
    {
      p = NULL;
      return false;
    }

    programs[&shader] = p;

    return true;
  }
  else
    return false;
}

bool
ShaderEngine::checkForCgCompileError(const char *situation)
{
  CGerror error;
  const char *string = cgGetLastErrorString(&error);

  error = cgGetError();
  if (error != CG_NO_ERROR)
  {
    std::cout << "Cg: Compilation Error" << std::endl;
    std::cout << "Cg: %" << situation << " - " << string << std::endl;
    if (error == CG_COMPILER_ERROR)
    {
      std::cout << "Cg: " << cgGetLastListing(myCgContext) << std::endl;
    }
    return true;
  }

  return false;
}

void
ShaderEngine::checkForCgError(const char *situation)
{
  CGerror error;
  const char *string = cgGetLastErrorString(&error);

  if (error != CG_NO_ERROR)
  {
    std::cout << "Cg: %" << situation << " - " << string << std::endl;
    if (error == CG_COMPILER_ERROR)
    {
      std::cout << "Cg: " << cgGetLastListing(myCgContext) << std::endl;
    }
    exit(1);
  }
}

void
ShaderEngine::SetupCg()
{
  std::string line;
  std::ifstream myfile(CMAKE_INSTALL_PREFIX "/share/projectM/shaders/projectM.cg");

  if (myfile.is_open())
  {
    while (!myfile.eof())
    {
      std::getline(myfile, line);
      cgTemplate.append(line + "\n");
    }
    myfile.close();
  }
  else
    std::cout << "Unable to load shader template \"" << CMAKE_INSTALL_PREFIX "/share/projectM/shaders/projectM.cg\"" << std::endl;

  std::ifstream myfile2(CMAKE_INSTALL_PREFIX "/share/projectM/shaders/blur.cg");
  if (myfile2.is_open())
  {
    while (!myfile2.eof())
    {
      std::getline(myfile2, line);
      blurProgram.append(line + "\n");
    }
    myfile2.close();
  }
  else
    std::cout << "Unable to load blur template" << std::endl;

  myCgContext = cgCreateContext();
  checkForCgError("creating context");
  cgGLSetDebugMode(CG_FALSE);
  cgSetParameterSettingMode(myCgContext, CG_DEFERRED_PARAMETER_SETTING);

  myCgProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);

  // HACK breaks with buggy ati video drivers such as my own
  // -carmelo.piccione@gmail.com 7/26/2010
  //cgGLSetOptimalOptions(myCgProfile);
  checkForCgError("selecting fragment profile");

  profileName = cgGetProfileString(myCgProfile);
  std::cout << "Cg: Initialized profile: " << profileName << std::endl;
  //std::cout<< blurProgram.c_str()<<std::endl;
  blur1Program = cgCreateProgram(myCgContext, CG_SOURCE, blurProgram.c_str(), myCgProfile, "blur1", NULL);

  checkForCgCompileError("creating blur1 program");
  if (blur1Program == NULL)
    exit(1);
  cgGLLoadProgram(blur1Program);

  checkForCgError("loading blur1 program");

  blur2Program = cgCreateProgram(myCgContext, CG_SOURCE, blurProgram.c_str(), myCgProfile, "blurVert", NULL);

  checkForCgCompileError("creating blur2 program");
  if (blur2Program == NULL)
    exit(1);
  cgGLLoadProgram(blur2Program);

  checkForCgError("loading blur2 program");

}

void
ShaderEngine::SetupCgVariables(CGprogram program, const Pipeline &pipeline, const PipelineContext &context)
{

  float slow_roam_cos[4] =  { 0.5 + 0.5 * cos(context.time * 0.005), 0.5 + 0.5 * cos(context.time * 0.008), 0.5 + 0.5 * cos(context.time * 0.013), 0.5 + 0.5 * cos(context.time * 0.022) };
  float roam_cos[4] = { 0.5 + 0.5 * cos(context.time * 0.3), 0.5 + 0.5 * cos(context.time * 1.3), 0.5 + 0.5 * cos(context.time * 5), 0.5  + 0.5 * cos(context.time * 20) };
  float slow_roam_sin[4] =  { 0.5 + 0.5 * sin(context.time * 0.005), 0.5 + 0.5 * sin(context.time * 0.008), 0.5 + 0.5 * sin(context.time * 0.013), 0.5 + 0.5 * sin(context.time * 0.022) };
  float roam_sin[4] = { 0.5 + 0.5 * sin(context.time * 0.3), 0.5 + 0.5 * sin(context.time * 1.3), 0.5 + 0.5 * sin(context.time * 5), 0.5  + 0.5 * sin(context.time * 20) };

  cgGLSetParameter4fv(cgGetNamedParameter(program, "slow_roam_cos"), slow_roam_cos);
  cgGLSetParameter4fv(cgGetNamedParameter(program, "roam_cos"), roam_cos);
  cgGLSetParameter4fv(cgGetNamedParameter(program, "slow_roam_sin"), slow_roam_sin);
  cgGLSetParameter4fv(cgGetNamedParameter(program, "roam_sin"), roam_sin);

  cgGLSetParameter1f(cgGetNamedParameter(program, "time"), context.time);
  cgGLSetParameter4f(cgGetNamedParameter(program, "rand_preset"), rand_preset[0], rand_preset[1], rand_preset[2], rand_preset[3]);
  cgGLSetParameter4f(cgGetNamedParameter(program, "rand_frame"), (rand() % 100) * .01, (rand() % 100) * .01, (rand()% 100) * .01, (rand() % 100) * .01);
  cgGLSetParameter1f(cgGetNamedParameter(program, "fps"), context.fps);
  cgGLSetParameter1f(cgGetNamedParameter(program, "frame"), context.frame);
  cgGLSetParameter1f(cgGetNamedParameter(program, "progress"), context.progress);

  cgGLSetParameter1f(cgGetNamedParameter(program, "blur1_min"), pipeline.blur1n);
  cgGLSetParameter1f(cgGetNamedParameter(program, "blur1_max"), pipeline.blur1x);
  cgGLSetParameter1f(cgGetNamedParameter(program, "blur2_min"), pipeline.blur2n);
  cgGLSetParameter1f(cgGetNamedParameter(program, "blur2_max"), pipeline.blur2x);
  cgGLSetParameter1f(cgGetNamedParameter(program, "blur3_min"), pipeline.blur3n);
  cgGLSetParameter1f(cgGetNamedParameter(program, "blur3_max"), pipeline.blur3x);

  cgGLSetParameter1f(cgGetNamedParameter(program, "bass"), beatDetect->bass);
  cgGLSetParameter1f(cgGetNamedParameter(program, "mid"), beatDetect->mid);
  cgGLSetParameter1f(cgGetNamedParameter(program, "treb"), beatDetect->treb);
  cgGLSetParameter1f(cgGetNamedParameter(program, "bass_att"), beatDetect->bass_att);
  cgGLSetParameter1f(cgGetNamedParameter(program, "mid_att"), beatDetect->mid_att);
  cgGLSetParameter1f(cgGetNamedParameter(program, "treb_att"), beatDetect->treb_att);
  cgGLSetParameter1f(cgGetNamedParameter(program, "vol"), beatDetect->vol);
  cgGLSetParameter1f(cgGetNamedParameter(program, "vol_att"), beatDetect->vol);

  cgGLSetParameter4f(cgGetNamedParameter(program, "texsize"), texsize, texsize, 1 / (float) texsize, 1
  / (float) texsize);
  cgGLSetParameter4f(cgGetNamedParameter(program, "aspect"), 1 / aspect, 1, aspect, 1);

  if (blur1_enabled)
  {
    cgGLSetTextureParameter(cgGetNamedParameter(program, "sampler_blur1"), blur1_tex);
    cgGLEnableTextureParameter(cgGetNamedParameter(program, "sampler_blur1"));
  }
  if (blur2_enabled)
  {
    cgGLSetTextureParameter(cgGetNamedParameter(program, "sampler_blur2"), blur2_tex);
    cgGLEnableTextureParameter(cgGetNamedParameter(program, "sampler_blur2"));
  }
  if (blur3_enabled)
  {
    cgGLSetTextureParameter(cgGetNamedParameter(program, "sampler_blur3"), blur3_tex);
    cgGLEnableTextureParameter(cgGetNamedParameter(program, "sampler_blur3"));
  }
}

void
ShaderEngine::SetupUserTexture(CGprogram program, const UserTexture* texture)
{
  std::string samplerName = "sampler_" + texture->qname;

  CGparameter param = cgGetNamedParameter(program, samplerName.c_str());
  checkForCgError("getting parameter");
  cgGLSetTextureParameter(param, texture->texID);
  checkForCgError("setting parameter");
  cgGLEnableTextureParameter(param);
  checkForCgError("enabling parameter");
  //std::cout<<texture->texID<<" "<<samplerName<<std::endl;

  if (texture->texsizeDefined)
  {
    std::string texsizeName = "texsize_" + texture->name;
    cgGLSetParameter4f (cgGetNamedParameter (program, texsizeName.c_str()),
                        texture->width, texture->height,
                        1 / (float) texture->width, 1 / (float) texture->height);
    checkForCgError("setting parameter texsize");
  }
}

void
ShaderEngine::SetupUserTextureState( const UserTexture* texture)
{
  glBindTexture(GL_TEXTURE_2D, texture->texID);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, texture->bilinear ? GL_LINEAR : GL_NEAREST);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, texture->bilinear ? GL_LINEAR : GL_NEAREST);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, texture->wrap ? GL_REPEAT : GL_CLAMP);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, texture->wrap ? GL_REPEAT : GL_CLAMP);
}

void
ShaderEngine::SetupCgQVariables(CGprogram program, const Pipeline &q)
{
  cgGLSetParameter4f(cgGetNamedParameter(program, "_qa"), q.q[0], q.q[1], q.q[2], q.q[3]);
  cgGLSetParameter4f(cgGetNamedParameter(program, "_qb"), q.q[4], q.q[5], q.q[6], q.q[7]);
  cgGLSetParameter4f(cgGetNamedParameter(program, "_qc"), q.q[8], q.q[9], q.q[10], q.q[11]);
  cgGLSetParameter4f(cgGetNamedParameter(program, "_qd"), q.q[12], q.q[13], q.q[14], q.q[15]);
  cgGLSetParameter4f(cgGetNamedParameter(program, "_qe"), q.q[16], q.q[17], q.q[18], q.q[19]);
  cgGLSetParameter4f(cgGetNamedParameter(program, "_qf"), q.q[20], q.q[21], q.q[22], q.q[23]);
  cgGLSetParameter4f(cgGetNamedParameter(program, "_qg"), q.q[24], q.q[25], q.q[26], q.q[27]);
  cgGLSetParameter4f(cgGetNamedParameter(program, "_qh"), q.q[28], q.q[29], q.q[30], q.q[31]);
}

void
ShaderEngine::setAspect(float aspect)
{
  this->aspect = aspect;
}
void
ShaderEngine::RenderBlurTextures(const Pipeline &pipeline, const PipelineContext &pipelineContext, const int texsize)
{
  if (blur1_enabled || blur2_enabled || blur3_enabled)
  {
    float tex[4][2] =
      {
      { 0, 1 },
      { 0, 0 },
      { 1, 0 },
      { 1, 1 } };

    glBlendFunc(GL_ONE, GL_ZERO);
    glColor4f(1.0, 1.0, 1.0, 1.0f);

    glBindTexture(GL_TEXTURE_2D, mainTextureId);
    glEnable(GL_TEXTURE_2D);

    glEnableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_COLOR_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glTexCoordPointer(2, GL_FLOAT, 0, tex);

    cgGLEnableProfile(myCgProfile);
    checkForCgError("enabling profile");

    if (blur1_enabled)
    {
      cgGLSetParameter4f (cgGetNamedParameter(blur1Program, "srctexsize"), texsize/2, texsize/2,
                          2 / (float) texsize, 2 / (float) texsize);
      cgGLSetParameter4f (cgGetNamedParameter(blur2Program, "srctexsize"), texsize/2 , texsize/2,
                          2 / (float) texsize, 2 / (float) texsize);


      float pointsold[4][2] =
        {
        { 0, 1 },
        { 0, 0 },
        { 1, 0 },
        { 1, 1 } };
      float points[4][2] =
        {
        { 0, 0.5 },
        { 0, 0 },
        { 0.5, 0 },
        { 0.5, 0.5 } };

      cgGLBindProgram(blur1Program);
      checkForCgError("binding blur1 program");

      glVertexPointer(2, GL_FLOAT, 0, points);
      glBlendFunc(GL_ONE,GL_ZERO);
      glDrawArrays(GL_TRIANGLE_FAN, 0, 4);


      glBindTexture(GL_TEXTURE_2D, blur1_tex);
      glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize/2, texsize/2);
    }

    if (blur2_enabled)
    {
      cgGLSetParameter4f (cgGetNamedParameter(blur1Program, "srctexsize"), texsize/2, texsize/2,
                          2 / (float) texsize, 2 / (float) texsize);
      cgGLSetParameter4f (cgGetNamedParameter(blur2Program, "srctexsize"), texsize/2, texsize/2,
                          2 / (float) texsize, 2 / (float) texsize);


      float points[4][2] =
        {
        { 0, 0.25 },
        { 0, 0 },
        { 0.25, 0 },
        { 0.25, 0.25 } };

      glVertexPointer(2, GL_FLOAT, 0, points);
      glBlendFunc(GL_ONE,GL_ZERO);
      glDrawArrays(GL_TRIANGLE_FAN, 0, 4);


      glBindTexture(GL_TEXTURE_2D, blur2_tex);
      glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize/4, texsize/4);
    }

    if (blur3_enabled)
    {
      cgGLSetParameter4f (cgGetNamedParameter(blur2Program, "srctexsize"), texsize / 4, texsize / 4,
                          4 / (float) texsize, 4 / (float) texsize);
      cgGLSetParameter4f (cgGetNamedParameter(blur2Program, "srctexsize"), texsize / 4, texsize / 4,
                          4 / (float) texsize, 4 / (float) texsize);
      float points[4][2] =
        {
        { 0, 0.125 },
        { 0, 0 },
        { 0.125, 0 },
        { 0.125, 0.125 } };

      glVertexPointer(2, GL_FLOAT, 0, points);
      glBlendFunc(GL_ONE,GL_ZERO);
      glDrawArrays(GL_TRIANGLE_FAN, 0, 4);


      glBindTexture(GL_TEXTURE_2D, blur3_tex);
      glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize/8, texsize/8);
    }


    cgGLUnbindProgram(myCgProfile);
    checkForCgError("unbinding blur2 program");


    cgGLDisableProfile(myCgProfile);
    checkForCgError("disabling blur profile");

    glDisable(GL_TEXTURE_2D);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  }
}

void
ShaderEngine::loadShader(Shader &shader)
{
  if (shader.enabled)
  {
    cgDestroyProgram(programs[&shader]);
    programs.erase(&shader);
  }
  shader.enabled = LoadCgProgram(shader);
}

void
ShaderEngine::disableShader()
{
  if (enabled)
  {
    cgGLUnbindProgram(myCgProfile);
    checkForCgError("disabling fragment profile");
    cgGLDisableProfile(myCgProfile);
    checkForCgError("disabling fragment profile");
  }
  enabled = false;
}

void
ShaderEngine::enableShader(Shader &shader, const Pipeline &pipeline, const PipelineContext &pipelineContext)
{
  enabled = false;
  if (shader.enabled)
  {

    for (std::map<std::string, UserTexture*>::const_iterator pos = shader.textures.begin();
         pos != shader.textures.end();
         ++pos)
      SetupUserTextureState( pos->second);


    CGprogram program = programs[&shader];
    for (std::map<std::string, UserTexture*>::const_iterator pos = shader.textures.begin();
         pos != shader.textures.end();
         ++pos)
    SetupUserTexture(program, pos->second);

    cgGLEnableProfile(myCgProfile);
    checkForCgError("enabling warp profile");

    cgGLBindProgram(program);
    checkForCgError("binding warp program");

    SetupCgVariables(program, pipeline, pipelineContext);
    SetupCgQVariables(program, pipeline);

    enabled = true;
  }
}

void
ShaderEngine::reset()
{
  rand_preset[0] = (rand() % 100) * .01;
  rand_preset[1] = (rand() % 100) * .01;
  rand_preset[2] = (rand() % 100) * .01;
  rand_preset[3] = (rand() % 100) * .01;
}

#endif