//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============

//

// Purpose:

//

// $NoKeywords: $

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

// Triangle rendering, if any

#include "hud.h"

//#include "gl_main.h"

#include "cl_util.h"

// Triangle rendering apis are in gEngfuncs.pTriAPI

#include "const.h"

#include "entity_state.h"

#include "cl_entity.h"

#include "triangleapi.h"

// Triangle rendering apis are in gEngfuncs.pTriAPI

#include "const.h"

#include "entity_state.h"

#include "cl_entity.h"

#include "triangleapi.h"

#include <windows.h>

#include <gl/gl.h>

//#include <gl/glext.h>

//#include <cg/cg.h>

//#include <cg/cgGL.h>

#define DLLEXPORT __declspec( dllexport )

extern "C"

{

  void DLLEXPORT HUD_DrawNormalTriangles( void );

  void DLLEXPORT HUD_DrawTransparentTriangles( void );

};

//#define TEST_IT

#if defined( TEST_IT )

/*

=================

Draw_Triangles

Example routine.  Draws a sprite offset from the player origin.

=================

*/

void Draw_Triangles( void )

{

  cl_entity_t *player;

  vec3_t org;

  // Load it up with some bogus data

  player = gEngfuncs.GetLocalPlayer();

  if ( !player )

    return;

  org = player->origin;

  org.x += 50;

  org.y += 50;

  if (gHUD.m_hsprCursor == 0)

  {

    char sz[256];

    sprintf( sz, "sprites/cursor.spr" );

    gHUD.m_hsprCursor = SPR_Load( sz );

  }

  if ( !gEngfuncs.pTriAPI->SpriteTexture( (struct model_s *)gEngfuncs.GetSpritePointer( gHUD.m_hsprCursor ), 0 ))

  {

    return;

  }

  // Create a triangle, sigh

  gEngfuncs.pTriAPI->RenderMode( kRenderNormal );

  gEngfuncs.pTriAPI->CullFace( TRI_NONE );

  gEngfuncs.pTriAPI->Begin( TRI_QUADS );

  // Overload p->color with index into tracer palette, p->packedColor with brightness

  gEngfuncs.pTriAPI->Color4f( 1.0, 1.0, 1.0, 1.0 );

  // UNDONE: This gouraud shading causes tracers to disappear on some cards (permedia2)

  gEngfuncs.pTriAPI->Brightness( 1 );

  gEngfuncs.pTriAPI->TexCoord2f( 0, 0 );

  gEngfuncs.pTriAPI->Vertex3f( org.x, org.y, org.z );

  gEngfuncs.pTriAPI->Brightness( 1 );

  gEngfuncs.pTriAPI->TexCoord2f( 0, 1 );

  gEngfuncs.pTriAPI->Vertex3f( org.x, org.y + 50, org.z );

  gEngfuncs.pTriAPI->Brightness( 1 );

  gEngfuncs.pTriAPI->TexCoord2f( 1, 1 );

  gEngfuncs.pTriAPI->Vertex3f( org.x + 50, org.y + 50, org.z );

  gEngfuncs.pTriAPI->Brightness( 1 );

  gEngfuncs.pTriAPI->TexCoord2f( 1, 0 );

  gEngfuncs.pTriAPI->Vertex3f( org.x + 50, org.y, org.z );

  gEngfuncs.pTriAPI->End();

  gEngfuncs.pTriAPI->RenderMode( kRenderNormal );

}

#endif

/*

=================

HUD_DrawNormalTriangles

Non-transparent triangles-- add them here

=================

*/

void DLLEXPORT HUD_DrawNormalTriangles( void )

{

  gHUD.m_Spectator.DrawOverview();

#if defined( TEST_IT )

  //	Draw_Triangles();

#endif

}

/*

=================

HUD_DrawTransparentTriangles

Render any triangles with transparent rendermode needs here

=================

*/

void DLLEXPORT HUD_DrawTransparentTriangles( void )

{

#if defined( TEST_IT )

  //	Draw_Triangles();

#endif

}

/*

=================

Real-Time TRON

Glow

=================

*/

#include "r_studioint.h"

extern engine_studio_api_t IEngineStudio;

bool g_bInitialised = false;

extern PFNGLACTIVETEXTUREARBPROC glActiveTextureARB;

extern PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB;

