2 This file is part of the 3dengfx, realtime visualization system.
3 Copyright (c) 2004, 2005 John Tsiombikas <nuclear@siggraph.org>
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.
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.
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
20 /* main 3dengfx state control, and low level OpenGL interaction
22 * Author: John Tsiombikas 2004
25 #include "3dengfx_config.h"
33 #include "fxwt/fxwt.hpp"
34 #include "fxwt/init.hpp"
35 #include "fxwt/gfx_library.h"
36 #include "3denginefx.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"
52 #ifdef SINGLE_PRECISION_MATH
53 #define GL_SCALAR_TYPE GL_FLOAT
55 #define GL_SCALAR_TYPE GL_DOUBLE
56 #endif // SINGLE_PRECISION_MATH
59 void (*load_matrix_gl)(const Matrix4x4 &mat);
62 #ifdef SINGLE_PRECISION_MATH
63 PFNGLLOADTRANSPOSEMATRIXFARBPROC glLoadTransposeMatrix;
65 PFNGLLOADTRANSPOSEMATRIXDARBPROC glLoadTransposeMatrix;
66 #endif // SINGLE_PRECISION_MATH
68 PFNGLACTIVETEXTUREARBPROC glActiveTexture;
69 PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTexture;
71 PFNGLBINDBUFFERARBPROC glBindBuffer;
72 PFNGLBUFFERDATAARBPROC glBufferData;
73 PFNGLDELETEBUFFERSARBPROC glDeleteBuffers;
74 PFNGLISBUFFERARBPROC glIsBuffer;
75 PFNGLMAPBUFFERARBPROC glMapBuffer;
76 PFNGLUNMAPBUFFERARBPROC glUnmapBuffer;
77 PFNGLGENBUFFERSARBPROC glGenBuffers;
79 // fragment/vertex program extensions
80 PFNGLBINDPROGRAMARBPROC glBindProgram;
81 PFNGLGENPROGRAMSARBPROC glGenPrograms;
82 PFNGLDELETEPROGRAMSARBPROC glDeletePrograms;
83 PFNGLPROGRAMSTRINGARBPROC glProgramString;
86 PFNGLPOINTPARAMETERFARBPROC glPointParameterf;
87 PFNGLPOINTPARAMETERFVARBPROC glPointParameterfv;
89 // --- OpenGL 2.0 Shading Language ---
92 PFNGLDELETEOBJECTARBPROC glDeleteObject;
93 PFNGLATTACHOBJECTARBPROC glAttachObject;
94 PFNGLDETACHOBJECTARBPROC glDetachObject;
95 PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameteriv;
96 PFNGLGETINFOLOGARBPROC glGetInfoLog;
99 PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObject;
100 PFNGLLINKPROGRAMARBPROC glLinkProgram;
101 PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObject;
104 PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObject;
105 PFNGLSHADERSOURCEARBPROC glShaderSource;
106 PFNGLCOMPILESHADERARBPROC glCompileShader;
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;
120 using namespace glext;
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]"
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)
144 namespace engfx_state {
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;
154 using namespace engfx_state;
156 GraphicsInitParameters *load_graphics_context_config(const char *fname) {
157 static GraphicsInitParameters gip;
162 gip.stencil_bits = 8;
163 gip.dont_care_flags = 0;
165 if(load_config_file(fname) == -1) {
166 error("%s: could not load config file", __func__);
170 const ConfigOption *cfgopt;
171 while((cfgopt = get_next_option())) {
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;
179 error("%s: error parsing config file %s", __func__, fname);
182 } else if(!strcmp(cfgopt->option, "resolution")) {
183 if(!isdigit(cfgopt->str_value[0])) {
184 error("%s: error parsing config file %s", __func__, fname);
187 gip.x = atoi(cfgopt->str_value);
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);
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")) {
202 gip.dont_care_flags |= DONT_CARE_BPP;
204 error("%s: error parsing config file %s", __func__, fname);
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")) {
212 gip.dont_care_flags |= DONT_CARE_DEPTH;
214 error("%s: error parsing config file %s", __func__, fname);
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;
224 error("%s: error parsing config file %s", __func__, fname);
230 destroy_config_parser();
235 /* ---- get_system_capabilities() ----
236 * Retrieves information on the graphics subsystem capabilities
237 * and returns a SysCaps structure describing them
239 SysCaps get_system_capabilities() {
240 static bool first_call = true;
247 // get extensions & vendor strings
248 const char *tmp_str = (const char*)glGetString(GL_EXTENSIONS);
250 error("%s: glGetString() failed, possibly no valid GL context", __func__);
253 char *ext_str = new char[strlen(tmp_str) + 1];
254 strcpy(ext_str, tmp_str);
256 char *cptr = ext_str;
258 if(*cptr == ' ') *cptr = '\n';
263 info("Supported extensions:\n-------------\n%s", ext_str);
266 info("Rendering System Information:");
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\")");
274 // fill the SysCaps structure
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);
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");
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);
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");
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];
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)
342 void load_matrix_transpose_arb(const Matrix4x4 &mat) {
343 glLoadTransposeMatrix(mat.opengl_matrix());
346 void load_matrix_transpose_manual(const Matrix4x4 &mat) {
347 #ifdef SINGLE_PRECISION_MATH
348 glLoadMatrixf(mat.transposed().opengl_matrix());
350 glLoadMatrixd(mat.transposed().opengl_matrix());
351 #endif // SINGLE_PRECISION_MATH
355 //////////////// 3D Engine Initialization ////////////////
357 static const char *signame(int sig) {
360 return "segmentation fault (SIGSEGV)";
362 return "illegal instruction (SIGILL)";
364 return "termination signal (SIGTERM)";
366 return "floating point exception (SIGFPE)";
368 return "interrupt signal (SIGINT)";
372 return "can't happen";
375 static void signal_handler(int sig) {
376 error("It seems this is the end... caught %s, exiting...", signame(sig));
377 destroy_graphics_context();
381 /* ---- create_graphics_context() ----
382 * initializes the graphics subsystem according to the init parameters
384 bool create_graphics_context(const GraphicsInitParameters &gip) {
388 remove(get_log_filename());
390 if(!fxwt::init_graphics(&gparams)) {
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);
400 #if GFX_LIBRARY == GTK
405 if(!start_gl()) return false;
413 * short graphics context creation
414 * creates a graphics context (windowed or fullscreen)
415 * given only the wanted resolution and a fullscreen flag.
417 bool create_graphics_context(int x, int y, bool fullscreen)
419 GraphicsInitParameters gip;
424 gip.fullscreen = fullscreen;
425 gip.stencil_bits = 8;
426 gip.dont_care_flags = DONT_CARE_DEPTH | DONT_CARE_STENCIL | DONT_CARE_BPP;
428 return create_graphics_context(gip);
431 /* OpenGL startup after initialization */
433 SysCaps sys_caps = get_system_capabilities();
435 glext::glActiveTexture = (PFNGLACTIVETEXTUREARBPROC)glGetProcAddress("glActiveTextureARB");
436 glext::glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREARBPROC)glGetProcAddress("glClientActiveTextureARB");
438 if(!glext::glActiveTexture || !glext::glClientActiveTexture) {
439 warning("No multitexturing support.");
440 sys_caps.multitex = false;
443 if(sys_caps.load_transpose) {
444 #ifdef SINGLE_PRECISION_MATH
445 glLoadTransposeMatrix = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)glGetProcAddress("glLoadTransposeMatrixfARB");
447 glLoadTransposeMatrix = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)glGetProcAddress("glLoadTransposeMatrixdARB");
448 #endif // SINGLE_PRECISION_MATH
450 load_matrix_gl = load_matrix_transpose_arb;
452 load_matrix_gl = load_matrix_transpose_manual;
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");
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");
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");
479 glCreateProgramObject = (PFNGLCREATEPROGRAMOBJECTARBPROC)glGetProcAddress("glCreateProgramObjectARB");
480 glLinkProgram = (PFNGLLINKPROGRAMARBPROC)glGetProcAddress("glLinkProgramARB");
481 glUseProgramObject = (PFNGLUSEPROGRAMOBJECTARBPROC)glGetProcAddress("glUseProgramObjectARB");
483 glCreateShaderObject = (PFNGLCREATESHADEROBJECTARBPROC)glGetProcAddress("glCreateShaderObjectARB");
484 glShaderSource = (PFNGLSHADERSOURCEARBPROC)glGetProcAddress("glShaderSourceARB");
485 glCompileShader = (PFNGLCOMPILESHADERARBPROC)glGetProcAddress("glCompileShaderARB");
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");
498 if(sys_caps.point_params) {
499 glext::glPointParameterf = (PFNGLPOINTPARAMETERFARBPROC)glGetProcAddress("glPointParameterfARB");
500 glext::glPointParameterfv = (PFNGLPOINTPARAMETERFVARBPROC)glGetProcAddress("glPointParameterfvARB");
502 if(!glext::glPointParameterfv) {
503 error("error loading glPointParameterfv");
506 if(!glext::glPointParameterf) {
507 error("error loading glPointParameterf");
514 set_default_states();
518 void destroy_graphics_context() {
519 static bool destroy_called_again = false;
521 if(destroy_called_again) {
522 warning("Multiple destroy_graphics_context() calls");
525 destroy_called_again = true;
529 if(!gc_valid) return;
531 info("3d engine shutting down...");
534 fxwt::destroy_graphics();
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);
543 set_auto_normalize(false);
545 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
546 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
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));
552 memset(coord_index, 0, MAX_TEXTURES * sizeof(int));
554 for(int i=0; i<8; i++) {
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);
562 float quadratic[] = {0.0f, 0.0f, 0.01f};
563 glext::glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION_ARB, quadratic);
567 const GraphicsInitParameters *get_graphics_init_parameters() {
571 void clear(const Color &color) {
572 glClearColor(color.r, color.g, color.b, color.a);
573 glClear(GL_COLOR_BUFFER_BIT);
576 void clear_zbuffer(scalar_t zval) {
578 glClear(GL_DEPTH_BUFFER_BIT);
581 void clear_stencil(unsigned char sval) {
582 glClearStencil(sval);
583 glClear(GL_STENCIL_BUFFER_BIT);
586 void clear_zbuffer_stencil(scalar_t zval, unsigned char sval) {
588 glClearStencil(sval);
589 glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
595 fxwt::swap_buffers();
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]);
605 glMatrixMode(GL_PROJECTION);
606 load_matrix_gl(proj_matrix);
608 Matrix4x4 modelview = view_matrix * world_matrix;
609 glMatrixMode(GL_MODELVIEW);
610 load_matrix_gl(modelview);
613 #define BUFFER_OFFSET(i) ((char *)NULL + (i))
615 void draw(const VertexArray &varray) {
616 load_xform_matrices();
618 bool use_vbo = !varray.get_dynamic() && sys_caps.vertex_buffers;
620 glEnableClientState(GL_VERTEX_ARRAY);
621 glEnableClientState(GL_COLOR_ARRAY);
622 glEnableClientState(GL_NORMAL_ARRAY);
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));
631 for(int i=0; i<MAX_TEXTURES; i++) {
632 select_texture_unit(i);
633 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
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));
639 glBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
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);
645 for(int i=0; i<MAX_TEXTURES; i++) {
646 select_texture_unit(i);
647 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
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]]);
654 glDrawArrays(primitive_type, 0, varray.get_count());
656 glDisableClientState(GL_VERTEX_ARRAY);
657 glDisableClientState(GL_COLOR_ARRAY);
658 glDisableClientState(GL_NORMAL_ARRAY);
660 for(int i=0; i<MAX_TEXTURES; i++) {
661 select_texture_unit(i);
662 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
666 void draw(const VertexArray &varray, const IndexArray &iarray) {
667 load_xform_matrices();
669 bool use_vbo = !varray.get_dynamic() && sys_caps.vertex_buffers;
670 bool use_ibo = false;//!iarray.get_dynamic() && sys_caps.vertex_buffers;
672 glEnableClientState(GL_VERTEX_ARRAY);
673 glEnableClientState(GL_COLOR_ARRAY);
674 glEnableClientState(GL_NORMAL_ARRAY);
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));
683 for(int i=0; i<MAX_TEXTURES; i++) {
684 select_texture_unit(i);
685 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
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));
691 glBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
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);
697 for(int i=0; i<MAX_TEXTURES; i++) {
698 select_texture_unit(i);
699 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
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]]);
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);
711 glDrawElements(primitive_type, iarray.get_count(), GL_UNSIGNED_INT, iarray.get_data());
714 glDisableClientState(GL_VERTEX_ARRAY);
715 glDisableClientState(GL_COLOR_ARRAY);
716 glDisableClientState(GL_NORMAL_ARRAY);
718 for(int i=0; i<MAX_TEXTURES; i++) {
719 select_texture_unit(i);
720 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
725 /* draw_line(start_vertex, end_vertex, start_width, end_width)
726 * Draws a line as a cylindrically billboarded elongated quad.
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;
734 Vector3 cam_pos = Vector3(0,0,0).transformed(inv_view_matrix);
736 Vector3 vec = p2 - p1;
737 scalar_t len = vec.length();
740 basis.k = -(cam_pos - ((p2 + p1) / 2)).normalized();
742 basis.i = cross_product(basis.j, basis.k).normalized();
743 basis.k = cross_product(basis.i, basis.j).normalized();
745 world_matrix.set_translation(p1);
746 world_matrix = world_matrix * Matrix4x4(basis.create_rotation_matrix());
747 load_xform_matrices();
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)
757 set_primitive_type(QUAD_LIST);
758 draw(VertexArray(quad, 4));
759 set_primitive_type(TRIANGLE_LIST);
763 void draw_point(const Vertex &pt, scalar_t size) {
767 Vector3 cam_pos = Vector3(0,0,0).transformed(inv_view_matrix);
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);
775 world_matrix.set_translation(p);
776 world_matrix = world_matrix * Matrix4x4(basis.create_rotation_matrix());
777 load_xform_matrices();
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)
787 set_primitive_type(QUAD_LIST);
788 draw(VertexArray(quad, 4));
789 set_primitive_type(TRIANGLE_LIST);
795 void draw_scr_quad(const Vector2 &corner1, const Vector2 &corner2, const Color &color, bool reset_xform) {
797 glMatrixMode(GL_MODELVIEW);
802 glMatrixMode(GL_PROJECTION);
805 glOrtho(0.0, 1.0, 1.0, 0.0, 0.0, 1.0);
807 glDisable(GL_LIGHTING);
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);
821 glEnable(GL_LIGHTING);
826 glMatrixMode(GL_MODELVIEW);
831 int get_texture_unit_count() {
832 return sys_caps.max_texture_units;
835 //////////////////// render states /////////////////////
837 void set_primitive_type(PrimitiveType pt) {
841 void set_backface_culling(bool enable) {
843 glEnable(GL_CULL_FACE);
845 glDisable(GL_CULL_FACE);
849 void set_front_face(FaceOrder order) {
853 void set_auto_normalize(bool enable) {
855 glEnable(GL_NORMALIZE);
857 glDisable(GL_NORMALIZE);
861 void set_color_write(bool red, bool green, bool blue, bool alpha) {
862 glColorMask(red, green, blue, alpha);
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);
871 ///////////////// blending states ///////////////
873 void set_alpha_blending(bool enable) {
881 void set_blend_func(BlendingFactor src, BlendingFactor dest) {
882 glBlendFunc(src, dest);
885 ///////////////// zbuffer states ////////////////
887 void set_zbuffering(bool enable) {
889 glEnable(GL_DEPTH_TEST);
891 glDisable(GL_DEPTH_TEST);
895 void set_zwrite(bool enable) {
899 void set_zfunc(CmpFunc func) {
903 /////////////// stencil states //////////////////
904 void set_stencil_buffering(bool enable) {
906 glEnable(GL_STENCIL_TEST);
908 glDisable(GL_STENCIL_TEST);
912 void set_stencil_pass_op(StencilOp sop) {
914 glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
917 void set_stencil_fail_op(StencilOp sop) {
919 glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
922 void set_stencil_pass_zfail_op(StencilOp sop) {
923 stencil_pzfail = sop;
924 glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
927 void set_stencil_op(StencilOp fail, StencilOp spass_zfail, StencilOp pass) {
929 stencil_pzfail = spass_zfail;
931 glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
934 void set_stencil_func(CmpFunc func) {
935 glStencilFunc(func, stencil_ref, 0xffffffff);
938 void set_stencil_reference(unsigned int ref) {
942 ///////////// texture & material states //////////////
944 void set_point_sprites(bool enable) {
945 if(sys_caps.point_sprites) {
947 glEnable(GL_POINT_SPRITE_ARB);
949 glDisable(GL_POINT_SPRITE_ARB);
954 void set_texture_filtering(int tex_unit, TextureFilteringType tex_filter) {
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);
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);
971 case TRILINEAR_FILTERING:
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);
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);
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);
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();
996 void set_mip_mapping(bool enable) {
1000 void set_material(const Material &mat) {
1001 mat.set_glmaterial();
1004 void use_vertex_colors(bool enable) {
1006 glEnable(GL_COLOR_MATERIAL);
1008 glDisable(GL_COLOR_MATERIAL);
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;
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();
1021 if(tex == prev) return;
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);
1030 if(prev->get_type() == TEX_CUBE) {
1033 if(rt_stack.empty()) {
1034 set_viewport(0, 0, gparams.x, gparams.y);
1036 set_viewport(0, 0, rt_stack.top()->width, rt_stack.top()->height);
1040 if(tex->get_type() == TEX_CUBE) {
1041 set_viewport(0, 0, tex->width, tex->height);
1045 if(tex->get_type() == TEX_CUBE) face_stack.push(cube_map_face);
1049 void copy_texture(Texture *tex, bool full_screen) {
1052 int width = full_screen ? get_graphics_init_parameters()->x : tex->width;
1053 int height = full_screen ? get_graphics_init_parameters()->y : tex->height;
1055 set_texture(0, tex);
1056 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width, height);
1059 // multitexturing interface
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);
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]);
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]);
1082 void set_texture_unit_color(int tex_unit, TextureBlendFunction op, TextureBlendArgument arg1, TextureBlendArgument arg2, TextureBlendArgument arg3) {
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);
1094 void set_texture_unit_alpha(int tex_unit, TextureBlendFunction op, TextureBlendArgument arg1, TextureBlendArgument arg2, TextureBlendArgument arg3) {
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);
1106 void set_texture_coord_index(int tex_unit, int index) {
1107 coord_index[tex_unit] = index;
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);
1116 //void set_texture_transform_state(int sttex_unitage, TexTransformState TexXForm);
1117 //void set_texture_coord_generator(int stage, TexGen tgen);
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);
1127 // programmable interface
1128 void set_gfx_program(GfxProg *prog) {
1129 if(!sys_caps.prog.glslang) return;
1133 if(!prog->linked) return;
1135 glUseProgramObject(prog->prog);
1137 // call any registered update handlers
1138 if(prog->update_handler) {
1139 prog->update_handler(prog);
1142 glUseProgramObject(0);
1147 void set_lighting(bool enable) {
1149 glEnable(GL_LIGHTING);
1151 glDisable(GL_LIGHTING);
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);
1160 void set_shading_mode(ShadeMode mode) {
1164 void set_bump_light(const Light *light) {
1168 // transformation matrices
1169 void set_matrix(TransformType xform_type, const Matrix4x4 &mat, int num) {
1170 switch(xform_type) {
1177 inv_view_matrix = view_matrix.inverse();
1178 view_mat_camera = 0;
1181 case XFORM_PROJECTION:
1186 tex_matrix[num] = mat;
1191 Matrix4x4 get_matrix(TransformType xform_type, int num) {
1192 switch(xform_type) {
1194 return world_matrix;
1200 return tex_matrix[num];
1202 case XFORM_PROJECTION:
1208 void set_viewport(unsigned int x, unsigned int y, unsigned int xsize, unsigned int ysize) {
1209 glViewport(x, y, xsize, ysize);
1212 // normalized set_viewport()
1213 void set_viewport_norm(float x, float y, float xsize, float ysize)
1215 glViewport((int) (x * gparams.x), (int)(y * gparams.y),
1216 (int) (xsize * gparams.x), int (ysize * gparams.y));
1219 Matrix4x4 create_projection_matrix(scalar_t vfov, scalar_t aspect, scalar_t near_clip, scalar_t far_clip) {
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);
1231 mat[2][3] = -q * near_clip;
1233 scalar_t f = 1.0f / (scalar_t)tan(vfov * 0.5f);
1236 mat[0][0] = f / aspect;
1238 mat[2][2] = (far_clip + near_clip) / (near_clip - far_clip);
1240 mat[2][3] = (2.0f * far_clip * near_clip) / (near_clip - far_clip);
1250 bool screen_capture(char *fname, enum image_file_format fmt) {
1252 static const char *suffix[] = {"png", "jpg", "tga", "oug1", "oug2"};
1256 uint32_t *pixels = new uint32_t[x * y];
1257 glReadPixels(0, 0, x, y, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
1260 static char fname_buf[50];
1262 sprintf(fname, "3dengfx_shot%04d.%s", scr_num++, suffix[fmt]);
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);