git.mutantstargoat.com Git - summerhack/blob - src/3dengfx/src/3dengfx/3denginefx.cpp

   1 /*
   2 This file is part of the 3dengfx, realtime visualization system.
   3 Copyright (c) 2004, 2005 John Tsiombikas <nuclear@siggraph.org>
   4
   5 3dengfx is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 3dengfx is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with 3dengfx; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19
  20 /* main 3dengfx state control, and low level OpenGL interaction
  21  *
  22  * Author: John Tsiombikas 2004
  23  */
  24
  25 #include "3dengfx_config.h"
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <signal.h>
  30 #include <iostream>
  31 #include <list>
  32 #include "opengl.h"
  33 #include "fxwt/fxwt.hpp"
  34 #include "fxwt/init.hpp"
  35 #include "fxwt/gfx_library.h"
  36 #include "3denginefx.hpp"
  37 #include "texman.hpp"
  38 #include "sdrman.hpp"
  39 #include "camera.hpp"
  40 #include "gfx/3dgeom.hpp"
  41 #include "gfxprog.hpp"
  42 #include "gfx/image.h"
  43 #include "common/config_parser.h"
  44 #include "common/err_msg.h"
  45 #include "dsys/dsys.hpp"
  46
  47 using std::cout;
  48 using std::cerr;
  49 using std::endl;
  50 using std::string;
  51
  52 #ifdef SINGLE_PRECISION_MATH
  53 #define GL_SCALAR_TYPE  GL_FLOAT
  54 #else
  55 #define GL_SCALAR_TYPE  GL_DOUBLE
  56 #endif  // SINGLE_PRECISION_MATH
  57
  58
  59 void (*load_matrix_gl)(const Matrix4x4 &mat);
  60
  61 namespace glext {
  62 #ifdef SINGLE_PRECISION_MATH
  63         PFNGLLOADTRANSPOSEMATRIXFARBPROC glLoadTransposeMatrix;
  64 #else
  65         PFNGLLOADTRANSPOSEMATRIXDARBPROC glLoadTransposeMatrix;
  66 #endif  // SINGLE_PRECISION_MATH
  67
  68         PFNGLACTIVETEXTUREARBPROC glActiveTexture;
  69         PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTexture;
  70
  71         PFNGLBINDBUFFERARBPROC glBindBuffer;
  72         PFNGLBUFFERDATAARBPROC glBufferData;
  73         PFNGLDELETEBUFFERSARBPROC glDeleteBuffers;
  74         PFNGLISBUFFERARBPROC glIsBuffer;
  75         PFNGLMAPBUFFERARBPROC glMapBuffer;
  76         PFNGLUNMAPBUFFERARBPROC glUnmapBuffer;
  77         PFNGLGENBUFFERSARBPROC glGenBuffers;
  78
  79         // fragment/vertex program extensions
  80         PFNGLBINDPROGRAMARBPROC glBindProgram;
  81         PFNGLGENPROGRAMSARBPROC glGenPrograms;
  82         PFNGLDELETEPROGRAMSARBPROC glDeletePrograms;
  83         PFNGLPROGRAMSTRINGARBPROC glProgramString;
  84
  85         // point parameters
  86         PFNGLPOINTPARAMETERFARBPROC glPointParameterf;
  87         PFNGLPOINTPARAMETERFVARBPROC glPointParameterfv;
  88
  89         // --- OpenGL 2.0 Shading Language ---
  90
  91         // - objects
  92         PFNGLDELETEOBJECTARBPROC glDeleteObject;
  93         PFNGLATTACHOBJECTARBPROC glAttachObject;
  94         PFNGLDETACHOBJECTARBPROC glDetachObject;
  95         PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameteriv;
  96         PFNGLGETINFOLOGARBPROC glGetInfoLog;
  97
  98         // - program objects
  99         PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObject;
 100         PFNGLLINKPROGRAMARBPROC glLinkProgram;
 101         PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObject;
 102
 103         // - shader objects
 104         PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObject;
 105         PFNGLSHADERSOURCEARBPROC glShaderSource;
 106         PFNGLCOMPILESHADERARBPROC glCompileShader;
 107
 108         // - uniforms
 109         PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocation;
 110         PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniform;
 111         PFNGLUNIFORM1IARBPROC glUniform1i;
 112         PFNGLUNIFORM1FARBPROC glUniform1f;
 113         PFNGLUNIFORM2FARBPROC glUniform2f;
 114         PFNGLUNIFORM3FARBPROC glUniform3f;
 115         PFNGLUNIFORM4FARBPROC glUniform4f;
 116         PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fv;
 117         PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fv;
 118 }
 119
 120 using namespace glext;
 121
 122 static const char *gl_error_string[] = {
 123         "GL_INVALID_ENUM",              // 0x500
 124         "GL_INVALID_VALUE",             // 0x501
 125         "GL_INVALID_OPERATION", // 0x502
 126         "GL_STACK_OVERFLOW",    // 0x503
 127         "GL_STACK_UNDERFLOW",   // 0x504
 128         "GL_OUT_OF_MEMORY",             // 0x505
 129         "GL_NO_ERROR",                  // 0x0
 130         "[INVALID ERROR NUMBER]"
 131 };
 132
 133 ///////////////// local 3d engine state block ///////////////////
 134 static bool gc_valid;
 135 static GraphicsInitParameters gparams;
 136 static Matrix4x4 tex_matrix[8];
 137 static int coord_index[MAX_TEXTURES];
 138 static PrimitiveType primitive_type;
 139 static StencilOp stencil_fail, stencil_pass, stencil_pzfail;
 140 static int stencil_ref;
 141 static bool mipmapping = true;
 142 static TextureDim ttype[8];     // the type of each texture bound to each texunit (1D/2D/3D/CUBE)
 143
 144 namespace engfx_state {
 145         SysCaps sys_caps;
 146         Matrix4x4 world_matrix;
 147         Matrix4x4 view_matrix, inv_view_matrix;
 148         const Camera *view_mat_camera;
 149         Matrix4x4 proj_matrix;
 150         const Light *bump_light;
 151         int light_count;
 152 }
 153
 154 using namespace engfx_state;
 155
 156 GraphicsInitParameters *load_graphics_context_config(const char *fname) {
 157         static GraphicsInitParameters gip;
 158         gip.x = 640;
 159         gip.y = 480;
 160         gip.bpp = 16;
 161         gip.depth_bits = 16;
 162         gip.stencil_bits = 8;
 163         gip.dont_care_flags = 0;
 164
 165         if(load_config_file(fname) == -1) {
 166                 error("%s: could not load config file", __func__);
 167                 return 0;
 168         }
 169
 170         const ConfigOption *cfgopt;
 171         while((cfgopt = get_next_option())) {
 172
 173                 if(!strcmp(cfgopt->option, "fullscreen")) {
 174                         if(!strcmp(cfgopt->str_value, "true")) {
 175                                 gip.fullscreen = true;
 176                         } else if(!strcmp(cfgopt->str_value, "false")) {
 177                                 gip.fullscreen = false;
 178                         } else {
 179                                 error("%s: error parsing config file %s", __func__, fname);
 180                                 return 0;
 181                         }
 182                 } else if(!strcmp(cfgopt->option, "resolution")) {
 183                         if(!isdigit(cfgopt->str_value[0])) {
 184                                 error("%s: error parsing config file %s", __func__, fname);
 185                                 return 0;
 186                         }
 187                         gip.x = atoi(cfgopt->str_value);
 188
 189                         char *ptr = cfgopt->str_value;
 190                         while(*ptr && *ptr != 'x') *ptr++;
 191                         if(!*ptr || !*(ptr+1) || !isdigit(*(ptr+1))) {
 192                                 error("%s: error parsing config file %s", __func__, fname);
 193                                 return 0;
 194                         }
 195
 196                         gip.y = atoi(ptr + 1);
 197                 } else if(!strcmp(cfgopt->option, "bpp")) {
 198                         if(cfgopt->flags & CFGOPT_INT) {
 199                                 gip.bpp = cfgopt->int_value;
 200                         } else if(!strcmp(cfgopt->str_value, "dontcare")) {
 201                                 gip.bpp = 32;
 202                                 gip.dont_care_flags |= DONT_CARE_BPP;
 203                         } else {
 204                                 error("%s: error parsing config file %s", __func__, fname);
 205                                 return 0;
 206                         }
 207                 } else if(!strcmp(cfgopt->option, "zbuffer")) {
 208                         if(cfgopt->flags & CFGOPT_INT) {
 209                                 gip.depth_bits = cfgopt->int_value;
 210                         } else if(!strcmp(cfgopt->str_value, "dontcare")) {
 211                                 gip.depth_bits = 32;
 212                                 gip.dont_care_flags |= DONT_CARE_DEPTH;
 213                         } else {
 214                                 error("%s: error parsing config file %s", __func__, fname);
 215                                 return 0;
 216                         }
 217                 } else if(!strcmp(cfgopt->option, "stencil")) {
 218                         if(cfgopt->flags & CFGOPT_INT) {
 219                                 gip.stencil_bits = cfgopt->int_value;
 220                         } else if(!strcmp(cfgopt->str_value, "dontcare")) {
 221                                 gip.stencil_bits = 8;
 222                                 gip.dont_care_flags |= DONT_CARE_STENCIL;
 223                         } else {
 224                                 error("%s: error parsing config file %s", __func__, fname);
 225                                 return 0;
 226                         }
 227                 }
 228         }
 229
 230         destroy_config_parser();
 231
 232         return &gip;
 233 }
 234
 235 /* ---- get_system_capabilities() ----
 236  * Retrieves information on the graphics subsystem capabilities
 237  * and returns a SysCaps structure describing them
 238  */
 239 SysCaps get_system_capabilities() {
 240         static bool first_call = true;
 241
 242         if(!first_call) {
 243                 return sys_caps;
 244         }
 245         first_call = false;
 246
 247         // get extensions & vendor strings
 248         const char *tmp_str = (const char*)glGetString(GL_EXTENSIONS);
 249         if(!tmp_str) {
 250                 error("%s: glGetString() failed, possibly no valid GL context", __func__);
 251                 exit(-1);
 252         }
 253         char *ext_str = new char[strlen(tmp_str) + 1];
 254         strcpy(ext_str, tmp_str);
 255
 256         char *cptr = ext_str;
 257         while(*cptr) {
 258                 if(*cptr == ' ') *cptr = '\n';
 259                 cptr++;
 260         }
 261
 262         set_verbosity(2);
 263         info("Supported extensions:\n-------------\n%s", ext_str);
 264         set_verbosity(3);
 265
 266         info("Rendering System Information:");
 267
 268         const char *vendor = (const char*)glGetString(GL_VENDOR);
 269         info("  Vendor: %s", vendor);
 270         info("Renderer: %s", glGetString(GL_RENDERER));
 271         info(" Version: %s", glGetString(GL_VERSION));
 272         info("(note: the list of extensions is logged seperately at \"gl_ext.log\")");
 273
 274         // fill the SysCaps structure
 275         //SysCaps sys_caps;
 276         sys_caps.multitex = (bool)strstr(ext_str, "GL_ARB_multitexture");
 277         sys_caps.load_transpose = (bool)strstr(ext_str, "GL_ARB_transpose_matrix");
 278         sys_caps.gen_mipmaps = (bool)strstr(ext_str, "GL_SGIS_generate_mipmap");
 279         sys_caps.tex_combine_ops = (bool)strstr(ext_str, "GL_ARB_texture_env_combine");
 280         sys_caps.bump_dot3 = (bool)strstr(ext_str, "GL_ARB_texture_env_dot3");
 281         sys_caps.bump_env = (bool)strstr(ext_str, "GL_ATI_envmap_bumpmap");
 282         sys_caps.vertex_buffers = (bool)strstr(ext_str, "GL_ARB_vertex_buffer_object");
 283         sys_caps.depth_texture = (bool)strstr(ext_str, "GL_ARB_depth_texture");
 284         sys_caps.shadow_mapping = (bool)strstr(ext_str, "GL_ARB_shadow");
 285         sys_caps.point_sprites = (bool)strstr(ext_str, "GL_ARB_point_sprite");
 286         sys_caps.point_params = (bool)strstr(ext_str, "GL_ARB_point_parameters");
 287         glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &sys_caps.max_texture_units);
 288         sys_caps.non_power_of_two_textures = (bool)strstr(ext_str, "GL_ARB_texture_non_power_of_two");
 289         glGetIntegerv(GL_MAX_LIGHTS, &sys_caps.max_lights);
 290
 291         sys_caps.prog.asm_vertex = (bool)strstr(ext_str, "GL_ARB_vertex_program");
 292         sys_caps.prog.asm_pixel = (bool)strstr(ext_str, "GL_ARB_fragment_program");
 293         sys_caps.prog.glslang = (bool)strstr(ext_str, "GL_ARB_shading_language_100");
 294         sys_caps.prog.shader_obj = (bool)strstr(ext_str, "GL_ARB_shader_objects");
 295         sys_caps.prog.glsl_vertex = (bool)strstr(ext_str, "GL_ARB_vertex_shader");
 296         sys_caps.prog.glsl_pixel = (bool)strstr(ext_str, "GL_ARB_fragment_shader");
 297
 298         delete [] ext_str;
 299
 300         // also log these things
 301         info("-------------------");
 302         info("System Capabilities");
 303         info("-------------------");
 304         info("Load transposed matrices: %s", sys_caps.load_transpose ? "yes" : "no");
 305         info("Auto-generate mipmaps (SGIS): %s", sys_caps.gen_mipmaps ? "yes" : "no");
 306         info("Custom texture combination operations: %s", sys_caps.tex_combine_ops ? "yes" : "no");
 307         info("Diffuse bump mapping (dot3): %s", sys_caps.bump_dot3 ? "yes" : "no");
 308         info("Specular bump mapping (env-bump): %s", sys_caps.bump_env ? "yes" : "no");
 309         info("Video memory vertex/index buffers: %s", sys_caps.vertex_buffers ? "yes" : "no");
 310         info("Depth texture: %s", sys_caps.depth_texture ? "yes" : "no");
 311         info("Shadow mapping: %s", sys_caps.shadow_mapping ? "yes" : "no");
 312         info("Programmable vertex processing (asm): %s", sys_caps.prog.asm_vertex ? "yes" : "no");
 313         info("Programmable pixel processing (asm): %s", sys_caps.prog.asm_pixel ? "yes" : "no");
 314         info("OpenGL 2.0 shading language: %s", sys_caps.prog.glslang ? "yes" : "no");
 315         info("Programmable vertex processing (glsl): %s", sys_caps.prog.glsl_vertex ? "yes" : "no");
 316         info("Programmable pixel processing (glsl): %s", sys_caps.prog.glsl_pixel ? "yes" : "no");
 317         info("Point sprites: %s", sys_caps.point_sprites ? "yes" : "no");
 318         info("Point parameters: %s", sys_caps.point_params ? "yes" : "no");
 319         info("Non power of 2 textures: %s", sys_caps.non_power_of_two_textures ? "yes" : "no");
 320         info("Texture units: %d", sys_caps.max_texture_units);
 321         info("Max lights: %d", sys_caps.max_lights);
 322
 323         if(!sys_caps.point_sprites && !sys_caps.point_params) {
 324                 warning("no point sprites support, falling back to billboards which *may* degrade particle system performance");
 325         }
 326
 327         return sys_caps;
 328 }
 329
 330 const char *get_glerror_string(GLenum error) {
 331         if(!error) return gl_error_string[0x506];
 332         if(error < 0x500 || error > 0x505) error = 0x507;
 333         return gl_error_string[error - 0x500];
 334 }
 335
 336 /* load_matrix_transpose_arb() & load_matrix_transpose_manual()
 337  * --------------------------------------------------------
 338  * two functions to handle the transformation matrix loading
 339  * to OpenGL by either transposing the Matrix4x4 data or using
 340  * the transposed-loading extension (use through function pointer
 341  * LoadMatrixGL which is set during initialization to the correct one)
 342  */
 343 void load_matrix_transpose_arb(const Matrix4x4 &mat) {
 344         glLoadTransposeMatrix(mat.opengl_matrix());
 345 }
 346
 347 void load_matrix_transpose_manual(const Matrix4x4 &mat) {
 348 #ifdef SINGLE_PRECISION_MATH
 349         glLoadMatrixf(mat.transposed().opengl_matrix());
 350 #else
 351         glLoadMatrixd(mat.transposed().opengl_matrix());
 352 #endif  // SINGLE_PRECISION_MATH
 353 }
 354
 355
 356 //////////////// 3D Engine Initialization ////////////////
 357
 358 static const char *signame(int sig) {
 359         switch(sig) {
 360         case SIGSEGV:
 361                 return "segmentation fault (SIGSEGV)";
 362         case SIGILL:
 363                 return "illegal instruction (SIGILL)";
 364         case SIGTERM:
 365                 return "termination signal (SIGTERM)";
 366         case SIGFPE:
 367                 return "floating point exception (SIGFPE)";
 368         case SIGINT:
 369                 return "interrupt signal (SIGINT)";
 370         default:
 371                 return "unknown";
 372         }
 373         return "can't happen";
 374 }
 375
 376 static void signal_handler(int sig) {
 377         error("It seems this is the end... caught %s, exiting...", signame(sig));
 378         destroy_graphics_context();
 379         exit(EXIT_FAILURE);
 380 }
 381
 382 /* ---- create_graphics_context() ----
 383  * initializes the graphics subsystem according to the init parameters
 384  */
 385 bool create_graphics_context(const GraphicsInitParameters &gip) {
 386
 387         gparams = gip;
 388
 389         remove(get_log_filename());
 390
 391         if(!fxwt::init_graphics(&gparams)) {
 392                 return false;
 393         }
 394
 395         signal(SIGSEGV, signal_handler);
 396         signal(SIGILL, signal_handler);
 397         signal(SIGTERM, signal_handler);
 398         signal(SIGFPE, signal_handler);
 399         signal(SIGINT, signal_handler);
 400
 401 #if GFX_LIBRARY == GTK
 402         fxwt::init();
 403         dsys::init();
 404         return true;
 405 #else
 406         if(!start_gl()) return false;
 407         fxwt::init();
 408         dsys::init();
 409         return true;
 410 #endif  // GTK
 411 }
 412
 413 /*
 414  * short graphics context creation
 415  * creates a graphics context (windowed or fullscreen)
 416  * given only the wanted resolution and a fullscreen flag.
 417  */
 418 bool create_graphics_context(int x, int y, bool fullscreen)
 419 {
 420         GraphicsInitParameters gip;
 421         gip.x = x;
 422         gip.y = y;
 423         gip.bpp = 32;
 424         gip.depth_bits = 32;
 425         gip.fullscreen = fullscreen;
 426         gip.stencil_bits = 8;
 427         gip.dont_care_flags = DONT_CARE_DEPTH | DONT_CARE_STENCIL | DONT_CARE_BPP;
 428
 429         return create_graphics_context(gip);
 430 }
 431
 432 /* OpenGL startup after initialization */
 433 bool start_gl() {
 434         SysCaps sys_caps = get_system_capabilities();
 435
 436         glext::glActiveTexture = (PFNGLACTIVETEXTUREARBPROC)glGetProcAddress("glActiveTextureARB");
 437         glext::glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREARBPROC)glGetProcAddress("glClientActiveTextureARB");
 438
 439         if(!glext::glActiveTexture || !glext::glClientActiveTexture) {
 440                 warning("No multitexturing support.");
 441                 sys_caps.multitex = false;
 442         }
 443
 444         if(sys_caps.load_transpose) {
 445 #ifdef SINGLE_PRECISION_MATH
 446                 glLoadTransposeMatrix = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)glGetProcAddress("glLoadTransposeMatrixfARB");
 447 #else
 448                 glLoadTransposeMatrix = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)glGetProcAddress("glLoadTransposeMatrixdARB");
 449 #endif  // SINGLE_PRECISION_MATH
 450
 451                 load_matrix_gl = load_matrix_transpose_arb;
 452         } else {
 453                 load_matrix_gl = load_matrix_transpose_manual;
 454         }
 455
 456         if(sys_caps.vertex_buffers) {
 457                 glBindBuffer = (PFNGLBINDBUFFERARBPROC)glGetProcAddress("glBindBufferARB");
 458                 glBufferData = (PFNGLBUFFERDATAARBPROC)glGetProcAddress("glBufferDataARB");
 459                 glDeleteBuffers = (PFNGLDELETEBUFFERSARBPROC)glGetProcAddress("glDeleteBuffersARB");
 460                 glIsBuffer = (PFNGLISBUFFERARBPROC)glGetProcAddress("glIsBufferARB");
 461                 glMapBuffer = (PFNGLMAPBUFFERARBPROC)glGetProcAddress("glMapBufferARB");
 462                 glUnmapBuffer = (PFNGLUNMAPBUFFERARBPROC)glGetProcAddress("glUnmapBufferARB");
 463                 glGenBuffers = (PFNGLGENBUFFERSARBPROC)glGetProcAddress("glGenBuffersARB");
 464         }
 465
 466         if(sys_caps.prog.asm_vertex || sys_caps.prog.asm_pixel) {
 467                 glBindProgram = (PFNGLBINDPROGRAMARBPROC)glGetProcAddress("glBindProgramARB");
 468                 glGenPrograms = (PFNGLGENPROGRAMSARBPROC)glGetProcAddress("glGenProgramsARB");
 469                 glDeletePrograms = (PFNGLDELETEPROGRAMSARBPROC)glGetProcAddress("glDeleteProgramsARB");
 470                 glProgramString = (PFNGLPROGRAMSTRINGARBPROC)glGetProcAddress("glProgramStringARB");
 471         }
 472
 473         if(sys_caps.prog.shader_obj) {
 474                 glDeleteObject = (PFNGLDELETEOBJECTARBPROC)glGetProcAddress("glDeleteObjectARB");
 475                 glAttachObject = (PFNGLATTACHOBJECTARBPROC)glGetProcAddress("glAttachObjectARB");
 476                 glDetachObject = (PFNGLDETACHOBJECTARBPROC)glGetProcAddress("glDetachObjectARB");
 477                 glGetObjectParameteriv = (PFNGLGETOBJECTPARAMETERIVARBPROC)glGetProcAddress("glGetObjectParameterivARB");
 478                 glGetInfoLog = (PFNGLGETINFOLOGARBPROC)glGetProcAddress("glGetInfoLogARB");
 479
 480                 glCreateProgramObject = (PFNGLCREATEPROGRAMOBJECTARBPROC)glGetProcAddress("glCreateProgramObjectARB");
 481                 glLinkProgram = (PFNGLLINKPROGRAMARBPROC)glGetProcAddress("glLinkProgramARB");
 482                 glUseProgramObject = (PFNGLUSEPROGRAMOBJECTARBPROC)glGetProcAddress("glUseProgramObjectARB");
 483
 484                 glCreateShaderObject = (PFNGLCREATESHADEROBJECTARBPROC)glGetProcAddress("glCreateShaderObjectARB");
 485                 glShaderSource = (PFNGLSHADERSOURCEARBPROC)glGetProcAddress("glShaderSourceARB");
 486                 glCompileShader = (PFNGLCOMPILESHADERARBPROC)glGetProcAddress("glCompileShaderARB");
 487
 488                 glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONARBPROC)glGetProcAddress("glGetUniformLocationARB");
 489                 glGetActiveUniform = (PFNGLGETACTIVEUNIFORMARBPROC)glGetProcAddress("glGetActiveUniformARB");
 490                 glUniform1i = (PFNGLUNIFORM1IARBPROC)glGetProcAddress("glUniform1iARB");
 491                 glUniform1f = (PFNGLUNIFORM1FARBPROC)glGetProcAddress("glUniform1fARB");
 492                 glUniform2f = (PFNGLUNIFORM2FARBPROC)glGetProcAddress("glUniform2fARB");
 493                 glUniform3f = (PFNGLUNIFORM3FARBPROC)glGetProcAddress("glUniform3fARB");
 494                 glUniform4f = (PFNGLUNIFORM4FARBPROC)glGetProcAddress("glUniform4fARB");
 495                 glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVARBPROC)glGetProcAddress("glUniformMatrix3fvARB");
 496                 glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVARBPROC)glGetProcAddress("glUniformMatrix4fvARB");
 497         }
 498
 499         if(sys_caps.point_params) {
 500                 glext::glPointParameterf = (PFNGLPOINTPARAMETERFARBPROC)glGetProcAddress("glPointParameterfARB");
 501                 glext::glPointParameterfv = (PFNGLPOINTPARAMETERFVARBPROC)glGetProcAddress("glPointParameterfvARB");
 502
 503                 if(!glext::glPointParameterfv) {
 504                         error("error loading glPointParameterfv");
 505                         return false;
 506                 }
 507                 if(!glext::glPointParameterf) {
 508                         error("error loading glPointParameterf");
 509                         return false;
 510                 }
 511         }
 512
 513         gc_valid = true;
 514
 515         set_default_states();
 516         return true;
 517 }
 518
 519 void destroy_graphics_context() {
 520         static bool destroy_called_again = false;
 521
 522         if(destroy_called_again) {
 523                 warning("Multiple destroy_graphics_context() calls");
 524                 return;
 525         } else {
 526                 destroy_called_again = true;
 527         }
 528
 529         dsys::clean_up();
 530         if(!gc_valid) return;
 531         gc_valid = false;
 532         info("3d engine shutting down...");
 533         destroy_textures();
 534         destroy_shaders();
 535         fxwt::destroy_graphics();
 536 }
 537
 538 void set_default_states() {
 539         set_primitive_type(TRIANGLE_LIST);
 540         set_front_face(ORDER_CW);
 541         set_backface_culling(true);
 542         set_zbuffering(true);
 543         set_lighting(true);
 544         set_auto_normalize(false);
 545
 546         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
 547         glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
 548
 549         set_matrix(XFORM_WORLD, Matrix4x4());
 550         set_matrix(XFORM_VIEW, Matrix4x4());
 551         set_matrix(XFORM_PROJECTION, create_projection_matrix(quarter_pi, 1.333333f, 1.0f, 1000.0f));
 552
 553         memset(coord_index, 0, MAX_TEXTURES * sizeof(int));
 554
 555         for(int i=0; i<8; i++) {
 556                 ttype[i] = TEX_2D;
 557         }
 558
 559         if(sys_caps.point_params) {
 560                 glext::glPointParameterf(GL_POINT_SIZE_MIN_ARB, 1.0);
 561                 glext::glPointParameterf(GL_POINT_SIZE_MAX_ARB, 256.0);
 562
 563                 float quadratic[] = {0.0f, 0.0f, 0.01f};
 564                 glext::glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION_ARB, quadratic);
 565         }
 566 }
 567
 568 const GraphicsInitParameters *get_graphics_init_parameters() {
 569         return &gparams;
 570 }
 571
 572 void clear(const Color &color) {
 573         glClearColor(color.r, color.g, color.b, color.a);
 574         glClear(GL_COLOR_BUFFER_BIT);
 575 }
 576
 577 void clear_zbuffer(scalar_t zval) {
 578         glClearDepth(zval);
 579         glClear(GL_DEPTH_BUFFER_BIT);
 580 }
 581
 582 void clear_stencil(unsigned char sval) {
 583         glClearStencil(sval);
 584         glClear(GL_STENCIL_BUFFER_BIT);
 585 }
 586
 587 void clear_zbuffer_stencil(scalar_t zval, unsigned char sval) {
 588         glClearDepth(zval);
 589         glClearStencil(sval);
 590         glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 591 }
 592
 593 void flip() {
 594         glFlush();
 595         glFinish();
 596         fxwt::swap_buffers();
 597 }
 598
 599 void load_xform_matrices() {
 600         for(int i=0; i<sys_caps.max_texture_units; i++) {
 601                 select_texture_unit(i);
 602                 glMatrixMode(GL_TEXTURE);
 603                 load_matrix_gl(tex_matrix[i]);
 604         }
 605
 606         glMatrixMode(GL_PROJECTION);
 607         load_matrix_gl(proj_matrix);
 608
 609         Matrix4x4 modelview = view_matrix * world_matrix;
 610         glMatrixMode(GL_MODELVIEW);
 611         load_matrix_gl(modelview);
 612 }
 613
 614 #define BUFFER_OFFSET(i) ((char *)NULL + (i))
 615
 616 void draw(const VertexArray &varray) {
 617         load_xform_matrices();
 618
 619         bool use_vbo = !varray.get_dynamic() && sys_caps.vertex_buffers;
 620
 621         glEnableClientState(GL_VERTEX_ARRAY);
 622         glEnableClientState(GL_COLOR_ARRAY);
 623         glEnableClientState(GL_NORMAL_ARRAY);
 624
 625         if(use_vbo) {
 626                 Vertex v;
 627                 glBindBuffer(GL_ARRAY_BUFFER_ARB, varray.get_buffer_object());
 628                 glVertexPointer(3, GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.pos - (char*)&v));
 629                 glNormalPointer(GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.normal - (char*)&v));
 630                 glColorPointer(4, GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.color - (char*)&v));
 631
 632                 for(int i=0; i<MAX_TEXTURES; i++) {
 633                         select_texture_unit(i);
 634                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 635
 636                         int dim = ttype[i] == TEX_1D ? 1 : (ttype[i] == TEX_3D || ttype[i] == TEX_CUBE ? 3 : 2);
 637                         glTexCoordPointer(dim, GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.tex[coord_index[i]] - (char*)&v));
 638                 }
 639
 640                 glBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
 641         } else {
 642                 glVertexPointer(3, GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->pos);
 643                 glNormalPointer(GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->normal);
 644                 glColorPointer(4, GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->color);
 645
 646                 for(int i=0; i<MAX_TEXTURES; i++) {
 647                         select_texture_unit(i);
 648                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 649
 650                         int dim = ttype[i] == TEX_1D ? 1 : (ttype[i] == TEX_3D || ttype[i] == TEX_CUBE ? 3 : 2);
 651                         glTexCoordPointer(dim, GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->tex[coord_index[i]]);
 652                 }
 653         }
 654
 655         glDrawArrays(primitive_type, 0, varray.get_count());
 656
 657         glDisableClientState(GL_VERTEX_ARRAY);
 658         glDisableClientState(GL_COLOR_ARRAY);
 659         glDisableClientState(GL_NORMAL_ARRAY);
 660
 661         for(int i=0; i<MAX_TEXTURES; i++) {
 662                 select_texture_unit(i);
 663                 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 664         }
 665 }
 666
 667 void draw(const VertexArray &varray, const IndexArray &iarray) {
 668         load_xform_matrices();
 669
 670         bool use_vbo = !varray.get_dynamic() && sys_caps.vertex_buffers;
 671         bool use_ibo = false;//!iarray.get_dynamic() && sys_caps.vertex_buffers;
 672
 673         glEnableClientState(GL_VERTEX_ARRAY);
 674         glEnableClientState(GL_COLOR_ARRAY);
 675         glEnableClientState(GL_NORMAL_ARRAY);
 676
 677         if(use_vbo) {
 678                 Vertex v;
 679                 glBindBuffer(GL_ARRAY_BUFFER_ARB, varray.get_buffer_object());
 680                 glVertexPointer(3, GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.pos - (char*)&v));
 681                 glNormalPointer(GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.normal - (char*)&v));
 682                 glColorPointer(4, GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.color - (char*)&v));
 683
 684                 for(int i=0; i<MAX_TEXTURES; i++) {
 685                         select_texture_unit(i);
 686                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 687
 688                         int dim = ttype[i] == TEX_1D ? 1 : (ttype[i] == TEX_3D || ttype[i] == TEX_CUBE ? 3 : 2);
 689                         glTexCoordPointer(dim, GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.tex[coord_index[i]] - (char*)&v));
 690                 }
 691
 692                 glBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
 693         } else {
 694                 glVertexPointer(3, GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->pos);
 695                 glNormalPointer(GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->normal);
 696                 glColorPointer(4, GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->color);
 697
 698                 for(int i=0; i<MAX_TEXTURES; i++) {
 699                         select_texture_unit(i);
 700                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 701
 702                         int dim = ttype[i] == TEX_1D ? 1 : (ttype[i] == TEX_3D || ttype[i] == TEX_CUBE ? 3 : 2);
 703                         glTexCoordPointer(dim, GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->tex[coord_index[i]]);
 704                 }
 705         }
 706
 707         if(use_ibo) {
 708                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, iarray.get_buffer_object());
 709                 glDrawElements(primitive_type, iarray.get_count(), GL_UNSIGNED_INT, 0);
 710                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
 711         } else {
 712                 glDrawElements(primitive_type, iarray.get_count(), GL_UNSIGNED_INT, iarray.get_data());
 713         }
 714
 715         glDisableClientState(GL_VERTEX_ARRAY);
 716         glDisableClientState(GL_COLOR_ARRAY);
 717         glDisableClientState(GL_NORMAL_ARRAY);
 718
 719         for(int i=0; i<MAX_TEXTURES; i++) {
 720                 select_texture_unit(i);
 721                 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 722         }
 723 }
 724
 725
 726 /* draw_line(start_vertex, end_vertex, start_width, end_width)
 727  * Draws a line as a cylindrically billboarded elongated quad.
 728  */
 729 void draw_line(const Vertex &v1, const Vertex &v2, scalar_t w1, scalar_t w2, const Color &col) {
 730         if(w2 < 0.0) w2 = w1;
 731
 732         Vector3 p1 = v1.pos;
 733         Vector3 p2 = v2.pos;
 734
 735         Vector3 cam_pos = Vector3(0,0,0).transformed(inv_view_matrix);
 736
 737         Vector3 vec = p2 - p1;
 738         scalar_t len = vec.length();
 739
 740         Basis basis;
 741         basis.k = -(cam_pos - ((p2 + p1) / 2)).normalized();
 742         basis.j = vec / len;
 743         basis.i = cross_product(basis.j, basis.k).normalized();
 744         basis.k = cross_product(basis.i, basis.j).normalized();
 745
 746         world_matrix.set_translation(p1);
 747         world_matrix = world_matrix * Matrix4x4(basis.create_rotation_matrix());
 748         load_xform_matrices();
 749
 750         Vertex quad[] = {
 751                 Vertex(Vector3(-w1, 0, 0), v1.tex[0].u, 0.0, col),
 752                 Vertex(Vector3(-w2, len, 0), v2.tex[0].u, 0.0, col),
 753                 Vertex(Vector3(w2, len, 0), v2.tex[0].u, 1.0, col),
 754                 Vertex(Vector3(w1, 0, 0), v1.tex[0].u, 1.0, col)
 755         };
 756
 757         set_lighting(false);
 758         set_primitive_type(QUAD_LIST);
 759         draw(VertexArray(quad, 4));
 760         set_primitive_type(TRIANGLE_LIST);
 761         set_lighting(true);
 762 }
 763
 764 void draw_point(const Vertex &pt, scalar_t size) {
 765
 766         Vector3 p = pt.pos;
 767
 768         Vector3 cam_pos = Vector3(0,0,0).transformed(inv_view_matrix);
 769
 770         Basis basis;
 771         basis.k = -(cam_pos - p).normalized();
 772         basis.j = Vector3(0, 1, 0);
 773         basis.i = cross_product(basis.j, basis.k);
 774         basis.j = cross_product(basis.k, basis.i);
 775
 776         world_matrix.set_translation(p);
 777         world_matrix = world_matrix * Matrix4x4(basis.create_rotation_matrix());
 778         load_xform_matrices();
 779
 780         Vertex quad[] = {
 781                 Vertex(Vector3(-size, -size, 0), 0.0, 0.0, pt.color),
 782                 Vertex(Vector3(-size, size, 0), 0.0, 1.0, pt.color),
 783                 Vertex(Vector3(size, size, 0), 1.0, 1.0, pt.color),
 784                 Vertex(Vector3(size, -size, 0), 1.0, 0.0, pt.color)
 785         };
 786
 787         set_lighting(false);
 788         set_primitive_type(QUAD_LIST);
 789         draw(VertexArray(quad, 4));
 790         set_primitive_type(TRIANGLE_LIST);
 791         set_lighting(true);
 792
 793 }
 794
 795
 796 void draw_scr_quad(const Vector2 &corner1, const Vector2 &corner2, const Color &color, bool reset_xform) {
 797         if(reset_xform) {
 798                 glMatrixMode(GL_MODELVIEW);
 799                 glPushMatrix();
 800                 glLoadIdentity();
 801         }
 802
 803         glMatrixMode(GL_PROJECTION);
 804         glPushMatrix();
 805         glLoadIdentity();
 806         glOrtho(0.0, 1.0, 1.0, 0.0, 0.0, 1.0);
 807
 808         glDisable(GL_LIGHTING);
 809
 810         glBegin(GL_QUADS);
 811         glColor4f(color.r, color.g, color.b, color.a);
 812         glTexCoord2f(0.0f, 1.0f);
 813         glVertex3f(corner1.x, corner1.y, -0.5);
 814         glTexCoord2f(1.0f, 1.0f);
 815         glVertex3f(corner2.x, corner1.y, -0.5);
 816         glTexCoord2f(1.0f, 0.0f);
 817         glVertex3f(corner2.x, corner2.y, -0.5);
 818         glTexCoord2f(0.0f, 0.0f);
 819         glVertex3f(corner1.x, corner2.y, -0.5);
 820         glEnd();
 821
 822         glEnable(GL_LIGHTING);
 823
 824         glPopMatrix();
 825
 826         if(reset_xform) {
 827                 glMatrixMode(GL_MODELVIEW);
 828                 glPopMatrix();
 829         }
 830 }
 831
 832 int get_texture_unit_count() {
 833         return sys_caps.max_texture_units;
 834 }
 835
 836 //////////////////// render states /////////////////////
 837
 838 void set_primitive_type(PrimitiveType pt) {
 839         primitive_type = pt;
 840 }
 841
 842 void set_backface_culling(bool enable) {
 843         if(enable) {
 844                 glEnable(GL_CULL_FACE);
 845         } else {
 846                 glDisable(GL_CULL_FACE);
 847         }
 848 }
 849
 850 void set_front_face(FaceOrder order) {
 851         glFrontFace(order);
 852 }
 853
 854 void set_auto_normalize(bool enable) {
 855         if(enable) {
 856                 glEnable(GL_NORMALIZE);
 857         } else {
 858                 glDisable(GL_NORMALIZE);
 859         }
 860 }
 861
 862 void set_color_write(bool red, bool green, bool blue, bool alpha) {
 863         glColorMask(red, green, blue, alpha);
 864 }
 865
 866 void set_wireframe(bool enable) {
 867         //set_primitive_type(enable ? LINE_LIST : TRIANGLE_LIST);
 868         glPolygonMode(GL_FRONT_AND_BACK, enable ? GL_LINE : GL_FILL);
 869 }
 870
 871
 872 ///////////////// blending states ///////////////
 873
 874 void set_alpha_blending(bool enable) {
 875         if(enable) {
 876                 glEnable(GL_BLEND);
 877         } else {
 878                 glDisable(GL_BLEND);
 879         }
 880 }
 881
 882 void set_blend_func(BlendingFactor src, BlendingFactor dest) {
 883         glBlendFunc(src, dest);
 884 }
 885
 886 ///////////////// zbuffer states ////////////////
 887
 888 void set_zbuffering(bool enable) {
 889         if(enable) {
 890                 glEnable(GL_DEPTH_TEST);
 891         } else {
 892                 glDisable(GL_DEPTH_TEST);
 893         }
 894 }
 895
 896 void set_zwrite(bool enable) {
 897         glDepthMask(enable);
 898 }
 899
 900 void set_zfunc(CmpFunc func) {
 901         glDepthFunc(func);
 902 }
 903
 904 /////////////// stencil states //////////////////
 905 void set_stencil_buffering(bool enable) {
 906         if(enable) {
 907                 glEnable(GL_STENCIL_TEST);
 908         } else {
 909                 glDisable(GL_STENCIL_TEST);
 910         }
 911 }
 912
 913 void set_stencil_pass_op(StencilOp sop) {
 914         stencil_pass = sop;
 915         glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
 916 }
 917
 918 void set_stencil_fail_op(StencilOp sop) {
 919         stencil_fail = sop;
 920         glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
 921 }
 922
 923 void set_stencil_pass_zfail_op(StencilOp sop) {
 924         stencil_pzfail = sop;
 925         glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
 926 }
 927
 928 void set_stencil_op(StencilOp fail, StencilOp spass_zfail, StencilOp pass) {
 929         stencil_fail = fail;
 930         stencil_pzfail = spass_zfail;
 931         stencil_pass = pass;
 932         glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
 933 }
 934
 935 void set_stencil_func(CmpFunc func) {
 936         glStencilFunc(func, stencil_ref, 0xffffffff);
 937 }
 938
 939 void set_stencil_reference(unsigned int ref) {
 940         stencil_ref = ref;
 941 }
 942
 943 ///////////// texture & material states //////////////
 944
 945 void set_point_sprites(bool enable) {
 946         if(sys_caps.point_sprites) {
 947                 if(enable) {
 948                         glEnable(GL_POINT_SPRITE_ARB);
 949                 } else {
 950                         glDisable(GL_POINT_SPRITE_ARB);
 951                 }
 952         }
 953 }
 954
 955 void set_texture_filtering(int tex_unit, TextureFilteringType tex_filter) {
 956
 957         int min_filter;
 958
 959         switch(tex_filter) {
 960         case POINT_SAMPLING:
 961                 min_filter = mipmapping ? GL_NEAREST_MIPMAP_NEAREST : GL_NEAREST;
 962                 glTexParameteri(ttype[tex_unit], GL_TEXTURE_MIN_FILTER, min_filter);
 963                 glTexParameteri(ttype[tex_unit], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 964                 break;
 965
 966         case BILINEAR_FILTERING:
 967                 min_filter = mipmapping ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR;
 968                 glTexParameteri(ttype[tex_unit], GL_TEXTURE_MIN_FILTER, min_filter);
 969                 glTexParameteri(ttype[tex_unit], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 970                 break;
 971
 972         case TRILINEAR_FILTERING:
 973         default:
 974                 min_filter = mipmapping ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
 975                 glTexParameteri(ttype[tex_unit], GL_TEXTURE_MIN_FILTER, min_filter);
 976                 glTexParameteri(ttype[tex_unit], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 977                 break;
 978         }
 979 }
 980
 981 void set_texture_addressing(int tex_unit, TextureAddressing uaddr, TextureAddressing vaddr) {
 982         glTexParameteri(ttype[tex_unit], GL_TEXTURE_WRAP_S, uaddr);
 983         glTexParameteri(ttype[tex_unit], GL_TEXTURE_WRAP_T, vaddr);
 984 }
 985
 986 void set_texture_border_color(int tex_unit, const Color &color) {
 987         float col[] = {color.r, color.g, color.b, color.a};
 988         glTexParameterfv(ttype[tex_unit], GL_TEXTURE_BORDER_COLOR, col);
 989 }
 990
 991 void set_texture(int tex_unit, const Texture *tex) {
 992         select_texture_unit(tex_unit);
 993         glBindTexture(tex->get_type(), tex->tex_id);
 994         ttype[tex_unit] = tex->get_type();
 995 }
 996
 997 void set_mip_mapping(bool enable) {
 998         mipmapping = enable;
 999 }
1000
1001 void set_material(const Material &mat) {
1002         mat.set_glmaterial();
1003 }
1004
1005 void use_vertex_colors(bool enable) {
1006         if(enable) {
1007                 glEnable(GL_COLOR_MATERIAL);
1008         } else {
1009                 glDisable(GL_COLOR_MATERIAL);
1010         }
1011 }
1012
1013
1014 void set_render_target(Texture *tex, CubeMapFace cube_map_face) {
1015         static std::stack<Texture*> rt_stack;
1016         static std::stack<CubeMapFace> face_stack;
1017
1018         Texture *prev = rt_stack.empty() ? 0 : rt_stack.top();
1019         CubeMapFace prev_face = CUBE_MAP_PX; // just to get rid of the uninitialized var warning
1020         if(!face_stack.empty()) prev_face = face_stack.top();
1021
1022         if(tex == prev) return;
1023
1024         if(prev) {
1025                 set_texture(0, prev);
1026                 glCopyTexSubImage2D(prev->get_type() == TEX_CUBE ? prev_face : GL_TEXTURE_2D, 0, 0, 0, 0, 0, prev->width, prev->height);
1027         }
1028
1029         if(!tex) {
1030                 rt_stack.pop();
1031                 if(prev->get_type() == TEX_CUBE) {
1032                         face_stack.pop();
1033
1034                         if(rt_stack.empty()) {
1035                                 set_viewport(0, 0, gparams.x, gparams.y);
1036                         } else {
1037                                 set_viewport(0, 0, rt_stack.top()->width, rt_stack.top()->height);
1038                         }
1039                 }
1040         } else {
1041                 if(tex->get_type() == TEX_CUBE) {
1042                         set_viewport(0, 0, tex->width, tex->height);
1043                 }
1044
1045                 rt_stack.push(tex);
1046                 if(tex->get_type() == TEX_CUBE) face_stack.push(cube_map_face);
1047         }
1048 }
1049
1050 void copy_texture(Texture *tex, bool full_screen) {
1051         if(!tex) return;
1052
1053         int width = full_screen ? get_graphics_init_parameters()->x : tex->width;
1054         int height = full_screen ? get_graphics_init_parameters()->y : tex->height;
1055
1056         set_texture(0, tex);
1057         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width, height);
1058 }
1059
1060 // multitexturing interface
1061
1062 void select_texture_unit(int tex_unit) {
1063         if(sys_caps.multitex) {
1064                 glext::glActiveTexture(GL_TEXTURE0 + tex_unit);
1065                 glext::glClientActiveTexture(GL_TEXTURE0 + tex_unit);
1066         }
1067 }
1068
1069 void enable_texture_unit(int tex_unit) {
1070         if(!tex_unit || (sys_caps.multitex && tex_unit < sys_caps.max_texture_units)) {
1071                 select_texture_unit(tex_unit);
1072                 glEnable(ttype[tex_unit]);
1073         }
1074 }
1075
1076 void disable_texture_unit(int tex_unit) {
1077         if(!tex_unit || (sys_caps.multitex && tex_unit < sys_caps.max_texture_units)) {
1078                 select_texture_unit(tex_unit);
1079                 glDisable(ttype[tex_unit]);
1080         }
1081 }
1082
1083 void set_texture_unit_color(int tex_unit, TextureBlendFunction op, TextureBlendArgument arg1, TextureBlendArgument arg2, TextureBlendArgument arg3) {
1084
1085         select_texture_unit(tex_unit);
1086         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
1087         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, op);
1088         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, arg1);
1089         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, arg2);
1090         if(arg3 != TARG_NONE) {
1091                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, arg3);
1092         }
1093 }
1094
1095 void set_texture_unit_alpha(int tex_unit, TextureBlendFunction op, TextureBlendArgument arg1, TextureBlendArgument arg2, TextureBlendArgument arg3) {
1096
1097         select_texture_unit(tex_unit);
1098         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
1099         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, op);
1100         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, arg1);
1101         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, arg2);
1102         if(arg3 != TARG_NONE) {
1103                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, arg3);
1104         }
1105 }
1106
1107 void set_texture_coord_index(int tex_unit, int index) {
1108         coord_index[tex_unit] = index;
1109 }
1110
1111 void set_texture_constant(int tex_unit, const Color &col) {
1112         float color[] = {col.r, col.g, col.b, col.a};
1113         select_texture_unit(tex_unit);
1114         glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
1115 }
1116
1117 //void set_texture_transform_state(int sttex_unitage, TexTransformState TexXForm);
1118 //void set_texture_coord_generator(int stage, TexGen tgen);
1119
1120 void set_point_sprite_coords(int tex_unit, bool enable) {
1121         if(sys_caps.point_params) {
1122                 select_texture_unit(tex_unit);
1123                 glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, enable ? GL_TRUE : GL_FALSE);
1124         }
1125 }
1126
1127
1128 // programmable interface
1129 void set_gfx_program(GfxProg *prog) {
1130         if(!sys_caps.prog.glslang) return;
1131         if(prog) {
1132                 if(!prog->linked) {
1133                         prog->link();
1134                         if(!prog->linked) return;
1135                 }
1136                 glUseProgramObject(prog->prog);
1137
1138                 // call any registered update handlers
1139                 if(prog->update_handler) {
1140                         prog->update_handler(prog);
1141                 }
1142         } else {
1143                 glUseProgramObject(0);
1144         }
1145 }
1146
1147 // lighting states
1148 void set_lighting(bool enable) {
1149         if(enable) {
1150                 glEnable(GL_LIGHTING);
1151         } else {
1152                 glDisable(GL_LIGHTING);
1153         }
1154 }
1155
1156 void set_ambient_light(const Color &ambient_color) {
1157         float col[] = {ambient_color.r, ambient_color.g, ambient_color.b, ambient_color.a};
1158         glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
1159 }
1160
1161 void set_shading_mode(ShadeMode mode) {
1162         glShadeModel(mode);
1163 }
1164
1165 void set_bump_light(const Light *light) {
1166         bump_light = light;
1167 }
1168
1169 // transformation matrices
1170 void set_matrix(TransformType xform_type, const Matrix4x4 &mat, int num) {
1171         switch(xform_type) {
1172         case XFORM_WORLD:
1173                 world_matrix = mat;
1174                 break;
1175
1176         case XFORM_VIEW:
1177                 view_matrix = mat;
1178                 inv_view_matrix = view_matrix.inverse();
1179                 view_mat_camera = 0;
1180                 break;
1181
1182         case XFORM_PROJECTION:
1183                 proj_matrix = mat;
1184                 break;
1185
1186         case XFORM_TEXTURE:
1187                 tex_matrix[num] = mat;
1188                 break;
1189         }
1190 }
1191
1192 Matrix4x4 get_matrix(TransformType xform_type, int num) {
1193         switch(xform_type) {
1194         case XFORM_WORLD:
1195                 return world_matrix;
1196
1197         case XFORM_VIEW:
1198                 return view_matrix;
1199
1200         case XFORM_TEXTURE:
1201                 return tex_matrix[num];
1202
1203         case XFORM_PROJECTION:
1204         default:
1205                 return proj_matrix;
1206         }
1207 }
1208
1209 void set_viewport(unsigned int x, unsigned int y, unsigned int xsize, unsigned int ysize) {
1210         glViewport(x, y, xsize, ysize);
1211 }
1212
1213 // normalized set_viewport()
1214 void set_viewport_norm(float x, float y, float xsize, float ysize)
1215 {
1216         glViewport((int) (x * gparams.x), (int)(y * gparams.y),
1217                 (int) (xsize * gparams.x), int (ysize * gparams.y));
1218 }
1219
1220 Matrix4x4 create_projection_matrix(scalar_t vfov, scalar_t aspect, scalar_t near_clip, scalar_t far_clip) {
1221 #ifdef COORD_LHS
1222         scalar_t hfov = vfov * aspect;
1223         scalar_t w = 1.0f / (scalar_t)tan(hfov * 0.5f);
1224         scalar_t h = 1.0f / (scalar_t)tan(vfov * 0.5f);
1225         scalar_t q = far_clip / (far_clip - near_clip);
1226
1227         Matrix4x4 mat;
1228         mat[0][0] = w;
1229         mat[1][1] = h;
1230         mat[2][2] = q;
1231         mat[3][2] = 1.0f;
1232         mat[2][3] = -q * near_clip;
1233 #else
1234         scalar_t f = 1.0f / (scalar_t)tan(vfov * 0.5f);
1235
1236         Matrix4x4 mat;
1237         mat[0][0] = f / aspect;
1238         mat[1][1] = f;
1239         mat[2][2] = (far_clip + near_clip) / (near_clip - far_clip);
1240         mat[3][2] = -1.0f;
1241         mat[2][3] = (2.0f * far_clip * near_clip) / (near_clip - far_clip);
1242         mat[3][3] = 0;
1243 #endif
1244
1245         return mat;
1246 }
1247
1248
1249 // ---- misc ----
1250
1251 bool screen_capture(char *fname, enum image_file_format fmt) {
1252         static int scr_num;
1253         static const char *suffix[] = {"png", "jpg", "tga", "oug1", "oug2"};
1254         int x = gparams.x;
1255         int y = gparams.y;
1256
1257         uint32_t *pixels = new uint32_t[x * y];
1258         glReadPixels(0, 0, x, y, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
1259
1260         if(!fname) {
1261                 static char fname_buf[50];
1262                 fname = fname_buf;
1263                 sprintf(fname, "3dengfx_shot%04d.%s", scr_num++, suffix[fmt]);
1264         }
1265
1266         unsigned int flags = get_image_save_flags();
1267         set_image_save_flags(flags | IMG_SAVE_INVERT);
1268         int res = save_image(fname, pixels, x, y, fmt);
1269         set_image_save_flags(flags);
1270
1271         delete [] pixels;
1272         return res != -1;
1273 }