CGcontext g_cgContext;

CGprofile g_cgVertProfile;

CGprofile g_cgFragProfile;

CGprogram g_cgVP_GlowDarken;

CGprogram g_cgFP_GlowDarken;

CGprogram g_cgVP_GlowBlur;

CGprogram g_cgFP_GlowBlur;

CGprogram g_cgVP_GlowCombine;

CGprogram g_cgFP_GlowCombine;

CGparameter g_cgpVP0_ModelViewMatrix;

CGparameter g_cgpVP1_ModelViewMatrix;

CGparameter g_cgpVP1_XOffset;

CGparameter g_cgpVP1_YOffset;

CGparameter g_cgpVP2_ModelViewMatrix;

unsigned int g_uiSceneTex;

unsigned int g_uiBlurTex;

bool LoadProgram(CGprogram* pDest, CGprofile profile, const char* szFile)

{

  const char* szGameDir = gEngfuncs.pfnGetGameDirectory();

  char file[512];

  sprintf(file, "%s/%s", szGameDir, szFile);

  *pDest = cgCreateProgramFromFile(g_cgContext, CG_SOURCE, file, profile, "main", 0);

  if (!(*pDest)) {

    MessageBox(NULL, cgGetErrorString(cgGetError()), NULL, NULL);

    return false;

  }

  cgGLLoadProgram(*pDest);

  return true;

}

void InitScreenGlow(void)

{

  if (IEngineStudio.IsHardware() != 1)

    return;

  gEngfuncs.pfnRegisterVariable("cg_blur_steps", "4", 0);

  // OPENGL EXTENSION LOADING

  glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)wglGetProcAddress("glActiveTextureARB");

  // TEXTURE CREATION

  unsigned char* pBlankTex = new unsigned char[ScreenWidth*ScreenHeight*3];

  memset(pBlankTex, 0, ScreenWidth*ScreenHeight*3);

  glGenTextures(1, &g_uiSceneTex);

  glBindTexture(GL_TEXTURE_RECTANGLE_NV, g_uiSceneTex);

  glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

  glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB8, ScreenWidth, ScreenHeight, 0, GL_RGB8, GL_UNSIGNED_BYTE, pBlankTex);

  glGenTextures(1, &g_uiBlurTex);

  glBindTexture(GL_TEXTURE_RECTANGLE_NV, g_uiBlurTex);

  glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

  glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB8, ScreenWidth/2, ScreenHeight/2, 0, GL_RGB8, GL_UNSIGNED_BYTE, pBlankTex);

  delete[] pBlankTex;

  g_bInitialised = true;

  // CG INITIALISATION

  g_cgContext = cgCreateContext();

  if (!g_cgContext) {

    MessageBox(NULL, "Couldn't make Cg context", NULL, NULL);

    return;

  }

  // VERTEX PROFILE

  g_cgVertProfile = cgGLGetLatestProfile(CG_GL_VERTEX);

  if (g_cgVertProfile == CG_PROFILE_UNKNOWN) {

    MessageBox(NULL, "Couldn't fetch valid VP profile", NULL, NULL);

    return;

  }

  cgGLSetOptimalOptions(g_cgVertProfile);

  // VP LOADING

  if (!LoadProgram(&g_cgVP_GlowDarken, g_cgVertProfile, "cgprograms/glow_darken_vp.cg"))

    return;

  if (!LoadProgram(&g_cgVP_GlowBlur, g_cgVertProfile, "cgprograms/glow_blur_vp.cg"))

    return;

  if (!LoadProgram(&g_cgVP_GlowCombine, g_cgVertProfile, "cgprograms/glow_combine_vp.cg"))

    return;

  // VP PARAM GRABBING

  g_cgpVP0_ModelViewMatrix = cgGetNamedParameter(g_cgVP_GlowDarken, "ModelViewProj");

  g_cgpVP1_ModelViewMatrix = cgGetNamedParameter(g_cgVP_GlowBlur, "ModelViewProj");

  g_cgpVP1_XOffset = cgGetNamedParameter(g_cgVP_GlowBlur, "XOffset");

  g_cgpVP1_YOffset = cgGetNamedParameter(g_cgVP_GlowBlur, "YOffset");

  g_cgpVP2_ModelViewMatrix = cgGetNamedParameter(g_cgVP_GlowCombine, "ModelViewProj");

  // FRAGMENT PROFILE

  g_cgFragProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);

  if (g_cgFragProfile == CG_PROFILE_UNKNOWN) {

    MessageBox(NULL, "Couldn't fetch valid FP profile", NULL, NULL);

    return;

  }

  cgGLSetOptimalOptions(g_cgFragProfile);

  // FP LOADING

  if (!LoadProgram(&g_cgFP_GlowDarken, g_cgFragProfile, "cgprograms/glow_darken_fp.cg"))

    return;

  if (!LoadProgram(&g_cgFP_GlowBlur, g_cgFragProfile, "cgprograms/glow_blur_fp.cg"))

    return;

  if (!LoadProgram(&g_cgFP_GlowCombine, g_cgFragProfile, "cgprograms/glow_combine_fp.cg"))

    return;

}

