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.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);
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");
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);
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");
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];
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)
343 void load_matrix_transpose_arb(const Matrix4x4 &mat) {
344 glLoadTransposeMatrix(mat.opengl_matrix());
347 void load_matrix_transpose_manual(const Matrix4x4 &mat) {
348 #ifdef SINGLE_PRECISION_MATH
349 glLoadMatrixf(mat.transposed().opengl_matrix());
351 glLoadMatrixd(mat.transposed().opengl_matrix());
352 #endif // SINGLE_PRECISION_MATH
356 //////////////// 3D Engine Initialization ////////////////
358 static const char *signame(int sig) {
361 return "segmentation fault (SIGSEGV)";
363 return "illegal instruction (SIGILL)";
365 return "termination signal (SIGTERM)";
367 return "floating point exception (SIGFPE)";
369 return "interrupt signal (SIGINT)";
373 return "can't happen";
376 static void signal_handler(int sig) {
377 error("It seems this is the end... caught %s, exiting...", signame(sig));
378 destroy_graphics_context();
382 /* ---- create_graphics_context() ----
383 * initializes the graphics subsystem according to the init parameters
385 bool create_graphics_context(const GraphicsInitParameters &gip) {
389 remove(get_log_filename());
391 if(!fxwt::init_graphics(&gparams)) {
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);
401 #if GFX_LIBRARY == GTK
406 if(!start_gl()) return false;
414 * short graphics context creation
415 * creates a graphics context (windowed or fullscreen)
416 * given only the wanted resolution and a fullscreen flag.
418 bool create_graphics_context(int x, int y, bool fullscreen)
420 GraphicsInitParameters gip;
425 gip.fullscreen = fullscreen;
426 gip.stencil_bits = 8;
427 gip.dont_care_flags = DONT_CARE_DEPTH | DONT_CARE_STENCIL | DONT_CARE_BPP;
429 return create_graphics_context(gip);
432 /* OpenGL startup after initialization */
434 SysCaps sys_caps = get_system_capabilities();
436 glext::glActiveTexture = (PFNGLACTIVETEXTUREARBPROC)glGetProcAddress("glActiveTextureARB");
437 glext::glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREARBPROC)glGetProcAddress("glClientActiveTextureARB");
439 if(!glext::glActiveTexture || !glext::glClientActiveTexture) {
440 warning("No multitexturing support.");
441 sys_caps.multitex = false;
444 if(sys_caps.load_transpose) {
445 #ifdef SINGLE_PRECISION_MATH
446 glLoadTransposeMatrix = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)glGetProcAddress("glLoadTransposeMatrixfARB");
448 glLoadTransposeMatrix = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)glGetProcAddress("glLoadTransposeMatrixdARB");
449 #endif // SINGLE_PRECISION_MATH
451 load_matrix_gl = load_matrix_transpose_arb;
453 load_matrix_gl = load_matrix_transpose_manual;
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");
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");
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");
480 glCreateProgramObject = (PFNGLCREATEPROGRAMOBJECTARBPROC)glGetProcAddress("glCreateProgramObjectARB");
481 glLinkProgram = (PFNGLLINKPROGRAMARBPROC)glGetProcAddress("glLinkProgramARB");
482 glUseProgramObject = (PFNGLUSEPROGRAMOBJECTARBPROC)glGetProcAddress("glUseProgramObjectARB");
484 glCreateShaderObject = (PFNGLCREATESHADEROBJECTARBPROC)glGetProcAddress("glCreateShaderObjectARB");
485 glShaderSource = (PFNGLSHADERSOURCEARBPROC)glGetProcAddress("glShaderSourceARB");
486 glCompileShader = (PFNGLCOMPILESHADERARBPROC)glGetProcAddress("glCompileShaderARB");
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");
499 if(sys_caps.point_params) {
500 glext::glPointParameterf = (PFNGLPOINTPARAMETERFARBPROC)glGetProcAddress("glPointParameterfARB");
501 glext::glPointParameterfv = (PFNGLPOINTPARAMETERFVARBPROC)glGetProcAddress("glPointParameterfvARB");
503 if(!glext::glPointParameterfv) {
504 error("error loading glPointParameterfv");
507 if(!glext::glPointParameterf) {
508 error("error loading glPointParameterf");
515 set_default_states();
519 void destroy_graphics_context() {
520 static bool destroy_called_again = false;
522 if(destroy_called_again) {
523 warning("Multiple destroy_graphics_context() calls");
526 destroy_called_again = true;
530 if(!gc_valid) return;
532 info("3d engine shutting down...");
535 fxwt::destroy_graphics();
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);
544 set_auto_normalize(false);
546 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
547 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
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));
553 memset(coord_index, 0, MAX_TEXTURES * sizeof(int));
555 for(int i=0; i<8; i++) {
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);
563 float quadratic[] = {0.0f, 0.0f, 0.01f};
564 glext::glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION_ARB, quadratic);
568 const GraphicsInitParameters *get_graphics_init_parameters() {
572 void clear(const Color &color) {
573 glClearColor(color.r, color.g, color.b, color.a);
574 glClear(GL_COLOR_BUFFER_BIT);
577 void clear_zbuffer(scalar_t zval) {
579 glClear(GL_DEPTH_BUFFER_BIT);
582 void clear_stencil(unsigned char sval) {
583 glClearStencil(sval);
584 glClear(GL_STENCIL_BUFFER_BIT);
587 void clear_zbuffer_stencil(scalar_t zval, unsigned char sval) {
589 glClearStencil(sval);
590 glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
596 fxwt::swap_buffers();
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]);
606 glMatrixMode(GL_PROJECTION);
607 load_matrix_gl(proj_matrix);
609 Matrix4x4 modelview = view_matrix * world_matrix;
610 glMatrixMode(GL_MODELVIEW);
611 load_matrix_gl(modelview);
614 #define BUFFER_OFFSET(i) ((char *)NULL + (i))
616 void draw(const VertexArray &varray) {
617 load_xform_matrices();
619 bool use_vbo = !varray.get_dynamic() && sys_caps.vertex_buffers;
621 glEnableClientState(GL_VERTEX_ARRAY);
622 glEnableClientState(GL_COLOR_ARRAY);
623 glEnableClientState(GL_NORMAL_ARRAY);
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));
632 for(int i=0; i<MAX_TEXTURES; i++) {
633 select_texture_unit(i);
634 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
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));
640 glBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
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);
646 for(int i=0; i<MAX_TEXTURES; i++) {
647 select_texture_unit(i);
648 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
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]]);
655 glDrawArrays(primitive_type, 0, varray.get_count());
657 glDisableClientState(GL_VERTEX_ARRAY);
658 glDisableClientState(GL_COLOR_ARRAY);
659 glDisableClientState(GL_NORMAL_ARRAY);
661 for(int i=0; i<MAX_TEXTURES; i++) {
662 select_texture_unit(i);
663 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
667 void draw(const VertexArray &varray, const IndexArray &iarray) {
668 load_xform_matrices();
670 bool use_vbo = !varray.get_dynamic() && sys_caps.vertex_buffers;
671 bool use_ibo = false;//!iarray.get_dynamic() && sys_caps.vertex_buffers;
673 glEnableClientState(GL_VERTEX_ARRAY);
674 glEnableClientState(GL_COLOR_ARRAY);
675 glEnableClientState(GL_NORMAL_ARRAY);
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));
684 for(int i=0; i<MAX_TEXTURES; i++) {
685 select_texture_unit(i);
686 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
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));
692 glBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
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);
698 for(int i=0; i<MAX_TEXTURES; i++) {
699 select_texture_unit(i);
700 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
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]]);
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);
712 glDrawElements(primitive_type, iarray.get_count(), GL_UNSIGNED_INT, iarray.get_data());
715 glDisableClientState(GL_VERTEX_ARRAY);
716 glDisableClientState(GL_COLOR_ARRAY);
717 glDisableClientState(GL_NORMAL_ARRAY);
719 for(int i=0; i<MAX_TEXTURES; i++) {
720 select_texture_unit(i);
721 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
726 /* draw_line(start_vertex, end_vertex, start_width, end_width)
727 * Draws a line as a cylindrically billboarded elongated quad.
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;
735 Vector3 cam_pos = Vector3(0,0,0).transformed(inv_view_matrix);
737 Vector3 vec = p2 - p1;
738 scalar_t len = vec.length();
741 basis.k = -(cam_pos - ((p2 + p1) / 2)).normalized();
743 basis.i = cross_product(basis.j, basis.k).normalized();
744 basis.k = cross_product(basis.i, basis.j).normalized();
746 world_matrix.set_translation(p1);
747 world_matrix = world_matrix * Matrix4x4(basis.create_rotation_matrix());
748 load_xform_matrices();
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)
758 set_primitive_type(QUAD_LIST);
759 draw(VertexArray(quad, 4));
760 set_primitive_type(TRIANGLE_LIST);
764 void draw_point(const Vertex &pt, scalar_t size) {
768 Vector3 cam_pos = Vector3(0,0,0).transformed(inv_view_matrix);
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);
776 world_matrix.set_translation(p);
777 world_matrix = world_matrix * Matrix4x4(basis.create_rotation_matrix());
778 load_xform_matrices();
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)
788 set_primitive_type(QUAD_LIST);
789 draw(VertexArray(quad, 4));
790 set_primitive_type(TRIANGLE_LIST);
796 void draw_scr_quad(const Vector2 &corner1, const Vector2 &corner2, const Color &color, bool reset_xform) {
798 glMatrixMode(GL_MODELVIEW);
803 glMatrixMode(GL_PROJECTION);
806 glOrtho(0.0, 1.0, 1.0, 0.0, 0.0, 1.0);
808 glDisable(GL_LIGHTING);
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);
822 glEnable(GL_LIGHTING);
827 glMatrixMode(GL_MODELVIEW);
832 int get_texture_unit_count() {
833 return sys_caps.max_texture_units;
836 //////////////////// render states /////////////////////
838 void set_primitive_type(PrimitiveType pt) {
842 void set_backface_culling(bool enable) {
844 glEnable(GL_CULL_FACE);
846 glDisable(GL_CULL_FACE);
850 void set_front_face(FaceOrder order) {
854 void set_auto_normalize(bool enable) {
856 glEnable(GL_NORMALIZE);
858 glDisable(GL_NORMALIZE);
862 void set_color_write(bool red, bool green, bool blue, bool alpha) {
863 glColorMask(red, green, blue, alpha);
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);
872 ///////////////// blending states ///////////////
874 void set_alpha_blending(bool enable) {
882 void set_blend_func(BlendingFactor src, BlendingFactor dest) {
883 glBlendFunc(src, dest);
886 ///////////////// zbuffer states ////////////////
888 void set_zbuffering(bool enable) {
890 glEnable(GL_DEPTH_TEST);
892 glDisable(GL_DEPTH_TEST);
896 void set_zwrite(bool enable) {
900 void set_zfunc(CmpFunc func) {
904 /////////////// stencil states //////////////////
905 void set_stencil_buffering(bool enable) {
907 glEnable(GL_STENCIL_TEST);
909 glDisable(GL_STENCIL_TEST);
913 void set_stencil_pass_op(StencilOp sop) {
915 glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
918 void set_stencil_fail_op(StencilOp sop) {
920 glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
923 void set_stencil_pass_zfail_op(StencilOp sop) {
924 stencil_pzfail = sop;
925 glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
928 void set_stencil_op(StencilOp fail, StencilOp spass_zfail, StencilOp pass) {
930 stencil_pzfail = spass_zfail;
932 glStencilOp(stencil_fail, stencil_pzfail, stencil_pass);
935 void set_stencil_func(CmpFunc func) {
936 glStencilFunc(func, stencil_ref, 0xffffffff);
939 void set_stencil_reference(unsigned int ref) {
943 ///////////// texture & material states //////////////
945 void set_point_sprites(bool enable) {
946 if(sys_caps.point_sprites) {
948 glEnable(GL_POINT_SPRITE_ARB);
950 glDisable(GL_POINT_SPRITE_ARB);
955 void set_texture_filtering(int tex_unit, TextureFilteringType tex_filter) {
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);
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);
972 case TRILINEAR_FILTERING:
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);
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);
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);
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();
997 void set_mip_mapping(bool enable) {
1001 void set_material(const Material &mat) {
1002 mat.set_glmaterial();
1005 void use_vertex_colors(bool enable) {
1007 glEnable(GL_COLOR_MATERIAL);
1009 glDisable(GL_COLOR_MATERIAL);
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;
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();
1022 if(tex == prev) return;
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);
1031 if(prev->get_type() == TEX_CUBE) {
1034 if(rt_stack.empty()) {
1035 set_viewport(0, 0, gparams.x, gparams.y);
1037 set_viewport(0, 0, rt_stack.top()->width, rt_stack.top()->height);
1041 if(tex->get_type() == TEX_CUBE) {
1042 set_viewport(0, 0, tex->width, tex->height);
1046 if(tex->get_type() == TEX_CUBE) face_stack.push(cube_map_face);
1050 void copy_texture(Texture *tex, bool full_screen) {
1053 int width = full_screen ? get_graphics_init_parameters()->x : tex->width;
1054 int height = full_screen ? get_graphics_init_parameters()->y : tex->height;
1056 set_texture(0, tex);
1057 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width, height);
1060 // multitexturing interface
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);
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]);
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]);
1083 void set_texture_unit_color(int tex_unit, TextureBlendFunction op, TextureBlendArgument arg1, TextureBlendArgument arg2, TextureBlendArgument arg3) {
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);
1095 void set_texture_unit_alpha(int tex_unit, TextureBlendFunction op, TextureBlendArgument arg1, TextureBlendArgument arg2, TextureBlendArgument arg3) {
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);
1107 void set_texture_coord_index(int tex_unit, int index) {
1108 coord_index[tex_unit] = index;
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);
1117 //void set_texture_transform_state(int sttex_unitage, TexTransformState TexXForm);
1118 //void set_texture_coord_generator(int stage, TexGen tgen);
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);
1128 // programmable interface
1129 void set_gfx_program(GfxProg *prog) {
1130 if(!sys_caps.prog.glslang) return;
1134 if(!prog->linked) return;
1136 glUseProgramObject(prog->prog);
1138 // call any registered update handlers
1139 if(prog->update_handler) {
1140 prog->update_handler(prog);
1143 glUseProgramObject(0);
1148 void set_lighting(bool enable) {
1150 glEnable(GL_LIGHTING);
1152 glDisable(GL_LIGHTING);
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);
1161 void set_shading_mode(ShadeMode mode) {
1165 void set_bump_light(const Light *light) {
1169 // transformation matrices
1170 void set_matrix(TransformType xform_type, const Matrix4x4 &mat, int num) {
1171 switch(xform_type) {
1178 inv_view_matrix = view_matrix.inverse();
1179 view_mat_camera = 0;
1182 case XFORM_PROJECTION:
1187 tex_matrix[num] = mat;
1192 Matrix4x4 get_matrix(TransformType xform_type, int num) {
1193 switch(xform_type) {
1195 return world_matrix;
1201 return tex_matrix[num];
1203 case XFORM_PROJECTION:
1209 void set_viewport(unsigned int x, unsigned int y, unsigned int xsize, unsigned int ysize) {
1210 glViewport(x, y, xsize, ysize);
1213 // normalized set_viewport()
1214 void set_viewport_norm(float x, float y, float xsize, float ysize)
1216 glViewport((int) (x * gparams.x), (int)(y * gparams.y),
1217 (int) (xsize * gparams.x), int (ysize * gparams.y));
1220 Matrix4x4 create_projection_matrix(scalar_t vfov, scalar_t aspect, scalar_t near_clip, scalar_t far_clip) {
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);
1232 mat[2][3] = -q * near_clip;
1234 scalar_t f = 1.0f / (scalar_t)tan(vfov * 0.5f);
1237 mat[0][0] = f / aspect;
1239 mat[2][2] = (far_clip + near_clip) / (near_clip - far_clip);
1241 mat[2][3] = (2.0f * far_clip * near_clip) / (near_clip - far_clip);
1251 bool screen_capture(char *fname, enum image_file_format fmt) {
1253 static const char *suffix[] = {"png", "jpg", "tga", "oug1", "oug2"};
1257 uint32_t *pixels = new uint32_t[x * y];
1258 glReadPixels(0, 0, x, y, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
1261 static char fname_buf[50];
1263 sprintf(fname, "3dengfx_shot%04d.%s", scr_num++, suffix[fmt]);
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);