Berserker@Wolfenstein win-x86 Jan 3 2015
----- FS_Startup -----
Current search path:
d:\Временное\Игры\Return to Castle Wolfenstein\Victors\main\victors_1.pk3 (5320 files)
d:\Временное\Игры\Return to Castle Wolfenstein\Victors\main\victors_0.pk3 (905 files)
d:\Временное\Игры\Return to Castle Wolfenstein\Victors/main
----------------------
6225 files in pk3 files
execing default.cfg
couldn't exec language.cfg
exec <filename> : execute a script file
exec <filename> : execute a script file
Hunk_Clear: reset the hunk ok
...detecting OS, found NT: Windows XP x86 Professional
...detecting CPU, found AuthenticAMD MMX SSE SSE2 SSE3 (2/2 available/total logical CPUs) 2600 MHz
...switching keyboard to English
...using profile 'Серёга'
Registered for RawInput.
----- Client Initialization -----
----- Initializing Renderer ----
-------------------------------
----- Client Initialization Complete -----
----- R_Init -----
Initializing OpenGL subsystem
...initializing QGL
...calling LoadLibrary( 'C:\WINDOWS\system32\opengl32.dll' ): succeeded
...setting mode 10: 2048 1536 FullScreen
...WARNING: fullscreen unavailable in this mode
...setting mode 10: 2048 1536 Windowed
...registered window class
...created window@250,31 (2054x1562)
...getting DC: succeeded
...GLW_ChoosePFD( 32, 24 )
...95 PFDs found
...hardware acceleration found
...PIXELFORMAT 2 selected
...creating standart GL context: succeeded
...making context current: succeeded
...setting mode 10: 2048 1536 Windowed
...using WGL_ARB_create_context (ARB)
...deleting standard GL context: succeeded
...creating GL 3.2 compatible context: succeeded
...allocating 3982 bytes for 163 GL_EXTENSION strings
...using 503 bytes of WGL_EXTENSIONS string (ARB)
X..GL_S3_s3tc not found
X..ignoring compression for textures
X..ignoring compression for normalmaps
...using GL_EXT_texture_filter_anisotropic [Max.level 16]
...using WGL_EXT_swap_control (EXT)
X..WGL_EXT_swap_control_tear not found
...using WGL_AMD_gpu_association (AMD)
...using GL_EXT_framebuffer_blit (Core)
...using GL_ARB_multitexture (Core)
...using GL_EXT_texture_edge_clamp
...using GL_ARB_texture_border_clamp
...using GL_ARB_shader_objects (ARB)
...using GL_ARB_vertex_shader (Core)
...using GL_ARB_fragment_shader
...using GL_ARB_texture_cube_map
...using GL_ARB_vertex_buffer_object (Core)
...using GL_ARB_vertex_array_object (Core)
...using GL_ARB_framebuffer_object (Core)
...using GL_ARB_texture_rectangle
...using GL_ARB_draw_buffers (Core) [8]
...using GL_ARB_texture_float
...using GL_ARB_texture_rg
...using GL_ARB_occlusion_query2 (Core)
GL_VENDOR: ATI Technologies Inc.
GL_RENDERER: ATI Radeon HD 4600 Series
AMD h/w detected. Video RAM size: 512 MB total, 0 MB free.
GL_VERSION: 3.2.10061 Core Profile Forward-Compatible Context
GLSL_VERSION: 3.30
GL_MAX_TEXTURE_SIZE: 8192
GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB: 8192
GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB: 1024
GL_MAX_VERTEX_ATTRIBS_ARB: 16
GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB: 16
GL_MAX_TEXTURE_IMAGE_UNITS_ARB: 16
GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB: 32
GL_MAX_VARYING_FLOATS_ARB: 64
GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB: 1024
GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: 16
PIXELFORMAT: color(32-bits) depth(24-bit)
MODE: 10, 2048 x 1536 windowed hz: 60
Using OpenGL 3.2 compatibility profile context
RENDERER: fake PPL
GAMMA: glsl shader
CPU: AuthenticAMD MMX SSE SSE2 SSE3 (2/2 available/total logical CPUs)
texturemode: GL_LINEAR_MIPMAP_NEAREST
picmip: 0
colorMap compression: none
normalMap compression: none
Using ATI specific paths
Forcing glFinish
Initializing GLSL programs
...using medium integer precision
...using high float precision
Vertex shader '_replace.vsh'
1: #version 130
2: precision mediump int;
3: precision highp float;
4: #ifndef CSM
5: #define CSM
6: #endif
7: #ifndef FAKE_PPL
8: #define FAKE_PPL
9: #endif
10:
11: uniform mat4 u_ModelViewMatrix;
12: uniform mat4 u_ModelViewProjectionMatrix;
13: out vec3 v_clipVertex;
14: out vec4 color;
15: out vec2 texCoord;
16: #define GLSL_DEFORM_EXPAND 1.0
17: #define GLSL_DEFORM_WAVE 2.0
18: #define GLSL_DEFORM_BULGE 3.0
19: #define GLSL_DEFORM_MOVE 4.0
20: #define GLSL_DEFORM_WAVE2 5.0
21:
22: #define GF_NONE 0.0
23: #define GF_SIN 1.0
24: #define GF_SQUARE 2.0
25: #define GF_TRIANGLE 3.0
26: #define GF_SAWTOOTH 4.0
27: #define GF_INVERSE_SAWTOOTH 5.0
28:
29: in vec3 attr_Position;
30: in vec3 attr_Position2;
31: in vec4 attr_Color;
32: in vec2 attr_texCoords;
33: in vec2 attr_lightCoords;
34: in vec3 attr_Normal;
35:
36: uniform float u_deformParms[31]; // MAX_SHADER_DEFORMS * 9 + MAX_SHADER_DEFORMS + 1
37: uniform float u_backlerp;
38:
39: float TABLE(in float table, in float v)
40: {
41: if (table == GF_SIN)
42: return sin(v);
43: if (table == GF_SQUARE)
44: return sign(sin(v));
45: if (table == GF_TRIANGLE)
46: return max(1.0 - abs(v), 0.0);
47: if (table == GF_SAWTOOTH)
48: return v - floor(v);
49: if (table == GF_INVERSE_SAWTOOTH)
50: return 1.0 - (v - floor(v));
51: return 0.0; // GF_NONE
52: }
53:
54: vec4 DeformGeometry()
55: {
56: float f;
57: int j = 0, deformOffs = 0;
58: int numDeforms = int(u_deformParms[deformOffs++]);
59:
60: vec3 xyz = mix(attr_Position, attr_Position2, u_backlerp);
61:
62: // unroll deform loop (#define MAX_SHADER_DEFORMS 3)
63: // for stupid NVidia GLSL compiler (new Detonator + old cards like 9600GT/8500GT)
64: if (numDeforms > 0)
65: {
66: f = u_deformParms[deformOffs++];
67: if (f == GLSL_DEFORM_EXPAND)
68: { // queue:
69: // scale
70: xyz += attr_Normal * u_deformParms[deformOffs++];
71: }
72: if (f == GLSL_DEFORM_BULGE)
73: { // queue:
74: // backEnd.refdef.time * ds->bulgeSpeed * 0.001f
75: // ds->bulgeWidth
76: // ds->bulgeHeight
77: float now = u_deformParms[deformOffs++];
78: float off = 0.7853981634 * attr_texCoords.s * u_deformParms[deformOffs++] + now;
79: xyz += attr_Normal * sin(off) * u_deformParms[deformOffs++];
80: }
81: if (f == GLSL_DEFORM_WAVE)
82: { // queue:
83: // deformationSpread
84: // table
85: // base
86: // amplitude
87: // phase + freq
88: float off = 6.2831853072 * ( xyz.x + xyz.y + xyz.z ) * u_deformParms[deformOffs++];
89: float table = u_deformParms[deformOffs++];
90: float base = u_deformParms[deformOffs++];
91: float amplitude = u_deformParms[deformOffs++];
92: float pf = u_deformParms[deformOffs++] + off;
93: xyz += attr_Normal * (base + TABLE(table, pf) * amplitude);
94: }
95: if (f == GLSL_DEFORM_MOVE)
96: { // queue:
97: // ds->moveVector[0]
98: // ds->moveVector[1]
99: // ds->moveVector[2]
100: xyz.x += u_deformParms[deformOffs++];
101: xyz.y += u_deformParms[deformOffs++];
102: xyz.z += u_deformParms[deformOffs++];
103: }
104: if (f == GLSL_DEFORM_WAVE2)
105: { // queue:
106: // deformationSpread
107: // table
108: // base
109: // amplitude
110: // phase + freq
111: // 1.0 or -1.0 for inverse
112: // vec3 worldUp
113: float off = 6.2831853072 * ( xyz.x + xyz.y + xyz.z ) * u_deformParms[deformOffs++];
114: float table = u_deformParms[deformOffs++];
115: float base = u_deformParms[deformOffs++];
116: float amplitude = u_deformParms[deformOffs++];
117: float pf = u_deformParms[deformOffs++] + off;
118: float inverse = u_deformParms[deformOffs++];
119: vec3 worldUp;
120: worldUp[0] = u_deformParms[deformOffs++];
121: worldUp[1] = u_deformParms[deformOffs++];
122: worldUp[2] = u_deformParms[deformOffs++];
123: float m = max(0.0, (base + TABLE(table, pf) * amplitude) * dot(attr_Normal, worldUp));
124: xyz += worldUp * inverse * m;
125: }
126: }
127:
128: if (numDeforms > 1)
129: {
130: f = u_deformParms[deformOffs++];
131: if (f == GLSL_DEFORM_EXPAND)
132: { // queue:
133: // scale
134: xyz += attr_Normal * u_deformParms[deformOffs++];
135: }
136: if (f == GLSL_DEFORM_BULGE)
137: { // queue:
138: // backEnd.refdef.time * ds->bulgeSpeed * 0.001f
139: // ds->bulgeWidth
140: // ds->bulgeHeight
141: float now = u_deformParms[deformOffs++];
142: float off = 0.7853981634 * attr_texCoords.s * u_deformParms[deformOffs++] + now;
143: xyz += attr_Normal * sin(off) * u_deformParms[deformOffs++];
144: }
145: if (f == GLSL_DEFORM_WAVE)
146: { // queue:
147: // deformationSpread
148: // table
149: // base
150: // amplitude
151: // phase + freq
152: float off = 6.2831853072 * ( xyz.x + xyz.y + xyz.z ) * u_deformParms[deformOffs++];
153: float table = u_deformParms[deformOffs++];
154: float base = u_deformParms[deformOffs++];
155: float amplitude = u_deformParms[deformOffs++];
156: float pf = u_deformParms[deformOffs++] + off;
157: xyz += attr_Normal * (base + TABLE(table, pf) * amplitude);
158: }
159: if (f == GLSL_DEFORM_MOVE)
160: { // queue:
161: // ds->moveVector[0]
162: // ds->moveVector[1]
163: // ds->moveVector[2]
164: xyz.x += u_deformParms[deformOffs++];
165: xyz.y += u_deformParms[deformOffs++];
166: xyz.z += u_deformParms[deformOffs++];
167: }
168: if (f == GLSL_DEFORM_WAVE2)
169: { // queue:
170: // deformationSpread
171: // table
172: // base
173: // amplitude
174: // phase + freq
175: // 1.0 or -1.0 for inverse
176: // vec3 worldUp
177: float off = 6.2831853072 * ( xyz.x + xyz.y + xyz.z ) * u_deformParms[deformOffs++];
178: float table = u_deformParms[deformOffs++];
179: float base = u_deformParms[deformOffs++];
180: float amplitude = u_deformParms[deformOffs++];
181: float pf = u_deformParms[deformOffs++] + off;
182: float inverse = u_deformParms[deformOffs++];
183: vec3 worldUp;
184: worldUp[0] = u_deformParms[deformOffs++];
185: worldUp[1] = u_deformParms[deformOffs++];
186: worldUp[2] = u_deformParms[deformOffs++];
187: float m = max(0.0, (base + TABLE(table, pf) * amplitude) * dot(attr_Normal, worldUp));
188: xyz += worldUp * inverse * m;
189: }
190: }
191:
192: if (numDeforms > 2)
193: {
194: f = u_deformParms[deformOffs++];
195: if (f == GLSL_DEFORM_EXPAND)
196: { // queue:
197: // scale
198: xyz += attr_Normal * u_deformParms[deformOffs++];
199: }
200: if (f == GLSL_DEFORM_BULGE)
201: { // queue:
202: // backEnd.refdef.time * ds->bulgeSpeed * 0.001f
203: // ds->bulgeWidth
204: // ds->bulgeHeight
205: float now = u_deformParms[deformOffs++];
206: float off = 0.7853981634 * attr_texCoords.s * u_deformParms[deformOffs++] + now;
207: xyz += attr_Normal * sin(off) * u_deformParms[deformOffs++];
208: }
209: if (f == GLSL_DEFORM_WAVE)
210: { // queue:
211: // deformationSpread
212: // table
213: // base
214: // amplitude
215: // phase + freq
216: float off = 6.2831853072 * ( xyz.x + xyz.y + xyz.z ) * u_deformParms[deformOffs++];
217: float table = u_deformParms[deformOffs++];
218: float base = u_deformParms[deformOffs++];
219: float amplitude = u_deformParms[deformOffs++];
220: float pf = u_deformParms[deformOffs++] + off;
221: xyz += attr_Normal * (base + TABLE(table, pf) * amplitude);
222: }
223: if (f == GLSL_DEFORM_MOVE)
224: { // queue:
225: // ds->moveVector[0]
226: // ds->moveVector[1]
227: // ds->moveVector[2]
228: xyz.x += u_deformParms[deformOffs++];
229: xyz.y += u_deformParms[deformOffs++];
230: xyz.z += u_deformParms[deformOffs++];
231: }
232: if (f == GLSL_DEFORM_WAVE2)
233: { // queue:
234: // deformationSpread
235: // table
236: // base
237: // amplitude
238: // phase + freq
239: // 1.0 or -1.0 for inverse
240: // vec3 worldUp
241: float off = 6.2831853072 * ( xyz.x + xyz.y + xyz.z ) * u_deformParms[deformOffs++];
242: float table = u_deformParms[deformOffs++];
243: float base = u_deformParms[deformOffs++];
244: float amplitude = u_deformParms[deformOffs++];
245: float pf = u_deformParms[deformOffs++] + off;
246: float inverse = u_deformParms[deformOffs++];
247: vec3 worldUp;
248: worldUp[0] = u_deformParms[deformOffs++];
249: worldUp[1] = u_deformParms[deformOffs++];
250: worldUp[2] = u_deformParms[deformOffs++];
251: float m = max(0.0, (base + TABLE(table, pf) * amplitude) * dot(attr_Normal, worldUp));
252: xyz += worldUp * inverse * m;
253: }
254: }
255:
256:
257: return vec4(xyz, 1.0);
258: }
259: uniform vec4 u_gen;
260: uniform vec4 u_parm0;
261: uniform vec4 u_parm1;
262: uniform vec4 u_parm2;
263: uniform vec4 u_parma0;
264: uniform vec3 u_parma1;
265: uniform vec4 u_fogDistanceVector;
266: uniform vec4 u_fogDepthVector;
267: uniform float u_eyeT;
268:
269: #define GLSL_CGEN_CONST 0.0
270: #define GLSL_CGEN_LIGHTING_DIFFUSE 1.0
271: #define GLSL_CGEN_VERTEX 2.0
272: #define GLSL_CGEN_ONE_MINUS_VERTEX 3.0
273: #define GLSL_CGEN_VERTEX_ALPHA 4.0
274: #define GLSL_CGEN_ONE_MINUS_VERTEX_ALPHA 5.0
275:
276: #define GLSL_AGEN_CONST 0.0
277: #define GLSL_AGEN_LIGHTING_SPECULAR 1.0
278: #define GLSL_AGEN_VERTEX 2.0
279: #define GLSL_AGEN_ONE_MINUS_VERTEX 3.0
280: #define GLSL_AGEN_VERTEX_COLOR 4.0
281: #define GLSL_AGEN_ONE_MINUS_VERTEX_COLOR 5.0
282: #define GLSL_AGEN_PORTAL 6.0
283: #define GLSL_AGEN_NORMALZFADE 7.0
284: #define GLSL_AGEN_NORMALZFADE_ZOMBIEFX 8.0
285:
286: vec4 colorGen (in vec3 glVertex, in vec4 gen, in vec4 parm0, in vec4 parm1, in vec4 parm2, in vec4 parma0, in vec3 parma1)
287: {
288: vec4 col = parm0; // default is GLSL_CGEN_CONST
289:
290: if (gen.x == GLSL_CGEN_LIGHTING_DIFFUSE)
291: { // parm0.xyz = lightDir
292: // parm1 = ambientLight
293: // parm2 = directedLight
294: float incoming = dot(attr_Normal, parm0.xyz);
295: col = vec4(parm1.rgb + max(incoming, 0.0) * parm2.rgb, 1.0);
296: }
297: if (gen.x == GLSL_CGEN_VERTEX)
298: col = attr_Color;
299: if (gen.x == GLSL_CGEN_ONE_MINUS_VERTEX)
300: col = 1.0 - attr_Color;
301: if (gen.x == GLSL_CGEN_VERTEX_ALPHA)
302: col = vec4(attr_Color.a);
303: if (gen.x == GLSL_CGEN_ONE_MINUS_VERTEX_ALPHA)
304: col = 1.0 - vec4(attr_Color.a);
305:
306: if (gen.y >= GLSL_AGEN_CONST)
307: {
308: if (gen.y == GLSL_AGEN_CONST)
309: col.a = parm0.a;
310: if (gen.y == GLSL_AGEN_LIGHTING_SPECULAR)
311: { // parma0.xyz = backEnd.or.viewOrigin
312: vec3 lightDir = normalize(vec3(-960.0, 1980.0, 96.0) - glVertex);
313: float d = dot(attr_Normal, lightDir);
314: vec3 reflected = attr_Normal * 2.0 * d - lightDir;
315: vec3 viewer = parma0.xyz - glVertex;
316: float ilength = inversesqrt(dot(viewer, viewer));
317: float l = max(dot(reflected, viewer) * ilength, 0.0);
318: col.a = l*l*l*l;
319: }
320: if (gen.y == GLSL_AGEN_NORMALZFADE)
321: { // parma0.xyz = worldUp
322: // parma0.w = pStage->constantColor[3]/255.0
323: // parma1.x = lowest
324: // parma1.y = highest
325: // parma1.z = scale
326: float dt = dot(attr_Normal, parma0.xyz);
327: float range = (parma1.y - parma1.x) * 0.5;
328: if (dt > parma1.x && dt < parma1.y)
329: {
330: if (dt < parma1.x + range)
331: col.a = parma1.z * clamp(parma0.w * (dt - parma1.x) / range, 0.0, 1.0);
332: else
333: col.a = parma1.z * clamp(parma0.w * (1.0 - (dt - parma1.x - range) / range), 0.0, 1.0);
334: }
335: else
336: col.a = 0.0;
337: }
338: if (gen.y == GLSL_AGEN_NORMALZFADE_ZOMBIEFX)
339: { // parma0.xyz = worldUp
340: // parma0.w = backEnd.currentEntity->e.shaderRGBA[3] / 255.0
341: float dt = dot(attr_Normal, parma0.xyz);
342: float tmp = (dt + 1.0) * 0.5;
343: col.a = clamp(parma0.w * (tmp + 2.0 * (1.0 - tmp)), 0.0, 1.0);
344: }
345: if (gen.y == GLSL_AGEN_VERTEX)
346: col.a = attr_Color.a;
347: if (gen.y == GLSL_AGEN_ONE_MINUS_VERTEX)
348: col.a = 1.0 - attr_Color.a;
349: if (gen.y == GLSL_AGEN_VERTEX_COLOR)
350: col.a = (attr_Color.r + attr_Color.g + attr_Color.b) * 0.33333;
351: if (gen.y == GLSL_AGEN_ONE_MINUS_VERTEX_COLOR)
352: col.a = 1.0 - (attr_Color.r + attr_Color.g + attr_Color.b) * 0.33333;
353: if (gen.y == GLSL_AGEN_PORTAL)
354: { // parma0.xyz = backEnd.viewParms.or.origin
355: // parma0.w = 1.0 / tess.shader->portalRange
356: col.a = length(glVertex - parma0.xyz) * parma0.w;
357: }
358: }
359:
360: if (gen.z != 0.0) // ACFF_MODULATE_*
361: {
362: float s = dot(glVertex, u_fogDistanceVector.xyz) + u_fogDistanceVector.w;
363: float t = dot(glVertex, u_fogDepthVector.xyz) + u_fogDepthVector.w;
364: if (u_eyeT < 0.0)
365: {
366: if (t < 1.0)
367: return col; // point is outside, so no fogging
368: t = 1.0/32.0 + 30.0/32.0 * t / ( t - u_eyeT ); // cut the distance at the fog plane
369: }
370: else
371: {
372: if (t < 0.0)
373: return col; // point is outside, so no fogging
374: t = 31.0/32.0;
375: }
376: s -= 1.0/512.0;
377: if ( s < 0.0 )
378: return col;
379: if ( t < 31.0/32.0 )
380: s *= (t - 1.0/32.0) / (30.0/32.0);
381: s = min(s * 8.0, 1.0);
382: float f = 1.0 - sqrt(s);
383: if (gen.z == 1.0) // ACFF_MODULATE_RGB
384: col.rgb *= f;
385: if (gen.z == 2.0) // ACFF_MODULATE_ALPHA
386: col.a *= f;
387: if (gen.z == 3.0) // ACFF_MODULATE_RGBA
388: col *= f;
389: }
390:
391: return col;
392: }
393: uniform vec2 u_tgen;
394: uniform vec3 u_parmtc;
395: uniform vec3 u_tcGenVectorS;
396: uniform vec3 u_tcGenVectorT;
397: uniform float u_tcModParms[29]; // TR_MAX_TEXMODS * 6 + TR_MAX_TEXMODS + 1
398:
399: #define TCGEN_TEXTURE 1.0
400: #define TCGEN_LIGHTMAP 2.0
401: #define TCGEN_ENVIRONMENT_MAPPED 3.0
402: #define TCGEN_FIRERISEENV_MAPPED 4.0
403: #define TCGEN_FOG 5.0
404: #define TCGEN_VECTOR 6.0
405:
406: #define GLSL_TMOD_NONE 0.0
407: #define GLSL_TMOD_TURBULENT 1.0
408: #define GLSL_TMOD_MATRIX 2.0
409: #define GLSL_TMOD_SWAP 3.0
410:
411: void tcGen (out vec2 st, in vec3 glVertex)
412: {
413: int tcOffs = 0;
414: // texGen:
415: st = vec2(0.0); // TCGEN_BAD (default) shut up compiler
416: if (u_tgen.x == TCGEN_TEXTURE)
417: st = attr_texCoords;
418: if (u_tgen.x == TCGEN_LIGHTMAP)
419: st = attr_lightCoords;
420: if (u_tgen.x == TCGEN_ENVIRONMENT_MAPPED)
421: { // u_parmtc = backEnd.or.viewOrigin
422: vec3 viewer = normalize(u_parmtc - glVertex);
423: float d = dot(attr_Normal, viewer);
424: vec3 reflected = attr_Normal * 2.0 * d - viewer;
425: st = 0.5 + reflected.yz * vec2(0.5, -0.5);
426: }
427: if (u_tgen.x == TCGEN_FIRERISEENV_MAPPED)
428: { // u_parmtc = normalize(-backEnd.currentEntity->e.fireRiseDir)
429: float d = dot(attr_Normal, u_parmtc);
430: vec3 reflected = attr_Normal * 2.0 * d - u_parmtc;
431: st = 0.5 + reflected.yz * vec2(0.5, -0.5);
432: }
433: if (u_tgen.x == TCGEN_FOG)
434: {
435: st.s = dot(glVertex, u_fogDistanceVector.xyz) + u_fogDistanceVector.w;
436: st.t = dot(glVertex, u_fogDepthVector.xyz) + u_fogDepthVector.w;
437: if (u_eyeT < 0.0)
438: {
439: if (st.t < 1.0)
440: st.t = 1.0/32.0; // point is outside, so no fogging
441: else
442: st.t = 1.0/32.0 + 30.0/32.0 * st.t / ( st.t - u_eyeT ); // cut the distance at the fog plane
443: }
444: else
445: {
446: if (st.t < 0.0)
447: st.t = 1.0/32.0; // point is outside, so no fogging
448: else
449: st.t = 31.0/32.0;
450: }
451: }
452: if (u_tgen.x == TCGEN_VECTOR)
453: st = vec2( dot(glVertex, u_tcGenVectorS), dot(glVertex, u_tcGenVectorT) );
454: {
455: float f = u_tcModParms[tcOffs++];
456: if (f == GLSL_TMOD_NONE)
457: return;
458: if (f == GLSL_TMOD_MATRIX)
459: { // stupid ATI HD2600 can't parse 'a*u[t++]+b*u[t++]+u[t++]'
(
460: vec2 sm = st;
461: float pa, pb, pc, pd, pe, pf;
462: pa = u_tcModParms[tcOffs++];
463: pb = u_tcModParms[tcOffs++];
464: pc = u_tcModParms[tcOffs++];
465: pd = u_tcModParms[tcOffs++];
466: pe = u_tcModParms[tcOffs++];
467: pf = u_tcModParms[tcOffs++];
468: st.s = dot(vec3(sm, 1.0), vec3(pa, pb, pc));
469: st.t = dot(vec3(sm, 1.0), vec3(pd, pe, pf));
470: }
471: if (f == GLSL_TMOD_TURBULENT)
472: {
473: vec2 sm;
474: float now = u_tcModParms[tcOffs++];
475: float amplitude = u_tcModParms[tcOffs++];
476: sm.x = sin(((glVertex.x + glVertex.z) * 0.125/128.0 + now) * 2.0 * 3.14159);
477: sm.y = sin((glVertex.y * 0.125/128.0 + now) * 2.0 * 3.14159);
478: st += sm * amplitude;
479: }
480: if (f == GLSL_TMOD_SWAP)
481: {
482: vec2 sm = st;
483: st = vec2(sm.t, 1.0 - sm.s);
484: }
485: }
486: {
487: float f = u_tcModParms[tcOffs++];
488: if (f == GLSL_TMOD_NONE)
489: return;
490: if (f == GLSL_TMOD_MATRIX)
491: { // stupid ATI HD2600 can't parse 'a*u[t++]+b*u[t++]+u[t++]'
(
492: vec2 sm = st;
493: float pa, pb, pc, pd, pe, pf;
494: pa = u_tcModParms[tcOffs++];
495: pb = u_tcModParms[tcOffs++];
496: pc = u_tcModParms[tcOffs++];
497: pd = u_tcModParms[tcOffs++];
498: pe = u_tcModParms[tcOffs++];
499: pf = u_tcModParms[tcOffs++];
500: st.s = dot(vec3(sm, 1.0), vec3(pa, pb, pc));
501: st.t = dot(vec3(sm, 1.0), vec3(pd, pe, pf));
502: }
503: if (f == GLSL_TMOD_TURBULENT)
504: {
505: vec2 sm;
506: float now = u_tcModParms[tcOffs++];
507: float amplitude = u_tcModParms[tcOffs++];
508: sm.x = sin(((glVertex.x + glVertex.z) * 0.125/128.0 + now) * 2.0 * 3.14159);
509: sm.y = sin((glVertex.y * 0.125/128.0 + now) * 2.0 * 3.14159);
510: st += sm * amplitude;
511: }
512: if (f == GLSL_TMOD_SWAP)
513: {
514: vec2 sm = st;
515: st = vec2(sm.t, 1.0 - sm.s);
516: }
517: }
518: {
519: float f = u_tcModParms[tcOffs++];
520: if (f == GLSL_TMOD_NONE)
521: return;
522: if (f == GLSL_TMOD_MATRIX)
523: { // stupid ATI HD2600 can't parse 'a*u[t++]+b*u[t++]+u[t++]'
(
524: vec2 sm = st;
525: float pa, pb, pc, pd, pe, pf;
526: pa = u_tcModParms[tcOffs++];
527: pb = u_tcModParms[tcOffs++];
528: pc = u_tcModParms[tcOffs++];
529: pd = u_tcModParms[tcOffs++];
530: pe = u_tcModParms[tcOffs++];
531: pf = u_tcModParms[tcOffs++];
532: st.s = dot(vec3(sm, 1.0), vec3(pa, pb, pc));
533: st.t = dot(vec3(sm, 1.0), vec3(pd, pe, pf));
534: }
535: if (f == GLSL_TMOD_TURBULENT)
536: {
537: vec2 sm;
538: float now = u_tcModParms[tcOffs++];
539: float amplitude = u_tcModParms[tcOffs++];
540: sm.x = sin(((glVertex.x + glVertex.z) * 0.125/128.0 + now) * 2.0 * 3.14159);
541: sm.y = sin((glVertex.y * 0.125/128.0 + now) * 2.0 * 3.14159);
542: st += sm * amplitude;
543: }
544: if (f == GLSL_TMOD_SWAP)
545: {
546: vec2 sm = st;
547: st = vec2(sm.t, 1.0 - sm.s);
548: }
549: }
550: {
551: float f = u_tcModParms[tcOffs++];
552: if (f == GLSL_TMOD_NONE)
553: return;
554: if (f == GLSL_TMOD_MATRIX)
555: { // stupid ATI HD2600 can't parse 'a*u[t++]+b*u[t++]+u[t++]'
(
556: vec2 sm = st;
557: float pa, pb, pc, pd, pe, pf;
558: pa = u_tcModParms[tcOffs++];
559: pb = u_tcModParms[tcOffs++];
560: pc = u_tcModParms[tcOffs++];
561: pd = u_tcModParms[tcOffs++];
562: pe = u_tcModParms[tcOffs++];
563: pf = u_tcModParms[tcOffs++];
564: st.s = dot(vec3(sm, 1.0), vec3(pa, pb, pc));
565: st.t = dot(vec3(sm, 1.0), vec3(pd, pe, pf));
566: }
567: if (f == GLSL_TMOD_TURBULENT)
568: {
569: vec2 sm;
570: float now = u_tcModParms[tcOffs++];
571: float amplitude = u_tcModParms[tcOffs++];
572: sm.x = sin(((glVertex.x + glVertex.z) * 0.125/128.0 + now) * 2.0 * 3.14159);
573: sm.y = sin((glVertex.y * 0.125/128.0 + now) * 2.0 * 3.14159);
574: st += sm * amplitude;
575: }
576: if (f == GLSL_TMOD_SWAP)
577: {
578: vec2 sm = st;
579: st = vec2(sm.t, 1.0 - sm.s);
580: }
581: }
582:
583: }
584:
585: void main(void)
586: {
587: vec4 glVertex = DeformGeometry();
588: color = colorGen(glVertex.xyz, u_gen, u_parm0, u_parm1, u_parm2, u_parma0, u_parma1);
589: tcGen(texCoord, glVertex.xyz);
590: gl_Position = u_ModelViewProjectionMatrix * glVertex;
591: v_clipVertex = (u_ModelViewMatrix * glVertex).xyz;
592: }
593:
----- CL_Shutdown -----
RE_Shutdown( 1 )
Shutting down OpenGL subsystem
...wglMakeCurrent( NULL, NULL ): success
...deleting GL context: success
...releasing DC: success
...destroying window
...shutting down QGL
...unloading OpenGL DLL
-----------------------
_replace.vsh: bad GLSL shader
Добавлено: 03 янв 2015 03:53