void DrawQuad(int width, int height)

{

  glBegin(GL_QUADS);

  glTexCoord2f(0,0);

  glVertex3f(0, 1, -1);

  glTexCoord2f(0,height);

  glVertex3f(0, 0, -1);

  glTexCoord2f(width,height);

  glVertex3f(1, 0, -1);

  glTexCoord2f(width,0);

  glVertex3f(1, 1, -1);

  glEnd();

}

void DoBlur(unsigned int uiSrcTex, unsigned int uiTargetTex, int srcTexWidth, int srcTexHeight, int destTexWidth, int destTexHeight, float xofs, float yofs)

{

  cgGLBindProgram(g_cgVP_GlowBlur);

  cgGLBindProgram(g_cgFP_GlowBlur);

  glActiveTextureARB(GL_TEXTURE0_ARB);

  glEnable(GL_TEXTURE_RECTANGLE_NV);

  glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiSrcTex);

  glActiveTextureARB(GL_TEXTURE1_ARB);

  glEnable(GL_TEXTURE_RECTANGLE_NV);

  glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiSrcTex);

  glActiveTextureARB(GL_TEXTURE2_ARB);

  glEnable(GL_TEXTURE_RECTANGLE_NV);

  glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiSrcTex);

  glActiveTextureARB(GL_TEXTURE3_ARB);

  glEnable(GL_TEXTURE_RECTANGLE_NV);

  glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiSrcTex);

  cgGLSetParameter1f(g_cgpVP1_XOffset, xofs);

  cgGLSetParameter1f(g_cgpVP1_YOffset, yofs);

  glViewport(0, 0, destTexWidth, destTexHeight);

  DrawQuad(srcTexWidth, srcTexHeight);

  glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiTargetTex);

  glCopyTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB, 0, 0, destTexWidth, destTexHeight, 0);

}

void RenderScreenGlow(void)

