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.load_transpose = (bool)strstr(ext_str, "GL_ARB_transpose_matrix");
 277         sys_caps.gen_mipmaps = (bool)strstr(ext_str, "GL_SGIS_generate_mipmap");
 278         sys_caps.tex_combine_ops = (bool)strstr(ext_str, "GL_ARB_texture_env_combine");
 279         sys_caps.bump_dot3 = (bool)strstr(ext_str, "GL_ARB_texture_env_dot3");
 280         sys_caps.bump_env = (bool)strstr(ext_str, "GL_ATI_envmap_bumpmap");
 281         sys_caps.vertex_buffers = (bool)strstr(ext_str, "GL_ARB_vertex_buffer_object");
 282         sys_caps.depth_texture = (bool)strstr(ext_str, "GL_ARB_depth_texture");
 283         sys_caps.shadow_mapping = (bool)strstr(ext_str, "GL_ARB_shadow");
 284         sys_caps.point_sprites = (bool)strstr(ext_str, "GL_ARB_point_sprite");
 285         sys_caps.point_params = (bool)strstr(ext_str, "GL_ARB_point_parameters");
 286         glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &sys_caps.max_texture_units);
 287         sys_caps.non_power_of_two_textures = (bool)strstr(ext_str, "GL_ARB_texture_non_power_of_two");
 288         glGetIntegerv(GL_MAX_LIGHTS, &sys_caps.max_lights);
 289
 290         sys_caps.prog.asm_vertex = (bool)strstr(ext_str, "GL_ARB_vertex_program");
 291         sys_caps.prog.asm_pixel = (bool)strstr(ext_str, "GL_ARB_fragment_program");
 292         sys_caps.prog.glslang = (bool)strstr(ext_str, "GL_ARB_shading_language_100");
 293         sys_caps.prog.shader_obj = (bool)strstr(ext_str, "GL_ARB_shader_objects");
 294         sys_caps.prog.glsl_vertex = (bool)strstr(ext_str, "GL_ARB_vertex_shader");
 295         sys_caps.prog.glsl_pixel = (bool)strstr(ext_str, "GL_ARB_fragment_shader");
 296
 297         delete [] ext_str;
 298
 299         // also log these things
 300         info("-------------------");
 301         info("System Capabilities");
 302         info("-------------------");
 303         info("Load transposed matrices: %s", sys_caps.load_transpose ? "yes" : "no");
 304         info("Auto-generate mipmaps (SGIS): %s", sys_caps.gen_mipmaps ? "yes" : "no");
 305         info("Custom texture combination operations: %s", sys_caps.tex_combine_ops ? "yes" : "no");
 306         info("Diffuse bump mapping (dot3): %s", sys_caps.bump_dot3 ? "yes" : "no");
 307         info("Specular bump mapping (env-bump): %s", sys_caps.bump_env ? "yes" : "no");
 308         info("Video memory vertex/index buffers: %s", sys_caps.vertex_buffers ? "yes" : "no");
 309         info("Depth texture: %s", sys_caps.depth_texture ? "yes" : "no");
 310         info("Shadow mapping: %s", sys_caps.shadow_mapping ? "yes" : "no");
 311         info("Programmable vertex processing (asm): %s", sys_caps.prog.asm_vertex ? "yes" : "no");
 312         info("Programmable pixel processing (asm): %s", sys_caps.prog.asm_pixel ? "yes" : "no");
 313         info("OpenGL 2.0 shading language: %s", sys_caps.prog.glslang ? "yes" : "no");
 314         info("Programmable vertex processing (glsl): %s", sys_caps.prog.glsl_vertex ? "yes" : "no");
 315         info("Programmable pixel processing (glsl): %s", sys_caps.prog.glsl_pixel ? "yes" : "no");
 316         info("Point sprites: %s", sys_caps.point_sprites ? "yes" : "no");
 317         info("Point parameters: %s", sys_caps.point_params ? "yes" : "no");
 318         info("Non power of 2 textures: %s", sys_caps.non_power_of_two_textures ? "yes" : "no");
 319         info("Texture units: %d", sys_caps.max_texture_units);
 320         info("Max lights: %d", sys_caps.max_lights);
 321
 322         if(!sys_caps.point_sprites && !sys_caps.point_params) {
 323                 warning("no point sprites support, falling back to billboards which *may* degrade particle system performance");
 324         }
 325
 326         return sys_caps;
 327 }
 328
 329 const char *get_glerror_string(GLenum error) {
 330         if(!error) return gl_error_string[0x506];
 331         if(error < 0x500 || error > 0x505) error = 0x507;
 332         return gl_error_string[error - 0x500];
 333 }
 334
 335 /* load_matrix_transpose_arb() & load_matrix_transpose_manual()
 336  * --------------------------------------------------------
 337  * two functions to handle the transformation matrix loading
 338  * to OpenGL by either transposing the Matrix4x4 data or using
 339  * the transposed-loading extension (use through function pointer
 340  * LoadMatrixGL which is set during initialization to the correct one)
 341  */
 342 void load_matrix_transpose_arb(const Matrix4x4 &mat) {
 343         glLoadTransposeMatrix(mat.opengl_matrix());
 344 }
 345
 346 void load_matrix_transpose_manual(const Matrix4x4 &mat) {
 347 #ifdef SINGLE_PRECISION_MATH
 348         glLoadMatrixf(mat.transposed().opengl_matrix());
 349 #else
 350         glLoadMatrixd(mat.transposed().opengl_matrix());
 351 #endif  // SINGLE_PRECISION_MATH
 352 }
 353
 354
 355 //////////////// 3D Engine Initialization ////////////////
 356
 357 static const char *signame(int sig) {
 358         switch(sig) {
 359         case SIGSEGV:
 360                 return "segmentation fault (SIGSEGV)";
 361         case SIGILL:
 362                 return "illegal instruction (SIGILL)";
 363         case SIGTERM:
 364                 return "termination signal (SIGTERM)";
 365         case SIGFPE:
 366                 return "floating point exception (SIGFPE)";
 367         case SIGINT:
 368                 return "interrupt signal (SIGINT)";
 369         default:
 370                 return "unknown";
 371         }
 372         return "can't happen";
 373 }
 374
 375 static void signal_handler(int sig) {
 376         error("It seems this is the end... caught %s, exiting...", signame(sig));
 377         destroy_graphics_context();
 378         exit(EXIT_FAILURE);
 379 }
 380
 381 /* ---- create_graphics_context() ----
 382  * initializes the graphics subsystem according to the init parameters
 383  */
 384 bool create_graphics_context(const GraphicsInitParameters &gip) {
 385
 386         gparams = gip;
 387
 388         remove(get_log_filename());
 389
 390         if(!fxwt::init_graphics(&gparams)) {
 391                 return false;
 392         }
 393
 394         signal(SIGSEGV, signal_handler);
 395         signal(SIGILL, signal_handler);
 396         signal(SIGTERM, signal_handler);
 397         signal(SIGFPE, signal_handler);
 398         signal(SIGINT, signal_handler);
 399
 400 #if GFX_LIBRARY == GTK
 401         fxwt::init();
 402         dsys::init();
 403         return true;
 404 #else
 405         if(!start_gl()) return false;
 406         fxwt::init();
 407         dsys::init();
 408         return true;
 409 #endif  // GTK
 410 }
 411
 412 /*
 413  * short graphics context creation
 414  * creates a graphics context (windowed or fullscreen)
 415  * given only the wanted resolution and a fullscreen flag.
 416  */
 417 bool create_graphics_context(int x, int y, bool fullscreen)
 418 {
 419         GraphicsInitParameters gip;
 420         gip.x = x;
 421         gip.y = y;
 422         gip.bpp = 32;
 423         gip.depth_bits = 32;
 424         gip.fullscreen = fullscreen;
 425         gip.stencil_bits = 8;
 426         gip.dont_care_flags = DONT_CARE_DEPTH | DONT_CARE_STENCIL | DONT_CARE_BPP;
 427
 428         return create_graphics_context(gip);
 429 }
 430
 431 /* OpenGL startup after initialization */
 432 bool start_gl() {
 433         SysCaps sys_caps = get_system_capabilities();
 434
 435         glext::glActiveTexture = (PFNGLACTIVETEXTUREARBPROC)glGetProcAddress("glActiveTextureARB");
 436         glext::glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREARBPROC)glGetProcAddress("glClientActiveTextureARB");
 437
 438         if(!glext::glActiveTexture || !glext::glClientActiveTexture) {
 439                 warning("No multitexturing support.");
 440                 sys_caps.multitex = false;
 441         }
 442
 443         if(sys_caps.load_transpose) {
 444 #ifdef SINGLE_PRECISION_MATH
 445                 glLoadTransposeMatrix = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)glGetProcAddress("glLoadTransposeMatrixfARB");
 446 #else
 447                 glLoadTransposeMatrix = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)glGetProcAddress("glLoadTransposeMatrixdARB");
 448 #endif  // SINGLE_PRECISION_MATH
 449
 450                 load_matrix_gl = load_matrix_transpose_arb;
 451         } else {
 452                 load_matrix_gl = load_matrix_transpose_manual;
 453         }
 454
 455         if(sys_caps.vertex_buffers) {
 456                 glBindBuffer = (PFNGLBINDBUFFERARBPROC)glGetProcAddress("glBindBufferARB");
 457                 glBufferData = (PFNGLBUFFERDATAARBPROC)glGetProcAddress("glBufferDataARB");
 458                 glDeleteBuffers = (PFNGLDELETEBUFFERSARBPROC)glGetProcAddress("glDeleteBuffersARB");
 459                 glIsBuffer = (PFNGLISBUFFERARBPROC)glGetProcAddress("glIsBufferARB");
 460                 glMapBuffer = (PFNGLMAPBUFFERARBPROC)glGetProcAddress("glMapBufferARB");
 461                 glUnmapBuffer = (PFNGLUNMAPBUFFERARBPROC)glGetProcAddress("glUnmapBufferARB");
 462                 glGenBuffers = (PFNGLGENBUFFERSARBPROC)glGetProcAddress("glGenBuffersARB");
 463         }
 464
 465         if(sys_caps.prog.asm_vertex || sys_caps.prog.asm_pixel) {
 466                 glBindProgram = (PFNGLBINDPROGRAMARBPROC)glGetProcAddress("glBindProgramARB");
 467                 glGenPrograms = (PFNGLGENPROGRAMSARBPROC)glGetProcAddress("glGenProgramsARB");
 468                 glDeletePrograms = (PFNGLDELETEPROGRAMSARBPROC)glGetProcAddress("glDeleteProgramsARB");
 469                 glProgramString = (PFNGLPROGRAMSTRINGARBPROC)glGetProcAddress("glProgramStringARB");
 470         }
 471
 472         if(sys_caps.prog.shader_obj) {
 473                 glDeleteObject = (PFNGLDELETEOBJECTARBPROC)glGetProcAddress("glDeleteObjectARB");
 474                 glAttachObject = (PFNGLATTACHOBJECTARBPROC)glGetProcAddress("glAttachObjectARB");
 475                 glDetachObject = (PFNGLDETACHOBJECTARBPROC)glGetProcAddress("glDetachObjectARB");
 476                 glGetObjectParameteriv = (PFNGLGETOBJECTPARAMETERIVARBPROC)glGetProcAddress("glGetObjectParameterivARB");
 477                 glGetInfoLog = (PFNGLGETINFOLOGARBPROC)glGetProcAddress("glGetInfoLogARB");
 478
 479                 glCreateProgramObject = (PFNGLCREATEPROGRAMOBJECTARBPROC)glGetProcAddress("glCreateProgramObjectARB");
 480                 glLinkProgram = (PFNGLLINKPROGRAMARBPROC)glGetProcAddress("glLinkProgramARB");
 481                 glUseProgramObject = (PFNGLUSEPROGRAMOBJECTARBPROC)glGetProcAddress("glUseProgramObjectARB");
 482
 483                 glCreateShaderObject = (PFNGLCREATESHADEROBJECTARBPROC)glGetProcAddress("glCreateShaderObjectARB");
 484                 glShaderSource = (PFNGLSHADERSOURCEARBPROC)glGetProcAddress("glShaderSourceARB");
 485                 glCompileShader = (PFNGLCOMPILESHADERARBPROC)glGetProcAddress("glCompileShaderARB");
 486
 487                 glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONARBPROC)glGetProcAddress("glGetUniformLocationARB");
 488                 glGetActiveUniform = (PFNGLGETACTIVEUNIFORMARBPROC)glGetProcAddress("glGetActiveUniformARB");
 489                 glUniform1i = (PFNGLUNIFORM1IARBPROC)glGetProcAddress("glUniform1iARB");
 490                 glUniform1f = (PFNGLUNIFORM1FARBPROC)glGetProcAddress("glUniform1fARB");
 491                 glUniform2f = (PFNGLUNIFORM2FARBPROC)glGetProcAddress("glUniform2fARB");
 492                 glUniform3f = (PFNGLUNIFORM3FARBPROC)glGetProcAddress("glUniform3fARB");
 493                 glUniform4f = (PFNGLUNIFORM4FARBPROC)glGetProcAddress("glUniform4fARB");
 494                 glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVARBPROC)glGetProcAddress("glUniformMatrix3fvARB");
 495                 glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVARBPROC)glGetProcAddress("glUniformMatrix4fvARB");
 496         }
 497
 498         if(sys_caps.point_params) {
 499                 glext::glPointParameterf = (PFNGLPOINTPARAMETERFARBPROC)glGetProcAddress("glPointParameterfARB");
 500                 glext::glPointParameterfv = (PFNGLPOINTPARAMETERFVARBPROC)glGetProcAddress("glPointParameterfvARB");
 501
 502                 if(!glext::glPointParameterfv) {
 503                         error("error loading glPointParameterfv");
 504                         return false;
 505                 }
 506                 if(!glext::glPointParameterf) {
 507                         error("error loading glPointParameterf");
 508                         return false;
 509                 }
 510         }
 511
 512         gc_valid = true;
 513
 514         set_default_states();
 515         return true;
 516 }
 517
 518 void destroy_graphics_context() {
 519         static bool destroy_called_again = false;
 520
 521         if(destroy_called_again) {
 522                 warning("Multiple destroy_graphics_context() calls");
 523                 return;
 524         } else {
 525                 destroy_called_again = true;
 526         }
 527
 528         dsys::clean_up();
 529         if(!gc_valid) return;
 530         gc_valid = false;
 531         info("3d engine shutting down...");
 532         destroy_textures();
 533         destroy_shaders();
 534         fxwt::destroy_graphics();
 535 }
 536
 537 void set_default_states() {
 538         set_primitive_type(TRIANGLE_LIST);
 539         set_front_face(ORDER_CW);
 540         set_backface_culling(true);
 541         set_zbuffering(true);
 542         set_lighting(true);
 543         set_auto_normalize(false);
 544
 545         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
 546         glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
 547
 548         set_matrix(XFORM_WORLD, Matrix4x4());
 549         set_matrix(XFORM_VIEW, Matrix4x4());
 550         set_matrix(XFORM_PROJECTION, create_projection_matrix(quarter_pi, 1.333333f, 1.0f, 1000.0f));
 551
 552         memset(coord_index, 0, MAX_TEXTURES * sizeof(int));
 553
 554         for(int i=0; i<8; i++) {
 555                 ttype[i] = TEX_2D;
 556         }
 557
 558         if(sys_caps.point_params) {
 559                 glext::glPointParameterf(GL_POINT_SIZE_MIN_ARB, 1.0);
 560                 glext::glPointParameterf(GL_POINT_SIZE_MAX_ARB, 256.0);
 561
 562                 float quadratic[] = {0.0f, 0.0f, 0.01f};
 563                 glext::glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION_ARB, quadratic);
 564         }
 565 }
 566
 567 const GraphicsInitParameters *get_graphics_init_parameters() {
 568         return &gparams;
 569 }
 570
 571 void clear(const Color &color) {
 572         glClearColor(color.r, color.g, color.b, color.a);
 573         glClear(GL_COLOR_BUFFER_BIT);
 574 }
 575
 576 void clear_zbuffer(scalar_t zval) {
 577         glClearDepth(zval);
 578         glClear(GL_DEPTH_BUFFER_BIT);
 579 }
 580
 581 void clear_stencil(unsigned char sval) {
 582         glClearStencil(sval);
 583         glClear(GL_STENCIL_BUFFER_BIT);
 584 }
 585
 586 void clear_zbuffer_stencil(scalar_t zval, unsigned char sval) {
 587         glClearDepth(zval);
 588         glClearStencil(sval);
 589         glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 590 }
 591
 592 void flip() {
 593         glFlush();
 594         glFinish();
 595         fxwt::swap_buffers();
 596 }
 597
 598 void load_xform_matrices() {
 599         for(int i=0; i<sys_caps.max_texture_units; i++) {
 600                 select_texture_unit(i);
 601                 glMatrixMode(GL_TEXTURE);
 602                 load_matrix_gl(tex_matrix[i]);
 603         }
 604
 605         glMatrixMode(GL_PROJECTION);
 606         load_matrix_gl(proj_matrix);
 607
 608         Matrix4x4 modelview = view_matrix * world_matrix;
 609         glMatrixMode(GL_MODELVIEW);
 610         load_matrix_gl(modelview);
 611 }
 612
 613 #define BUFFER_OFFSET(i) ((char *)NULL + (i))
 614
 615 void draw(const VertexArray &varray) {
 616         load_xform_matrices();
 617
 618         bool use_vbo = !varray.get_dynamic() && sys_caps.vertex_buffers;
 619
 620         glEnableClientState(GL_VERTEX_ARRAY);
 621         glEnableClientState(GL_COLOR_ARRAY);
 622         glEnableClientState(GL_NORMAL_ARRAY);
 623
 624         if(use_vbo) {
 625                 Vertex v;
 626                 glBindBuffer(GL_ARRAY_BUFFER_ARB, varray.get_buffer_object());
 627                 glVertexPointer(3, GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.pos - (char*)&v));
 628                 glNormalPointer(GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.normal - (char*)&v));
 629                 glColorPointer(4, GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.color - (char*)&v));
 630
 631                 for(int i=0; i<MAX_TEXTURES; i++) {
 632                         select_texture_unit(i);
 633                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 634
 635                         int dim = ttype[i] == TEX_1D ? 1 : (ttype[i] == TEX_3D || ttype[i] == TEX_CUBE ? 3 : 2);
 636                         glTexCoordPointer(dim, GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.tex[coord_index[i]] - (char*)&v));
 637                 }
 638
 639                 glBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
 640         } else {
 641                 glVertexPointer(3, GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->pos);
 642                 glNormalPointer(GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->normal);
 643                 glColorPointer(4, GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->color);
 644
 645                 for(int i=0; i<MAX_TEXTURES; i++) {
 646                         select_texture_unit(i);
 647                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 648
 649                         int dim = ttype[i] == TEX_1D ? 1 : (ttype[i] == TEX_3D || ttype[i] == TEX_CUBE ? 3 : 2);
 650                         glTexCoordPointer(dim, GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->tex[coord_index[i]]);
 651                 }
 652         }
 653
 654         glDrawArrays(primitive_type, 0, varray.get_count());
 655
 656         glDisableClientState(GL_VERTEX_ARRAY);
 657         glDisableClientState(GL_COLOR_ARRAY);
 658         glDisableClientState(GL_NORMAL_ARRAY);
 659
 660         for(int i=0; i<MAX_TEXTURES; i++) {
 661                 select_texture_unit(i);
 662                 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 663         }
 664 }
 665
 666 void draw(const VertexArray &varray, const IndexArray &iarray) {
 667         load_xform_matrices();
 668
 669         bool use_vbo = !varray.get_dynamic() && sys_caps.vertex_buffers;
 670         bool use_ibo = false;//!iarray.get_dynamic() && sys_caps.vertex_buffers;
 671
 672         glEnableClientState(GL_VERTEX_ARRAY);
 673         glEnableClientState(GL_COLOR_ARRAY);
 674         glEnableClientState(GL_NORMAL_ARRAY);
 675
 676         if(use_vbo) {
 677                 Vertex v;
 678                 glBindBuffer(GL_ARRAY_BUFFER_ARB, varray.get_buffer_object());
 679                 glVertexPointer(3, GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.pos - (char*)&v));
 680                 glNormalPointer(GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.normal - (char*)&v));
 681                 glColorPointer(4, GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.color - (char*)&v));
 682
 683                 for(int i=0; i<MAX_TEXTURES; i++) {
 684                         select_texture_unit(i);
 685                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 686
 687                         int dim = ttype[i] == TEX_1D ? 1 : (ttype[i] == TEX_3D || ttype[i] == TEX_CUBE ? 3 : 2);
 688                         glTexCoordPointer(dim, GL_SCALAR_TYPE, sizeof(Vertex), (void*)((char*)&v.tex[coord_index[i]] - (char*)&v));
 689                 }
 690
 691                 glBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
 692         } else {
 693                 glVertexPointer(3, GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->pos);
 694                 glNormalPointer(GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->normal);
 695                 glColorPointer(4, GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->color);
 696
 697                 for(int i=0; i<MAX_TEXTURES; i++) {
 698                         select_texture_unit(i);
 699                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 700
 701                         int dim = ttype[i] == TEX_1D ? 1 : (ttype[i] == TEX_3D || ttype[i] == TEX_CUBE ? 3 : 2);
 702                         glTexCoordPointer(dim, GL_SCALAR_TYPE, sizeof(Vertex), &varray.get_data()->tex[coord_index[i]]);
 703                 }
 704         }
 705
 706         if(use_ibo) {
 707                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, iarray.get_buffer_object());
 708                 glDrawElements(primitive_type, iarray.get_count(), GL_UNSIGNED_INT, 0);
 709                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
 710         } else {
 711                 glDrawElements(primitive_type, iarray.get_count(), GL_UNSIGNED_INT, iarray.get_data());
 712         }
 713
 714         glDisableClientState(GL_VERTEX_ARRAY);
 715         glDisableClientState(GL_COLOR_ARRAY);
 716         glDisableClientState(GL_NORMAL_ARRAY);
 717
 718         for(int i=0; i<MAX_TEXTURES; i++) {
 719                 select_texture_unit(i);
 720                 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 721         }
 722 }
 723
 724
 725 /* draw_line(start_vertex, end_vertex, start_width, end_width)
 726  * Draws a line as a cylindrically billboarded elongated quad.
 727  */
 728 void draw_line(const Vertex &v1, const Vertex &v2, scalar_t w1, scalar_t w2, const Color &col) {
 729         if(w2 < 0.0) w2 = w1;
 730
 731         Vector3 p1 = v1.pos;
 732         Vector3 p2 = v2.pos;
 733
 734         Vector3 cam_pos = Vector3(0,0,0).transformed(inv_view_matrix);
 735
 736         Vector3 vec = p2 - p1;
 737         scalar_t len = vec.length();
 738
 739         Basis basis;
 740         basis.k = -(cam_pos - ((p2 + p1) / 2)).normalized();
 741         basis.j = vec / len;
 742         basis.i = cross_product(basis.j, basis.k).normalized();
 743         basis.k = cross_product(basis.i, basis.j).normalized();
 744
 745         world_matrix.set_translation(p1);
 746         world_matrix = world_matrix * Matrix4x4(basis.create_rotation_matrix());
 747         load_xform_matrices();
 748
 749         Vertex quad[] = {
 750                 Vertex(Vector3(-w1, 0, 0), v1.tex[0].u, 0.0, col),
 751                 Vertex(Vector3(-w2, len, 0), v2.tex[0].u, 0.0, col),
 752                 Vertex(Vector3(w2, len, 0), v2.tex[0].u, 1.0, col),
 753                 Vertex(Vector3(w1, 0, 0), v1.tex[0].u, 1.0, col)
 754         };
 755
 756         set_lighting(false);
 757         set_primitive_type(QUAD_LIST);
 758         draw(VertexArray(quad, 4));
 759         set_primitive_type(TRIANGLE_LIST);
 760         set_lighting(true);
 761 }
 762
 763 void draw_point(const Vertex &pt, scalar_t size) {
 764
 765         Vector3 p = pt.pos;
 766
 767         Vector3 cam_pos = Vector3(0,0,0).transformed(inv_view_matrix);
 768
 769         Basis basis;
 770         basis.k = -(cam_pos - p).normalized();
 771         basis.j = Vector3(0, 1, 0);
 772         basis.i = cross_product(basis.j, basis.k);
 773         basis.j = cross_product(basis.k, basis.i);
 774
 775         world_matrix.set_translation(p);
 776         world_matrix = world_matrix * Matrix4x4(basis.create_rotation_matrix());
 777         load_xform_matrices();
 778
 779         Vertex quad[] = {
 780                 Vertex(Vector3(-size, -size, 0), 0.0, 0.0, pt.color),
 781                 Vertex(Vector3(-size, size, 0), 0.0, 1.0, pt.color),
 782                 Vertex(Vector3(size, size, 0), 1.0, 1.0, pt.color),
 783                 Vertex(Vector3(size, -size, 0), 1.0, 0.0, pt.color)
 784         };
 785
 786         set_lighting(false);
 787         set_primitive_type(QUAD_LIST);
 788         draw(VertexArray(quad, 4));
 789         set_primitive_type(TRIANGLE_LIST);
 790         set_lighting(true);
 791
 792 }
 793
 794
 795 void draw_scr_quad(const Vector2 &corner1, const Vector2 &corner2, const Color &color, bool reset_xform) {
 796         if(reset_xform) {
 797                 glMatrixMode(GL_MODELVIEW);
 798                 glPushMatrix();
 799                 glLoadIdentity();
 800         }
 801
 802         glMatrixMode(GL_PROJECTION);
 803         glPushMatrix();
 804         glLoadIdentity();
 805         glOrtho(0.0, 1.0, 1.0, 0.0, 0.0, 1.0);
 806
 807         glDisable(GL_LIGHTING);
 808
 809         glBegin(GL_QUADS);
 810         glColor4f(color.r, color.g, color.b, color.a);
 811         glTexCoord2f(0.0f, 1.0f);
 812         glVertex3f(corner1.x, corner1.y, -0.5);
 813         glTexCoord2f(1.0f, 1.0f);
 814         glVertex3f(corner2.x, corner1.y, -0.5);
 815         glTexCoord2f(1.0f, 0.0f);
 816         glVertex3f(corner2.x, corner2.y, -0.5);
 817         glTexCoord2f(0.0f, 0.0f);
 818         glVertex3f(corner1.x, corner2.y, -0.5);
 819         glEnd();
 820
 821         glEnable(GL_LIGHTING);
 822
 823         glPopMatrix();
 824
 825         if(reset_xform) {
 826                 glMatrixMode(GL_MODELVIEW);
 827                 glPopMatrix();
 828         }
 829 }
 830
 831 int get_texture_unit_count() {
 832         return sys_caps.max_texture_units;
 833 }
 834
 835 //////////////////// render states /////////////////////
 836
 837 void set_primitive_type(PrimitiveType pt) {
 838         primitive_type = pt;
 839 }
 840
 841 void set_backface_culling(bool enable) {
 842         if(enable) {
 843                 glEnable(GL_CULL_FACE);
 844         } else {
 845                 glDisable(GL_CULL_FACE);
 846         }
 847 }
 848
 849 void set_front_face(FaceOrder order) {
 850         glFrontFace(order);
 851 }
 852
 853 void set_auto_normalize(bool enable) {
 854         if(enable) {
 855                 glEnable(GL_NORMALIZE);
 856         } else {
 857                 glDisable(GL_NORMALIZE);
 858         }
 859 }
 860
 861 void set_color_write(bool red, bool green, bool blue, bool alpha) {
 862         glColorMask(red, green, blue, alpha);
 863 }
 864
 865 void set_wireframe(bool enable) {
 866         //set_primitive_type(enable ? LINE_LIST : TRIANGLE_LIST);
 867         glPolygonMode(GL_FRONT_AND_BACK, enable ? GL_LINE : GL_FILL);
 868 }
 869
 870
 871 ///////////////// blending states ///////////////
 872
 873 void set_alpha_blending(bool enable) {
 874         if(enable) {
 875                 glEnable(GL_BLEND);
 876         } else {
 877                 glDisable(GL_BLEND);
 878         }
 879 }
 880
 881 void set_blend_func(BlendingFactor src, BlendingFactor dest) {
 882         glBlendFunc(src, dest);
 883 }
 884
 885 ///////////////// zbuffer states ////////////////
 886
 887 void set_zbuffering(bool enable) {
 888         if(enable) {
 889                 glEnable(GL_DEPTH_TEST);
 890         } else {
 891                 glDisable(GL_DEPTH_TEST);
 892         }
 893 }
 894
 895 void set_zwrite(bool enable) {
 896         glDepthMask(enable);
 897 }
 898
 899 void set_zfunc(CmpFunc func) {
 900         glDepthFunc(func);
 901 }
 902
 903 /////////////// stencil states //////////////////
 904 void set_stencil_buffering(bool enable) {
 905         if(enable) {
 906                 glEnable(GL_STENCIL_TEST);
 907         } else {
 908                 glDisable(GL_STENCIL_TEST);
 909         }
 910 }
 911
 912 void set_stencil_pass_op(StencilOp sop) {
 913         stencil_pass = sop;
 914         glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
 915 }
 916
 917 void set_stencil_fail_op(StencilOp sop) {
 918         stencil_fail = sop;
 919         glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
 920 }
 921
 922 void set_stencil_pass_zfail_op(StencilOp sop) {
 923         stencil_pzfail = sop;
 924         glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
 925 }
 926
 927 void set_stencil_op(StencilOp fail, StencilOp spass_zfail, StencilOp pass) {
 928         stencil_fail = fail;
 929         stencil_pzfail = spass_zfail;
 930         stencil_pass = pass;
 931         glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
 932 }
 933
 934 void set_stencil_func(CmpFunc func) {
 935         glStencilFunc(func, stencil_ref, 0xffffffff);
 936 }
 937
 938 void set_stencil_reference(unsigned int ref) {
 939         stencil_ref = ref;
 940 }
 941
 942 ///////////// texture & material states //////////////
 943
 944 void set_point_sprites(bool enable) {
 945         if(sys_caps.point_sprites) {
 946                 if(enable) {
 947                         glEnable(GL_POINT_SPRITE_ARB);
 948                 } else {
 949                         glDisable(GL_POINT_SPRITE_ARB);
 950                 }
 951         }
 952 }
 953
 954 void set_texture_filtering(int tex_unit, TextureFilteringType tex_filter) {
 955
 956         int min_filter;
 957
 958         switch(tex_filter) {
 959         case POINT_SAMPLING:
 960                 min_filter = mipmapping ? GL_NEAREST_MIPMAP_NEAREST : GL_NEAREST;
 961                 glTexParameteri(ttype[tex_unit], GL_TEXTURE_MIN_FILTER, min_filter);
 962                 glTexParameteri(ttype[tex_unit], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 963                 break;
 964
 965         case BILINEAR_FILTERING:
 966                 min_filter = mipmapping ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR;
 967                 glTexParameteri(ttype[tex_unit], GL_TEXTURE_MIN_FILTER, min_filter);
 968                 glTexParameteri(ttype[tex_unit], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 969                 break;
 970
 971         case TRILINEAR_FILTERING:
 972         default:
 973                 min_filter = mipmapping ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
 974                 glTexParameteri(ttype[tex_unit], GL_TEXTURE_MIN_FILTER, min_filter);
 975                 glTexParameteri(ttype[tex_unit], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 976                 break;
 977         }
 978 }
 979
 980 void set_texture_addressing(int tex_unit, TextureAddressing uaddr, TextureAddressing vaddr) {
 981         glTexParameteri(ttype[tex_unit], GL_TEXTURE_WRAP_S, uaddr);
 982         glTexParameteri(ttype[tex_unit], GL_TEXTURE_WRAP_T, vaddr);
 983 }
 984
 985 void set_texture_border_color(int tex_unit, const Color &color) {
 986         float col[] = {color.r, color.g, color.b, color.a};
 987         glTexParameterfv(ttype[tex_unit], GL_TEXTURE_BORDER_COLOR, col);
 988 }
 989
 990 void set_texture(int tex_unit, const Texture *tex) {
 991         select_texture_unit(tex_unit);
 992         glBindTexture(tex->get_type(), tex->tex_id);
 993         ttype[tex_unit] = tex->get_type();
 994 }
 995
 996 void set_mip_mapping(bool enable) {
 997         mipmapping = enable;
 998 }
 999
1000 void set_material(const Material &mat) {
1001         mat.set_glmaterial();
1002 }
1003
1004 void use_vertex_colors(bool enable) {
1005         if(enable) {
1006                 glEnable(GL_COLOR_MATERIAL);
1007         } else {
1008                 glDisable(GL_COLOR_MATERIAL);
1009         }
1010 }
1011
1012
1013 void set_render_target(Texture *tex, CubeMapFace cube_map_face) {
1014         static std::stack<Texture*> rt_stack;
1015         static std::stack<CubeMapFace> face_stack;
1016
1017         Texture *prev = rt_stack.empty() ? 0 : rt_stack.top();
1018         CubeMapFace prev_face = CUBE_MAP_PX; // just to get rid of the uninitialized var warning
1019         if(!face_stack.empty()) prev_face = face_stack.top();
1020
1021         if(tex == prev) return;
1022
1023         if(prev) {
1024                 set_texture(0, prev);
1025                 glCopyTexSubImage2D(prev->get_type() == TEX_CUBE ? prev_face : GL_TEXTURE_2D, 0, 0, 0, 0, 0, prev->width, prev->height);
1026         }
1027
1028         if(!tex) {
1029                 rt_stack.pop();
1030                 if(prev->get_type() == TEX_CUBE) {
1031                         face_stack.pop();
1032
1033                         if(rt_stack.empty()) {
1034                                 set_viewport(0, 0, gparams.x, gparams.y);
1035                         } else {
1036                                 set_viewport(0, 0, rt_stack.top()->width, rt_stack.top()->height);
1037                         }
1038                 }
1039         } else {
1040                 if(tex->get_type() == TEX_CUBE) {
1041                         set_viewport(0, 0, tex->width, tex->height);
1042                 }
1043
1044                 rt_stack.push(tex);
1045                 if(tex->get_type() == TEX_CUBE) face_stack.push(cube_map_face);
1046         }
1047 }
1048
1049 void copy_texture(Texture *tex, bool full_screen) {
1050         if(!tex) return;
1051
1052         int width = full_screen ? get_graphics_init_parameters()->x : tex->width;
1053         int height = full_screen ? get_graphics_init_parameters()->y : tex->height;
1054
1055         set_texture(0, tex);
1056         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width, height);
1057 }
1058
1059 // multitexturing interface
1060
1061 void select_texture_unit(int tex_unit) {
1062         if(sys_caps.multitex) {
1063                 glext::glActiveTexture(GL_TEXTURE0 + tex_unit);
1064                 glext::glClientActiveTexture(GL_TEXTURE0 + tex_unit);
1065         }
1066 }
1067
1068 void enable_texture_unit(int tex_unit) {
1069         if(!tex_unit || (sys_caps.multitex && tex_unit < sys_caps.max_texture_units)) {
1070                 select_texture_unit(tex_unit);
1071                 glEnable(ttype[tex_unit]);
1072         }
1073 }
1074
1075 void disable_texture_unit(int tex_unit) {
1076         if(!tex_unit || (sys_caps.multitex && tex_unit < sys_caps.max_texture_units)) {
1077                 select_texture_unit(tex_unit);
1078                 glDisable(ttype[tex_unit]);
1079         }
1080 }
1081
1082 void set_texture_unit_color(int tex_unit, TextureBlendFunction op, TextureBlendArgument arg1, TextureBlendArgument arg2, TextureBlendArgument arg3) {
1083
1084         select_texture_unit(tex_unit);
1085         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
1086         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, op);
1087         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, arg1);
1088         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, arg2);
1089         if(arg3 != TARG_NONE) {
1090                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, arg3);
1091         }
1092 }
1093
1094 void set_texture_unit_alpha(int tex_unit, TextureBlendFunction op, TextureBlendArgument arg1, TextureBlendArgument arg2, TextureBlendArgument arg3) {
1095
1096         select_texture_unit(tex_unit);
1097         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
1098         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, op);
1099         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, arg1);
1100         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, arg2);
1101         if(arg3 != TARG_NONE) {
1102                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, arg3);
1103         }
1104 }
1105
1106 void set_texture_coord_index(int tex_unit, int index) {
1107         coord_index[tex_unit] = index;
1108 }
1109
1110 void set_texture_constant(int tex_unit, const Color &col) {
1111         float color[] = {col.r, col.g, col.b, col.a};
1112         select_texture_unit(tex_unit);
1113         glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
1114 }
1115
1116 //void set_texture_transform_state(int sttex_unitage, TexTransformState TexXForm);
1117 //void set_texture_coord_generator(int stage, TexGen tgen);
1118
1119 void set_point_sprite_coords(int tex_unit, bool enable) {
1120         if(sys_caps.point_params) {
1121                 select_texture_unit(tex_unit);
1122                 glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, enable ? GL_TRUE : GL_FALSE);
1123         }
1124 }
1125
1126
1127 // programmable interface
1128 void set_gfx_program(GfxProg *prog) {
1129         if(!sys_caps.prog.glslang) return;
1130         if(prog) {
1131                 if(!prog->linked) {
1132                         prog->link();
1133                         if(!prog->linked) return;
1134                 }
1135                 glUseProgramObject(prog->prog);
1136
1137                 // call any registered update handlers
1138                 if(prog->update_handler) {
1139                         prog->update_handler(prog);
1140                 }
1141         } else {
1142                 glUseProgramObject(0);
1143         }
1144 }
1145
1146 // lighting states
1147 void set_lighting(bool enable) {
1148         if(enable) {
1149                 glEnable(GL_LIGHTING);
1150         } else {
1151                 glDisable(GL_LIGHTING);
1152         }
1153 }
1154
1155 void set_ambient_light(const Color &ambient_color) {
1156         float col[] = {ambient_color.r, ambient_color.g, ambient_color.b, ambient_color.a};
1157         glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
1158 }
1159
1160 void set_shading_mode(ShadeMode mode) {
1161         glShadeModel(mode);
1162 }
1163
1164 void set_bump_light(const Light *light) {
1165         bump_light = light;
1166 }
1167
1168 // transformation matrices
1169 void set_matrix(TransformType xform_type, const Matrix4x4 &mat, int num) {
1170         switch(xform_type) {
1171         case XFORM_WORLD:
1172                 world_matrix = mat;
1173                 break;
1174
1175         case XFORM_VIEW:
1176                 view_matrix = mat;
1177                 inv_view_matrix = view_matrix.inverse();
1178                 view_mat_camera = 0;
1179                 break;
1180
1181         case XFORM_PROJECTION:
1182                 proj_matrix = mat;
1183                 break;
1184
1185         case XFORM_TEXTURE:
1186                 tex_matrix[num] = mat;
1187                 break;
1188         }
1189 }
1190
1191 Matrix4x4 get_matrix(TransformType xform_type, int num) {
1192         switch(xform_type) {
1193         case XFORM_WORLD:
1194                 return world_matrix;
1195
1196         case XFORM_VIEW:
1197                 return view_matrix;
1198
1199         case XFORM_TEXTURE:
1200                 return tex_matrix[num];
1201
1202         case XFORM_PROJECTION:
1203         default:
1204                 return proj_matrix;
1205         }
1206 }
1207
1208 void set_viewport(unsigned int x, unsigned int y, unsigned int xsize, unsigned int ysize) {
1209         glViewport(x, y, xsize, ysize);
1210 }
1211
1212 // normalized set_viewport()
1213 void set_viewport_norm(float x, float y, float xsize, float ysize)
1214 {
1215         glViewport((int) (x * gparams.x), (int)(y * gparams.y),
1216                 (int) (xsize * gparams.x), int (ysize * gparams.y));
1217 }
1218
1219 Matrix4x4 create_projection_matrix(scalar_t vfov, scalar_t aspect, scalar_t near_clip, scalar_t far_clip) {
1220 #ifdef COORD_LHS
1221         scalar_t hfov = vfov * aspect;
1222         scalar_t w = 1.0f / (scalar_t)tan(hfov * 0.5f);
1223         scalar_t h = 1.0f / (scalar_t)tan(vfov * 0.5f);
1224         scalar_t q = far_clip / (far_clip - near_clip);
1225
1226         Matrix4x4 mat;
1227         mat[0][0] = w;
1228         mat[1][1] = h;
1229         mat[2][2] = q;
1230         mat[3][2] = 1.0f;
1231         mat[2][3] = -q * near_clip;
1232 #else
1233         scalar_t f = 1.0f / (scalar_t)tan(vfov * 0.5f);
1234
1235         Matrix4x4 mat;
1236         mat[0][0] = f / aspect;
1237         mat[1][1] = f;
1238         mat[2][2] = (far_clip + near_clip) / (near_clip - far_clip);
1239         mat[3][2] = -1.0f;
1240         mat[2][3] = (2.0f * far_clip * near_clip) / (near_clip - far_clip);
1241         mat[3][3] = 0;
1242 #endif
1243
1244         return mat;
1245 }
1246
1247
1248 // ---- misc ----
1249
1250 bool screen_capture(char *fname, enum image_file_format fmt) {
1251         static int scr_num;
1252         static const char *suffix[] = {"png", "jpg", "tga", "oug1", "oug2"};
1253         int x = gparams.x;
1254         int y = gparams.y;
1255
1256         uint32_t *pixels = new uint32_t[x * y];
1257         glReadPixels(0, 0, x, y, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
1258
1259         if(!fname) {
1260                 static char fname_buf[50];
1261                 fname = fname_buf;
1262                 sprintf(fname, "3dengfx_shot%04d.%s", scr_num++, suffix[fmt]);
1263         }
1264
1265         unsigned int flags = get_image_save_flags();
1266         set_image_save_flags(flags | IMG_SAVE_INVERT);
1267         int res = save_image(fname, pixels, x, y, fmt);
1268         set_image_save_flags(flags);
1269
1270         delete [] pixels;
1271         return res != -1;
1272 }