FS2_Open
Open source remastering of the Freespace 2 engine
gropengltnl.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) Volition, Inc. 1999. All rights reserved.
3  *
4  * All source code herein is the property of Volition, Inc. You may not sell
5  * or otherwise commercially exploit the source or things you created based on the
6  * source.
7  *
8 */
9 
10 
11 #ifdef _WIN32
12 #include <windows.h>
13 #endif
14 
15 #include "cmdline/cmdline.h"
16 #include "globalincs/alphacolors.h"
17 #include "globalincs/def_files.h"
18 #include "globalincs/systemvars.h"
19 #include "graphics/2d.h"
20 #include "graphics/grinternal.h"
21 #include "graphics/gropengldraw.h"
23 #include "graphics/gropengllight.h"
25 #include "graphics/gropenglstate.h"
27 #include "graphics/gropengltnl.h"
28 #include "lighting/lighting.h"
29 #include "math/vecmat.h"
30 #include "render/3d.h"
31 #include "weapon/trails.h"
32 
33 extern int GLOWMAP;
34 extern int CLOAKMAP;
35 extern int SPECMAP;
36 extern int NORMMAP;
37 extern int MISCMAP;
38 extern int HEIGHTMAP;
39 extern int G3_user_clip;
42 extern int Interp_multitex_cloakmap;
43 extern int Interp_cloakmap_alpha;
44 
45 extern bool Basemap_override;
46 extern bool Envmap_override;
47 extern bool Specmap_override;
48 extern bool Normalmap_override;
49 extern bool Heightmap_override;
50 extern bool GLSL_override;
51 extern bool Shadow_override;
52 
53 static int GL_modelview_matrix_depth = 1;
54 static int GL_htl_projection_matrix_set = 0;
55 static int GL_htl_view_matrix_set = 0;
56 static int GL_htl_2d_matrix_depth = 0;
57 static int GL_htl_2d_matrix_set = 0;
58 
59 static GLfloat GL_env_texture_matrix[16] = { 0.0f };
60 static bool GL_env_texture_matrix_set = false;
61 
62 static GLdouble eyex, eyey, eyez;
63 static GLdouble vmatrix[16];
64 
65 static vec3d last_view_pos;
66 static matrix last_view_orient;
67 
69 
70 static bool use_last_view = false;
71 
73 
76 
77 float GL_thrust_scale = -1.0f;
80 bool Using_Team_Color = false;
81 
83 
89 
91 
97 
98  GLuint texture; // for texture buffer objects
99 };
100 
102  GLfloat *array_list; // interleaved array
104 
107 
110 
112  array_list(NULL), index_list(NULL),
113  vb_handle(-1), ib_handle(-1), vbo_size(0), ibo_size(0)
114  {
115  }
116 
117  void clear();
118 };
119 
121 {
122  if (array_list) {
124  }
125 
126  if (index_list) {
128  }
129 
130  if ( vb_handle >= 0 ) {
132  }
133 
134  if ( ib_handle >= 0 ) {
136  }
137 }
138 
139 static SCP_vector<opengl_buffer_object> GL_buffer_objects;
140 static SCP_vector<opengl_vertex_buffer> GL_vertex_buffers;
141 static opengl_vertex_buffer *g_vbp = NULL;
142 static int GL_vertex_buffers_in_use = 0;
143 
145 {
146  opengl_buffer_object buffer_obj;
147 
148  buffer_obj.usage = usage;
149  buffer_obj.type = type;
150  buffer_obj.size = 0;
151 
152  vglGenBuffersARB(1, &buffer_obj.buffer_id);
153 
154  GL_buffer_objects.push_back(buffer_obj);
155 
156  return GL_buffer_objects.size() - 1;
157 }
158 
160 {
161  Assert(handle >= 0);
162  Assert((size_t)handle < GL_buffer_objects.size());
163 
164  opengl_buffer_object &buffer_obj = GL_buffer_objects[handle];
165 
166  switch ( buffer_obj.type ) {
167  case GL_ARRAY_BUFFER_ARB:
168  GL_state.Array.BindArrayBuffer(buffer_obj.buffer_id);
169  break;
171  GL_state.Array.BindElementBuffer(buffer_obj.buffer_id);
172  break;
174  GL_state.Array.BindTextureBuffer(buffer_obj.buffer_id);
175  break;
176  case GL_UNIFORM_BUFFER:
177  GL_state.Array.BindUniformBuffer(buffer_obj.buffer_id);
178  break;
179  default:
180  Int3();
181  return;
182  break;
183  }
184 }
185 
187 {
188  Assert(handle >= 0);
189  Assert((size_t)handle < GL_buffer_objects.size());
190 
191  opengl_buffer_object &buffer_obj = GL_buffer_objects[handle];
192 
194 
195  GL_vertex_data_in -= buffer_obj.size;
196  buffer_obj.size = size;
197  GL_vertex_data_in += buffer_obj.size;
198 
199  vglBufferDataARB(buffer_obj.type, size, data, buffer_obj.usage);
200 }
201 
203 {
204  Assert(handle >= 0);
205  Assert((size_t)handle < GL_buffer_objects.size());
206 
207  opengl_buffer_object &buffer_obj = GL_buffer_objects[handle];
208 
209  if ( buffer_obj.type == GL_TEXTURE_BUFFER_ARB ) {
210  glDeleteTextures(1, &buffer_obj.texture);
211  }
212 
213  GL_vertex_data_in -= buffer_obj.size;
214 
215  vglDeleteBuffersARB(1, &buffer_obj.buffer_id);
216 }
217 
219 {
220  if (!Use_VBOs) {
221  return -1;
222  }
223 
225 }
226 
228 {
230  return -1;
231  }
232 
233  // create the buffer
235 
237 
238  opengl_buffer_object &buffer_obj = GL_buffer_objects[buffer_object_handle];
239 
240  // create the texture
241  glGenTextures(1, &buffer_obj.texture);
243 
245 
246  gr_opengl_update_buffer_object(buffer_object_handle, 100, NULL);
247 
249 
251 
252  return buffer_object_handle;
253 }
254 
256 {
257  if ( Transform_buffer_handle < 0 || size <= 0 ) {
258  return;
259  }
260 
262 }
263 
265 {
266  if ( Transform_buffer_handle < 0 ) {
267  return 0;
268  }
269 
270  return GL_buffer_objects[Transform_buffer_handle].texture;
271 }
272 
274 {
276 }
277 
278 static void opengl_gen_buffer(opengl_vertex_buffer *vbp)
279 {
280  if ( !Use_VBOs ) {
281  return;
282  }
283 
284  if ( !vbp ) {
285  return;
286  }
287 
288  if ( !(vbp->vbo_size && vbp->ibo_size) ) {
289  return;
290  }
291 
292  // create vertex buffer
293  {
294  // clear any existing errors
295  glGetError();
296 
298 
299  // make sure we have one
300  if ( vbp->vb_handle >= 0 ) {
302 
303  // just in case
304  if ( opengl_check_for_errors() ) {
306  vbp->vb_handle = -1;
307  return;
308  }
309 
311 
312  vm_free(vbp->array_list);
313  vbp->array_list = NULL;
314  }
315  }
316 
317  // create index buffer
318  {
319  // clear any existing errors
320  glGetError();
321 
323 
324  // make sure we have one
325  if ( vbp->ib_handle >= 0 ) {
327 
328  // just in case
329  if ( opengl_check_for_errors() ) {
331  vbp->ib_handle = -1;
332  return;
333  }
334 
336 
337  vm_free(vbp->index_list);
338  vbp->index_list = NULL;
339  }
340  }
341 }
342 
344 {
345  if (Cmdline_nohtl) {
346  return -1;
347  }
348 
349  opengl_vertex_buffer vbuffer;
350 
351  GL_vertex_buffers.push_back( vbuffer );
352  GL_vertex_buffers_in_use++;
353 
354  return (int)(GL_vertex_buffers.size() - 1);
355 }
356 
357 bool gr_opengl_config_buffer(const int buffer_id, vertex_buffer *vb, bool update_ibuffer_only)
358 {
359  if (Cmdline_nohtl) {
360  return false;
361  }
362 
363  if (buffer_id < 0) {
364  return false;
365  }
366 
367  Assert( buffer_id < (int)GL_vertex_buffers.size() );
368 
369  if (vb == NULL) {
370  return false;
371  }
372 
373  if ( !(vb->flags & VB_FLAG_POSITION) ) {
374  Int3();
375  return false;
376  }
377 
378  opengl_vertex_buffer *m_vbp = &GL_vertex_buffers[buffer_id];
379 
380 
381  vb->stride = 0;
382 
383  // position
384  Verify( update_ibuffer_only || vb->model_list->vert != NULL );
385 
386  vb->stride += (3 * sizeof(GLfloat));
387 
388  // normals
389  if (vb->flags & VB_FLAG_NORMAL) {
390  Verify( update_ibuffer_only || vb->model_list->norm != NULL );
391 
392  vb->stride += (3 * sizeof(GLfloat));
393  }
394 
395  // uv coords
396  if (vb->flags & VB_FLAG_UV1) {
397  vb->stride += (2 * sizeof(GLfloat));
398  }
399 
400  // tangent space data for normal maps (shaders only)
401  if (vb->flags & VB_FLAG_TANGENT) {
403 
404  Verify( update_ibuffer_only || vb->model_list->tsb != NULL );
405  vb->stride += (4 * sizeof(GLfloat));
406  }
407 
408  if (vb->flags & VB_FLAG_MODEL_ID) {
409  Assert( GLSL_version >= 130 );
410 
411  Verify( update_ibuffer_only || vb->model_list->submodels != NULL );
412  vb->stride += (1 * sizeof(GLfloat));
413  }
414 
415  // offsets for this chunk
416  if ( !update_ibuffer_only ) {
417  vb->vertex_offset = m_vbp->vbo_size;
418  m_vbp->vbo_size += vb->stride * vb->model_list->n_verts;
419  }
420 
421  for (size_t idx = 0; idx < vb->tex_buf.size(); idx++) {
422  buffer_data *bd = &vb->tex_buf[idx];
423 
424  bd->index_offset = m_vbp->ibo_size;
425  m_vbp->ibo_size += bd->n_verts * ((bd->flags & VB_FLAG_LARGE_INDEX) ? sizeof(uint) : sizeof(ushort));
426 
427  // even out index buffer so we are always word aligned
428  m_vbp->ibo_size += m_vbp->ibo_size % sizeof(uint);
429  }
430 
431  return true;
432 }
433 
434 bool gr_opengl_pack_buffer(const int buffer_id, vertex_buffer *vb)
435 {
436  if (Cmdline_nohtl) {
437  return false;
438  }
439 
440  if (buffer_id < 0) {
441  return false;
442  }
443 
444  Assert( buffer_id < (int)GL_vertex_buffers.size() );
445 
446  opengl_vertex_buffer *m_vbp = &GL_vertex_buffers[buffer_id];
447 
448  // NULL means that we are done with the buffer and can create the IBO/VBO
449  // returns false here only for some minor error prevention
450  if (vb == NULL) {
451  opengl_gen_buffer(m_vbp);
452  return false;
453  }
454 
455  int i, n_verts = 0;
456  size_t j;
457  uint arsize = 0;
458 
459 
460  if (m_vbp->array_list == NULL) {
461  m_vbp->array_list = (GLfloat*)vm_malloc_q(m_vbp->vbo_size);
462 
463  // return invalid if we don't have the memory
464  if (m_vbp->array_list == NULL) {
465  return false;
466  }
467 
468  memset(m_vbp->array_list, 0, m_vbp->vbo_size);
469  }
470 
471  if (m_vbp->index_list == NULL) {
472  m_vbp->index_list = (GLubyte*)vm_malloc_q(m_vbp->ibo_size);
473 
474  // return invalid if we don't have the memory
475  if (m_vbp->index_list == NULL) {
476  return false;
477  }
478 
479  memset(m_vbp->index_list, 0, m_vbp->ibo_size);
480  }
481 
482  // bump to our index in the array
483  GLfloat *array = m_vbp->array_list + (vb->vertex_offset / sizeof(GLfloat));
484 
485  // generate the vertex array
486  n_verts = vb->model_list->n_verts;
487  for (i = 0; i < n_verts; i++) {
488  vertex *vl = &vb->model_list->vert[i];
489 
490  // don't try to generate more data than what's available
491  Assert( ((arsize * sizeof(GLfloat)) + vb->stride) <= (m_vbp->vbo_size - vb->vertex_offset) );
492 
493  // NOTE: UV->NORM->TSB->VERT, This array order *must* be preserved!!
494 
495  // tex coords
496  if (vb->flags & VB_FLAG_UV1) {
497  array[arsize++] = vl->texture_position.u;
498  array[arsize++] = vl->texture_position.v;
499  }
500 
501  // normals
502  if (vb->flags & VB_FLAG_NORMAL) {
503  vec3d *nl = &vb->model_list->norm[i];
504  array[arsize++] = nl->xyz.x;
505  array[arsize++] = nl->xyz.y;
506  array[arsize++] = nl->xyz.z;
507  }
508 
509  // tangent space data
510  if (vb->flags & VB_FLAG_TANGENT) {
511  tsb_t *tsb = &vb->model_list->tsb[i];
512  array[arsize++] = tsb->tangent.xyz.x;
513  array[arsize++] = tsb->tangent.xyz.y;
514  array[arsize++] = tsb->tangent.xyz.z;
515  array[arsize++] = tsb->scaler;
516  }
517 
518  if (vb->flags & VB_FLAG_MODEL_ID) {
519  array[arsize++] = (float)vb->model_list->submodels[i];
520  }
521 
522  // verts
523  array[arsize++] = vl->world.xyz.x;
524  array[arsize++] = vl->world.xyz.y;
525  array[arsize++] = vl->world.xyz.z;
526  }
527 
528  // generate the index array
529  for (j = 0; j < vb->tex_buf.size(); j++) {
530  buffer_data* tex_buf = &vb->tex_buf[j];
531  n_verts = tex_buf->n_verts;
532  uint offset = tex_buf->index_offset;
533  const uint *index = tex_buf->get_index();
534 
535  // bump to our spot in the buffer
536  GLubyte *ibuf = m_vbp->index_list + offset;
537 
538  if (vb->tex_buf[j].flags & VB_FLAG_LARGE_INDEX) {
539  memcpy(ibuf, index, n_verts * sizeof(uint));
540  } else {
541  ushort *mybuf = (ushort*)ibuf;
542 
543  for (i = 0; i < n_verts; i++) {
544  mybuf[i] = (ushort)index[i];
545  }
546  }
547  }
548 
549  return true;
550 }
551 
553 {
554  if (Cmdline_nohtl) {
555  return;
556  }
557 
558  g_vbp = NULL;
559 
560  if (idx < 0) {
561  if (Use_VBOs) {
564  }
565 
568  }
569 
570  return;
571  }
572 
573  Assert( idx < (int)GL_vertex_buffers.size() );
574 
575  g_vbp = &GL_vertex_buffers[idx];
576 }
577 
579 {
580  if (Cmdline_nohtl) {
581  return;
582  }
583 
584  if (idx < 0) {
585  return;
586  }
587 
588  Assert( idx < (int)GL_vertex_buffers.size() );
589 
590  opengl_vertex_buffer *vbp = &GL_vertex_buffers[idx];
591 
592  vbp->clear();
593 
594  // we try to take advantage of the fact that there shouldn't be a lot of buffer
595  // deletions/additions going on all of the time, so a model_unload_all() and/or
596  // game_level_close() should pretty much keep everything cleared out on a
597  // regular basis
598  if (--GL_vertex_buffers_in_use <= 0) {
599  GL_vertex_buffers.clear();
600  }
601 
602  g_vbp = NULL;
603 }
604 
606 {
607  for (uint i = 0; i < GL_vertex_buffers.size(); i++) {
609  }
610 
611  for ( uint i = 0; i < GL_buffer_objects.size(); i++ ) {
613  }
614 
615  GL_vertex_buffers.clear();
616  GL_vertex_buffers_in_use = 0;
617 }
618 
620 {
621  GL_vertex_buffers.reserve(MAX_POLYGON_MODELS);
624 
626 
627  if ( Transform_buffer_handle < 0 ) {
628  Cmdline_no_batching = true;
629  }
630 
632  {
633  //Setup shadow map framebuffer
636 
638 
641 // GL_state.Texture.SetTarget(GL_TEXTURE_2D);
643 
649 
650 // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
651 // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
652 // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
653 // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
654 // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
655  //glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT);
656  //glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
657  //glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_DEPTH_TEXTURE_MODE_ARB, GL_INTENSITY);
658  int size = (Cmdline_shadow_quality == 2 ? 1024 : 512);
660  //glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, size, size, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
661 
663  //vglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, Shadow_map_depth_texture, 0);
664 
666 
669  //GL_state.Texture.SetTarget(GL_TEXTURE_2D);
671 
677 // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
678 // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
679 // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
680 // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
681 // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
683  //glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, size, size, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
684 
686  //vglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, Shadow_map_texture, 0);
687 
689 
690  opengl_check_for_errors("post_init_framebuffer()");
691  }
692 }
693 
695 {
696  if ( Shadow_map_depth_texture ) {
699  }
700 
701  if ( Shadow_map_texture ) {
703  Shadow_map_texture = 0;
704  }
705 
707 }
708 
709 void mix_two_team_colors(team_color* dest, team_color* a, team_color* b, float mix_factor) {
710  dest->base.r = a->base.r * (1.0f - mix_factor) + b->base.r * mix_factor;
711  dest->base.g = a->base.g * (1.0f - mix_factor) + b->base.g * mix_factor;
712  dest->base.b = a->base.b * (1.0f - mix_factor) + b->base.b * mix_factor;
713 
714  dest->stripe.r = a->stripe.r * (1.0f - mix_factor) + b->stripe.r * mix_factor;
715  dest->stripe.g = a->stripe.g * (1.0f - mix_factor) + b->stripe.g * mix_factor;
716  dest->stripe.b = a->stripe.b * (1.0f - mix_factor) + b->stripe.b * mix_factor;
717 }
718 
720 {
721  if ( colors == NULL ) {
722  Using_Team_Color = false;
723  } else {
724  Using_Team_Color = true;
725  Current_temp_color = *colors;
726  Current_team_color = &Current_temp_color;
727  }
728 }
729 
731 {
733 }
734 
735 static void opengl_init_arrays(opengl_vertex_buffer *vbp, const vertex_buffer *bufferp)
736 {
737  GLint offset = (GLint)bufferp->vertex_offset;
738  GLubyte *ptr = NULL;
739 
741  offset = 0;
742  }
743 
744  // vertex buffer
745 
746  if ( vbp->vb_handle >= 0 ) {
748  } else {
749  ptr = (GLubyte*)vbp->array_list;
750  }
751 
752  vertex_layout vert_def;
753 
754  if (bufferp->flags & VB_FLAG_UV1) {
755  vert_def.add_vertex_component(vertex_format_data::TEX_COORD, bufferp->stride, ptr + offset);
756  offset += (2 * sizeof(GLfloat));
757  }
758 
759  if (bufferp->flags & VB_FLAG_NORMAL) {
760  vert_def.add_vertex_component(vertex_format_data::NORMAL, bufferp->stride, ptr + offset);
761  offset += (3 * sizeof(GLfloat));
762  }
763 
764  if (bufferp->flags & VB_FLAG_TANGENT) {
765  // we treat this as texture coords for ease of use
766  // NOTE: this is forced on tex unit 1!!!
767  vert_def.add_vertex_component(vertex_format_data::TANGENT, bufferp->stride, ptr + offset);
768  offset += (4 * sizeof(GLfloat));
769  }
770 
771  if (bufferp->flags & VB_FLAG_MODEL_ID) {
772  vert_def.add_vertex_component(vertex_format_data::MODEL_ID, bufferp->stride, ptr + offset);
773  offset += (1 * sizeof(GLfloat));
774  }
775 
776  Assert( bufferp->flags & VB_FLAG_POSITION );
777  vert_def.add_vertex_component(vertex_format_data::POSITION3, bufferp->stride, ptr + offset);
778  offset += (3 * sizeof(GLfloat));
779 
780  opengl_bind_vertex_layout(vert_def);
781 }
782 
783 #define DO_RENDER() \
784  if (Cmdline_drawelements) \
785  glDrawElements(GL_TRIANGLES, count, element_type, ibuffer + (datap->index_offset + start)); \
786  else \
787  vglDrawRangeElements(GL_TRIANGLES, datap->i_first, datap->i_last, count, element_type, ibuffer + (datap->index_offset + start));
788 
789 unsigned int GL_last_shader_flags = 0;
791 
792 static void opengl_render_pipeline_fixed(int start, const vertex_buffer *bufferp, const buffer_data *datap, int flags);
793 
794 extern bool Scene_framebuffer_in_frame;
796 extern matrix Object_matrix;
797 extern vec3d Object_position;
798 extern int Interp_thrust_scale_subobj;
799 extern float Interp_thrust_scale;
800 static void opengl_render_pipeline_program(int start, const vertex_buffer *bufferp, const buffer_data *datap, int flags)
801 {
802  unsigned int shader_flags = 0;
803  int sdr_index = -1;
804  int r, g, b, a, tmap_type;
805  GLubyte *ibuffer = NULL;
806 
807  int end = (datap->n_verts - 1);
808  int count = (end - (start*3) + 1);
809 
810  GLenum element_type = (datap->flags & VB_FLAG_LARGE_INDEX) ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT;
811 
812  opengl_vertex_buffer *vbp = g_vbp;
813  Assert( vbp );
814 
815  int textured = ((flags & TMAP_FLAG_TEXTURED) && (bufferp->flags & VB_FLAG_UV1));
816 
817  // setup shader flags for the things that we want/need
818  shader_flags = gr_determine_model_shader_flags(
820  GL_state.Fog() ? true : false,
821  textured ? true : false,
823  GL_thrust_scale > 0.0f,
826  flags,
827  SPECMAP,
828  GLOWMAP,
829  NORMMAP,
830  HEIGHTMAP,
831  ENVMAP,
832  MISCMAP
833  );
834 
835  // find proper shader
836  if (shader_flags == GL_last_shader_flags) {
837  sdr_index = GL_last_shader_index;
838  } else {
839  sdr_index = gr_opengl_maybe_create_shader(SDR_TYPE_MODEL, shader_flags);
840 
841  if (sdr_index < 0) {
842  opengl_render_pipeline_fixed(start, bufferp, datap, flags);
843  return;
844  }
845 
846  GL_last_shader_index = sdr_index;
847  GL_last_shader_flags = shader_flags;
848  }
849 
850  Assert( sdr_index >= 0 );
851 
852  opengl_shader_set_current( sdr_index );
853 
856 
857  opengl_setup_render_states(r, g, b, a, tmap_type, flags);
858  GL_state.Color( (ubyte)r, (ubyte)g, (ubyte)b, (ubyte)a );
859 
861 
862  // basic setup of all data
863  opengl_init_arrays(vbp, bufferp);
864 
865  if ( vbp->ib_handle >= 0 ) {
867  } else {
868  ibuffer = (GLubyte*)vbp->index_list;
869  }
870 
871  opengl_tnl_set_material(flags, shader_flags, tmap_type);
872 
874  vglDrawElementsInstancedBaseVertex(GL_TRIANGLES, count, element_type, ibuffer + (datap->index_offset + start), 4, (GLint)bufferp->vertex_offset/bufferp->stride);
875  } else {
877  if (Cmdline_drawelements) {
878  vglDrawElementsBaseVertex(GL_TRIANGLES, count, element_type, ibuffer + (datap->index_offset + start), (GLint)bufferp->vertex_offset/bufferp->stride);
879  } else {
880  vglDrawRangeElementsBaseVertex(GL_TRIANGLES, datap->i_first, datap->i_last, count, element_type, ibuffer + (datap->index_offset + start), (GLint)bufferp->vertex_offset/bufferp->stride);
881  }
882  } else {
883  if (Cmdline_drawelements) {
884  glDrawElements(GL_TRIANGLES, count, element_type, ibuffer + (datap->index_offset + start));
885  } else {
886  vglDrawRangeElements(GL_TRIANGLES, datap->i_first, datap->i_last, count, element_type, ibuffer + (datap->index_offset + start));
887  }
888  }
889  }
890 /*
891  int n_light_passes = (MIN(Num_active_gl_lights, GL_max_lights) - 1) / 3;
892 
893  if (lighting_is_enabled && n_light_passes > 0) {
894  shader_flags = SDR_FLAG_LIGHT;
895 
896  if (textured) {
897  if ( !Basemap_override ) {
898  shader_flags |= SDR_FLAG_DIFFUSE_MAP;
899  }
900 
901  if ( (SPECMAP > 0) && !Specmap_override ) {
902  shader_flags |= SDR_FLAG_SPEC_MAP;
903  }
904  }
905 
906  opengl::shader_manager::get()->apply_main_shader(shader_flags);
907  sdr = opengl::shader_manager::get()->get_main_shader();
908 
909  if (sdr) {
910  GL_state.BlendFunc(GL_ONE, GL_ONE);
911 
912  int zbuf = gr_zbuffer_set(GR_ZBUFF_READ);
913 
914  static const float GL_light_zero[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
915  glMaterialfv( GL_FRONT, GL_AMBIENT, GL_light_zero );
916  glMaterialfv( GL_FRONT, GL_EMISSION, GL_light_zero );
917 
918  GL_state.DepthMask(GL_FALSE);
919  GL_state.DepthFunc(GL_LEQUAL);
920 
921  for (int i = 0; i < n_light_passes; i++) {
922  int offset = 3 * (i+1) - 1;
923  opengl_change_active_lights(0, offset);
924 
925  n_lights = MIN(Num_active_gl_lights, GL_max_lights) - offset;
926  sdr->set_uniform(opengl::main_shader::n_lights, n_lights);
927 
928  DO_RENDER();
929  }
930 
931  gr_zbuffer_set(zbuf);
932  }
933  }
934 */
935 /*
936  if (Num_active_gl_lights > 4) {
937  opengl_change_active_lights(0, 4);
938 
939  int n_lights = MIN(Num_active_gl_lights, GL_max_lights) - 5;
940  vglUniform1iARB( opengl_shader_get_uniform("n_lights"), n_lights );
941 
942  opengl_default_light_settings(0, 0, 0);
943 
944  opengl_shader_set_current( &GL_shader[2] );
945 
946  GL_state.SetAlphaBlendMode(ALPHA_BLEND_ADDITIVE);
947 
948  GL_state.DepthMask(GL_FALSE);
949  GL_state.DepthFunc(GL_LEQUAL);
950 
951  DO_RENDER();
952  }
953 */
955 }
956 
957 static void opengl_render_pipeline_fixed(int start, const vertex_buffer *bufferp, const buffer_data *datap, int flags)
958 {
959  float u_scale, v_scale;
960  int render_pass = 0;
961  int r, g, b, a, tmap_type;
962  GLubyte *ibuffer = NULL;
963  GLubyte *vbuffer = NULL;
964 
965  bool rendered_env = false;
966  bool using_glow = false;
967  bool using_spec = false;
968  bool using_env = false;
969 
970  int end = (datap->n_verts - 1);
971  int count = (end - start + 1);
972 
973  GLenum element_type = (datap->flags & VB_FLAG_LARGE_INDEX) ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT;
974 
975  opengl_vertex_buffer *vbp = g_vbp;
976  Assert( vbp );
977 
978  int textured = ((flags & TMAP_FLAG_TEXTURED) && (bufferp->flags & VB_FLAG_UV1));
979 
980  if (textured ) {
981  if ( Cmdline_glow && (GLOWMAP > 0) ) {
982  using_glow = true;
983  }
984 
985  if (lighting_is_enabled) {
987 
988  if ( !GL_state.Fog() && (SPECMAP > 0) && !Specmap_override ) {
989  using_spec = true;
990 
991  if ( (ENVMAP > 0) && !Envmap_override ) {
992  using_env = true;
993  }
994  }
995  }
996  }
997 
998  render_pass = 0;
999 
1000  opengl_default_light_settings( !GL_center_alpha, (GL_light_factor > 0.25f), (using_spec) ? 0 : 1 );
1002 
1003  opengl_setup_render_states(r, g, b, a, tmap_type, flags);
1004  GL_state.Color( (ubyte)r, (ubyte)g, (ubyte)b, (ubyte)a );
1005 
1006  // basic setup of all data
1007  opengl_init_arrays(vbp, bufferp);
1008 
1009  if ( vbp->ib_handle >= 0 ) {
1011  } else {
1012  ibuffer = (GLubyte*)vbp->index_list;
1013  }
1014 
1015  if ( vbp->vb_handle < 0 ) {
1016  vbuffer = (GLubyte*)vbp->array_list;
1017  }
1018 
1019  // if we're not doing an alpha pass, turn on the alpha mask
1020  if ( !(flags & TMAP_FLAG_ALPHA) ) {
1021  gr_alpha_mask_set(1, 0.95f);
1022  }
1023 
1024  #define BUFFER_OFFSET(off) (vbuffer+bufferp->vertex_offset+(off))
1025 
1026 // -------- Begin 1st PASS (base texture, glow) ---------------------------------- //
1027  if (textured) {
1028  render_pass = 0;
1029 
1030  // base texture
1031  if ( !Basemap_override ) {
1033  GL_state.Array.SetActiveClientUnit(render_pass);
1035  GL_state.Array.TexPointer( 2, GL_FLOAT, bufferp->stride, BUFFER_OFFSET(0) );
1036  }
1037 
1038  gr_opengl_tcache_set(gr_screen.current_bitmap, tmap_type, &u_scale, &v_scale, render_pass);
1039 
1040  // increment texture count for this pass
1041  render_pass++; // bump!
1042  }
1043 
1044  // glowmaps!
1045  if (using_glow) {
1046  GL_state.Array.SetActiveClientUnit(render_pass);
1049  GL_state.Array.TexPointer( 2, GL_FLOAT, bufferp->stride, 0 );
1050  } else {
1051  GL_state.Array.TexPointer( 2, GL_FLOAT, bufferp->stride, BUFFER_OFFSET(0) );
1052  }
1053 
1054  // set glowmap on relevant ARB
1055  gr_opengl_tcache_set(GLOWMAP, tmap_type, &u_scale, &v_scale, render_pass);
1056 
1058 
1059  render_pass++; // bump!
1060  }
1061  }
1062 
1063  // DRAW IT!!
1065  if (Cmdline_drawelements) {
1066  vglDrawElementsBaseVertex(GL_TRIANGLES, count, element_type, ibuffer + (datap->index_offset + start), (GLint)bufferp->vertex_offset/bufferp->stride);
1067  } else {
1068  vglDrawRangeElementsBaseVertex(GL_TRIANGLES, datap->i_first, datap->i_last, count, element_type, ibuffer + (datap->index_offset + start), (GLint)bufferp->vertex_offset/bufferp->stride);
1069  }
1070  } else {
1071  if (Cmdline_drawelements) {
1072  glDrawElements(GL_TRIANGLES, count, element_type, ibuffer + (datap->index_offset + start));
1073  } else {
1074  vglDrawRangeElements(GL_TRIANGLES, datap->i_first, datap->i_last, count, element_type, ibuffer + (datap->index_offset + start));
1075  }
1076  }
1077 
1078 // -------- End 2nd PASS --------------------------------------------------------- //
1079 
1080 
1081 // -------- Begin 2nd pass (additional lighting) --------------------------------- //
1082 /* if ( (textured) && (lighting_is_enabled) && !(GL_state.Fog()) && (Num_active_gl_lights > GL_max_lights) ) {
1083  // the lighting code needs to do this better, may need some adjustment later since I'm only trying
1084  // to avoid rendering 7+ extra passes for lights which probably won't affect current object, but as
1085  // a performance hack I guess this will have to do for now...
1086  // restrict the number of extra lighting passes based on LOD:
1087  // - LOD0: only 2 extra passes (3 main passes total, rendering 24 light sources)
1088  // - LOD1: only 1 extra pass (2 main passes total, rendering 16 light sources)
1089  // - LOD2+: no extra passes (1 main pass total, rendering 8 light sources)
1090  extern int Interp_detail_level;
1091  int max_passes = (2 - Interp_detail_level);
1092 
1093  if (max_passes > 0) {
1094  int max_lights = (Num_active_gl_lights - 1) / GL_max_lights;
1095 
1096  if (max_lights > 0) {
1097  int i;
1098 
1099  opengl_set_state( TEXTURE_SOURCE_DECAL, ALPHA_BLEND_ALPHA_ADDITIVE, ZBUFFER_TYPE_READ );
1100 
1101  for (i = 1; i < render_pass; i++) {
1102  opengl_switch_arb(i, 0);
1103  }
1104 
1105  for (i = 1; (i < max_lights) && (i < max_passes); i++) {
1106  opengl_change_active_lights(i);
1107 
1108  // DRAW IT!!
1109  DO_RENDER();
1110  }
1111 
1112  // reset the active lights to the first set to render the spec related passes with
1113  // for performance and quality reasons they don't get special lighting passes
1114  opengl_change_active_lights(0);
1115  }
1116  }
1117  }*/
1118 // -------- End 2nd PASS --------------------------------------------------------- //
1119 
1120 
1121 // -------- Begin 3rd PASS (environment map) ------------------------------------- //
1122  if (using_env) {
1123  // turn all previously used arbs off before the specular pass
1124  // this fixes the glowmap multitexture rendering problem - taylor
1126 
1127  render_pass = 0;
1128 
1129  // set specmap, for us to modulate against
1131  GL_state.Array.SetActiveClientUnit(render_pass);
1134  }
1135 
1136  // set specmap on relevant ARB
1137  gr_opengl_tcache_set(SPECMAP, tmap_type, &u_scale, &v_scale, render_pass);
1138 
1141 
1142  // as a crazy and sometimes useless hack, avoid using alpha when specmap has none
1143  if ( bm_has_alpha_channel(SPECMAP) ) {
1151  } else {
1158  }
1159 
1160  render_pass++; // bump!
1161 
1162  // now move the to the envmap
1164  GL_state.Array.SetActiveClientUnit(render_pass);
1167  }
1168 
1169  gr_opengl_tcache_set(ENVMAP, TCACHE_TYPE_CUBEMAP, &u_scale, &v_scale, render_pass);
1170 
1176 
1178 
1180 
1184 
1188 
1192 
1193  // set the matrix for the texture mode
1194  if (GL_env_texture_matrix_set) {
1196  glPushMatrix();
1197  glLoadMatrixf(GL_env_texture_matrix);
1198  // switch back to the default modelview mode
1200  }
1201 
1202  render_pass++; // bump!
1203 
1204  GLfloat ambient_save[4];
1205  glGetMaterialfv( GL_FRONT, GL_AMBIENT, ambient_save );
1206 
1207  GLfloat ambient[4] = { 0.47f, 0.47f, 0.47f, 1.0f };
1208  glMaterialfv( GL_FRONT, GL_AMBIENT, ambient );
1209 
1210  // DRAW IT!!
1212  if (Cmdline_drawelements) {
1213  vglDrawElementsBaseVertex(GL_TRIANGLES, count, element_type, ibuffer + (datap->index_offset + start), (GLint)bufferp->vertex_offset/bufferp->stride);
1214  } else {
1215  vglDrawRangeElementsBaseVertex(GL_TRIANGLES, datap->i_first, datap->i_last, count, element_type, ibuffer + (datap->index_offset + start), (GLint)bufferp->vertex_offset/bufferp->stride);
1216  }
1217  } else {
1218  if (Cmdline_drawelements) {
1219  glDrawElements(GL_TRIANGLES, count, element_type, ibuffer + (datap->index_offset + start));
1220  } else {
1221  vglDrawRangeElements(GL_TRIANGLES, datap->i_first, datap->i_last, count, element_type, ibuffer + (datap->index_offset + start));
1222  }
1223  }
1224 
1225  // disable and reset everything we changed
1227 
1228  // reset original ambient light value
1229  glMaterialfv( GL_FRONT, GL_AMBIENT, ambient_save );
1230 
1231  // pop off the texture matrix we used for the envmap
1232  if (GL_env_texture_matrix_set) {
1234  glPopMatrix();
1236  }
1237 
1241 
1243 
1246 
1247  rendered_env = true;
1248  }
1249 // -------- End 3rd PASS --------------------------------------------------------- //
1250 
1251 
1252 // -------- Begin 4th PASS (specular/shine map) ---------------------------------- //
1253  if (using_spec) {
1254  // turn all previously used arbs off before the specular pass
1255  // this fixes the glowmap multitexture rendering problem - taylor
1259 
1260  render_pass = 0;
1261 
1265  GL_state.Array.TexPointer( 2, GL_FLOAT, bufferp->stride, BUFFER_OFFSET(0) );
1266  }
1267 
1268  gr_opengl_tcache_set(SPECMAP, tmap_type, &u_scale, &v_scale, render_pass);
1269 
1270  // render with spec lighting only
1272 
1278 
1279  GL_state.Texture.SetRGBScale( (rendered_env) ? 2.0f : 4.0f );
1280 
1282 
1285 
1286  // DRAW IT!!
1288  if (Cmdline_drawelements) {
1289  vglDrawElementsBaseVertex(GL_TRIANGLES, count, element_type, ibuffer + (datap->index_offset + start), (GLint)bufferp->vertex_offset/bufferp->stride);
1290  } else {
1291  vglDrawRangeElementsBaseVertex(GL_TRIANGLES, datap->i_first, datap->i_last, count, element_type, ibuffer + (datap->index_offset + start), (GLint)bufferp->vertex_offset/bufferp->stride);
1292  }
1293  } else {
1294  if (Cmdline_drawelements) {
1295  glDrawElements(GL_TRIANGLES, count, element_type, ibuffer + (datap->index_offset + start));
1296  } else {
1297  vglDrawRangeElements(GL_TRIANGLES, datap->i_first, datap->i_last, count, element_type, ibuffer + (datap->index_offset + start));
1298  }
1299  }
1300 
1302 
1304  }
1305 // -------- End 4th PASS --------------------------------------------------------- //
1306 
1307  // make sure everthing gets turned back off
1308  gr_alpha_mask_set(0, 1.0f);
1325 }
1326 
1327 // start is the first part of the buffer to render, n_prim is the number of primitives, index_list is an index buffer, if index_list == NULL render non-indexed
1328 void gr_opengl_render_buffer(int start, const vertex_buffer *bufferp, int texi, int flags)
1329 {
1330  Assert( GL_htl_projection_matrix_set );
1331  Assert( GL_htl_view_matrix_set );
1332 
1333  Verify( bufferp != NULL );
1334 
1335  GL_CHECK_FOR_ERRORS("start of render_buffer()");
1336 
1337  if ( GL_state.CullFace() ) {
1339  }
1340 
1341  Assert( texi >= 0 );
1342 
1343  const buffer_data *datap = &bufferp->tex_buf[texi];
1344 
1345  if ( is_minimum_GLSL_version() && !GLSL_override ) {
1346  opengl_render_pipeline_program(start, bufferp, datap, flags);
1347  } else {
1348  opengl_render_pipeline_fixed(start, bufferp, datap, flags);
1349  }
1350 
1351  GL_CHECK_FOR_ERRORS("end of render_buffer()");
1352 }
1353 
1356 extern GLuint Distortion_texture[2];
1357 extern int Distortion_switch;
1358 void gr_opengl_render_stream_buffer(int buffer_handle, int offset, int n_verts, int flags)
1359 {
1360  int alpha, tmap_type, r, g, b;
1361  float u_scale = 1.0f, v_scale = 1.0f;
1362  GLenum gl_mode = GL_TRIANGLE_FAN;
1363  GL_CHECK_FOR_ERRORS("start of render3d()");
1364 
1365  int stride = 0;
1366 
1367  GLubyte *ptr = NULL;
1368  int vert_offset = 0;
1369 
1370  int pos_offset = -1;
1371  int tex_offset = -1;
1372  int radius_offset = -1;
1373  int color_offset = -1;
1374  int up_offset = -1;
1375 
1376  if ( flags & TMAP_FLAG_VERTEX_GEN ) {
1377  stride = sizeof(particle_pnt);
1378 
1379  pos_offset = vert_offset;
1380  vert_offset += sizeof(vec3d);
1381 
1382  radius_offset = vert_offset;
1383  vert_offset += sizeof(float);
1384 
1385  up_offset = vert_offset;
1386  //tex_offset = vert_offset;
1387  vert_offset += sizeof(vec3d);
1388  } else {
1389  stride = sizeof(effect_vertex);
1390 
1391  pos_offset = vert_offset;
1392  vert_offset += sizeof(vec3d);
1393 
1394  tex_offset = vert_offset;
1395  vert_offset += sizeof(uv_pair);
1396 
1397  radius_offset = vert_offset;
1398  vert_offset += sizeof(float);
1399 
1400  color_offset = vert_offset;
1401  vert_offset += sizeof(ubyte)*4;
1402  }
1403 
1404  opengl_setup_render_states(r, g, b, alpha, tmap_type, flags);
1405 
1406  opengl_bind_buffer_object(buffer_handle);
1407 
1408  vertex_layout vert_def;
1409 
1410  if ( flags & TMAP_FLAG_TEXTURED ) {
1411  if ( flags & TMAP_FLAG_SOFT_QUAD ) {
1412  if( (flags & TMAP_FLAG_DISTORTION) || (flags & TMAP_FLAG_DISTORTION_THRUSTER) ) {
1414 
1416 
1417  if ( radius_offset >= 0 ) {
1418  vert_def.add_vertex_component(vertex_format_data::RADIUS, stride, ptr + radius_offset);
1419  }
1421  } else if ( Cmdline_softparticles ) {
1423 
1425 
1426  if ( radius_offset >= 0 ) {
1427  vert_def.add_vertex_component(vertex_format_data::RADIUS, stride, ptr + radius_offset);
1428  }
1429 
1430  if ( up_offset >= 0 ) {
1431  vert_def.add_vertex_component(vertex_format_data::UVEC, stride, ptr + up_offset);
1432  }
1433  }
1434  }
1435 
1436  if ( !gr_opengl_tcache_set(gr_screen.current_bitmap, tmap_type, &u_scale, &v_scale) ) {
1437  return;
1438  }
1439 
1440  if ( tex_offset >= 0 ) {
1441  vert_def.add_vertex_component(vertex_format_data::TEX_COORD, stride, ptr + tex_offset);
1442  }
1443  }
1444 
1445  if (flags & TMAP_FLAG_TRILIST) {
1446  gl_mode = GL_TRIANGLES;
1447  } else if (flags & TMAP_FLAG_TRISTRIP) {
1448  gl_mode = GL_TRIANGLE_STRIP;
1449  } else if (flags & TMAP_FLAG_QUADLIST) {
1450  gl_mode = GL_QUADS;
1451  } else if (flags & TMAP_FLAG_QUADSTRIP) {
1452  gl_mode = GL_QUAD_STRIP;
1453  } else if (flags & TMAP_FLAG_POINTLIST) {
1454  gl_mode = GL_POINTS;
1455  } else if (flags & TMAP_FLAG_LINESTRIP) {
1456  gl_mode = GL_LINE_STRIP;
1457  }
1458 
1459  if ( (flags & TMAP_FLAG_RGB) && (flags & TMAP_FLAG_GOURAUD) && color_offset >= 0 ) {
1460  vert_def.add_vertex_component(vertex_format_data::COLOR4, stride, ptr + color_offset);
1461  } else {
1462  // use what opengl_setup_render_states() gives us since this works much better for nebula and transparency
1463  GL_state.Color( (ubyte)r, (ubyte)g, (ubyte)b, (ubyte)alpha );
1464  }
1465 
1466  if ( pos_offset >= 0 ) {
1467  vert_def.add_vertex_component(vertex_format_data::POSITION3, stride, ptr + pos_offset);
1468  }
1469 
1470  opengl_bind_vertex_layout(vert_def);
1471 
1472  glDrawArrays(gl_mode, offset, n_verts);
1473 
1474  if( (flags & TMAP_FLAG_DISTORTION) || (flags & TMAP_FLAG_DISTORTION_THRUSTER) ) {
1476  vglDrawBuffers(2, buffers);
1477  }
1478 
1479  GL_CHECK_FOR_ERRORS("end of render3d()");
1480 }
1481 
1482 void gr_opengl_start_instance_matrix(const vec3d *offset, const matrix *rotation)
1483 {
1484  if (Cmdline_nohtl) {
1485  return;
1486  }
1487 
1488  Assert( GL_htl_projection_matrix_set );
1489  Assert( GL_htl_view_matrix_set );
1490 
1491  if (offset == NULL) {
1492  offset = &vmd_zero_vector;
1493  }
1494 
1495  if (rotation == NULL) {
1496  rotation = &vmd_identity_matrix;
1497  }
1498 
1499  GL_CHECK_FOR_ERRORS("start of start_instance_matrix()");
1500 
1501  glPushMatrix();
1502 
1503  vec3d axis;
1504  float ang;
1505  vm_matrix_to_rot_axis_and_angle(rotation, &ang, &axis);
1506 
1507  glTranslatef( offset->xyz.x, offset->xyz.y, offset->xyz.z );
1508  if (fl_abs(ang) > 0.0f) {
1509  glRotatef( fl_degrees(ang), axis.xyz.x, axis.xyz.y, axis.xyz.z );
1510  }
1511 
1512  GL_CHECK_FOR_ERRORS("end of start_instance_matrix()");
1513 
1514  GL_modelview_matrix_depth++;
1515 }
1516 
1517 void gr_opengl_start_instance_angles(const vec3d *pos, const angles *rotation)
1518 {
1519  if (Cmdline_nohtl)
1520  return;
1521 
1522  Assert(GL_htl_projection_matrix_set);
1523  Assert(GL_htl_view_matrix_set);
1524 
1525  matrix m;
1526  vm_angles_2_matrix(&m, rotation);
1527 
1529 }
1530 
1532 {
1533  if (Cmdline_nohtl)
1534  return;
1535 
1536  Assert(GL_htl_projection_matrix_set);
1537  Assert(GL_htl_view_matrix_set);
1538 
1539  glPopMatrix();
1540 
1541  GL_modelview_matrix_depth--;
1542 }
1543 
1544 // the projection matrix; fov, aspect ratio, near, far
1545 void gr_opengl_set_projection_matrix(float fov, float aspect, float z_near, float z_far)
1546 {
1547  if (Cmdline_nohtl) {
1548  return;
1549  }
1550 
1551  GL_CHECK_FOR_ERRORS("start of set_projection_matrix()()");
1552 
1555  } else {
1557  }
1558 
1559 
1561  glLoadIdentity();
1562 
1563  GLdouble clip_width, clip_height;
1564 
1565  clip_height = tan( (double)fov * 0.5 ) * z_near;
1566  clip_width = clip_height * (GLdouble)aspect;
1567 
1569  glFrustum( -clip_width, clip_width, clip_height, -clip_height, z_near, z_far );
1570  } else {
1571  glFrustum( -clip_width, clip_width, -clip_height, clip_height, z_near, z_far );
1572  }
1573 
1575 
1576  GL_CHECK_FOR_ERRORS("end of set_projection_matrix()()");
1577 
1578  GL_htl_projection_matrix_set = 1;
1579 }
1580 
1582 {
1583  if (Cmdline_nohtl) {
1584  return;
1585  }
1586 
1587  GL_CHECK_FOR_ERRORS("start of end_projection_matrix()");
1588 
1590 
1592  glLoadIdentity();
1593 
1594  // the top and bottom positions are reversed on purpose, but RTT needs them the other way
1596  glOrtho(0, gr_screen.max_w, 0, gr_screen.max_h, -1.0, 1.0);
1597  } else {
1598  glOrtho(0, gr_screen.max_w, gr_screen.max_h, 0, -1.0, 1.0);
1599  }
1600 
1602 
1603  GL_CHECK_FOR_ERRORS("end of end_projection_matrix()");
1604 
1605  GL_htl_projection_matrix_set = 0;
1606 }
1607 
1609 {
1610  if (Cmdline_nohtl)
1611  return;
1612 
1613  Assert(GL_htl_projection_matrix_set);
1614  Assert(GL_modelview_matrix_depth == 1);
1615 
1616  GL_CHECK_FOR_ERRORS("start of set_view_matrix()");
1617 
1618  glPushMatrix();
1619 
1620  // right now it depends on your settings as to whether this has any effect in-mission
1621  // not much good now, but should be a bit more useful later on
1622  if ( !memcmp(pos, &last_view_pos, sizeof(vec3d)) && !memcmp(orient, &last_view_orient, sizeof(matrix)) ) {
1623  use_last_view = true;
1624  } else {
1625  memcpy(&last_view_pos, pos, sizeof(vec3d));
1626  memcpy(&last_view_orient, orient, sizeof(matrix));
1627 
1628  use_last_view = false;
1629  }
1630 
1631  if ( !use_last_view ) {
1632  // should already be normalized
1633  eyex = (GLdouble)pos->xyz.x;
1634  eyey = (GLdouble)pos->xyz.y;
1635  eyez = -(GLdouble)pos->xyz.z;
1636 
1637  // should already be normalized
1638  GLdouble fwdx = (GLdouble)orient->vec.fvec.xyz.x;
1639  GLdouble fwdy = (GLdouble)orient->vec.fvec.xyz.y;
1640  GLdouble fwdz = -(GLdouble)orient->vec.fvec.xyz.z;
1641 
1642  // should already be normalized
1643  GLdouble upx = (GLdouble)orient->vec.uvec.xyz.x;
1644  GLdouble upy = (GLdouble)orient->vec.uvec.xyz.y;
1645  GLdouble upz = -(GLdouble)orient->vec.uvec.xyz.z;
1646 
1647  GLdouble mag;
1648 
1649  // setup Side vector (crossprod of forward and up vectors)
1650  GLdouble Sx = (fwdy * upz) - (fwdz * upy);
1651  GLdouble Sy = (fwdz * upx) - (fwdx * upz);
1652  GLdouble Sz = (fwdx * upy) - (fwdy * upx);
1653 
1654  // normalize Side
1655  mag = 1.0 / sqrt( (Sx*Sx) + (Sy*Sy) + (Sz*Sz) );
1656 
1657  Sx *= mag;
1658  Sy *= mag;
1659  Sz *= mag;
1660 
1661  // setup Up vector (crossprod of Side and forward vectors)
1662  GLdouble Ux = (Sy * fwdz) - (Sz * fwdy);
1663  GLdouble Uy = (Sz * fwdx) - (Sx * fwdz);
1664  GLdouble Uz = (Sx * fwdy) - (Sy * fwdx);
1665 
1666  // normalize Up
1667  mag = 1.0 / sqrt( (Ux*Ux) + (Uy*Uy) + (Uz*Uz) );
1668 
1669  Ux *= mag;
1670  Uy *= mag;
1671  Uz *= mag;
1672 
1673  // store the result in our matrix
1674  memset( vmatrix, 0, sizeof(vmatrix) );
1675  vmatrix[0] = Sx; vmatrix[1] = Ux; vmatrix[2] = -fwdx;
1676  vmatrix[4] = Sy; vmatrix[5] = Uy; vmatrix[6] = -fwdy;
1677  vmatrix[8] = Sz; vmatrix[9] = Uz; vmatrix[10] = -fwdz;
1678  vmatrix[15] = 1.0;
1679  }
1680 
1681  glLoadMatrixd(vmatrix);
1682 
1683  glTranslated(-eyex, -eyey, -eyez);
1684  glScalef(1.0f, 1.0f, -1.0f);
1685 
1686 
1687  if (Cmdline_env) {
1688  GL_env_texture_matrix_set = true;
1689 
1690  // if our view setup is the same as previous call then we can skip this
1691  if ( !use_last_view ) {
1692  // setup the texture matrix which will make the the envmap keep lined
1693  // up properly with the environment
1694  GLfloat mview[16];
1695 
1697 
1698  // r.xyz <-- r.x, u.x, f.x
1699  GL_env_texture_matrix[0] = mview[0];
1700  GL_env_texture_matrix[1] = mview[4];
1701  GL_env_texture_matrix[2] = mview[8];
1702  // u.xyz <-- r.y, u.y, f.y
1703  GL_env_texture_matrix[4] = mview[1];
1704  GL_env_texture_matrix[5] = mview[5];
1705  GL_env_texture_matrix[6] = mview[9];
1706  // f.xyz <-- r.z, u.z, f.z
1707  GL_env_texture_matrix[8] = mview[2];
1708  GL_env_texture_matrix[9] = mview[6];
1709  GL_env_texture_matrix[10] = mview[10];
1710 
1711  GL_env_texture_matrix[15] = 1.0f;
1712  }
1713  }
1714 
1715  GL_CHECK_FOR_ERRORS("end of set_view_matrix()");
1716 
1717  GL_modelview_matrix_depth = 2;
1718  GL_htl_view_matrix_set = 1;
1719 }
1720 
1722 {
1723  if (Cmdline_nohtl)
1724  return;
1725 
1726  Assert(GL_modelview_matrix_depth == 2);
1727 
1728  glPopMatrix();
1729  glLoadIdentity();
1730 
1731  GL_modelview_matrix_depth = 1;
1732  GL_htl_view_matrix_set = 0;
1733  GL_env_texture_matrix_set = false;
1734 }
1735 
1736 // set a view and projection matrix for a 2D element
1737 // TODO: this probably needs to accept values
1738 void gr_opengl_set_2d_matrix(/*int x, int y, int w, int h*/)
1739 {
1740  if (Cmdline_nohtl) {
1741  return;
1742  }
1743 
1744  // don't bother with this if we aren't even going to need it
1745  if ( !GL_htl_projection_matrix_set ) {
1746  return;
1747  }
1748 
1749  Assert( GL_htl_2d_matrix_set == 0 );
1750  Assert( GL_htl_2d_matrix_depth == 0 );
1751 
1753 
1754  // the viewport needs to be the full screen size since glOrtho() is relative to it
1756 
1758  glPushMatrix();
1759  glLoadIdentity();
1760 
1761  // the top and bottom positions are reversed on purpose, but RTT needs them the other way
1763  glOrtho( 0, gr_screen.max_w, 0, gr_screen.max_h, -1, 1 );
1764  } else {
1765  glOrtho( 0, gr_screen.max_w, gr_screen.max_h, 0, -1, 1 );
1766  }
1767 
1769  glPushMatrix();
1770  glLoadIdentity();
1771 
1772 #ifndef NDEBUG
1773  // safety check to make sure we don't use more than 2 projection matrices
1774  GLint num_proj_stacks = 0;
1775  glGetIntegerv( GL_PROJECTION_STACK_DEPTH, &num_proj_stacks );
1776  Assert( num_proj_stacks <= 2 );
1777 #endif
1778 
1779  GL_htl_2d_matrix_set++;
1780  GL_htl_2d_matrix_depth++;
1781 }
1782 
1783 // ends a previously set 2d view and projection matrix
1785 {
1786  if (Cmdline_nohtl)
1787  return;
1788 
1789  if (!GL_htl_2d_matrix_set)
1790  return;
1791 
1792  Assert( GL_htl_2d_matrix_depth == 1 );
1793 
1794  // reset viewport to what it was originally set to by the proj matrix
1796 
1798  glPopMatrix();
1800  glPopMatrix();
1801 
1802  glPopAttrib();
1803 
1804  GL_htl_2d_matrix_set = 0;
1805  GL_htl_2d_matrix_depth = 0;
1806 }
1807 
1808 static bool GL_scale_matrix_set = false;
1809 
1810 void gr_opengl_push_scale_matrix(const vec3d *scale_factor)
1811 {
1812  if ( (scale_factor->xyz.x == 1) && (scale_factor->xyz.y == 1) && (scale_factor->xyz.z == 1) )
1813  return;
1814 
1815  GL_scale_matrix_set = true;
1816  glPushMatrix();
1817 
1818  GL_modelview_matrix_depth++;
1819 
1820  glScalef(scale_factor->xyz.x, scale_factor->xyz.y, scale_factor->xyz.z);
1821 }
1822 
1824 {
1825  if (!GL_scale_matrix_set)
1826  return;
1827 
1828  glPopMatrix();
1829 
1830  GL_modelview_matrix_depth--;
1831  GL_scale_matrix_set = false;
1832 }
1833 
1835 {
1836  if (Cmdline_nohtl) {
1837  return;
1838  }
1839 
1840  if ( is_minimum_GLSL_version() ) {
1841  return;
1842  }
1843 
1845 }
1846 
1848 {
1849  if (Cmdline_nohtl) {
1850  return;
1851  }
1852 
1853  if ( is_minimum_GLSL_version() ) {
1854  // bail since we're gonna clip in the shader
1855  return;
1856  }
1857 
1858  GLdouble clip_equation[4];
1859 
1860  clip_equation[0] = (GLdouble)G3_user_clip_normal.xyz.x;
1861  clip_equation[1] = (GLdouble)G3_user_clip_normal.xyz.y;
1862  clip_equation[2] = (GLdouble)G3_user_clip_normal.xyz.z;
1863 
1864  clip_equation[3] = (GLdouble)(G3_user_clip_normal.xyz.x * G3_user_clip_point.xyz.x)
1865  + (GLdouble)(G3_user_clip_normal.xyz.y * G3_user_clip_point.xyz.y)
1866  + (GLdouble)(G3_user_clip_normal.xyz.z * G3_user_clip_point.xyz.z);
1867  clip_equation[3] *= -1.0;
1868 
1869 
1870  glClipPlane(GL_CLIP_PLANE0, clip_equation);
1872 }
1873 
1874 extern bool Glowpoint_override;
1876 
1877 void gr_opengl_shadow_map_start(const matrix4 *shadow_view_matrix, const matrix *light_orient)
1878 {
1880  return;
1881 
1884 
1885  //glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
1887  vglDrawBuffers(1, buffers);
1888 
1889  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
1891 
1892  gr_opengl_set_lighting(false,false);
1893 
1894  Rendering_to_shadow_map = true;
1895  Glowpoint_override_save = Glowpoint_override;
1896  Glowpoint_override = true;
1897 
1898  GL_htl_projection_matrix_set = 1;
1899  gr_set_view_matrix(&Eye_position, light_orient);
1900 
1901  glGetFloatv(GL_MODELVIEW_MATRIX, (GLfloat*)shadow_view_matrix);
1902 
1903  int size = (Cmdline_shadow_quality == 2 ? 1024 : 512);
1904  glViewport(0, 0, size, size);
1905 }
1906 
1908 {
1910  return;
1911 
1913  Rendering_to_shadow_map = false;
1914 
1917  if(saved_fb)
1918  {
1919 // GLenum buffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT };
1920 // vglDrawBuffers(2, buffers);
1921  }
1922 
1923  Glowpoint_override = Glowpoint_override_save;
1924  GL_htl_projection_matrix_set = 0;
1925 
1928 }
1929 
1930 void opengl_tnl_set_material(int flags, uint shader_flags, int tmap_type)
1931 {
1932  float u_scale, v_scale;
1933  int render_pass = 0;
1934 
1935  if ( flags & TMAP_ANIMATED_SHADER ) {
1938  GL_state.Uniform.setUniformf("vpwidth", 1.0f/gr_screen.max_w);
1939  GL_state.Uniform.setUniformf("vpheight", 1.0f/gr_screen.max_h);
1940  }
1941 
1942  int num_lights = MIN(Num_active_gl_lights, GL_max_lights) - 1;
1943  GL_state.Uniform.setUniformi("n_lights", num_lights);
1944  GL_state.Uniform.setUniformf( "light_factor", GL_light_factor );
1945 
1946  if ( shader_flags & SDR_FLAG_MODEL_CLIP ) {
1947  GL_state.Uniform.setUniformi("use_clip_plane", G3_user_clip);
1948 
1949  if ( G3_user_clip ) {
1950  vec3d normal, pos;
1951 
1952  vm_vec_unrotate(&normal, &G3_user_clip_normal, &Eye_matrix);
1953  vm_vec_normalize(&normal);
1954 
1955  vm_vec_unrotate(&pos, &G3_user_clip_point, &Eye_matrix);
1956  vm_vec_add2(&pos, &Eye_position);
1957 
1958  matrix4 model_matrix;
1959  memset( &model_matrix, 0, sizeof(model_matrix) );
1960 
1961  model_matrix.a1d[0] = Object_matrix.vec.rvec.xyz.x; model_matrix.a1d[4] = Object_matrix.vec.uvec.xyz.x; model_matrix.a1d[8] = Object_matrix.vec.fvec.xyz.x;
1962  model_matrix.a1d[1] = Object_matrix.vec.rvec.xyz.y; model_matrix.a1d[5] = Object_matrix.vec.uvec.xyz.y; model_matrix.a1d[9] = Object_matrix.vec.fvec.xyz.y;
1963  model_matrix.a1d[2] = Object_matrix.vec.rvec.xyz.z; model_matrix.a1d[6] = Object_matrix.vec.uvec.xyz.z; model_matrix.a1d[10] = Object_matrix.vec.fvec.xyz.z;
1964  model_matrix.a1d[12] = Object_position.xyz.x;
1965  model_matrix.a1d[13] = Object_position.xyz.y;
1966  model_matrix.a1d[14] = Object_position.xyz.z;
1967  model_matrix.a1d[15] = 1.0f;
1968 
1969  GL_state.Uniform.setUniform3f("clip_normal", normal);
1970  GL_state.Uniform.setUniform3f("clip_position", pos);
1971  GL_state.Uniform.setUniformMatrix4f("world_matrix", model_matrix);
1972  }
1973  }
1974 
1975  if ( shader_flags & SDR_FLAG_MODEL_DIFFUSE_MAP ) {
1976  GL_state.Uniform.setUniformi("sBasemap", render_pass);
1977 
1978  if ( flags & TMAP_FLAG_DESATURATE ) {
1979  GL_state.Uniform.setUniformi("desaturate", 1);
1981  } else {
1982  GL_state.Uniform.setUniformi("desaturate", 0);
1983  }
1984 
1985  if ( flags & TMAP_FLAG_ALPHA ) {
1988  GL_state.Uniform.setUniformi("blend_alpha", 1);
1989  } else {
1990  GL_state.Uniform.setUniformi("blend_alpha", 2);
1991  }
1992  } else {
1993  GL_state.Uniform.setUniformi("blend_alpha", 0);
1994  }
1995 
1996  gr_opengl_tcache_set(gr_screen.current_bitmap, tmap_type, &u_scale, &v_scale, render_pass);
1997 
1998  ++render_pass;
1999  }
2000 
2001  if ( shader_flags & SDR_FLAG_MODEL_GLOW_MAP ) {
2002  GL_state.Uniform.setUniformi("sGlowmap", render_pass);
2003 
2004  gr_opengl_tcache_set(GLOWMAP, tmap_type, &u_scale, &v_scale, render_pass);
2005 
2006  ++render_pass;
2007  }
2008 
2009  if ( shader_flags & SDR_FLAG_MODEL_SPEC_MAP ) {
2010  GL_state.Uniform.setUniformi("sSpecmap", render_pass);
2011 
2012  gr_opengl_tcache_set(SPECMAP, tmap_type, &u_scale, &v_scale, render_pass);
2013 
2014  ++render_pass;
2015 
2016  if ( shader_flags & SDR_FLAG_MODEL_ENV_MAP) {
2017  // 0 == env with non-alpha specmap, 1 == env with alpha specmap
2018  int alpha_spec = bm_has_alpha_channel(SPECMAP) ? 1 : 0;
2019 
2020  matrix4 texture_mat;
2021 
2022  for ( int i = 0; i < 16; ++i ) {
2023  texture_mat.a1d[i] = GL_env_texture_matrix[i];
2024  }
2025 
2026  GL_state.Uniform.setUniformi("alpha_spec", alpha_spec);
2027  GL_state.Uniform.setUniformMatrix4fv("envMatrix", 1, &texture_mat);
2028  GL_state.Uniform.setUniformi("sEnvmap", render_pass);
2029 
2030  gr_opengl_tcache_set(ENVMAP, TCACHE_TYPE_CUBEMAP, &u_scale, &v_scale, render_pass);
2031 
2032  ++render_pass;
2033  }
2034  }
2035 
2036  if ( shader_flags & SDR_FLAG_MODEL_NORMAL_MAP ) {
2037  GL_state.Uniform.setUniformi("sNormalmap", render_pass);
2038 
2039  gr_opengl_tcache_set(NORMMAP, tmap_type, &u_scale, &v_scale, render_pass);
2040 
2041  ++render_pass;
2042  }
2043 
2044  if ( shader_flags & SDR_FLAG_MODEL_HEIGHT_MAP ) {
2045  GL_state.Uniform.setUniformi("sHeightmap", render_pass);
2046 
2047  gr_opengl_tcache_set(HEIGHTMAP, tmap_type, &u_scale, &v_scale, render_pass);
2048 
2049  ++render_pass;
2050  }
2051 
2052  if ( shader_flags & SDR_FLAG_MODEL_MISC_MAP ) {
2053  GL_state.Uniform.setUniformi("sMiscmap", render_pass);
2054 
2055  gr_opengl_tcache_set(MISCMAP, tmap_type, &u_scale, &v_scale, render_pass);
2056 
2057  ++render_pass;
2058  }
2059 
2060  if ( shader_flags & SDR_FLAG_MODEL_SHADOWS ) {
2061  matrix4 model_matrix;
2062  memset( &model_matrix, 0, sizeof(model_matrix) );
2063 
2064  model_matrix.a1d[0] = Object_matrix.vec.rvec.xyz.x; model_matrix.a1d[4] = Object_matrix.vec.uvec.xyz.x; model_matrix.a1d[8] = Object_matrix.vec.fvec.xyz.x;
2065  model_matrix.a1d[1] = Object_matrix.vec.rvec.xyz.y; model_matrix.a1d[5] = Object_matrix.vec.uvec.xyz.y; model_matrix.a1d[9] = Object_matrix.vec.fvec.xyz.y;
2066  model_matrix.a1d[2] = Object_matrix.vec.rvec.xyz.z; model_matrix.a1d[6] = Object_matrix.vec.uvec.xyz.z; model_matrix.a1d[10] = Object_matrix.vec.fvec.xyz.z;
2067  model_matrix.a1d[12] = Object_position.xyz.x;
2068  model_matrix.a1d[13] = Object_position.xyz.y;
2069  model_matrix.a1d[14] = Object_position.xyz.z;
2070  model_matrix.a1d[15] = 1.0f;
2071 
2074  GL_state.Uniform.setUniformMatrix4f("model_matrix", model_matrix);
2079  GL_state.Uniform.setUniformi("shadow_map", render_pass);
2080 
2081  GL_state.Texture.SetActiveUnit(render_pass);
2084 
2085  ++render_pass; // bump!
2086  }
2087 
2088  if ( shader_flags & SDR_FLAG_MODEL_SHADOW_MAP ) {
2090  }
2091 
2092  if ( shader_flags & SDR_FLAG_MODEL_ANIMATED ) {
2093  GL_state.Uniform.setUniformi("sFramebuffer", render_pass);
2094 
2095  GL_state.Texture.SetActiveUnit(render_pass);
2097 
2098  if ( Scene_framebuffer_in_frame ) {
2101  } else {
2102  GL_state.Texture.Enable(Framebuffer_fallback_texture_id);
2103  }
2104 
2105  ++render_pass;
2106  }
2107 
2108  if ( shader_flags & SDR_FLAG_MODEL_TRANSFORM ) {
2109  GL_state.Uniform.setUniformi("transform_tex", render_pass);
2110  GL_state.Uniform.setUniformi("buffer_matrix_offset", GL_transform_buffer_offset);
2111 
2112  GL_state.Texture.SetActiveUnit(render_pass);
2115 
2116  ++render_pass;
2117  }
2118 
2119  // Team colors are passed to the shader here, but the shader needs to handle their application.
2120  // By default, this is handled through the r and g channels of the misc map, but this can be changed
2121  // in the shader; test versions of this used the normal map r and b channels
2122  if ( (shader_flags & SDR_FLAG_MODEL_TEAMCOLOR) && (shader_flags & SDR_FLAG_MODEL_MISC_MAP) ) {
2123  vec3d stripe_color;
2124  vec3d base_color;
2125 
2126  stripe_color.xyz.x = Current_team_color->stripe.r;
2127  stripe_color.xyz.y = Current_team_color->stripe.g;
2128  stripe_color.xyz.z = Current_team_color->stripe.b;
2129 
2130  base_color.xyz.x = Current_team_color->base.r;
2131  base_color.xyz.y = Current_team_color->base.g;
2132  base_color.xyz.z = Current_team_color->base.b;
2133 
2134  GL_state.Uniform.setUniform3f("stripe_color", stripe_color);
2135  GL_state.Uniform.setUniform3f("base_color", base_color);
2136 
2137  if ( bm_has_alpha_channel(MISCMAP) ) {
2138  GL_state.Uniform.setUniformi("team_glow_enabled", 1);
2139  } else {
2140  GL_state.Uniform.setUniformi("team_glow_enabled", 0);
2141  }
2142  }
2143 
2144  if ( shader_flags & SDR_FLAG_MODEL_THRUSTER ) {
2145  GL_state.Uniform.setUniformf("thruster_scale", GL_thrust_scale);
2146  }
2147 }
2148 
2150 {
2151  uint sdr_effect_flags = 0;
2152 
2153  if ( flags & TMAP_FLAG_VERTEX_GEN ) {
2154  sdr_effect_flags |= SDR_FLAG_PARTICLE_POINT_GEN;
2155  }
2156 
2157  int sdr_index = gr_opengl_maybe_create_shader(SDR_TYPE_EFFECT_PARTICLE, sdr_effect_flags);
2158 
2159  opengl_shader_set_current(sdr_index);
2160 
2161  GL_state.Uniform.setUniformi("baseMap", 0);
2162  GL_state.Uniform.setUniformi("depthMap", 1);
2163  GL_state.Uniform.setUniformf("window_width", (float)gr_screen.max_w);
2164  GL_state.Uniform.setUniformf("window_height", (float)gr_screen.max_h);
2167 
2169  GL_state.Uniform.setUniformi("linear_depth", 0);
2170  } else {
2171  GL_state.Uniform.setUniformi("linear_depth", 1);
2172  }
2173 
2175  Assert(Scene_position_texture != 0);
2176 
2179  GL_state.Texture.Enable(Scene_position_texture);
2180  } else {
2181  Assert(Scene_depth_texture != 0);
2182 
2185  GL_state.Texture.Enable(Scene_depth_texture);
2186  }
2187 }
2188 
2190 {
2192 
2193  GL_state.Uniform.setUniformi("baseMap", 0);
2194  GL_state.Uniform.setUniformi("depthMap", 1);
2195  GL_state.Uniform.setUniformf("window_width", (float)gr_screen.max_w);
2196  GL_state.Uniform.setUniformf("window_height", (float)gr_screen.max_h);
2199  GL_state.Uniform.setUniformi("frameBuffer", 2);
2200 
2204 
2205  if(flags & TMAP_FLAG_DISTORTION_THRUSTER) {
2206  GL_state.Uniform.setUniformi("distMap", 3);
2207 
2210  GL_state.Texture.Enable(Distortion_texture[!Distortion_switch]);
2211  GL_state.Uniform.setUniformf("use_offset", 1.0f);
2212  } else {
2213  GL_state.Uniform.setUniformi("distMap", 0);
2214  GL_state.Uniform.setUniformf("use_offset", 0.0f);
2215  }
2216 
2217  Assert(Scene_depth_texture != 0);
2218 
2221  GL_state.Texture.Enable(Scene_depth_texture);
2222 }
unsigned int GLuint
Definition: Gl.h:52
WINGDIAPI void APIENTRY glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
struct team_color::@238 stripe
int * submodels
Definition: 2d.h:156
#define GL_COLOR_ATTACHMENT1_EXT
Definition: Glext.h:4190
void setUniformMatrix4fv(const SCP_string &name, const int count, const matrix4 *value)
#define gr_zbuffer_set
Definition: 2d.h:817
#define MAX_POLYGON_MODELS
Definition: globals.h:80
#define vm_malloc_q(size)
Definition: pstypes.h:554
#define TMAP_FLAG_POINTLIST
Definition: tmapper.h:89
int i
Definition: multi_pxo.cpp:466
#define vm_free(ptr)
Definition: pstypes.h:548
void SetWrapS(GLenum mode)
#define GL_SRC_ALPHA
Definition: Gl.h:121
void vm_matrix_to_rot_axis_and_angle(const matrix *m, float *theta, vec3d *rot_axis)
Definition: vecmat.cpp:1612
bool lighting_is_enabled
bool Normalmap_override
Definition: systemvars.cpp:73
#define Verify(x)
Definition: pstypes.h:272
#define gr_alpha_mask_set
Definition: 2d.h:823
#define MIN(a, b)
Definition: pstypes.h:296
#define MAX_SHADOW_CASCADES
Definition: shadows.h:16
#define TMAP_FLAG_SOFT_QUAD
Definition: tmapper.h:79
#define GL_ELEMENT_ARRAY_BUFFER_ARB
Definition: Glext.h:1370
WINGDIAPI void APIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count)
void setUniformf(const SCP_string &name, const float value)
void gr_opengl_end_projection_matrix()
GLuint opengl_get_transform_buffer_texture()
bool Basemap_override
Definition: systemvars.cpp:70
vec3d tangent
Definition: 2d.h:121
int Distortion_switch
#define vglFramebufferTextureEXT
float v
Definition: pstypes.h:135
matrix4 Shadow_view_matrix
Definition: shadows.cpp:24
void setUniformi(const SCP_string &name, const int value)
#define gr_end_view_matrix
Definition: 2d.h:896
vec3d * norm
Definition: 2d.h:154
#define vglBindFramebufferEXT
#define GL_FRONT
Definition: Gl.h:219
const GLuint * buffers
Definition: Glext.h:5493
WINGDIAPI void APIENTRY glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
GLuint index
Definition: Glext.h:5608
void opengl_setup_render_states(int &r, int &g, int &b, int &alpha, int &tmap_type, int flags, int is_scaler)
#define SDR_FLAG_MODEL_CLIP
Definition: 2d.h:65
WINGDIAPI void APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
#define GL_TEXTURE_2D_ARRAY_EXT
Definition: Glext.h:4389
opengl_array_state Array
matrix * vm_angles_2_matrix(matrix *m, const angles *a)
Definition: vecmat.cpp:752
#define OGL_ARB_FLOATING_POINT_TEXTURES
void Color(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha=255)
GLint GL_max_elements_vertices
Definition: gropengltnl.cpp:74
WINGDIAPI void APIENTRY glMatrixMode(GLenum mode)
void SetTexgenModeS(GLenum mode)
void mix_two_team_colors(team_color *dest, team_color *a, team_color *b, float mix_factor)
#define GL_SRC_COLOR
Definition: Gl.h:119
#define GR_ZBUFF_READ
Definition: 2d.h:674
void gr_opengl_set_2d_matrix()
WINGDIAPI void APIENTRY glLoadIdentity(void)
WINGDIAPI void APIENTRY glClear(GLbitfield mask)
GLuint Shadow_map_texture
Definition: gropengltnl.cpp:84
Assert(pm!=NULL)
WINGDIAPI void APIENTRY glTexEnvf(GLenum target, GLenum pname, GLfloat param)
int GL_center_alpha
float a1d[16]
Definition: pstypes.h:130
int GL_vertex_data_in
Definition: gropengltnl.cpp:72
#define GL_DEPTH_COMPONENT32
Definition: Glext.h:292
double GLdouble
Definition: Gl.h:55
Definition: pstypes.h:88
void gr_opengl_end_clip_plane()
WINGDIAPI void APIENTRY glDeleteTextures(GLsizei n, const GLuint *textures)
#define SDR_FLAG_MODEL_DIFFUSE_MAP
Definition: 2d.h:50
void gr_opengl_set_thrust_scale(float scale)
#define GL_MODULATE
Definition: Gl.h:907
#define GL_REFLECTION_MAP
Definition: Glext.h:253
int Cmdline_softparticles
Definition: cmdline.cpp:334
void gr_opengl_set_lighting(bool set, bool state)
#define GL_TRIANGLES
Definition: Gl.h:109
GLboolean TexgenR(GLint state=-1)
matrix Eye_matrix
Definition: 3dsetup.cpp:26
#define GL_UNSIGNED_INT
Definition: Gl.h:196
GLint GL_max_elements_indices
Definition: gropengltnl.cpp:75
struct vec3d vec3d
void gr_opengl_set_transform_buffer_offset(int offset)
struct vec3d::@225::@227 xyz
#define OGL_ARB_TEXTURE_BUFFER
GLclampf f
Definition: Glext.h:7097
void SetTexgenModeR(GLenum mode)
#define OGL_ARB_DRAW_ELEMENTS_BASE_VERTEX
float GL_light_factor
#define GR_ZBUFF_NONE
Definition: 2d.h:672
#define GL_LEQUAL
Definition: Gl.h:75
void BindElementBuffer(GLuint id)
bool gr_opengl_config_buffer(const int buffer_id, vertex_buffer *vb, bool update_ibuffer_only)
void setUniform3f(const SCP_string &name, const float x, const float y, const float z)
#define TMAP_FLAG_VERTEX_GEN
Definition: tmapper.h:92
void gr_opengl_deferred_light_cylinder_init(int segments)
bool Rendering_to_shadow_map
Definition: gropengltnl.cpp:88
int flags
Definition: 2d.h:307
#define GL_OPERAND0_RGB_ARB
Definition: Glext.h:1218
GLuint Scene_depth_texture
bool Specmap_override
Definition: systemvars.cpp:72
#define TMAP_FLAG_QUADSTRIP
Definition: tmapper.h:70
int n_verts
Definition: 2d.h:152
opengl_texture_state Texture
void gr_opengl_shadow_map_end()
ubyte blue
Definition: 2d.h:102
GLboolean CullFace(GLint state=-1)
vec3d Object_position
Definition: 3dsetup.cpp:42
hull_check orient
Definition: lua.cpp:5049
int Transform_buffer_handle
Definition: gropengltnl.cpp:90
bool Scene_framebuffer_in_frame
void gr_opengl_deferred_light_sphere_init(int rings, int segments)
void SetAlphaScale(GLfloat scale)
GLenum GLenum GLenum GLenum GLenum scale
Definition: Glext.h:8503
GLsizeiptr size
Definition: Glext.h:5496
#define Int3()
Definition: pstypes.h:292
#define GL_SOURCE1_RGB_ARB
Definition: Glext.h:1213
bool bm_has_alpha_channel(int handle)
Checks to see if the indexed bitmap has an alpha channel.
Definition: bmpman.cpp:903
int Interp_multitex_cloakmap
int gr_opengl_create_buffer()
#define GL_PROJECTION_STACK_DEPTH
Definition: Gl.h:433
#define TMAP_FLAG_DISTORTION
Definition: tmapper.h:85
WINGDIAPI void APIENTRY glClipPlane(GLenum plane, const GLdouble *equation)
#define GL_TEXTURE_WRAP_S
Definition: Gl.h:944
int CLOAKMAP
Definition: ship.cpp:14145
void gr_opengl_end_instance_matrix()
bool Glowpoint_override
Definition: systemvars.cpp:75
int n_verts
Definition: 2d.h:193
#define GL_FRAMEBUFFER_BINDING_EXT
Definition: Glext.h:4173
void opengl_delete_buffer_object(int handle)
#define TMAP_ANIMATED_SHADER
Definition: tmapper.h:76
WINGDIAPI void APIENTRY glPopMatrix(void)
#define SDR_FLAG_PARTICLE_POINT_GEN
Definition: 2d.h:67
int clip_height
Definition: 2d.h:378
GLenum type
Definition: Gl.h:1492
int GLOWMAP
References a map that is a fully lit version of its index -Bobboau.
Definition: bmpman.cpp:57
WINGDIAPI void APIENTRY glLoadMatrixf(const GLfloat *m)
ubyte green
Definition: 2d.h:101
#define SDR_FLAG_MODEL_MISC_MAP
Definition: 2d.h:57
unsigned char GLubyte
Definition: Gl.h:50
int Interp_thrust_scale_subobj
SCP_vector< buffer_data > tex_buf
Definition: 2d.h:314
int Cmdline_env
Definition: cmdline.cpp:323
uv_pair texture_position
Definition: pstypes.h:174
#define GL_DEPTH_ATTACHMENT_EXT
Definition: Glext.h:4205
int G3_user_clip
Definition: 3dsetup.cpp:360
#define GL_LINE_STRIP
Definition: Gl.h:108
#define gr_set_view_matrix
Definition: 2d.h:895
bool Cmdline_no_batching
Definition: cmdline.cpp:341
#define GL_FALSE
Definition: Gl.h:139
#define GL_STREAM_DRAW_ARB
Definition: Glext.h:1389
WINGDIAPI void APIENTRY glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
#define GL_UNIFORM_BUFFER
Definition: Glext.h:1729
#define GL_TRANSFORM_BIT
Definition: Gl.h:94
void opengl_tnl_set_material_soft_particle(uint flags)
GLintptr offset
Definition: Glext.h:5497
#define SDR_FLAG_MODEL_SPEC_MAP
Definition: 2d.h:52
void gr_opengl_render_stream_buffer(int buffer_handle, int offset, int n_verts, int flags)
matrix Object_matrix
Definition: 3dsetup.cpp:43
void vm_vec_add2(vec3d *dest, const vec3d *src)
Definition: vecmat.cpp:178
int Cmdline_nohtl
Definition: cmdline.cpp:438
GLboolean DepthMask(GLint state=-1)
GLdouble GLdouble GLdouble r
Definition: Glext.h:5337
#define GL_LINEAR
Definition: Gl.h:931
#define vglDrawElementsInstancedBaseVertex
struct matrix::@228::@230 vec
unsigned int uint
Definition: pstypes.h:64
int offset_x
Definition: 2d.h:376
GLboolean GLboolean g
Definition: Glext.h:5781
void add_vertex_component(vertex_format_data::vertex_format format_type, uint stride, void *src)
Definition: 2d.h:1054
void gr_opengl_render_buffer(int start, const vertex_buffer *bufferp, int texi, int flags)
#define vglTexImage3D
#define TMAP_FLAG_GOURAUD
Definition: tmapper.h:40
#define vglDeleteBuffersARB
void gr_opengl_update_buffer_object(int handle, uint size, void *data)
GLboolean GLboolean GLboolean GLboolean a
Definition: Glext.h:5781
#define VB_FLAG_LARGE_INDEX
Definition: 2d.h:1009
#define SDR_FLAG_MODEL_SHADOW_MAP
Definition: 2d.h:61
#define GL_AMBIENT
Definition: Gl.h:655
int MISCMAP
Utility map, to be utilized for various things shader authors can come up with.
Definition: bmpman.cpp:62
int Cmdline_normal
Definition: cmdline.cpp:331
bool GL_rendering_to_texture
#define fl_degrees(fl)
Definition: floating.h:45
int NORMMAP
Normal mapping.
Definition: bmpman.cpp:60
#define GL_COMBINE_RGB
Definition: Glext.h:259
bool Using_Team_Color
Definition: gropengltnl.cpp:80
void gr_opengl_set_center_alpha(int type)
#define GL_FRAMEBUFFER_EXT
Definition: Glext.h:4207
void gr_opengl_destroy_buffer(int idx)
WINGDIAPI void APIENTRY glGenTextures(GLsizei n, GLuint *textures)
float Max_draw_distance
Definition: 2d.cpp:85
#define TCACHE_TYPE_CUBEMAP
Definition: grinternal.h:55
int Cmdline_glow
Definition: cmdline.cpp:326
WINGDIAPI void APIENTRY glPushAttrib(GLbitfield mask)
bool Shadow_override
Definition: systemvars.cpp:80
void SetAlphaBlendMode(gr_alpha_blend ab)
#define GL_CLIP_PLANE0
Definition: Gl.h:156
tsb_t * tsb
Definition: 2d.h:155
team_color Current_temp_color
Definition: gropengltnl.cpp:79
ubyte red
Definition: 2d.h:100
float b
Definition: 2d.h:111
#define VB_FLAG_MODEL_ID
Definition: 2d.h:1010
#define vglDrawRangeElements
#define fl_abs(fl)
Definition: floating.h:31
#define GL_SOURCE0_RGB_ARB
Definition: Glext.h:1212
void gr_opengl_set_buffer(int idx)
int GL_transform_buffer_offset
Definition: gropengltnl.cpp:82
#define TMAP_FLAG_DESATURATE
Definition: tmapper.h:87
float u
Definition: pstypes.h:135
#define TMAP_FLAG_BATCH_TRANSFORMS
Definition: tmapper.h:54
#define vglDrawElementsBaseVertex
WINGDIAPI void APIENTRY glTranslated(GLdouble x, GLdouble y, GLdouble z)
#define SDR_FLAG_MODEL_NORMAL_MAP
Definition: 2d.h:53
GLuint Scene_position_texture
unsigned int GL_last_shader_flags
poly_list * model_list
Definition: 2d.h:312
#define GL_RGBA32F_ARB
Definition: Glext.h:1524
void gr_opengl_push_scale_matrix(const vec3d *scale_factor)
#define GL_TRUE
Definition: Gl.h:138
#define GL_DYNAMIC_DRAW_ARB
Definition: Glext.h:1395
float Shadow_cascade_distances[MAX_SHADOW_CASCADES]
Definition: shadows.cpp:26
#define VB_FLAG_POSITION
Definition: 2d.h:999
void gr_opengl_end_view_matrix()
#define GL_TEXTURE_WRAP_R
Definition: Glext.h:68
#define GL_CHECK_FOR_ERRORS(s)
Definition: gropengl.h:661
#define GL_OPERAND1_RGB_ARB
Definition: Glext.h:1219
int idx
Definition: multiui.cpp:761
void gr_opengl_set_projection_matrix(float fov, float aspect, float z_near, float z_far)
void TexPointer(GLint size, GLenum type, GLsizei stride, GLvoid *pointer)
#define GL_TEXTURE_MAG_FILTER
Definition: Gl.h:942
opengl_uniform_state Uniform
vec3d * vm_vec_unrotate(vec3d *dest, const vec3d *src, const matrix *m)
Definition: vecmat.cpp:959
void gr_opengl_end_2d_matrix()
#define Is_Extension_Enabled(x)
int GL_last_shader_index
void SetTarget(GLenum tex_target)
WINGDIAPI void APIENTRY glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
int Cmdline_shadow_quality
Definition: cmdline.cpp:344
int Cmdline_no_deferred_lighting
Definition: cmdline.cpp:345
size_t index_offset
Definition: 2d.h:195
GLboolean Normalize(GLint state=-1)
unsigned char ubyte
Definition: pstypes.h:62
void gr_opengl_pop_scale_matrix()
#define vglDrawRangeElementsBaseVertex
#define GL_TRIANGLE_FAN
Definition: Gl.h:111
void Enable(GLuint tex_id=0)
int GLSL_version
Definition: gropengl.cpp:58
WINGDIAPI void APIENTRY glDrawBuffer(GLenum mode)
WINGDIAPI void APIENTRY glPopAttrib(void)
float r
Definition: 2d.h:111
#define TMAP_FLAG_LINESTRIP
Definition: tmapper.h:90
#define GL_MODELVIEW
Definition: Gl.h:751
matrix4 Shadow_proj_matrix[MAX_SHADOW_CASCADES]
Definition: shadows.cpp:25
#define GL_CLAMP_TO_EDGE
Definition: Glext.h:81
WINGDIAPI void APIENTRY glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
#define vglTexBufferARB
WINGDIAPI void APIENTRY glGetIntegerv(GLenum pname, GLint *params)
WINGDIAPI void APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
int max_w
Definition: 2d.h:360
#define TMAP_FLAG_RGB
Definition: tmapper.h:39
void SetWrapR(GLenum mode)
int Interp_cloakmap_alpha
WINGDIAPI void APIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
void opengl_tnl_set_material_distortion(uint flags)
GLuint start
Definition: Gl.h:1502
int Num_active_gl_lights
float opengl_shader_get_animated_timer()
#define SDR_FLAG_MODEL_TEAMCOLOR
Definition: 2d.h:58
GLboolean TexgenT(GLint state=-1)
#define GL_UNSIGNED_INT_8_8_8_8_REV
Definition: Glext.h:75
bool Heightmap_override
Definition: systemvars.cpp:74
GLbitfield flags
Definition: Glext.h:6722
vertex * vert
Definition: 2d.h:153
#define GL_STATIC_DRAW_ARB
Definition: Glext.h:1392
Definition: 2d.h:109
#define VB_FLAG_TANGENT
Definition: 2d.h:1008
uint i_last
Definition: 2d.h:202
GLint GL_max_lights
#define SDR_FLAG_MODEL_GLOW_MAP
Definition: 2d.h:51
void BindArrayBuffer(GLuint id)
WINGDIAPI void APIENTRY glLoadMatrixd(const GLdouble *m)
void gr_opengl_set_team_color(const team_color *colors)
int offset_y
Definition: 2d.h:376
vec3d Eye_position
Definition: 3dsetup.cpp:27
#define GL_MODELVIEW_MATRIX
Definition: Gl.h:435
GLboolean GLboolean GLboolean b
Definition: Glext.h:5781
#define GL_TEXTURE_2D
Definition: Gl.h:570
#define SDR_FLAG_MODEL_ENV_MAP
Definition: 2d.h:55
#define vglDrawBuffers
void SetWrapT(GLenum mode)
void opengl_set_additive_tex_env()
if(aifft_max_checks<=0)
Definition: aiturret.cpp:1581
#define TMAP_FLAG_TRILIST
Definition: tmapper.h:68
typedef float(SCP_EXT_CALLCONV *SCPTRACKIR_PFFLOATVOID)()
GLboolean ClipPlane(GLint num, GLint state=-1)
#define GL_TEXTURE_WRAP_T
Definition: Gl.h:945
int Cmdline_drawelements
Definition: cmdline.cpp:448
WINGDIAPI void APIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
Definition: 2d.h:120
WINGDIAPI void APIENTRY glGetFloatv(GLenum pname, GLfloat *params)
#define GL_ARRAY_BUFFER_ARB
Definition: Glext.h:1369
struct team_color::@237 base
size_t vertex_offset
Definition: 2d.h:310
int gr_opengl_maybe_create_shader(shader_type shader_t, unsigned int flags)
opengl_state GL_state
GLboolean Fog(GLint state=-1)
int flags
Definition: 2d.h:190
#define SDR_FLAG_MODEL_HEIGHT_MAP
Definition: 2d.h:54
const uint * get_index() const
Definition: 2d.h:197
#define vglGenFramebuffersEXT
WINGDIAPI void APIENTRY glPushMatrix(void)
GLuint shadow_fbo
Definition: gropengltnl.cpp:86
bool gr_opengl_pack_buffer(const int buffer_id, vertex_buffer *vb)
bool Envmap_override
Definition: systemvars.cpp:71
int opengl_shader_get_animated_effect()
#define GL_TEXTURE_MIN_FILTER
Definition: Gl.h:943
GLsizeiptr const GLvoid GLenum usage
Definition: Glext.h:5496
int clip_width
Definition: 2d.h:378
screen gr_screen
Definition: 2d.cpp:46
void opengl_set_texture_target(GLenum target)
float Min_draw_distance
Definition: 2d.cpp:84
int opengl_create_texture_buffer_object()
int Use_VBOs
Definition: gropengl.cpp:76
unsigned short ushort
Definition: pstypes.h:63
float g
Definition: 2d.h:111
GLuint Scene_effect_texture
#define GL_PREVIOUS_ARB
Definition: Glext.h:1230
#define SDR_FLAG_MODEL_SHADOWS
Definition: 2d.h:63
#define TMAP_FLAG_ALPHA
Definition: tmapper.h:53
int max_h
Definition: 2d.h:360
#define VB_FLAG_NORMAL
Definition: 2d.h:1001
GLenum GLsizei GLenum GLenum const GLvoid * data
Definition: Gl.h:1509
#define TMAP_FLAG_TEXTURED
Definition: tmapper.h:36
uint gr_determine_model_shader_flags(bool lighting, bool fog, bool textured, bool in_shadow_map, bool thruster_scale, bool transform, bool team_color_set, int tmap_flags, int spec_map, int glow_map, int normal_map, int height_map, int env_map, int misc_map)
Definition: 2d.cpp:2131
bool GLSL_override
Definition: systemvars.cpp:77
void gr_opengl_shadow_map_start(const matrix4 *shadow_view_matrix, const matrix *light_orient)
void opengl_bind_buffer_object(int handle)
color current_color
Definition: 2d.h:396
void SetRGBScale(GLfloat scale)
Definition: gropenglstate.h:97
WINGDIAPI void APIENTRY glBindTexture(GLenum target, GLuint texture)
void gr_opengl_start_instance_matrix(const vec3d *offset, const matrix *rotation)
hull_check pos
Definition: lua.cpp:5050
#define GL_TEXTURE
Definition: Gl.h:753
struct effect_vertex effect_vertex
GLuint Shadow_map_depth_texture
Definition: gropengltnl.cpp:85
const GLfloat * m
Definition: Glext.h:10319
GLint saved_fb
Definition: gropengltnl.cpp:87
int gr_opengl_create_stream_buffer_object()
void SetShaderMode(GLboolean mode)
#define vglBufferDataARB
int ENVMAP
References a map that is for environment mapping -Bobboau.
Definition: bmpman.cpp:59
float fov
Definition: lua.cpp:9155
#define GL_RGB32F_ARB
Definition: Glext.h:1525
#define TMAP_FLAG_TRISTRIP
Definition: tmapper.h:67
#define GL_POINTS
Definition: Gl.h:105
GLint GLsizei count
Definition: Gl.h:1491
void SetActiveClientUnit(GLuint id)
void setUniformMatrix4f(const SCP_string &name, const matrix4 &val)
unsigned int GLenum
Definition: Gl.h:43
GLenum DepthFunc(GLenum new_val=GL_INVALID_ENUM)
WINGDIAPI void APIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z)
void BindTextureBuffer(GLuint id)
vec3d G3_user_clip_point
Definition: 3dsetup.cpp:362
int gr_opengl_tcache_set(int bitmap_handle, int bitmap_type, float *u_scale, float *v_scale, int stage)
uint stride
Definition: 2d.h:309
WINGDIAPI void APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param)
#define SDR_FLAG_MODEL_ANIMATED
Definition: 2d.h:56
#define GL_DEPTH_COMPONENT
Definition: Gl.h:779
#define GL_PROJECTION
Definition: Gl.h:752
vec3d world
Definition: pstypes.h:172
void opengl_destroy_all_buffers()
uint i_first
Definition: 2d.h:202
bool is_minimum_GLSL_version()
Definition: gropengl.cpp:2064
#define vglGenBuffersARB
#define GL_UNSIGNED_SHORT
Definition: Gl.h:194
#define GL_QUADS
Definition: Gl.h:112
void BindUniformBuffer(GLuint id)
GLboolean TexgenS(GLint state=-1)
bool Glowpoint_override_save
void gr_opengl_start_clip_plane()
void gr_opengl_set_view_matrix(const vec3d *pos, const matrix *orient)
void SetTexgenModeT(GLenum mode)
void gr_opengl_update_transform_buffer(void *data, uint size)
#define TMAP_FLAG_DISTORTION_THRUSTER
Definition: tmapper.h:82
void opengl_shader_set_current(opengl_shader_t *shader_obj)
void opengl_default_light_settings(int ambient, int emission, int specular)
WINGDIAPI void APIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z)
float Interp_thrust_scale
#define BUFFER_OFFSET(off)
#define GL_TEXTURE_ENV
Definition: Gl.h:917
struct uv_pair uv_pair
float scaler
Definition: 2d.h:122
#define SDR_FLAG_MODEL_TRANSFORM
Definition: 2d.h:59
GLclampf GLclampf GLclampf alpha
Definition: Glext.h:5177
float GL_thrust_scale
Definition: gropengltnl.cpp:77
#define TMAP_FLAG_QUADLIST
Definition: tmapper.h:69
vec3d G3_user_clip_normal
Definition: 3dsetup.cpp:361
void opengl_tnl_shutdown()
vec3d vmd_zero_vector
Definition: vecmat.cpp:24
team_color * Current_team_color
Definition: gropengltnl.cpp:78
#define GL_COLOR_BUFFER_BIT
Definition: Gl.h:96
GLenum FrontFaceValue(GLenum new_val=GL_INVALID_ENUM)
int opengl_create_buffer_object(GLenum type, GLenum usage)
#define GL_TEXTURE_BUFFER_ARB
Definition: Glext.h:1685
#define SDR_FLAG_MODEL_THRUSTER
Definition: 2d.h:64
void opengl_bind_vertex_layout(vertex_layout &layout)
WINGDIAPI GLenum APIENTRY glGetError(void)
#define GL_FLOAT
Definition: Gl.h:197
void opengl_tnl_init()
void opengl_tnl_set_material(int flags, uint shader_flags, int tmap_type)
matrix vmd_identity_matrix
Definition: vecmat.cpp:28
#define GL_CW
Definition: Gl.h:338
void gr_opengl_start_instance_angles(const vec3d *pos, const angles *rotation)
void SetActiveUnit(GLuint id=0)
#define GL_COLOR_ATTACHMENT0_EXT
Definition: Glext.h:4189
#define VB_FLAG_UV1
Definition: 2d.h:1004
int HEIGHTMAP
Height map for normal mapping.
Definition: bmpman.cpp:61
int opengl_check_for_errors(char *err_at)
Definition: gropengl.cpp:1252
GLuint GLuint end
Definition: Gl.h:1502
int SPECMAP
References a map that is for specular mapping -Bobboau.
Definition: bmpman.cpp:58
#define GL_QUAD_STRIP
Definition: Gl.h:113
#define GL_DEPTH_BUFFER_BIT
Definition: Gl.h:90
GLuint Framebuffer_fallback_texture_id
vec3d shadow_ref_point
Definition: gropengltnl.cpp:68
int GLint
Definition: Gl.h:48
float vm_vec_normalize(vec3d *v)
Definition: vecmat.cpp:460
int current_bitmap
Definition: 2d.h:395
#define GL_RGBA
Definition: Gl.h:785
float GLfloat
Definition: Gl.h:53
GLenum GLsizei stride
Definition: Gl.h:1492
GLuint Distortion_texture[2]
#define GL_TRIANGLE_STRIP
Definition: Gl.h:110
void SetEnvCombineMode(GLenum cmode, GLenum cfunc)