{

  if (IEngineStudio.IsHardware() != 1)

    return;

  if (!g_bInitialised)

    InitScreenGlow();

  if ((int)gEngfuncs.pfnGetCvarFloat("cg_blur_steps") == 0)

    return;

  // STEP 1: Grab the screen and put it into a texture

  glActiveTextureARB(GL_TEXTURE0_ARB);

  glEnable(GL_TEXTURE_RECTANGLE_NV);

  glBindTexture(GL_TEXTURE_RECTANGLE_NV, g_uiSceneTex);

  glCopyTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB, 0, 0, ScreenWidth, ScreenHeight, 0);

  // STEP 2: Set up an orthogonal projection

  glMatrixMode(GL_MODELVIEW);

  glPushMatrix();

  glLoadIdentity();

  glMatrixMode(GL_PROJECTION);

  glPushMatrix();

  glLoadIdentity();

  glOrtho(0, 1, 1, 0, 0.1, 100);

  glColor3f(1,1,1);

  // STEP 3: Initialize Cg programs and parameters for darkening mid to dark areas of the scene

  cgGLEnableProfile(g_cgVertProfile);

  cgGLEnableProfile(g_cgFragProfile);

  cgGLBindProgram(g_cgVP_GlowDarken);

  cgGLBindProgram(g_cgFP_GlowDarken);

  cgGLSetStateMatrixParameter(g_cgpVP0_ModelViewMatrix, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);

  // STEP 4: Render the current scene texture to a new, lower-res texture, darkening non-bright areas of the scene

  glViewport(0, 0, ScreenWidth/2, ScreenHeight/2);

  glActiveTextureARB(GL_TEXTURE0_ARB);

  glBindTexture(GL_TEXTURE_RECTANGLE_NV, g_uiSceneTex);

  DrawQuad(ScreenWidth, ScreenHeight);

  glBindTexture(GL_TEXTURE_RECTANGLE_NV, g_uiBlurTex);

  glCopyTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB, 0, 0, ScreenWidth/2, ScreenHeight/2, 0);

  // STEP 5: Initialise Cg programs and parameters for blurring

  cgGLBindProgram(g_cgVP_GlowBlur);

  cgGLBindProgram(g_cgFP_GlowBlur);

  cgGLSetStateMatrixParameter(g_cgpVP1_ModelViewMatrix, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);

  // STEP 6: Apply blur

  int iNumBlurSteps = (int)gEngfuncs.pfnGetCvarFloat("cg_blur_steps");

  for (int i = 0; i < iNumBlurSteps; i++) {

    DoBlur(g_uiBlurTex, g_uiBlurTex, ScreenWidth/2, ScreenHeight/2, ScreenWidth/2, ScreenHeight/2, 1, 0);

    DoBlur(g_uiBlurTex, g_uiBlurTex, ScreenWidth/2, ScreenHeight/2, ScreenWidth/2, ScreenHeight/2, 0, 1);

  }

  // STEP 7: Set up Cg for combining blurred glow with original scene

  cgGLBindProgram(g_cgVP_GlowCombine);

  cgGLBindProgram(g_cgFP_GlowCombine);

  cgGLSetStateMatrixParameter(g_cgpVP2_ModelViewMatrix, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);

  glActiveTextureARB(GL_TEXTURE0_ARB);

  glEnable(GL_TEXTURE_RECTANGLE_NV);

  glBindTexture(GL_TEXTURE_RECTANGLE_NV, g_uiSceneTex);

  glActiveTextureARB(GL_TEXTURE1_ARB);

  glEnable(GL_TEXTURE_RECTANGLE_NV);

  glBindTexture(GL_TEXTURE_RECTANGLE_NV, g_uiBlurTex);

  // STEP 8: Do the combination, rendering to the screen without grabbing it to a texture

  glViewport(0, 0, ScreenWidth, ScreenHeight);

  DrawQuad(ScreenWidth/2, ScreenHeight/2);

  // STEP 9: Restore the original projection and modelview matrices and disable rectangular textures on all units

  glMatrixMode(GL_PROJECTION);

  glPopMatrix();

  glMatrixMode(GL_MODELVIEW);

  glPopMatrix();

  cgGLDisableProfile(g_cgVertProfile);

  cgGLDisableProfile(g_cgFragProfile);

  glActiveTextureARB(GL_TEXTURE0_ARB);

  glDisable(GL_TEXTURE_RECTANGLE_NV);

  glActiveTextureARB(GL_TEXTURE1_ARB);

  glDisable(GL_TEXTURE_RECTANGLE_NV);

  glActiveTextureARB(GL_TEXTURE2_ARB);

  glDisable(GL_TEXTURE_RECTANGLE_NV);

  glActiveTextureARB(GL_TEXTURE3_ARB);

  glDisable(GL_TEXTURE_RECTANGLE_NV);

  glActiveTextureARB(GL_TEXTURE0_ARB);

}

void DLLEXPORT HUD_DrawNormalTriangles( void )

{

  if (g_HardwareCapable)

  {

    glPushAttrib(GL_ALL_ATTRIB_BITS);

    glActiveTextureARB(GL_TEXTURE1_ARB);

    glClientActiveTextureARB(GL_TEXTURE1_ARB);

    glDisable(GL_TEXTURE_2D);

    glActiveTextureARB(GL_TEXTURE0_ARB);

    glClientActiveTextureARB(GL_TEXTURE0_ARB);

    GL_Render(false);

    glPopAttrib();

  }

  gHUD.m_Spectator.DrawOverview();

}

/*

=================

HUD_DrawTransparentTriangles

Render any triangles with transparent rendermode needs here

=================

*/

void DLLEXPORT HUD_DrawTransparentTriangles( void )

{

  if (g_HardwareCapable)

    GL_Render(true);

}