1 /*
2 Copyright (C) 2001-2002 Charles Hollemeersch
3 Copyright (C) 2002 Jarno Paananen
4
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License
7 as published by the Free Software Foundation; either version 2
8 of the License, or (at your option) any later version.
9
10 This program 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.
13
14 See the GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20 PENTA: the whole file is freakin penta...
21
22 Same as gl_bumpmap.c but Matrox Parhelia optimized
23 These routines require 4 texture units and EXT_vertex_shader and
24 MTX_fragment shader extensions.
25
26 Most lights reqire 2 passes this way
27 1 diffuse
28 2 specular
29
30 If a light has a cubemap filter it requires 3 passes
31 1 attenuation
32 2 diffuse
33 3 specular
34 */
35
36 #include "quakedef.h"
37
38 #include "glATI.h" // Yes, for EXT_vertex_shader
39
40 static GLuint vertex_shader;
41 static GLuint fragment_shaders;
42
43
44 //#define PARHELIADEBUG
45
46 #if defined(PARHELIADEBUG) && defined(_WIN32)
47 #define checkerror() checkrealerror(__LINE__)
checkrealerror(int line)48 static void checkrealerror(int line)
49 {
50 GLuint error = glGetError();
51 if ( error != GL_NO_ERROR )
52 {
53 char buf[128];
54 wsprintf(buf, "ERROR (%08lx) on line %d\n", error, line );
55 MessageBox( NULL, buf, "ERROR", MB_OK );
56 }
57 }
58 #else
59
60 #define checkerror() do { } while(0)
61
62 #endif
63
64
65 // --- MTX_Fragment Shader Extension ---
66 #define GL_FRAGMENT_SHADER_MTX 0x8A80
67
68 // Get Parameters
69 #define GL_FS_BINDING_MTX 0x8A81
70 #define GL_MAX_TA_OPS_MTX 0x8A82
71 #define GL_OPT_TA_OPS_MTX 0x8A83
72 #define GL_TA_OPS_MTX 0x8A84
73 #define GL_MAX_FP_OPS_MTX 0x8A85
74 #define GL_MAX_FP_TEXTURES_MTX 0x8A86
75 #define GL_MAX_FP_COLOURS_MTX 0x8A87
76 #define GL_OPT_FP_OPS_MTX 0x8A88
77 #define GL_OPT_FP_TEXTURES_MTX 0x8A89
78 #define GL_OPT_FP_COLOURS_MTX 0x8A8A
79 #define GL_FP_OPS_MTX 0x8A8B
80 #define GL_FP_TEXTURES_MTX 0x8A8C
81 #define GL_FP_COLOURS_MTX 0x8A8D
82
83 // Texture Opcodes
84 #define GL_OP_TEX_NOP_MTX 0x8A8E
85 #define GL_OP_TEX_MTX 0x8A8F
86 #define GL_OP_TEX_COORD_MTX 0x8A90
87 #define GL_OP_TEXKILL_GE_MTX 0x8A91
88 #define GL_OP_TEXKILL_LT_MTX 0x8A92
89
90 #define GL_OP_TEXBEM_MTX 0x8A93
91 #define GL_OP_TEXDEP_AR_MTX 0x8A94
92 #define GL_OP_TEXDEP_GB_MTX 0x8A95
93 #define GL_OP_TEXDEP_RGB_MTX 0x8A96
94 #define GL_OP_TEXDOT3_COORD_MTX 0x8A97
95 #define GL_OP_TEXDOT3_MTX 0x8A98
96
97 #define GL_OP_TEXM3X2_MTX 0x8A99
98 #define GL_OP_TEXM3X2_DEPTH_MTX 0x8A9A
99
100 #define GL_OP_TEXM3X3_MTX 0x8A9B
101 #define GL_OP_TEXM3X3_COORD_MTX 0x8A9C
102 #define GL_OP_TEXM3X3_REFLECT_MTX 0x8A9D
103
104 #define GL_TEXBEM_MATRIX_MTX 0x8A9E
105 #define GL_TEXTURE_FORMAT_MTX 0x8A9F
106
107 // Texture Formats
108 #define GL_TEX_UNSIGNED_MTX 0x8AC0
109 #define GL_TEX_SIGNED_MTX 0x8AC1
110 #define GL_TEX_BIASED_MTX 0x8AC2
111
112 // Hints
113 #define GL_HINT_NEAREST_MTX 0x0001
114 #define GL_HINT_BILINEAR_MTX 0x0002
115 #define GL_HINT_TRILINEAR_MTX 0x0004
116 #define GL_HINT_ANISOTROPIC_MTX 0x0008
117 #define GL_HINT_TEXTURE_1D_MTX 0x0010
118 #define GL_HINT_TEXTURE_2D_MTX 0x0020
119 #define GL_HINT_TEXTURE_3D_MTX 0x0040
120 #define GL_HINT_TEXTURE_CUBE_MTX 0x0080
121 #define GL_HINT_TEXTURE_BEML_MTX 0x0100
122 #define GL_HINT_TEXTURE_BEM_MTX 0x0200
123
124 // Colour Opcodes
125 #define GL_OP_MOV_MTX 0x8AA0
126 #define GL_OP_ADD_MTX 0x8AA1
127 #define GL_OP_SUB_MTX 0x8AA2
128 #define GL_OP_MUL_MTX 0x8AA3
129 #define GL_OP_DP3_MTX 0x8AA4
130 #define GL_OP_DP4_MTX 0x8AA5
131 #define GL_OP_MAD_MTX 0x8AA6
132 #define GL_OP_LRP_MTX 0x8AA7
133 #define GL_OP_CND_MTX 0x8AA8
134 #define GL_OP_CMV_MTX 0x8AA9
135 #define GL_OP_CMP_MTX 0x8AAA
136
137 // Result
138 #define GL_COLOR0_MTX 0x0B00 // GL_CURRENT_COLOR
139 #define GL_COLOR1_MTX 0x8459 // GL_CURRENT_SECONDARY_COLOR
140 #define GL_TEXTURE0 0x84C0 // GL_TEXTURE0_ARB
141 #define GL_TEXTURE1 0x84C1 // GL_TEXTURE1_ARB
142 #define GL_TEXTURE2 0x84C2 // GL_TEXTURE2_ARB
143 #define GL_TEXTURE3 0x84C3 // GL_TEXTURE3_ARB
144 #define GL_TEMPORARY0_MTX 0x8AB0
145 #define GL_TEMPORARY1_MTX 0x8AB1
146 #define GL_IGNORED_MTX 0x8AB2
147 #define GL_OUTPUT_COLOR_MTX 0x8AB3
148
149 // Target
150 #define GL_RESULT_MTX 0x8AC3
151 #define GL_ARGUMENT0_MTX 0x8AC4
152 #define GL_ARGUMENT1_MTX 0x8AC5
153 #define GL_ARGUMENT2_MTX 0x8AC6
154
155 // Result Modifier
156 #define GL_SATURATE_MTX 0x8AC7
157 #define GL_SCALE_MTX 0x8AC8
158
159 // Arguments Modifier
160 #define GL_REPLICATE_MTX 0x8AC9
161 #define GL_CONVERT_MTX 0x8ACA
162
163 #define GL_NONE_MTX 0x8ACB
164
165 // GL_SCALE_MTX
166 #define GL_SCALE_X2_MTX 0x8ACC
167 #define GL_SCALE_X4_MTX 0x8ACD
168 #define GL_SCALE_X8_MTX 0x8ACE
169 #define GL_SCALE_D2_MTX 0x8ACF
170 #define GL_SCALE_D4_MTX 0x8AD0
171
172 // GL_CONVERT_MTX
173 #define GL_ARG_INVERT_MTX 0x8AB4
174 #define GL_ARG_NEGATE_MTX 0x8AB5
175 #define GL_ARG_BIAS_MTX 0x8AB6
176 #define GL_ARG_BIAS_NEGATE_MTX 0x8AB7
177 #define GL_ARG_SIGNED_MTX 0x8AB8
178 #define GL_ARG_SIGNED_NEGATE_MTX 0x8AB9
179
180 // GL_REPLICATE_MTX
181 #define GL_RED_MTX 0x8ABA
182 #define GL_GREEN_MTX 0x8ABB
183 #define GL_BLUE_MTX 0x8ABC
184 #define GL_ALPHA_MTX 0x8ABD
185
186
187 /* Fragment_Shader_ext */
188 typedef GLvoid (APIENTRY * PFNGLBEGINFRAGSHADEREXTPROC) ( GLvoid );
189 typedef GLvoid (APIENTRY * PFNGLBINDFRAGSHADEREXTPROC) ( GLuint id);
190 typedef GLvoid (APIENTRY * PFNGLDELETEFRAGSHADERSEXTPROC) ( GLsizei n, const GLuint *shaders );
191 typedef GLvoid (APIENTRY * PFNGLENDFRAGSHADEREXTPROC) ( GLvoid );
192 typedef GLvoid (APIENTRY * PFNGLFRAGPROCALPHAOP1EXTPROC) ( GLenum op, GLenum res, GLenum arg0 );
193 typedef GLvoid (APIENTRY * PFNGLFRAGPROCALPHAOP2EXTPROC) ( GLenum op, GLenum res, GLenum arg0, GLenum arg1 );
194 typedef GLvoid (APIENTRY * PFNGLFRAGPROCALPHAOP3EXTPROC) ( GLenum op, GLenum res, GLenum arg0, GLenum arg1, GLenum arg2 );
195 typedef GLvoid (APIENTRY * PFNGLFRAGPROCOPPARAMMTXEXTPROC) ( GLenum target, GLenum pname, GLenum param );
196 typedef GLvoid (APIENTRY * PFNGLFRAGPROCRGBAOP1EXTPROC) ( GLenum op, GLenum res, GLenum arg0 );
197 typedef GLvoid (APIENTRY * PFNGLFRAGPROCRGBAOP2EXTPROC) ( GLenum op, GLenum res, GLenum arg0, GLenum arg1 );
198 typedef GLvoid (APIENTRY * PFNGLFRAGPROCRGBAOP3EXTPROC) ( GLenum op, GLenum res, GLenum arg0, GLenum arg1, GLenum arg2 );
199 typedef GLuint (APIENTRY * PFNGLGENFRAGPROCINVARIANTBVEXTPROC) ( GLbyte* values);
200 typedef GLuint (APIENTRY * PFNGLGENFRAGPROCINVARIANTDVEXTPROC) ( GLdouble* values);
201 typedef GLuint (APIENTRY * PFNGLGENFRAGPROCINVARIANTFVEXTPROC) ( GLfloat* values);
202 typedef GLuint (APIENTRY * PFNGLGENFRAGPROCINVARIANTIVEXTPROC) ( GLint* values);
203 typedef GLuint (APIENTRY * PFNGLGENFRAGPROCINVARIANTSVEXTPROC) ( GLshort* values);
204 typedef GLuint (APIENTRY * PFNGLGENFRAGSHADERSEXTPROC) ( GLsizei n );
205 typedef GLboolean (APIENTRY * PFNGLISFRAGSHADEREXTPROC) ( GLuint id );
206 typedef GLvoid (APIENTRY * PFNGLSETFRAGPROCINVARIANTBVPROC) ( GLuint id, const GLbyte* values );
207 typedef GLvoid (APIENTRY * PFNGLSETFRAGPROCINVARIANTDVPROC) ( GLuint id, const GLdouble* values );
208 typedef GLvoid (APIENTRY * PFNGLSETFRAGPROCINVARIANTFVPROC) ( GLuint id, const GLfloat* values );
209 typedef GLvoid (APIENTRY * PFNGLSETFRAGPROCINVARIANTIVPROC) ( GLuint id, const GLint* values );
210 typedef GLvoid (APIENTRY * PFNGLSETFRAGPROCINVARIANTSVPROC) ( GLuint id, const GLshort* values );
211 typedef GLvoid (APIENTRY * PFNGLTEXADDRESSHINTSEXTPROC) ( GLenum target, GLbitfield hints );
212 typedef GLvoid (APIENTRY * PFNGLTEXADDRESSOP1EXTPROC) ( GLenum op, GLenum arg0 );
213 typedef GLvoid (APIENTRY * PFNGLTEXADDRESSOP2EXTPROC) ( GLenum op, GLenum arg0, GLenum arg1);
214 typedef GLvoid (APIENTRY * PFNGLTEXADDRESSOP3EXTPROC) ( GLenum op, GLenum arg0, GLenum arg1, GLenum arg2 );
215 typedef GLvoid (APIENTRY * PFNGLTEXADDRESSOP4EXTPROC) ( GLenum op, GLenum arg0, GLenum arg1, GLenum arg2, GLenum arg3 );
216 typedef GLvoid (APIENTRY * PFNGLTEXADDRESSPARAMFVEXTPROC) ( GLenum target, GLenum pname, const GLfloat* param );
217 typedef GLvoid (APIENTRY * PFNGLTEXADDRESSPARAMUIEXTPROC) ( GLenum target, GLenum pname, GLuint param );
218 typedef GLvoid (APIENTRY * PFNGLGETFRAGPROCINVARIANTBVEXTPROC) ( GLuint id, GLbyte* values);
219 typedef GLvoid (APIENTRY * PFNGLGETFRAGPROCINVARIANTDVEXTPROC) ( GLuint id, GLdouble* values);
220 typedef GLvoid (APIENTRY * PFNGLGETFRAGPROCINVARIANTFVEXTPROC) ( GLuint id, GLfloat* values);
221 typedef GLvoid (APIENTRY * PFNGLGETFRAGPROCINVARIANTIVEXTPROC) ( GLuint id, GLint* values);
222 typedef GLvoid (APIENTRY * PFNGLGETFRAGPROCINVARIANTSVEXTPROC) ( GLuint id, GLshort* values);
223 typedef GLvoid (APIENTRY * PFNGLGETTEXADDRESSPARAMFVEXTPROC) ( GLenum target, GLenum pname, GLfloat* param);
224 typedef GLvoid (APIENTRY * PFNGLGETTEXADDRESSPARAMUIVEXTPROC) ( GLenum target, GLenum pname, GLuint* param);
225
226
227 // --- End of MTX_Fragment Shader Extension ---
228
229 // Fragment Shader Extension Entry Points (pointers to the extension functions)
230 // ----------------------------------------------------------------------------
231
232 PFNGLBEGINFRAGSHADEREXTPROC qglBeginFragShaderMTX = NULL;
233 PFNGLBINDFRAGSHADEREXTPROC qglBindFragShaderMTX = NULL;
234 PFNGLDELETEFRAGSHADERSEXTPROC qglDeleteFragShadersMTX = NULL;
235 PFNGLENDFRAGSHADEREXTPROC qglEndFragShaderMTX = NULL;
236 PFNGLFRAGPROCALPHAOP1EXTPROC qglFragProcAlphaOp1MTX = NULL;
237 PFNGLFRAGPROCALPHAOP2EXTPROC qglFragProcAlphaOp2MTX = NULL;
238 PFNGLFRAGPROCALPHAOP3EXTPROC qglFragProcAlphaOp3MTX = NULL;
239 PFNGLFRAGPROCOPPARAMMTXEXTPROC qglFragProcOpParamMTX = NULL;
240 PFNGLFRAGPROCRGBAOP1EXTPROC qglFragProcRGBAOp1MTX = NULL;
241 PFNGLFRAGPROCRGBAOP2EXTPROC qglFragProcRGBAOp2MTX = NULL;
242 PFNGLFRAGPROCRGBAOP3EXTPROC qglFragProcRGBAOp3MTX = NULL;
243 PFNGLGENFRAGPROCINVARIANTBVEXTPROC qglGenFragProcInvariantBVMTX = NULL;
244 PFNGLGENFRAGPROCINVARIANTDVEXTPROC qglGenFragProcInvariantDVMTX = NULL;
245 PFNGLGENFRAGPROCINVARIANTFVEXTPROC qglGenFragProcInvariantFVMTX = NULL;
246 PFNGLGENFRAGPROCINVARIANTIVEXTPROC qglGenFragProcInvariantIVMTX = NULL;
247 PFNGLGENFRAGPROCINVARIANTSVEXTPROC qglGenFragProcInvariantSVMTX = NULL;
248 PFNGLGENFRAGSHADERSEXTPROC qglGenFragShadersMTX = NULL;
249 PFNGLISFRAGSHADEREXTPROC qglIsFragShaderMTX = NULL;
250 PFNGLSETFRAGPROCINVARIANTBVPROC qglSetFragProcInvariantBVMTX = NULL;
251 PFNGLSETFRAGPROCINVARIANTDVPROC qglSetFragProcInvariantDVMTX = NULL;
252 PFNGLSETFRAGPROCINVARIANTFVPROC qglSetFragProcInvariantFVMTX = NULL;
253 PFNGLSETFRAGPROCINVARIANTIVPROC qglSetFragProcInvariantIVMTX = NULL;
254 PFNGLSETFRAGPROCINVARIANTSVPROC qglSetFragProcInvariantSVMTX = NULL;
255 PFNGLTEXADDRESSHINTSEXTPROC qglTexAddressHintsMTX = NULL;
256 PFNGLTEXADDRESSOP1EXTPROC qglTexAddressOp1MTX = NULL;
257 PFNGLTEXADDRESSOP2EXTPROC qglTexAddressOp2MTX = NULL;
258 PFNGLTEXADDRESSOP3EXTPROC qglTexAddressOp3MTX = NULL;
259 PFNGLTEXADDRESSOP4EXTPROC qglTexAddressOp4MTX = NULL;
260 PFNGLTEXADDRESSPARAMFVEXTPROC qglTexAddressParamFVMTX = NULL;
261 PFNGLTEXADDRESSPARAMUIEXTPROC qglTexAddressParamUIMTX = NULL;
262 PFNGLGETFRAGPROCINVARIANTBVEXTPROC qglGetFragProcInvariantBVMTX = NULL;
263 PFNGLGETFRAGPROCINVARIANTDVEXTPROC qglGetFragProcInvariantDVMTX = NULL;
264 PFNGLGETFRAGPROCINVARIANTFVEXTPROC qglGetFragProcInvariantFVMTX = NULL;
265 PFNGLGETFRAGPROCINVARIANTIVEXTPROC qglGetFragProcInvariantIVMTX = NULL;
266 PFNGLGETFRAGPROCINVARIANTSVEXTPROC qglGetFragProcInvariantSVMTX = NULL;
267 PFNGLGETTEXADDRESSPARAMFVEXTPROC qglGetTexAddressParamFVMTX = NULL;
268 PFNGLGETTEXADDRESSPARAMUIVEXTPROC qglGetTexAddressParamUIVMTX = NULL;
269
270 // EXT_vertex_shader stuff is in gl_bumpradeon.c
271 extern PFNGLBEGINVERTEXSHADEREXTPROC qglBeginVertexShaderEXT;
272 extern PFNGLENDVERTEXSHADEREXTPROC qglEndVertexShaderEXT;
273 extern PFNGLBINDVERTEXSHADEREXTPROC qglBindVertexShaderEXT;
274 extern PFNGLGENVERTEXSHADERSEXTPROC qglGenVertexShadersEXT;
275 extern PFNGLDELETEVERTEXSHADEREXTPROC qglDeleteVertexShaderEXT;
276 extern PFNGLSHADEROP1EXTPROC qglShaderOp1EXT;
277 extern PFNGLSHADEROP2EXTPROC qglShaderOp2EXT;
278 extern PFNGLSHADEROP3EXTPROC qglShaderOp3EXT;
279 extern PFNGLSWIZZLEEXTPROC qglSwizzleEXT;
280 extern PFNGLWRITEMASKEXTPROC qglWriteMaskEXT;
281 extern PFNGLINSERTCOMPONENTEXTPROC qglInsertComponentEXT;
282 extern PFNGLEXTRACTCOMPONENTEXTPROC qglExtractComponentEXT;
283 extern PFNGLGENSYMBOLSEXTPROC qglGenSymbolsEXT;
284 extern PFNGLSETINVARIANTEXTPROC qglSetInvariantEXT;
285 extern PFNGLSETLOCALCONSTANTEXTPROC qglSetLocalConstantEXT;
286 extern PFNGLVARIANTBVEXTPROC qglVariantbvEXT;
287 extern PFNGLVARIANTSVEXTPROC qglVariantsvEXT;
288 extern PFNGLVARIANTIVEXTPROC qglVariantivEXT;
289 extern PFNGLVARIANTFVEXTPROC qglVariantfvEXT;
290 extern PFNGLVARIANTDVEXTPROC qglVariantdvEXT;
291 extern PFNGLVARIANTUBVEXTPROC qglVariantubvEXT;
292 extern PFNGLVARIANTUSVEXTPROC qglVariantusvEXT;
293 extern PFNGLVARIANTUIVEXTPROC qglVariantuivEXT;
294 extern PFNGLVARIANTPOINTEREXTPROC qglVariantPointerEXT;
295 extern PFNGLENABLEVARIANTCLIENTSTATEEXTPROC qglEnableVariantClientStateEXT;
296 extern PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC qglDisableVariantClientStateEXT;
297 extern PFNGLBINDLIGHTPARAMETEREXTPROC qglBindLightParameterEXT;
298 extern PFNGLBINDMATERIALPARAMETEREXTPROC qglBindMaterialParameterEXT;
299 extern PFNGLBINDTEXGENPARAMETEREXTPROC qglBindTexGenParameterEXT;
300 extern PFNGLBINDTEXTUREUNITPARAMETEREXTPROC qglBindTextureUnitParameterEXT;
301 extern PFNGLBINDPARAMETEREXTPROC qglBindParameterEXT;
302 extern PFNGLISVARIANTENABLEDEXTPROC qglIsVariantEnabledEXT;
303 extern PFNGLGETVARIANTBOOLEANVEXTPROC qglGetVariantBooleanvEXT;
304 extern PFNGLGETVARIANTINTEGERVEXTPROC qglGetVariantIntegervEXT;
305 extern PFNGLGETVARIANTFLOATVEXTPROC qglGetVariantFloatvEXT;
306 extern PFNGLGETVARIANTPOINTERVEXTPROC qglGetVariantPointervEXT;
307 extern PFNGLGETINVARIANTBOOLEANVEXTPROC qglGetInvariantBooleanvEXT;
308 extern PFNGLGETINVARIANTINTEGERVEXTPROC qglGetInvariantIntegervEXT;
309 extern PFNGLGETINVARIANTFLOATVEXTPROC qglGetInvariantFloatvEXT;
310 extern PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC qglGetLocalConstantBooleanvEXT;
311 extern PFNGLGETLOCALCONSTANTINTEGERVEXTPROC qglGetLocalConstantIntegervEXT;
312 extern PFNGLGETLOCALCONSTANTFLOATVEXTPROC qglGetLocalConstantFloatvEXT;
313
314
GL_CreateShadersParhelia()315 void GL_CreateShadersParhelia()
316 {
317 GLuint mvp, modelview, zcomp;
318 GLuint texturematrix;
319 GLuint vertex, normal;
320 GLuint texcoord0;
321 GLuint texcoord1;
322 GLuint texcoord2;
323 GLuint color;
324 GLuint disttemp, disttemp2;
325 GLuint fogstart, fogend;
326 GLuint scaler;
327 GLfloat scalervalues[4] = { 0.5, 0.5, 0.5, 0.5 };
328 int err;
329
330 #if !defined(__APPLE__) && !defined (MACOSX)
331 SAFE_GET_PROC( qglBeginVertexShaderEXT, PFNGLBEGINVERTEXSHADEREXTPROC, "glBeginVertexShaderEXT");
332 SAFE_GET_PROC( qglEndVertexShaderEXT, PFNGLENDVERTEXSHADEREXTPROC, "glEndVertexShaderEXT");
333 SAFE_GET_PROC( qglBindVertexShaderEXT, PFNGLBINDVERTEXSHADEREXTPROC, "glBindVertexShaderEXT");
334 SAFE_GET_PROC( qglGenVertexShadersEXT, PFNGLGENVERTEXSHADERSEXTPROC, "glGenVertexShadersEXT");
335 SAFE_GET_PROC( qglDeleteVertexShaderEXT, PFNGLDELETEVERTEXSHADEREXTPROC, "glDeleteVertexShaderEXT");
336 SAFE_GET_PROC( qglShaderOp1EXT, PFNGLSHADEROP1EXTPROC, "glShaderOp1EXT");
337 SAFE_GET_PROC( qglShaderOp2EXT, PFNGLSHADEROP2EXTPROC, "glShaderOp2EXT");
338 SAFE_GET_PROC( qglShaderOp3EXT, PFNGLSHADEROP3EXTPROC, "glShaderOp3EXT");
339 SAFE_GET_PROC( qglSwizzleEXT, PFNGLSWIZZLEEXTPROC, "glSwizzleEXT");
340 SAFE_GET_PROC( qglWriteMaskEXT, PFNGLWRITEMASKEXTPROC, "glWriteMaskEXT");
341 SAFE_GET_PROC( qglInsertComponentEXT, PFNGLINSERTCOMPONENTEXTPROC, "glInsertComponentEXT");
342 SAFE_GET_PROC( qglExtractComponentEXT, PFNGLEXTRACTCOMPONENTEXTPROC, "glExtractComponentEXT");
343 SAFE_GET_PROC( qglGenSymbolsEXT, PFNGLGENSYMBOLSEXTPROC, "glGenSymbolsEXT");
344 SAFE_GET_PROC( qglSetInvariantEXT, PFNGLSETINVARIANTEXTPROC, "glSetInvariantEXT");
345 SAFE_GET_PROC( qglSetLocalConstantEXT, PFNGLSETLOCALCONSTANTEXTPROC, "glSetLocalConstantEXT");
346 SAFE_GET_PROC( qglVariantbvEXT, PFNGLVARIANTBVEXTPROC, "glVariantbvEXT");
347 SAFE_GET_PROC( qglVariantsvEXT, PFNGLVARIANTSVEXTPROC, "glVariantsvEXT");
348 SAFE_GET_PROC( qglVariantivEXT, PFNGLVARIANTIVEXTPROC, "glVariantivEXT");
349 SAFE_GET_PROC( qglVariantfvEXT, PFNGLVARIANTFVEXTPROC, "glVariantfvEXT");
350 SAFE_GET_PROC( qglVariantdvEXT, PFNGLVARIANTDVEXTPROC, "glVariantdvEXT");
351 SAFE_GET_PROC( qglVariantubvEXT, PFNGLVARIANTUBVEXTPROC, "glVariantubvEXT");
352 SAFE_GET_PROC( qglVariantusvEXT, PFNGLVARIANTUSVEXTPROC, "glVariantusvEXT");
353 SAFE_GET_PROC( qglVariantuivEXT, PFNGLVARIANTUIVEXTPROC, "glVariantuivEXT");
354 SAFE_GET_PROC( qglVariantPointerEXT, PFNGLVARIANTPOINTEREXTPROC, "glVariantPointerEXT");
355 SAFE_GET_PROC( qglEnableVariantClientStateEXT, PFNGLENABLEVARIANTCLIENTSTATEEXTPROC, "glEnableVariantClientStateEXT");
356 SAFE_GET_PROC( qglDisableVariantClientStateEXT, PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC, "glDisableVariantClientStateEXT");
357 SAFE_GET_PROC( qglBindLightParameterEXT, PFNGLBINDLIGHTPARAMETEREXTPROC, "glBindLightParameterEXT");
358 SAFE_GET_PROC( qglBindMaterialParameterEXT, PFNGLBINDMATERIALPARAMETEREXTPROC, "glBindMaterialParameterEXT");
359 SAFE_GET_PROC( qglBindTexGenParameterEXT, PFNGLBINDTEXGENPARAMETEREXTPROC, "glBindTexGenParameterEXT");
360 SAFE_GET_PROC( qglBindTextureUnitParameterEXT, PFNGLBINDTEXTUREUNITPARAMETEREXTPROC, "glBindTextureUnitParameterEXT");
361 SAFE_GET_PROC( qglBindParameterEXT, PFNGLBINDPARAMETEREXTPROC, "glBindParameterEXT");
362 SAFE_GET_PROC( qglIsVariantEnabledEXT, PFNGLISVARIANTENABLEDEXTPROC, "glIsVariantEnabledEXT");
363 SAFE_GET_PROC( qglGetVariantBooleanvEXT, PFNGLGETVARIANTBOOLEANVEXTPROC, "glGetVariantBooleanvEXT");
364 SAFE_GET_PROC( qglGetVariantIntegervEXT, PFNGLGETVARIANTINTEGERVEXTPROC, "glGetVariantIntegervEXT");
365 SAFE_GET_PROC( qglGetVariantFloatvEXT, PFNGLGETVARIANTFLOATVEXTPROC, "glGetVariantFloatvEXT");
366 SAFE_GET_PROC( qglGetVariantPointervEXT, PFNGLGETVARIANTPOINTERVEXTPROC, "glGetVariantPointervEXT");
367 SAFE_GET_PROC( qglGetInvariantBooleanvEXT, PFNGLGETINVARIANTBOOLEANVEXTPROC, "glGetInvariantBooleanvEXT");
368 SAFE_GET_PROC( qglGetInvariantIntegervEXT, PFNGLGETINVARIANTINTEGERVEXTPROC, "glGetInvariantIntegervEXT");
369 SAFE_GET_PROC( qglGetInvariantFloatvEXT, PFNGLGETINVARIANTFLOATVEXTPROC, "glGetInvariantFloatvEXT");
370 SAFE_GET_PROC( qglGetLocalConstantBooleanvEXT, PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC, "glGetLocalConstantBooleanvEXT");
371 SAFE_GET_PROC( qglGetLocalConstantIntegervEXT, PFNGLGETLOCALCONSTANTINTEGERVEXTPROC, "glGetLocalConstantIntegervEXT");
372 SAFE_GET_PROC( qglGetLocalConstantFloatvEXT, PFNGLGETLOCALCONSTANTFLOATVEXTPROC, "glGetLocalConstantFloatvEXT");
373
374 SAFE_GET_PROC( qglBeginFragShaderMTX, PFNGLBEGINFRAGSHADEREXTPROC, "glBeginFragShaderMTX");
375 SAFE_GET_PROC( qglBindFragShaderMTX, PFNGLBINDFRAGSHADEREXTPROC, "glBindFragShaderMTX");
376 SAFE_GET_PROC( qglDeleteFragShadersMTX, PFNGLDELETEFRAGSHADERSEXTPROC, "glDeleteFragShadersMTX");
377 SAFE_GET_PROC( qglEndFragShaderMTX, PFNGLENDFRAGSHADEREXTPROC, "glEndFragShaderMTX");
378 SAFE_GET_PROC( qglFragProcAlphaOp1MTX, PFNGLFRAGPROCALPHAOP1EXTPROC, "glFragProcAlphaOp1MTX");
379 SAFE_GET_PROC( qglFragProcAlphaOp2MTX, PFNGLFRAGPROCALPHAOP2EXTPROC, "glFragProcAlphaOp2MTX");
380 SAFE_GET_PROC( qglFragProcAlphaOp3MTX, PFNGLFRAGPROCALPHAOP3EXTPROC, "glFragProcAlphaOp3MTX");
381 SAFE_GET_PROC( qglFragProcOpParamMTX, PFNGLFRAGPROCOPPARAMMTXEXTPROC, "glFragProcOpParamMTX");
382 SAFE_GET_PROC( qglFragProcRGBAOp1MTX, PFNGLFRAGPROCRGBAOP1EXTPROC, "glFragProcRGBAOp1MTX");
383 SAFE_GET_PROC( qglFragProcRGBAOp2MTX, PFNGLFRAGPROCRGBAOP2EXTPROC, "glFragProcRGBAOp2MTX");
384 SAFE_GET_PROC( qglFragProcRGBAOp3MTX, PFNGLFRAGPROCRGBAOP3EXTPROC, "glFragProcRGBAOp3MTX");
385 SAFE_GET_PROC( qglGenFragProcInvariantBVMTX, PFNGLGENFRAGPROCINVARIANTBVEXTPROC, "glGenFragProcInvariantbvMTX");
386 SAFE_GET_PROC( qglGenFragProcInvariantDVMTX, PFNGLGENFRAGPROCINVARIANTDVEXTPROC, "glGenFragProcInvariantdvMTX");
387 SAFE_GET_PROC( qglGenFragProcInvariantFVMTX, PFNGLGENFRAGPROCINVARIANTFVEXTPROC, "glGenFragProcInvariantfvMTX");
388 SAFE_GET_PROC( qglGenFragProcInvariantIVMTX, PFNGLGENFRAGPROCINVARIANTIVEXTPROC, "glGenFragProcInvariantivMTX");
389 SAFE_GET_PROC( qglGenFragProcInvariantSVMTX, PFNGLGENFRAGPROCINVARIANTSVEXTPROC, "glGenFragProcInvariantsvMTX");
390 SAFE_GET_PROC( qglGenFragShadersMTX, PFNGLGENFRAGSHADERSEXTPROC, "glGenFragShadersMTX");
391 SAFE_GET_PROC( qglIsFragShaderMTX, PFNGLISFRAGSHADEREXTPROC, "glIsFragShaderMTX");
392 SAFE_GET_PROC( qglSetFragProcInvariantBVMTX, PFNGLSETFRAGPROCINVARIANTBVPROC, "glSetFragProcInvariantbvMTX");
393 SAFE_GET_PROC( qglSetFragProcInvariantDVMTX, PFNGLSETFRAGPROCINVARIANTDVPROC, "glSetFragProcInvariantdvMTX");
394 SAFE_GET_PROC( qglSetFragProcInvariantFVMTX, PFNGLSETFRAGPROCINVARIANTFVPROC, "glSetFragProcInvariantfvMTX");
395 SAFE_GET_PROC( qglSetFragProcInvariantIVMTX, PFNGLSETFRAGPROCINVARIANTIVPROC, "glSetFragProcInvariantivMTX");
396 SAFE_GET_PROC( qglSetFragProcInvariantSVMTX, PFNGLSETFRAGPROCINVARIANTSVPROC, "glSetFragProcInvariantsvMTX");
397 SAFE_GET_PROC( qglTexAddressHintsMTX, PFNGLTEXADDRESSHINTSEXTPROC, "glTexAddressHintsMTX");
398 SAFE_GET_PROC( qglTexAddressOp1MTX, PFNGLTEXADDRESSOP1EXTPROC, "glTexAddressOp1MTX");
399 SAFE_GET_PROC( qglTexAddressOp2MTX, PFNGLTEXADDRESSOP2EXTPROC, "glTexAddressOp2MTX");
400 SAFE_GET_PROC( qglTexAddressOp3MTX, PFNGLTEXADDRESSOP3EXTPROC, "glTexAddressOp3MTX");
401 SAFE_GET_PROC( qglTexAddressOp4MTX, PFNGLTEXADDRESSOP4EXTPROC, "glTexAddressOp4MTX");
402 SAFE_GET_PROC( qglTexAddressParamFVMTX, PFNGLTEXADDRESSPARAMFVEXTPROC, "glTexAddressParamfvMTX");
403 SAFE_GET_PROC( qglTexAddressParamUIMTX, PFNGLTEXADDRESSPARAMUIEXTPROC, "glTexAddressParamuiMTX");
404 SAFE_GET_PROC( qglGetFragProcInvariantBVMTX, PFNGLGETFRAGPROCINVARIANTBVEXTPROC, "glGetFragProcInvariantbvMTX");
405 SAFE_GET_PROC( qglGetFragProcInvariantDVMTX, PFNGLGETFRAGPROCINVARIANTDVEXTPROC, "glGetFragProcInvariantdvMTX");
406 SAFE_GET_PROC( qglGetFragProcInvariantFVMTX, PFNGLGETFRAGPROCINVARIANTFVEXTPROC, "glGetFragProcInvariantfvMTX");
407 SAFE_GET_PROC( qglGetFragProcInvariantIVMTX, PFNGLGETFRAGPROCINVARIANTIVEXTPROC, "glGetFragProcInvariantivMTX");
408 SAFE_GET_PROC( qglGetFragProcInvariantSVMTX, PFNGLGETFRAGPROCINVARIANTSVEXTPROC, "glGetFragProcInvariantsvMTX");
409
410 SAFE_GET_PROC( qglGetTexAddressParamFVMTX, PFNGLGETTEXADDRESSPARAMFVEXTPROC, "glGetTexAddressParamfvMTX");
411 SAFE_GET_PROC( qglGetTexAddressParamUIVMTX, PFNGLGETTEXADDRESSPARAMUIVEXTPROC, "glGetTexAddressParamuivMTX");
412 #endif
413
414 //DEBUG
415 // Con_Printf("Errors before creating shaders...\n%s\n",gluErrorString(glGetError()));
416 // Con_Printf("----Fragment Shaders----\n");
417
418
419 // Generate two shaders, diffuse and specular, with two variants for cube and 3d atten texture
420 glEnable(GL_FRAGMENT_SHADER_MTX);
421
422 //DEBUG
423 // Con_Printf("Enabled GL_MTX_FRAGMENT_SHADER...\n%s\n",gluErrorString(glGetError()));
424
425
426 fragment_shaders = qglGenFragShadersMTX(4);
427
428 /*
429 if (fragment_shaders == 0)
430 {
431 Con_Printf("Error: unable to allocate shaders: %s\n", gluErrorString(glGetError()));
432 } else
433 {
434 Con_Printf("Allocated 4 fragment shaders\n");
435 };
436 */
437
438
439 // Diffuse shader 1 (3D atten)
440 qglBindFragShaderMTX(fragment_shaders);
441
442 //DEBUG
443 // Con_Printf("Shader %i Bind Status: %s\n",fragment_shaders,gluErrorString(glGetError()));
444
445
446
447 qglBeginFragShaderMTX();
448
449 qglFragProcRGBAOp1MTX(GL_OP_MOV_MTX, GL_TEMPORARY1_MTX, GL_COLOR0_MTX); //Matrox Work Around
450
451 // tex t0
452 qglTexAddressHintsMTX( GL_TEXTURE0, GL_HINT_TEXTURE_2D_MTX|GL_HINT_TRILINEAR_MTX);
453 qglTexAddressParamUIMTX( GL_TEXTURE0, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
454 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE0 );
455
456 // tex t1
457 qglTexAddressHintsMTX( GL_TEXTURE1, GL_HINT_TEXTURE_CUBE_MTX|GL_HINT_BILINEAR_MTX);
458 qglTexAddressParamUIMTX( GL_TEXTURE1, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
459 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE1 );
460
461 // tex t2
462 qglTexAddressHintsMTX( GL_TEXTURE2, GL_HINT_TEXTURE_2D_MTX|GL_HINT_TRILINEAR_MTX);
463 qglTexAddressParamUIMTX( GL_TEXTURE2, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
464 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE2 );
465
466 // tex t3 (3D)
467 qglTexAddressHintsMTX( GL_TEXTURE3, GL_HINT_TEXTURE_3D_MTX|GL_HINT_BILINEAR_MTX);
468 qglTexAddressParamUIMTX( GL_TEXTURE3, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
469 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE3 );
470
471 //dp3_sat r0, t0_bx2, t1_bx2
472 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SATURATE_MTX, GL_TRUE);
473 qglFragProcOpParamMTX(GL_ARGUMENT0_MTX, GL_CONVERT_MTX, GL_ARG_SIGNED_MTX);
474 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_CONVERT_MTX, GL_ARG_SIGNED_MTX);
475 qglFragProcRGBAOp2MTX(GL_OP_DP3_MTX, GL_TEMPORARY0_MTX, GL_TEXTURE0, GL_TEXTURE1);
476
477 //mul r0.rgb, r0, t2
478 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY0_MTX, GL_TEXTURE2);
479
480 //+add_x4 r1.a, t0_bx2.b, t0_bx2.b
481 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SATURATE_MTX, GL_TRUE);
482 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SCALE_MTX, GL_SCALE_X4_MTX);
483 qglFragProcOpParamMTX(GL_ARGUMENT0_MTX, GL_CONVERT_MTX, GL_ARG_SIGNED_MTX);
484 qglFragProcOpParamMTX(GL_ARGUMENT0_MTX, GL_REPLICATE_MTX, GL_BLUE_MTX);
485 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_CONVERT_MTX, GL_ARG_SIGNED_MTX);
486 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_REPLICATE_MTX, GL_BLUE_MTX);
487 qglFragProcRGBAOp1MTX(GL_OP_MOV_MTX, GL_IGNORED_MTX, GL_TEXTURE0); // [JPS] insert this
488 qglFragProcAlphaOp2MTX(GL_OP_ADD_MTX, GL_TEMPORARY1_MTX, GL_TEXTURE0, GL_TEXTURE0);
489
490 //mul r0, r0, v0
491 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY0_MTX, GL_COLOR0_MTX);
492
493 //mul r0, r0, t3
494 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY0_MTX, GL_TEXTURE3);
495
496 //mul r0, r0, r1.a
497 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SATURATE_MTX, GL_TRUE);
498 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_REPLICATE_MTX, GL_ALPHA_MTX);
499 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_OUTPUT_COLOR_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY1_MTX);
500
501 qglEndFragShaderMTX();
502
503 // DEBUG - display status of shader creation
504 // Con_Printf("Diffuse 1 Status: %s\n",gluErrorString(glGetError()));
505
506
507 // Diffuse shader 2 (cube atten)
508 qglBindFragShaderMTX(fragment_shaders+1);
509
510 //DEBUG
511 // Con_Printf("Shader %i Bind Status: %s\n",fragment_shaders+1,gluErrorString(glGetError()));
512
513 qglBeginFragShaderMTX();
514
515 qglFragProcRGBAOp1MTX(GL_OP_MOV_MTX, GL_TEMPORARY1_MTX, GL_COLOR0_MTX); //Matrox Work Around
516 // tex t0
517 qglTexAddressHintsMTX( GL_TEXTURE0, GL_HINT_TEXTURE_2D_MTX|GL_HINT_TRILINEAR_MTX);
518 qglTexAddressParamUIMTX( GL_TEXTURE0, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
519 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE0 );
520
521 // tex t1
522 qglTexAddressHintsMTX( GL_TEXTURE1, GL_HINT_TEXTURE_CUBE_MTX|GL_HINT_BILINEAR_MTX);
523 qglTexAddressParamUIMTX( GL_TEXTURE1, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
524 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE1 );
525
526 // tex t2
527 qglTexAddressHintsMTX( GL_TEXTURE2, GL_HINT_TEXTURE_2D_MTX|GL_HINT_TRILINEAR_MTX);
528 qglTexAddressParamUIMTX( GL_TEXTURE2, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
529 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE2 );
530
531 // tex t3 (cube)
532 qglTexAddressHintsMTX( GL_TEXTURE3, GL_HINT_TEXTURE_CUBE_MTX|GL_HINT_BILINEAR_MTX);
533 qglTexAddressParamUIMTX( GL_TEXTURE3, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
534 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE3 );
535
536 //dp3_sat r0, t0_bx2, t1_bx2
537 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SATURATE_MTX, GL_TRUE);
538 qglFragProcOpParamMTX(GL_ARGUMENT0_MTX, GL_CONVERT_MTX, GL_ARG_SIGNED_MTX);
539 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_CONVERT_MTX, GL_ARG_SIGNED_MTX);
540 qglFragProcRGBAOp2MTX(GL_OP_DP3_MTX, GL_TEMPORARY0_MTX, GL_TEXTURE0, GL_TEXTURE1);
541
542 //mul r0.rgb, r0, t2
543 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY0_MTX, GL_TEXTURE2);
544
545 //+add_x4 r1.a, t0_bx2.b, t0_bx2.b
546 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SATURATE_MTX, GL_TRUE);
547 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SCALE_MTX, GL_SCALE_X4_MTX);
548 qglFragProcOpParamMTX(GL_ARGUMENT0_MTX, GL_CONVERT_MTX, GL_ARG_SIGNED_MTX);
549 qglFragProcOpParamMTX(GL_ARGUMENT0_MTX, GL_REPLICATE_MTX, GL_BLUE_MTX);
550 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_CONVERT_MTX, GL_ARG_SIGNED_MTX);
551 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_REPLICATE_MTX, GL_BLUE_MTX);
552 qglFragProcRGBAOp1MTX(GL_OP_MOV_MTX, GL_IGNORED_MTX, GL_TEXTURE0); // [JPS] insert this
553 qglFragProcAlphaOp2MTX(GL_OP_ADD_MTX, GL_TEMPORARY1_MTX, GL_TEXTURE0, GL_TEXTURE0);
554
555 //mul r0, r0, v0
556 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY0_MTX, GL_COLOR0_MTX);
557
558 //mul r0, r0, t3
559 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY0_MTX, GL_TEXTURE3);
560
561 //mul r0, r0, r1.a
562 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SATURATE_MTX, GL_TRUE);
563 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_REPLICATE_MTX, GL_ALPHA_MTX);
564 qglFragProcRGBAOp1MTX(GL_OP_MOV_MTX, GL_IGNORED_MTX, GL_TEMPORARY0_MTX); // [JPS] insert this
565 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_OUTPUT_COLOR_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY1_MTX);
566
567 qglEndFragShaderMTX();
568
569 // DEBUG - display status of shader creation
570 // Con_Printf("Diffuse 2 Status: %s\n",gluErrorString(glGetError()));
571
572 // Specular shader 1 (3D atten)
573 qglBindFragShaderMTX(fragment_shaders+2);
574
575 //DEBUG
576 // Con_Printf("Shader %i Bind Status: %s\n",fragment_shaders+2,gluErrorString(glGetError()));
577
578 qglBeginFragShaderMTX();
579
580 qglFragProcRGBAOp1MTX(GL_OP_MOV_MTX, GL_TEMPORARY1_MTX, GL_COLOR0_MTX); //Matrox Work Around
581
582 // tex t0
583 qglTexAddressHintsMTX( GL_TEXTURE0, GL_HINT_TEXTURE_2D_MTX|GL_HINT_TRILINEAR_MTX);
584 qglTexAddressParamUIMTX( GL_TEXTURE0, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
585 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE0 );
586
587 // tex t1
588 qglTexAddressHintsMTX( GL_TEXTURE1, GL_HINT_TEXTURE_CUBE_MTX|GL_HINT_BILINEAR_MTX);
589 qglTexAddressParamUIMTX( GL_TEXTURE1, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
590 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE1 );
591
592 // tex t2
593 qglTexAddressHintsMTX( GL_TEXTURE2, GL_HINT_TEXTURE_2D_MTX|GL_HINT_TRILINEAR_MTX);
594 qglTexAddressParamUIMTX( GL_TEXTURE2, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
595 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE2 );
596
597 // tex t3 (3D)
598 qglTexAddressHintsMTX( GL_TEXTURE3, GL_HINT_TEXTURE_3D_MTX|GL_HINT_BILINEAR_MTX);
599 qglTexAddressParamUIMTX( GL_TEXTURE3, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
600 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE3 );
601
602 //dp3_sat r0, t0_bx2, t1_bx2
603 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SATURATE_MTX, GL_TRUE);
604 qglFragProcOpParamMTX(GL_ARGUMENT0_MTX, GL_CONVERT_MTX, GL_ARG_SIGNED_MTX);
605 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_CONVERT_MTX, GL_ARG_SIGNED_MTX);
606 qglFragProcRGBAOp2MTX(GL_OP_DP3_MTX, GL_TEMPORARY0_MTX, GL_TEXTURE0, GL_TEXTURE1);
607
608 //mul r1.rgb, t3, t0.a
609 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_REPLICATE_MTX, GL_ALPHA_MTX);
610 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY1_MTX, GL_TEXTURE3, GL_TEXTURE0);
611
612 //+mad_x2_sat r1.a, r0.b, r0.b, c0
613 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SATURATE_MTX, GL_TRUE);
614 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SCALE_MTX, GL_SCALE_X2_MTX);
615 qglFragProcOpParamMTX(GL_ARGUMENT0_MTX, GL_REPLICATE_MTX, GL_BLUE_MTX);
616 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_REPLICATE_MTX, GL_BLUE_MTX);
617 qglFragProcOpParamMTX(GL_ARGUMENT2_MTX, GL_CONVERT_MTX, GL_ARG_NEGATE_MTX);
618 scaler = qglGenFragProcInvariantFVMTX(scalervalues);
619 qglFragProcRGBAOp1MTX(GL_OP_MOV_MTX, GL_IGNORED_MTX, GL_TEXTURE0); // [JPS] insert this
620 qglFragProcAlphaOp3MTX(GL_OP_MAD_MTX, GL_TEMPORARY1_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY0_MTX, scaler);
621
622 //mul r0, r1, v0
623 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY1_MTX, GL_COLOR0_MTX);
624
625 //+mul r1.a, r1.a, r1.a
626 qglFragProcRGBAOp1MTX(GL_OP_MOV_MTX, GL_IGNORED_MTX, GL_TEXTURE0); // [JPS] insert this
627 qglFragProcAlphaOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY1_MTX, GL_TEMPORARY1_MTX, GL_TEMPORARY1_MTX);
628
629 //mul r1.a, r1.a, r1.a
630 qglFragProcRGBAOp1MTX(GL_OP_MOV_MTX, GL_IGNORED_MTX, GL_TEXTURE0); // [JPS] insert this
631 qglFragProcAlphaOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY1_MTX, GL_TEMPORARY1_MTX, GL_TEMPORARY1_MTX);
632
633
634 //mul r0, r0, r1.a
635 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_REPLICATE_MTX, GL_ALPHA_MTX);
636 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_OUTPUT_COLOR_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY1_MTX);
637
638 qglEndFragShaderMTX();
639
640 // DEBUG - display status of shader creation
641 // Con_Printf("Specular 1 Status: %s\n",gluErrorString(glGetError()));
642
643 // Specular shader 2 (cube atten)
644 qglBindFragShaderMTX(fragment_shaders+3);
645
646 //DEBUG
647 // Con_Printf("Shader %i Bind Status: %s\n",fragment_shaders+3,gluErrorString(glGetError()));
648
649 qglBeginFragShaderMTX();
650
651 qglFragProcRGBAOp1MTX(GL_OP_MOV_MTX, GL_TEMPORARY1_MTX, GL_COLOR0_MTX); //Matrox Work Around
652 // tex t0
653 qglTexAddressHintsMTX( GL_TEXTURE0, GL_HINT_TEXTURE_2D_MTX|GL_HINT_TRILINEAR_MTX);
654 qglTexAddressParamUIMTX( GL_TEXTURE0, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
655 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE0 );
656
657 // tex t1
658 qglTexAddressHintsMTX( GL_TEXTURE1, GL_HINT_TEXTURE_CUBE_MTX|GL_HINT_BILINEAR_MTX);
659 qglTexAddressParamUIMTX( GL_TEXTURE1, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
660 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE1 );
661
662 // tex t2
663 qglTexAddressHintsMTX( GL_TEXTURE2, GL_HINT_TEXTURE_2D_MTX|GL_HINT_TRILINEAR_MTX);
664 qglTexAddressParamUIMTX( GL_TEXTURE2, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
665 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE2 );
666
667 // tex t3 (cube)
668 qglTexAddressHintsMTX( GL_TEXTURE3, GL_HINT_TEXTURE_CUBE_MTX|GL_HINT_BILINEAR_MTX);
669 qglTexAddressParamUIMTX( GL_TEXTURE3, GL_TEXTURE_FORMAT_MTX, GL_TEX_UNSIGNED_MTX);
670 qglTexAddressOp1MTX( GL_OP_TEX_MTX, GL_TEXTURE3 );
671
672 //dp3_sat r0, t0_bx2, t1_bx2
673 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SATURATE_MTX, GL_TRUE);
674 qglFragProcOpParamMTX(GL_ARGUMENT0_MTX, GL_CONVERT_MTX, GL_ARG_SIGNED_MTX);
675 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_CONVERT_MTX, GL_ARG_SIGNED_MTX);
676 qglFragProcRGBAOp2MTX(GL_OP_DP3_MTX, GL_TEMPORARY0_MTX, GL_TEXTURE0, GL_TEXTURE1);
677
678
679 //mul r1.rgb, t3, t0.a
680 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_REPLICATE_MTX, GL_ALPHA_MTX);
681 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY1_MTX, GL_TEXTURE3, GL_TEXTURE0);
682
683 //+mad_x2_sat r1.a, r0.b, r0.b, c0
684 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SATURATE_MTX, GL_TRUE);
685 qglFragProcOpParamMTX(GL_RESULT_MTX, GL_SCALE_MTX, GL_SCALE_X2_MTX);
686 qglFragProcOpParamMTX(GL_ARGUMENT0_MTX, GL_REPLICATE_MTX, GL_BLUE_MTX);
687 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_REPLICATE_MTX, GL_BLUE_MTX);
688 qglFragProcOpParamMTX(GL_ARGUMENT2_MTX, GL_CONVERT_MTX, GL_ARG_NEGATE_MTX);
689 scaler = qglGenFragProcInvariantFVMTX(scalervalues);
690 qglFragProcRGBAOp1MTX(GL_OP_MOV_MTX, GL_IGNORED_MTX, GL_TEXTURE0); // [JPS] insert this
691 qglFragProcAlphaOp3MTX(GL_OP_MAD_MTX, GL_TEMPORARY1_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY0_MTX, scaler);
692
693 //mul r0, r1, v0
694 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY1_MTX, GL_COLOR0_MTX);
695
696 //+mul r1.a, r1.a, r1.a
697 qglFragProcRGBAOp1MTX(GL_OP_MOV_MTX, GL_IGNORED_MTX, GL_TEXTURE0); // [JPS] insert this
698 qglFragProcAlphaOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY1_MTX, GL_TEMPORARY1_MTX, GL_TEMPORARY1_MTX);
699
700 //mul r1.a, r1.a, r1.a
701 qglFragProcRGBAOp1MTX(GL_OP_MOV_MTX, GL_IGNORED_MTX, GL_TEXTURE0); // [JPS] insert this
702 qglFragProcAlphaOp2MTX(GL_OP_MUL_MTX, GL_TEMPORARY1_MTX, GL_TEMPORARY1_MTX, GL_TEMPORARY1_MTX);
703
704 //mul r0, r0, r1.a
705 qglFragProcOpParamMTX(GL_ARGUMENT1_MTX, GL_REPLICATE_MTX, GL_ALPHA_MTX);
706 qglFragProcRGBAOp2MTX(GL_OP_MUL_MTX, GL_OUTPUT_COLOR_MTX, GL_TEMPORARY0_MTX, GL_TEMPORARY1_MTX);
707
708 qglEndFragShaderMTX();
709
710 // DEBUG - display status of shader creation
711 // Con_Printf("Specular 2 Status: %s\n",gluErrorString(glGetError()));
712
713 glDisable(GL_FRAGMENT_SHADER_MTX);
714 // checkerror();
715 // Con_Printf("----Vertex Shaders----\n");
716 // Generate vertex shader
717 glEnable(GL_VERTEX_SHADER_EXT);
718
719
720 //DEBUG
721 // Con_Printf("Enabled GL_VERTEX_SHADER_EXT...\n%s\n",gluErrorString(glGetError()));
722
723 vertex_shader = qglGenVertexShadersEXT(1);
724
725 /*
726 //DEBUG
727 if (fragment_shaders == 0)
728 {
729 Con_Printf("Error: unable to allocate shaders: %s\n", gluErrorString(glGetError()));
730 } else
731 {
732 Con_Printf("Allocated 1 vertex shader\n");
733 };
734 */
735
736 qglBindVertexShaderEXT(vertex_shader);
737
738 //DEBUG
739 // Con_Printf("Shader %i Bind Status: %s\n",fragment_shaders,gluErrorString(glGetError()));
740
741 mvp = qglBindParameterEXT( GL_MVP_MATRIX_EXT );
742 modelview = qglBindParameterEXT( GL_MODELVIEW_MATRIX );
743 vertex = qglBindParameterEXT( GL_CURRENT_VERTEX_EXT );
744 normal = qglBindParameterEXT( GL_CURRENT_NORMAL );
745 color = qglBindParameterEXT( GL_CURRENT_COLOR );
746 texturematrix = qglBindTextureUnitParameterEXT( GL_TEXTURE3_ARB, GL_TEXTURE_MATRIX );
747 texcoord0 = qglBindTextureUnitParameterEXT( GL_TEXTURE0_ARB, GL_CURRENT_TEXTURE_COORDS );
748 texcoord1 = qglBindTextureUnitParameterEXT( GL_TEXTURE1_ARB, GL_CURRENT_TEXTURE_COORDS );
749 fogstart = qglBindParameterEXT( GL_FOG_START );
750 checkerror();
751 fogend = qglBindParameterEXT( GL_FOG_END );
752 checkerror();
753
754
755 qglBeginVertexShaderEXT();
756
757 disttemp = qglGenSymbolsEXT(GL_SCALAR_EXT, GL_LOCAL_EXT, GL_FULL_RANGE_EXT, 1);
758 disttemp2 = qglGenSymbolsEXT(GL_SCALAR_EXT, GL_LOCAL_EXT, GL_FULL_RANGE_EXT, 1);
759 zcomp = qglGenSymbolsEXT(GL_VECTOR_EXT, GL_LOCAL_EXT, GL_FULL_RANGE_EXT, 1);
760
761
762 // Generates a necessary input for the diffuse bumpmapping registers
763
764 // Transform vertex to view-space
765 qglShaderOp2EXT( GL_OP_MULTIPLY_MATRIX_EXT, GL_OUTPUT_VERTEX_EXT, mvp, vertex );
766
767 // Transform vertex by texture matrix and copy to output
768 qglShaderOp2EXT( GL_OP_MULTIPLY_MATRIX_EXT, GL_OUTPUT_TEXTURE_COORD3_EXT, texturematrix, vertex );
769
770 // copy tex coords of unit 0 to unit 2
771 qglShaderOp1EXT( GL_OP_MOV_EXT, GL_OUTPUT_TEXTURE_COORD0_EXT, texcoord0);
772 qglShaderOp1EXT( GL_OP_MOV_EXT, GL_OUTPUT_TEXTURE_COORD1_EXT, texcoord1);
773 qglShaderOp1EXT( GL_OP_MOV_EXT, GL_OUTPUT_TEXTURE_COORD2_EXT, texcoord0);
774 qglShaderOp1EXT( GL_OP_MOV_EXT, GL_OUTPUT_COLOR0_EXT, color);
775
776 // Transform vertex and take z for fog
777 qglExtractComponentEXT( zcomp, modelview, 2);
778 qglShaderOp2EXT( GL_OP_DOT4_EXT, disttemp, zcomp, vertex );
779
780 // calculate fog values end - z and end - start
781 qglShaderOp2EXT( GL_OP_SUB_EXT, disttemp, fogend, disttemp);
782 qglShaderOp2EXT( GL_OP_SUB_EXT, disttemp2, fogend, fogstart);
783
784 // divide end - z by end - start, that's it
785 qglShaderOp1EXT( GL_OP_RECIP_EXT, disttemp2, disttemp2);
786 qglShaderOp2EXT( GL_OP_MUL_EXT, GL_OUTPUT_FOG_EXT, disttemp, disttemp2);
787
788 qglEndVertexShaderEXT();
789
790 // DEBUG - display status of shader creation
791 // Con_Printf("Vertex Status: %s\n",gluErrorString(glGetError()));
792
793
794 glDisable(GL_VERTEX_SHADER_EXT);
795 // checkerror();
796
797 }
798
799 /*
800 Pixel shader for diffuse bump mapping does diffuse bumpmapping with norm
801 cube, self shadowing & dist attent in 1 pass
802 */
GL_EnableDiffuseShaderParhelia(qboolean world,vec3_t lightOrig)803 void GL_EnableDiffuseShaderParhelia(qboolean world, vec3_t lightOrig)
804 {
805 float invrad = 1/currentshadowlight->radius;
806
807 //tex 0 = normal map
808 //tex 1 = normalization cube map (tangent space light vector)
809 //tex 2 = color map
810 //tex 3 = (attenuation or light filter, depends on light settings but the
811 // actual register combiner setup does not change only the bound
812 // texture)
813
814 glEnable(GL_VERTEX_SHADER_EXT);
815 qglBindVertexShaderEXT( vertex_shader );
816 checkerror();
817
818 glEnable(GL_FRAGMENT_SHADER_MTX );
819
820 GL_SelectTexture(GL_TEXTURE1_ARB);
821 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
822 glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, normcube_texture_object);
823
824 GL_SelectTexture(GL_TEXTURE2_ARB);
825 glEnable(GL_TEXTURE_2D);
826
827 GL_SelectTexture(GL_TEXTURE3_ARB);
828 glMatrixMode(GL_TEXTURE);
829 glPushMatrix();
830 glLoadIdentity();
831 if (currentshadowlight->filtercube)
832 {
833 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
834 glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, currentshadowlight->filtercube);
835 GL_SetupCubeMapMatrix(world);
836
837 qglBindFragShaderMTX( fragment_shaders + 1 );
838 checkerror();
839
840 }
841 else
842 {
843 glEnable(GL_TEXTURE_3D);
844 glBindTexture(GL_TEXTURE_3D, atten3d_texture_object);
845
846 glTranslatef(0.5,0.5,0.5);
847 glScalef(0.5,0.5,0.5);
848 glScalef(invrad, invrad, invrad);
849 glTranslatef(-lightOrig[0], -lightOrig[1], -lightOrig[2]);
850
851 qglBindFragShaderMTX( fragment_shaders );
852 checkerror();
853 }
854
855 GL_SelectTexture(GL_TEXTURE0_ARB);
856
857 }
858
GL_DisableDiffuseShaderParhelia()859 void GL_DisableDiffuseShaderParhelia()
860 {
861 //tex 0 = normal map
862 //tex 1 = normalization cube map (tangent space light vector)
863 //tex 2 = color map
864 //tex 3 = (attenuation or light filter, depends on light settings)
865
866 glDisable(GL_VERTEX_SHADER_EXT);
867 glDisable(GL_FRAGMENT_SHADER_MTX );
868
869 GL_SelectTexture(GL_TEXTURE1_ARB);
870 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
871
872 GL_SelectTexture(GL_TEXTURE2_ARB);
873 glDisable(GL_TEXTURE_2D);
874
875 GL_SelectTexture(GL_TEXTURE3_ARB);
876 if (currentshadowlight->filtercube)
877 {
878 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
879 }
880 else
881 {
882 glDisable(GL_TEXTURE_3D);
883 }
884 glPopMatrix();
885 glMatrixMode(GL_MODELVIEW);
886
887 GL_SelectTexture(GL_TEXTURE0_ARB);
888 }
889
GL_EnableSpecularShaderParhelia(qboolean world,vec3_t lightOrig,qboolean alias)890 void GL_EnableSpecularShaderParhelia(qboolean world, vec3_t lightOrig,
891 qboolean alias)
892 {
893 vec3_t scaler = {0.5f, 0.5f, 0.5f};
894 float invrad = 1/currentshadowlight->radius;
895 glEnable(GL_VERTEX_SHADER_EXT);
896 qglBindVertexShaderEXT( vertex_shader );
897 checkerror();
898
899 glEnable(GL_FRAGMENT_SHADER_MTX );
900
901 //tex 0 = normal map
902 //tex 1 = normalization cube map (tangent space half angle)
903 //tex 2 = color map
904 //tex 3 = (attenuation or light filter, depends on light settings)
905
906 GL_SelectTexture(GL_TEXTURE1_ARB);
907 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
908 glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, normcube_texture_object);
909
910 GL_SelectTexture(GL_TEXTURE2_ARB);
911 glEnable(GL_TEXTURE_2D);
912
913 GL_SelectTexture(GL_TEXTURE3_ARB);
914 glMatrixMode(GL_TEXTURE);
915 glPushMatrix();
916 glLoadIdentity();
917
918 if (currentshadowlight->filtercube)
919 {
920 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
921 glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, currentshadowlight->filtercube);
922 GL_SetupCubeMapMatrix(world);
923
924 qglBindFragShaderMTX( fragment_shaders + 3 );
925 checkerror();
926 }
927 else
928 {
929 glEnable(GL_TEXTURE_3D);
930 glBindTexture(GL_TEXTURE_3D, atten3d_texture_object);
931
932 glTranslatef(0.5,0.5,0.5);
933 glScalef(0.5,0.5,0.5);
934 glScalef(invrad, invrad, invrad);
935 glTranslatef(-lightOrig[0], -lightOrig[1], -lightOrig[2]);
936
937 qglBindFragShaderMTX( fragment_shaders + 2 );
938 checkerror();
939 }
940
941 GL_SelectTexture(GL_TEXTURE0_ARB);
942
943 }
944
945 /*
946 GL_DisableSpecularShaderParhelia() ??
947 Same as GL_DisableDiffuseShaderParhelia()
948 */
949
GL_EnableAttentShaderParhelia(vec3_t lightOrig)950 void GL_EnableAttentShaderParhelia(vec3_t lightOrig)
951 {
952 float invrad = 1/currentshadowlight->radius;
953 glMatrixMode(GL_TEXTURE);
954 glPushMatrix();
955 glLoadIdentity();
956 glTranslatef(0.5,0.5,0.5);
957 glScalef(0.5,0.5,0.5);
958 glScalef(invrad, invrad, invrad);
959 glTranslatef(-lightOrig[0],
960 -lightOrig[1],
961 -lightOrig[2]);
962
963 glDisable(GL_TEXTURE_2D);
964 glEnable(GL_TEXTURE_3D);
965 glBindTexture(GL_TEXTURE_3D, atten3d_texture_object);
966 }
967
GL_DisableAttentShaderParhelia()968 void GL_DisableAttentShaderParhelia()
969 {
970 glPopMatrix();
971 glMatrixMode(GL_MODELVIEW);
972 glDisable(GL_TEXTURE_3D);
973 glEnable(GL_TEXTURE_2D);
974 }
975
R_DrawWorldParheliaDiffuse(lightcmd_t * lightCmds)976 void R_DrawWorldParheliaDiffuse(lightcmd_t *lightCmds)
977 {
978 int command, num, i;
979 int lightPos = 0;
980 vec3_t lightOr;
981 msurface_t *surf;
982 float *v;
983 texture_t *t;//XYZ
984
985 //support flickering lights
986 VectorCopy(currentshadowlight->origin,lightOr);
987
988 while (1)
989 {
990 command = lightCmds[lightPos++].asInt;
991 if (command == 0) break; //end of list
992
993 surf = lightCmds[lightPos++].asVoid;
994
995 if (surf->visframe != r_framecount)
996 {
997 lightPos+=(4+surf->polys->numverts*(2+3));
998 continue;
999 }
1000
1001
1002 num = surf->polys->numverts;
1003 lightPos+=4;//skip color
1004
1005 //XYZ
1006 t = R_TextureAnimation (surf->texinfo->texture);
1007
1008 GL_SelectTexture(GL_TEXTURE0_ARB);
1009 GL_Bind(t->gl_texturenum+1);
1010 GL_SelectTexture(GL_TEXTURE2_ARB);
1011 GL_Bind(t->gl_texturenum);
1012
1013 glBegin(command);
1014 //v = surf->polys->verts[0];
1015 v = (float *)(&globalVertexTable[surf->polys->firstvertex]);
1016 for (i=0; i<num; i++, v+= VERTEXSIZE)
1017 {
1018 //skip attent texture coord.
1019 lightPos+=2;
1020
1021 qglMultiTexCoord2fARB(GL_TEXTURE0_ARB, v[3], v[4]);
1022 qglMultiTexCoord3fvARB(GL_TEXTURE1_ARB,
1023 &lightCmds[lightPos].asFloat);
1024 lightPos+=3;
1025 //qglMultiTexCoord2fARB(GL_TEXTURE2_ARB, v[3], v[4]);
1026 //qglMultiTexCoord3fvARB(GL_TEXTURE3_ARB,&v[0]);
1027 glVertex3fv(&v[0]);
1028 }
1029 glEnd();
1030 }
1031
1032 GL_SelectTexture(GL_TEXTURE0_ARB);
1033 }
1034
R_DrawWorldParheliaSpecular(lightcmd_t * lightCmds)1035 void R_DrawWorldParheliaSpecular(lightcmd_t *lightCmds)
1036 {
1037 int command, num, i;
1038 int lightPos = 0;
1039 vec3_t tsH,H;
1040 float* lightP;
1041 msurface_t *surf;
1042 float *v;
1043 vec3_t lightDir;
1044 texture_t *t;//XYZ
1045
1046 //support flickering lights
1047 //VectorCopy(currentshadowlight->origin,lightOr);
1048
1049 while (1)
1050 {
1051 command = lightCmds[lightPos++].asInt;
1052 if (command == 0) break; //end of list
1053
1054 surf = lightCmds[lightPos++].asVoid;
1055
1056 if (surf->visframe != r_framecount)
1057 {
1058 lightPos+=(4+surf->polys->numverts*(2+3));
1059 continue;
1060 }
1061
1062 num = surf->polys->numverts;
1063 lightPos+=4;//skip color
1064
1065 //XYZ
1066 t = R_TextureAnimation (surf->texinfo->texture);
1067
1068
1069 GL_SelectTexture(GL_TEXTURE0_ARB);
1070 GL_Bind(t->gl_texturenum+1);
1071 GL_SelectTexture(GL_TEXTURE2_ARB);
1072 GL_Bind(t->gl_texturenum);
1073
1074 glBegin(command);
1075 //v = surf->polys->verts[0];
1076 v = (float *)(&globalVertexTable[surf->polys->firstvertex]);
1077 for (i=0; i<num; i++, v+= VERTEXSIZE)
1078 {
1079 lightPos+=2;//skip texcoords
1080 lightP = &lightCmds[lightPos].asFloat;
1081
1082 VectorCopy(lightP, lightDir);
1083 VectorNormalize(lightDir);
1084 lightPos+=3;
1085
1086 //calculate local H vector and put it into tangent space
1087
1088 //r_origin = camera position
1089 VectorSubtract(r_refdef.vieworg,v,H);
1090 VectorNormalize(H);
1091
1092 //put H in tangent space firste since lightDir (precalc) is already in tang space
1093 if (surf->flags & SURF_PLANEBACK)
1094 {
1095 tsH[2] = -DotProduct(H,surf->plane->normal);
1096 } else {
1097 tsH[2] = DotProduct(H,surf->plane->normal);
1098 }
1099
1100 tsH[1] = -DotProduct(H,surf->texinfo->vecs[1]);
1101 tsH[0] = DotProduct(H,surf->texinfo->vecs[0]);
1102
1103 //
1104 VectorAdd(lightDir,tsH,tsH);
1105
1106 qglMultiTexCoord2fARB(GL_TEXTURE0_ARB, v[3], v[4]);
1107 qglMultiTexCoord3fvARB(GL_TEXTURE1_ARB,&tsH[0]);
1108 glVertex3fv(&v[0]);
1109 }
1110 glEnd();
1111 }
1112
1113 GL_SelectTexture(GL_TEXTURE0_ARB);
1114 }
1115
R_DrawBrushParheliaDiffuse(entity_t * e)1116 void R_DrawBrushParheliaDiffuse(entity_t *e)
1117 {
1118 model_t *model = e->model;
1119 msurface_t *surf;
1120 glpoly_t *poly;
1121 int i, j, count;
1122 brushlightinstant_t *ins = e->brushlightinstant;
1123 float *v;
1124 texture_t *t; //XYZ
1125
1126 count = 0;
1127
1128 surf = &model->surfaces[model->firstmodelsurface];
1129 for (i=0; i<model->nummodelsurfaces; i++, surf++)
1130 {
1131 if (!ins->polygonVis[i]) continue;
1132
1133 poly = surf->polys;
1134
1135 //XYZ
1136 t = R_TextureAnimation (surf->texinfo->texture);
1137
1138 GL_SelectTexture(GL_TEXTURE0_ARB);
1139 GL_Bind(t->gl_texturenum+1);
1140 GL_SelectTexture(GL_TEXTURE2_ARB);
1141 GL_Bind(t->gl_texturenum);
1142
1143 glBegin(GL_TRIANGLE_FAN);
1144 //v = poly->verts[0];
1145 v = (float *)(&globalVertexTable[poly->firstvertex]);
1146 for (j=0 ; j<poly->numverts ; j++, v+= VERTEXSIZE)
1147 {
1148 qglMultiTexCoord2fARB(GL_TEXTURE0_ARB, v[3], v[4]);
1149 qglMultiTexCoord3fvARB(GL_TEXTURE1_ARB,&ins->tslights[count+j][0]);
1150 glVertex3fv(v);
1151 }
1152 glEnd();
1153 count+=surf->numedges;
1154 }
1155 }
1156
R_DrawBrushParheliaSpecular(entity_t * e)1157 void R_DrawBrushParheliaSpecular(entity_t *e)
1158 {
1159 model_t *model = e->model;
1160 msurface_t *surf;
1161 glpoly_t *poly;
1162 int i, j, count;
1163 brushlightinstant_t *ins = e->brushlightinstant;
1164 float *v;
1165 texture_t *t;//XYZ
1166
1167 count = 0;
1168
1169 surf = &model->surfaces[model->firstmodelsurface];
1170 for (i=0; i<model->nummodelsurfaces; i++, surf++)
1171 {
1172 if (!ins->polygonVis[i]) continue;
1173
1174 poly = surf->polys;
1175
1176 //XYZ
1177 t = R_TextureAnimation (surf->texinfo->texture);
1178
1179 GL_SelectTexture(GL_TEXTURE0_ARB);
1180 GL_Bind(t->gl_texturenum+1);
1181 GL_SelectTexture(GL_TEXTURE2_ARB);
1182 GL_Bind(t->gl_texturenum);
1183
1184 glBegin(GL_TRIANGLE_FAN);
1185 //v = poly->verts[0];
1186 v = (float *)(&globalVertexTable[poly->firstvertex]);
1187 for (j=0 ; j<poly->numverts ; j++, v+= VERTEXSIZE)
1188 {
1189 qglMultiTexCoord2fARB(GL_TEXTURE0_ARB, v[3], v[4]);
1190 qglMultiTexCoord3fvARB(GL_TEXTURE1_ARB,&ins->tshalfangles[count+j][0]);
1191 glVertex3fv(v);
1192 }
1193 glEnd();
1194 count+=surf->numedges;
1195 }
1196 }
1197
R_DrawAliasFrameParheliaDiffuse(aliashdr_t * paliashdr,aliasframeinstant_t * instant)1198 void R_DrawAliasFrameParheliaDiffuse (aliashdr_t *paliashdr,
1199 aliasframeinstant_t *instant)
1200 {
1201 mtriangle_t *tris;
1202 fstvert_t *texcoords;
1203 int anim;
1204 int *indecies;
1205 aliaslightinstant_t *linstant = instant->lightinstant;
1206
1207 tris = (mtriangle_t *)((byte *)paliashdr + paliashdr->triangles);
1208 texcoords = (fstvert_t *)((byte *)paliashdr + paliashdr->texcoords);
1209
1210 //bind normal map
1211 anim = (int)(cl.time*10) & 3;
1212
1213 GL_SelectTexture(GL_TEXTURE0_ARB);
1214 GL_Bind(paliashdr->gl_texturenum[currententity->skinnum][anim]+1);
1215 GL_SelectTexture(GL_TEXTURE2_ARB);
1216 GL_Bind(paliashdr->gl_texturenum[currententity->skinnum][anim]);
1217
1218 indecies = (int *)((byte *)paliashdr + paliashdr->indecies);
1219
1220 glVertexPointer(3, GL_FLOAT, 0, instant->vertices);
1221 glEnableClientState(GL_VERTEX_ARRAY);
1222
1223 qglClientActiveTextureARB(GL_TEXTURE0_ARB);
1224 glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
1225 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1226
1227 qglClientActiveTextureARB(GL_TEXTURE1_ARB);
1228 glTexCoordPointer(3, GL_FLOAT, 0, linstant->tslights);
1229 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1230
1231 //glDrawElements(GL_TRIANGLES,paliashdr->numtris*3,GL_UNSIGNED_INT,indecies);
1232 glDrawElements(GL_TRIANGLES,linstant->numtris*3,GL_UNSIGNED_INT,&linstant->indecies[0]);
1233
1234 if (sh_noshadowpopping.value && 0)
1235 {
1236 glStencilFunc(GL_LEQUAL, 1, 0xffffffff);
1237 glDrawElements(GL_TRIANGLES,(paliashdr->numtris*3)-(linstant->numtris*3),GL_UNSIGNED_INT,&linstant->indecies[linstant->numtris*3]);
1238 glStencilFunc(GL_EQUAL, 0, 0xffffffff);
1239 }
1240
1241 glDisableClientState(GL_VERTEX_ARRAY);
1242 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1243 qglClientActiveTextureARB(GL_TEXTURE0_ARB);
1244 GL_SelectTexture(GL_TEXTURE0_ARB);
1245 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1246 }
1247
R_DrawAliasFrameParheliaSpecular(aliashdr_t * paliashdr,aliasframeinstant_t * instant)1248 void R_DrawAliasFrameParheliaSpecular (aliashdr_t *paliashdr,
1249 aliasframeinstant_t *instant)
1250 {
1251 mtriangle_t *tris;
1252 fstvert_t *texcoords;
1253 vec3_t lightOr;
1254 int anim;
1255 int *indecies;
1256 aliaslightinstant_t *linstant = instant->lightinstant;
1257
1258 tris = (mtriangle_t *)((byte *)paliashdr + paliashdr->triangles);
1259 texcoords = (fstvert_t *)((byte *)paliashdr + paliashdr->texcoords);
1260
1261 VectorCopy(currentshadowlight->origin,lightOr);
1262
1263 // if (sh_noshadowpopping.value)
1264 // qglBindProgramNV( GL_VERTEX_PROGRAM_NV, specularaliasnopopping_program_object);
1265
1266 //bind normal map
1267 anim = (int)(cl.time*10) & 3;
1268
1269 GL_SelectTexture(GL_TEXTURE0_ARB);
1270 GL_Bind(paliashdr->gl_texturenum[currententity->skinnum][anim]+1);
1271 GL_SelectTexture(GL_TEXTURE2_ARB);
1272 GL_Bind(paliashdr->gl_texturenum[currententity->skinnum][anim]);
1273
1274 indecies = (int *)((byte *)paliashdr + paliashdr->indecies);
1275
1276 glVertexPointer(3, GL_FLOAT, 0, instant->vertices);
1277 glEnableClientState(GL_VERTEX_ARRAY);
1278
1279 qglClientActiveTextureARB(GL_TEXTURE0_ARB);
1280 glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
1281 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1282
1283 qglClientActiveTextureARB(GL_TEXTURE1_ARB);
1284 glTexCoordPointer(3, GL_FLOAT, 0, linstant->tshalfangles);
1285 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1286
1287 //to to correct self shadowing on alias models send the light vectors an extra time...
1288 if (sh_noshadowpopping.value && 0)
1289 {
1290 qglClientActiveTextureARB(GL_TEXTURE2_ARB);
1291 glTexCoordPointer(3, GL_FLOAT, 0, linstant->tslights);
1292 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1293 }
1294
1295 glDrawElements(GL_TRIANGLES,linstant->numtris*3,GL_UNSIGNED_INT,&linstant->indecies[0]);
1296
1297 if (sh_noshadowpopping.value && 0)
1298 {
1299 glStencilFunc(GL_LEQUAL, 1, 0xffffffff);
1300 //Con_Printf("%i backfacing tris\n",(paliashdr->numtris*3)-(linstant->numtris*3));
1301 glDrawElements(GL_TRIANGLES,(paliashdr->numtris*3)-(linstant->numtris*3),GL_UNSIGNED_INT,&linstant->indecies[linstant->numtris*3]);
1302 glStencilFunc(GL_EQUAL, 0, 0xffffffff);
1303 }
1304
1305 glDisableClientState(GL_VERTEX_ARRAY);
1306 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1307
1308
1309 GL_SelectTexture(GL_TEXTURE0_ARB);
1310 qglClientActiveTextureARB(GL_TEXTURE0_ARB);
1311 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1312 }
1313
R_DrawWorldBumpedParhelia()1314 void R_DrawWorldBumpedParhelia()
1315 {
1316 if (!currentshadowlight->visible)
1317 return;
1318
1319 glDepthMask (0);
1320 glShadeModel (GL_SMOOTH);
1321
1322 if (currentshadowlight->filtercube)
1323 {
1324 //draw attent into dest alpha
1325 GL_DrawAlpha();
1326 GL_EnableAttentShaderParhelia(currentshadowlight->origin);
1327 R_DrawWorldWV(currentshadowlight->lightCmds, false);
1328 GL_DisableAttentShaderParhelia();
1329 GL_ModulateAlphaDrawColor();
1330 }
1331 else
1332 {
1333 GL_AddColor();
1334 }
1335 glColor3fv(¤tshadowlight->color[0]);
1336
1337 GL_EnableDiffuseShaderParhelia(true,currentshadowlight->origin);
1338 R_DrawWorldParheliaDiffuse(currentshadowlight->lightCmds);
1339 GL_DisableDiffuseShaderParhelia();
1340
1341 GL_EnableSpecularShaderParhelia(true,currentshadowlight->origin,false);
1342 R_DrawWorldParheliaSpecular(currentshadowlight->lightCmds);
1343 GL_DisableDiffuseShaderParhelia();
1344
1345 glColor3f (1,1,1);
1346 glDisable (GL_BLEND);
1347 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1348 glDepthMask (1);
1349 }
1350
R_DrawBrushBumpedParhelia(entity_t * e)1351 void R_DrawBrushBumpedParhelia(entity_t *e)
1352 {
1353 if (currentshadowlight->filtercube)
1354 {
1355 //draw attent into dest alpha
1356 GL_DrawAlpha();
1357 GL_EnableAttentShaderParhelia(((brushlightinstant_t *)e->brushlightinstant)->lightpos);
1358 R_DrawBrushWV(e, false);
1359 GL_DisableAttentShaderParhelia();
1360 GL_ModulateAlphaDrawColor();
1361 }
1362 else
1363 {
1364 GL_AddColor();
1365 }
1366 glColor3fv(¤tshadowlight->color[0]);
1367
1368 GL_EnableDiffuseShaderParhelia(false,((brushlightinstant_t *)e->brushlightinstant)->lightpos);
1369 R_DrawBrushParheliaDiffuse(e);
1370 GL_DisableDiffuseShaderParhelia();
1371
1372 GL_EnableSpecularShaderParhelia(false,((brushlightinstant_t *)e->brushlightinstant)->lightpos,false);
1373 R_DrawBrushParheliaSpecular(e);
1374 GL_DisableDiffuseShaderParhelia();
1375 }
1376
R_DrawAliasBumpedParhelia(aliashdr_t * paliashdr,aliasframeinstant_t * instant)1377 void R_DrawAliasBumpedParhelia(aliashdr_t *paliashdr,
1378 aliasframeinstant_t *instant)
1379 {
1380 if (currentshadowlight->filtercube)
1381 {
1382 //draw attent into dest alpha
1383 GL_DrawAlpha();
1384 GL_EnableAttentShaderParhelia(instant->lightinstant->lightpos);
1385 R_DrawAliasFrameWV(paliashdr,instant, false);
1386 GL_DisableAttentShaderParhelia();
1387 GL_ModulateAlphaDrawColor();
1388 }
1389 else
1390 {
1391 GL_AddColor();
1392 }
1393 glColor3fv(¤tshadowlight->color[0]);
1394
1395 GL_EnableDiffuseShaderParhelia(false,instant->lightinstant->lightpos);
1396 R_DrawAliasFrameParheliaDiffuse(paliashdr,instant);
1397 GL_DisableDiffuseShaderParhelia();
1398
1399 GL_EnableSpecularShaderParhelia(false,instant->lightinstant->lightpos,true);
1400 R_DrawAliasFrameParheliaSpecular(paliashdr,instant);
1401 GL_DisableDiffuseShaderParhelia();
1402 }
1403
1404