#i
    Raydium - CQFD Corp.
    http://raydium.org/
    Released under both BSD license and Lesser GPL library license.
    See "license.txt" file.
*/

#ifndef DONT_INCLUDE_HEADERS
#include "index.h"
#else
#include "headers/render.h"
#endif

void raydium_callback_image(void);
void raydium_timecall_callback(void);
void raydium_hdr_block(signed char blocking);
signed char raydium_shader_current(int shader);
void raydium_shader_internal_vertex_attributes(int i);
void raydium_osd_draw_name (char *tex, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
void raydium_osd_color_change (GLfloat r, GLfloat g, GLfloat b);

// color is a GLfloat[4] (RGBA)
void raydium_render_lightmap_color(GLfloat *color)
{
memcpy(raydium_render_lightmap_color_value,color,raydium_internal_size_vector_float_4);

// Err ... no :/ There's no current color for other texture units than 0 ...
/*
glActiveTextureARB(GL_TEXTURE1_ARB);
glColor4fv(raydium_render_lightmap_color_value);
glActiveTextureARB(GL_TEXTURE0_ARB);
*/
}

void raydium_render_lightmap_color_4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a)
{
GLfloat col[4];
col[0]=r;
col[1]=g;
col[2]=b;
col[3]=a;
raydium_render_lightmap_color(col);
}

// let's keep this define here, until full tests
int raydium_rendering_prepare_texture_unit(GLenum tu,GLuint tex)
{
// cache state of each texunit
static GLuint texunit_state[RAYDIUM_RENDER_MAX_TEXUNITS];
static int first=1;
int tui;

if(first)
    {
    int i;
    for(i=0;i<RAYDIUM_RENDER_MAX_TEXUNITS;i++)
        texunit_state[i]=0;

    first=0;
    }

tui=tu-GL_TEXTURE0_ARB;


if(tui>=raydium_math_min(RAYDIUM_RENDER_MAX_TEXUNITS,raydium_texture_units) || tui<0)
    {
    raydium_log("render: texture unit %i is invalid (%i max, see RAYDIUM_RENDER_MAX_TEXUNITS or hardware specs)",
    tui,raydium_math_min(RAYDIUM_RENDER_MAX_TEXUNITS,raydium_texture_units));
    return 0;
    }

if(texunit_state[tui]==tex)
    return 0;

//~ raydium_log("tui %i <- tex %s",tui,raydium_texture_name[tex]);

texunit_state[tui]=tex;

#ifdef DEBUG_RENDER_VERTEXARRAY_GLBINDS_DISPLAY
printf("preparing texunit %i with %s\n",tui,raydium_texture_name[tex]);
raydium_render_debug_va_count++;
#endif


// prepare "lightmaps" texture units
if(tui>0)
{
 glEnd(); // ugly, but we must close all shapes, if any
 glActiveTextureARB(tu);

#ifndef RENDER_ALLOW_LIGHTING_FOR_LIGHTMAPS
 if(raydium_texture_islightmap[tex])
 {
 glDisable(GL_LIGHTING);
 }
 else if(raydium_light_enabled_tag)
        glEnable(GL_LIGHTING);
#endif

 glDisable(GL_TEXTURE
GEN_S);
 glDisable(GL_TEXTURE_GEN_T);
 //glDisable(GL_BLEND);


 if(tex)
 {
  if(!raydium_texture_cubemap[tex])
    {
    glEnable(GL_TEXTURE_2D);
    glDisable(GL_TEXTURE_CUBE_MAP);
    glBindTexture(GL_TEXTURE_2D,tex);
    }
  else
    {
    glDisable(GL_TEXTURE_2D);
    glEnable(GL_TEXTURE_CUBE_MAP);
    glBindTexture(GL_TEXTURE_CUBE_MAP,tex);
    }

  if(raydium_texture_env[tex])
  {
    glEnable(GL_TEXTURE_GEN_S);
    glEnable(GL_TEXTURE_GEN_T);
    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
    glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 1);
    glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE_EXT);
    glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB_EXT,GL_ADD);
  }
  else if(raydium_texture_islightmap[tex])
  {
    glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
    glColor4fv(raydium_render_lightmap_color_value);
  }
  else
  {
    glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE_EXT);
    glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB_EXT,GL_MODULATE);
    glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 2);
  }
 }
 else
 {
 glDisable(GL_TEXTURE_2D);
 glDisable(GL_TEXTURE_CUBE_MAP);
// glBindTexture(GL_TEXTURE_2D,0);
 }
 glActiveTextureARB(GL_TEXTURE0_ARB);
}
else // "standard" textunit
{
  // default (according GL specs) DIFFUSE value.
  GLfloat one[]={0.8f, 0.8f, 0.8f, 1.f};
  GLfloat zero[]={0.0,0.0,0.0,0.0};
  GLfloat *rgb;

  if(raydium_texture_nolight[tex])
    {
    glGetBooleanv(GL_LIGHTING,&raydium_render_internal_light_previous_step);
    glDisable(GL_LIGHTING);
    }

  i