notaz.gp2x.de / mupen64plus-pandora.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALL: Huge upstream synch + PerRom DelaySI & CountPerOp parameters
[mupen64plus-pandora.git] / source / gles2glide64 / src / Glitch64 / combiner.cpp
CommitLineData
98e75f2d 1/*
2* Glide64 - Glide video plugin for Nintendo 64 emulators.
3* Copyright (c) 2002 Dave2001
4* Copyright (c) 2003-2009 Sergey 'Gonetz' Lipski
5*
6* This program is free software; you can redistribute it and/or modify
7* it under the terms of the GNU General Public License as published by
8* the Free Software Foundation; either version 2 of the License, or
9* any later version.
10*
11* This program is distributed in the hope that it will be useful,
12* but WITHOUT ANY WARRANTY; without even the implied warranty of
13* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14* 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
21#ifdef _WIN32
22#include <windows.h>
23#else // _WIN32
24#include <string.h>
25#include <stdlib.h>
26#endif // _WIN32
27#include <math.h>
28#include <stdio.h>
29#include "glide.h"
30#include "main.h"
31
32#define GLchar char
33
34void vbo_draw();
35
36static int fct[4], source0[4], operand0[4], source1[4], operand1[4], source2[4], operand2[4];
37static int fcta[4],sourcea0[4],operanda0[4],sourcea1[4],operanda1[4],sourcea2[4],operanda2[4];
38static int alpha_ref, alpha_func;
39bool alpha_test = 0;
40
41float texture_env_color[4];
42float ccolor0[4];
43float ccolor1[4];
44static float chroma_color[4];
45int fog_enabled;
46static int chroma_enabled;
47static int chroma_other_color;
48static int chroma_other_alpha;
49static int dither_enabled;
50int blackandwhite0;
51int blackandwhite1;
52
53float fogStart,fogEnd;
54float fogColor[4];
55
56#ifdef _WIN32
57static float farF;
58static float nearF;
59#endif // _WIN32
60
61int need_lambda[2];
62float lambda_color[2][4];
63
64// shaders variables
65int need_to_compile;
66
67static GLuint fragment_shader_object;
68static GLuint fragment_depth_shader_object;
69static GLuint vertex_shader_object;
70static GLuint program_object_default;
71static GLuint program_object_depth;
72static GLuint program_object;
73static int constant_color_location;
74static int ccolor0_location;
75static int ccolor1_location;
76static int first_color = 1;
77static int first_alpha = 1;
78static int first_texture0 = 1;
79static int first_texture1 = 1;
80static int tex0_combiner_ext = 0;
81static int tex1_combiner_ext = 0;
82static int c_combiner_ext = 0;
83static int a_combiner_ext = 0;
84
85#define GLSL_VERSION "100"
86
87#define SHADER_HEADER \
88"#version " GLSL_VERSION " \n" \
89"#define gl_Color vFrontColor \n" \
90"#define gl_FrontColor vFrontColor \n" \
91"#define gl_TexCoord vTexCoord \n"
92
93#define SHADER_VARYING \
94"varying highp vec4 gl_FrontColor; \n" \
95"varying highp vec4 gl_TexCoord[4]; \n"
96
97static const char* fragment_shader_header =
98SHADER_HEADER
99"precision lowp float; \n"
100"uniform sampler2D texture0; \n"
101"uniform sampler2D texture1; \n"
102"uniform sampler2D ditherTex; \n"
103"uniform vec4 constant_color; \n"
104"uniform vec4 ccolor0; \n"
105"uniform vec4 ccolor1; \n"
106"uniform vec4 chroma_color; \n"
107"uniform float lambda; \n"
108"uniform vec3 fogColor; \n"
109"uniform float alphaRef; \n"
110SHADER_VARYING
111" \n"
112"void test_chroma(vec4 ctexture1); \n"
113" \n"
114" \n"
115"void main() \n"
116"{ \n"
117;
118
119// using gl_FragCoord is terribly slow on ATI and varying variables don't work for some unknown
120// reason, so we use the unused components of the texture2 coordinates
121static const char* fragment_shader_dither =
122" \n"
123/*" float dithx = (gl_TexCoord[2].b + 1.0)*0.5*1000.0; \n"
124" float dithy = (gl_TexCoord[2].a + 1.0)*0.5*1000.0; \n"
125" if(texture2D(ditherTex, vec2((dithx-32.0*floor(dithx/32.0))/32.0, \n"
126" (dithy-32.0*floor(dithy/32.0))/32.0)).a > 0.5) discard; \n"*/
127;
128
129static const char* fragment_shader_default =
130" gl_FragColor = texture2D(texture0, vec2(gl_TexCoord[0])); \n"
131;
132
133static const char* fragment_shader_readtex0color =
134" vec4 readtex0 = texture2D(texture0, vec2(gl_TexCoord[0])); \n"
135;
136
137static const char* fragment_shader_readtex0bw =
138" vec4 readtex0 = texture2D(texture0, vec2(gl_TexCoord[0])); \n"
139" readtex0 = vec4(vec3(readtex0.b), \n"
140" readtex0.r + readtex0.g * 8.0 / 256.0); \n"
141;
142static const char* fragment_shader_readtex0bw_2 =
143" vec4 readtex0 = vec4(dot(texture2D(texture0, vec2(gl_TexCoord[0])), vec4(1.0/3, 1.0/3, 1.0/3, 0))); \n"
144;
145
146static const char* fragment_shader_readtex1color =
147" vec4 readtex1 = texture2D(texture1, vec2(gl_TexCoord[1])); \n"
148;
149
150static const char* fragment_shader_readtex1bw =
151" vec4 readtex1 = texture2D(texture1, vec2(gl_TexCoord[1])); \n"
152" readtex1 = vec4(vec3(readtex1.b), \n"
153" readtex1.r + readtex1.g * 8.0 / 256.0); \n"
154;
155static const char* fragment_shader_readtex1bw_2 =
156" vec4 readtex1 = vec4(dot(texture2D(texture1, vec2(gl_TexCoord[1])), vec4(1.0/3, 1.0/3, 1.0/3, 0))); \n"
157;
158
159static const char* fragment_shader_fog =
160" float fog; \n"
161" fog = gl_TexCoord[0].b; \n"
162" gl_FragColor.rgb = mix(fogColor, gl_FragColor.rgb, fog); \n"
163;
164
165static const char* fragment_shader_end =
166"if(gl_FragColor.a <= alphaRef) {discard;} \n"
167" \n"
168"} \n"
169;
170
171static const char* fragment_shader_alt_end =
172" \n"
173"} \n"
174;
175
176static const char* vertex_shader =
177SHADER_HEADER
178"#define Z_MAX 65536.0 \n"
179"attribute highp vec4 aVertex; \n"
2d262872 180"attribute mediump vec4 aColor; \n" //*SEB* highp -> mediump
98e75f2d 181"attribute highp vec4 aMultiTexCoord0; \n"
182"attribute highp vec4 aMultiTexCoord1; \n"
183"attribute float aFog; \n"
184"uniform vec3 vertexOffset; \n" //Moved some calculations from grDrawXXX to shader
185"uniform vec4 textureSizes; \n"
186"uniform vec3 fogModeEndScale; \n" //0 = Mode, 1 = gl_Fog.end, 2 = gl_Fog.scale
187SHADER_VARYING
188" \n"
189"void main() \n"
190"{ \n"
191" float q = aVertex.w; \n"
192" float invertY = vertexOffset.z; \n" //Usually 1.0 but -1.0 when rendering to a texture (see inverted_culling grRenderBuffer)
193" gl_Position.x = (aVertex.x - vertexOffset.x) / vertexOffset.x; \n"
194" gl_Position.y = invertY *-(aVertex.y - vertexOffset.y) / vertexOffset.y; \n"
195" gl_Position.z = aVertex.z / Z_MAX; \n"
196" gl_Position.w = 1.0; \n"
197" gl_Position /= q; \n"
198" gl_FrontColor = aColor.bgra; \n"
199" \n"
200" gl_TexCoord[0] = vec4(aMultiTexCoord0.xy / q / textureSizes.xy,0,1); \n"
201" gl_TexCoord[1] = vec4(aMultiTexCoord1.xy / q / textureSizes.zw,0,1); \n"
202" \n"
203" float fogV = (1.0 / mix(q,aFog,fogModeEndScale[0])) / 255.0; \n"
204" //if(fogMode == 2) { \n"
205" // fogV = 1.0 / aFog / 255 \n"
206" //} \n"
207" \n"
208" float f = (fogModeEndScale[1] - fogV) * fogModeEndScale[2]; \n"
209" f = clamp(f, 0.0, 1.0); \n"
210" gl_TexCoord[0].b = f; \n"
211" gl_TexCoord[2].b = aVertex.x; \n"
212" gl_TexCoord[2].a = aVertex.y; \n"
213"} \n"
214;
215
216static char fragment_shader_color_combiner[1024];
217static char fragment_shader_alpha_combiner[1024];
218static char fragment_shader_texture1[1024];
219static char fragment_shader_texture0[1024];
220static char fragment_shader_chroma[1024];
221static char shader_log[2048];
222
223void check_compile(GLuint shader)
224{
225 GLint success;
226 glGetShaderiv(shader,GL_COMPILE_STATUS,&success);
227 if(!success)
228 {
229 char log[1024];
230 glGetShaderInfoLog(shader,1024,NULL,log);
231 LOGINFO(log);
232 }
233}
234
235void check_link(GLuint program)
236{
237 GLint success;
238 glGetProgramiv(program,GL_LINK_STATUS,&success);
239 if(!success)
240 {
241 char log[1024];
242 glGetProgramInfoLog(program,1024,NULL,log);
243 LOGINFO(log);
244 }
245}
246
247void init_combiner()
248{
249 int texture[4] = {0, 0, 0, 0};
250
251 glActiveTexture(GL_TEXTURE0);
252 glEnable(GL_TEXTURE_2D);
253
254 // creating a fake texture
255 glBindTexture(GL_TEXTURE_2D, default_texture);
256 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
257 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
258 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
259
260 glActiveTexture(GL_TEXTURE1);
261 glBindTexture(GL_TEXTURE_2D, default_texture);
262 glEnable(GL_TEXTURE_2D);
263
264 int texture0_location;
265 int texture1_location;
266 char *fragment_shader;
267 int log_length;
268
269//#ifndef ANDROID
2d262872 270#if 0
271// unfortunatly, Pandora has not the gl_FragDepthEXT extension... So I disable this block.
98e75f2d 272 // depth shader
273 fragment_depth_shader_object = glCreateShader(GL_FRAGMENT_SHADER);
274
2d262872 275 char s[512];
98e75f2d 276 // ZIGGY convert a 565 texture into depth component
2d262872 277 sprintf(s, "gl_FragDepthEXT = dot(texture2D(texture0, vec2(gl_TexCoord[0])), vec4(31*64*32, 63*32, 31, 0))*%g + %g; \n", zscale/2/65535.0, 1-zscale/2);
98e75f2d 278 fragment_shader = (char*)malloc(strlen(fragment_shader_header)+
279 strlen(s)+
280 strlen(fragment_shader_end)+1);
281 strcpy(fragment_shader, fragment_shader_header);
282 strcat(fragment_shader, s);
283 strcat(fragment_shader, fragment_shader_end);
284 glShaderSource(fragment_depth_shader_object, 1, (const GLchar**)&fragment_shader, NULL);
285 free(fragment_shader);
286
287 glCompileShader(fragment_depth_shader_object);
288 check_compile(fragment_depth_shader_object);
2d262872 289#endif
98e75f2d 290
291 // default shader
292 fragment_shader_object = glCreateShader(GL_FRAGMENT_SHADER);
293
294 fragment_shader = (char*)malloc(strlen(fragment_shader_header)+
295 strlen(fragment_shader_default)+
296 strlen(fragment_shader_alt_end)+1);
297 strcpy(fragment_shader, fragment_shader_header);
298 strcat(fragment_shader, fragment_shader_default);
299 strcat(fragment_shader, fragment_shader_alt_end); /*SEB*/
300 glShaderSource(fragment_shader_object, 1, (const GLchar**)&fragment_shader, NULL);
301 free(fragment_shader);
302
303 glCompileShader(fragment_shader_object);
304 check_compile(fragment_shader_object);
305
306 vertex_shader_object = glCreateShader(GL_VERTEX_SHADER);
307 glShaderSource(vertex_shader_object, 1, &vertex_shader, NULL);
308 glCompileShader(vertex_shader_object);
309 check_compile(vertex_shader_object);
310
311 // depth program
312 program_object = glCreateProgram();
313 program_object_depth = program_object;
314 glAttachShader(program_object, fragment_depth_shader_object);
315 glAttachShader(program_object, vertex_shader_object);
316
317 glBindAttribLocation(program_object,POSITION_ATTR,"aPosition");
318 glBindAttribLocation(program_object,COLOUR_ATTR,"aColor");
319 glBindAttribLocation(program_object,TEXCOORD_0_ATTR,"aMultiTexCoord0");
320 glBindAttribLocation(program_object,TEXCOORD_1_ATTR,"aMultiTexCoord1");
321 glBindAttribLocation(program_object,FOG_ATTR,"aFog");
322
323 glLinkProgram(program_object);
324 check_link(program_object);
325 glUseProgram(program_object);
326
327 texture0_location = glGetUniformLocation(program_object, "texture0");
328 texture1_location = glGetUniformLocation(program_object, "texture1");
329 glUniform1i(texture0_location, 0);
330 glUniform1i(texture1_location, 1);
331
332 // default program
333 program_object = glCreateProgram();
334 program_object_default = program_object;
335 glAttachShader(program_object, fragment_shader_object);
336 glAttachShader(program_object, vertex_shader_object);
337
338 glBindAttribLocation(program_object,POSITION_ATTR,"aPosition");
339 glBindAttribLocation(program_object,COLOUR_ATTR,"aColor");
340 glBindAttribLocation(program_object,TEXCOORD_0_ATTR,"aMultiTexCoord0");
341 glBindAttribLocation(program_object,TEXCOORD_1_ATTR,"aMultiTexCoord1");
342 glBindAttribLocation(program_object,FOG_ATTR,"aFog");
343
344 glLinkProgram(program_object);
345 check_link(program_object);
346 glUseProgram(program_object);
347
348 texture0_location = glGetUniformLocation(program_object, "texture0");
349 texture1_location = glGetUniformLocation(program_object, "texture1");
350 glUniform1i(texture0_location, 0);
351 glUniform1i(texture1_location, 1);
352
353 strcpy(fragment_shader_color_combiner, "");
354 strcpy(fragment_shader_alpha_combiner, "");
355 strcpy(fragment_shader_texture1, "vec4 ctexture1 = texture2D(texture0, vec2(gl_TexCoord[0])); \n");
356 strcpy(fragment_shader_texture0, "");
357
358 first_color = 1;
359 first_alpha = 1;
360 first_texture0 = 1;
361 first_texture1 = 1;
362 need_to_compile = 0;
363 fog_enabled = 0;
364 chroma_enabled = 0;
365 dither_enabled = 0;
366 blackandwhite0 = 0;
367 blackandwhite1 = 0;
368}
369
370void compile_chroma_shader()
371{
372 strcpy(fragment_shader_chroma, "\nvoid test_chroma(vec4 ctexture1)\n{\n");
373
374 switch(chroma_other_alpha)
375 {
376 case GR_COMBINE_OTHER_ITERATED:
377 strcat(fragment_shader_chroma, "float alpha = gl_Color.a; \n");
378 break;
379 case GR_COMBINE_OTHER_TEXTURE:
380 strcat(fragment_shader_chroma, "float alpha = ctexture1.a; \n");
381 break;
382 case GR_COMBINE_OTHER_CONSTANT:
383 strcat(fragment_shader_chroma, "float alpha = constant_color.a; \n");
384 break;
385 default:
386 display_warning("unknown compile_choma_shader_alpha : %x", chroma_other_alpha);
387 }
388
389 switch(chroma_other_color)
390 {
391 case GR_COMBINE_OTHER_ITERATED:
392 strcat(fragment_shader_chroma, "vec4 color = vec4(vec3(gl_Color),alpha); \n");
393 break;
394 case GR_COMBINE_OTHER_TEXTURE:
395 strcat(fragment_shader_chroma, "vec4 color = vec4(vec3(ctexture1),alpha); \n");
396 break;
397 case GR_COMBINE_OTHER_CONSTANT:
398 strcat(fragment_shader_chroma, "vec4 color = vec4(vec3(constant_color),alpha); \n");
399 break;
400 default:
401 display_warning("unknown compile_choma_shader_alpha : %x", chroma_other_color);
402 }
403
404 strcat(fragment_shader_chroma, "if (color.rgb == chroma_color.rgb) discard; \n");
405 strcat(fragment_shader_chroma, "}");
406}
407
408typedef struct _shader_program_key
409{
410 int color_combiner;
411 int alpha_combiner;
412 int texture0_combiner;
413 int texture1_combiner;
414 int texture0_combinera;
415 int texture1_combinera;
416 int fog_enabled;
417 int chroma_enabled;
418 int dither_enabled;
419 int blackandwhite0;
420 int blackandwhite1;
421 int alpha_test; //*SEB*
422 GLuint fragment_shader_object;
423 GLuint program_object;
424 int texture0_location;
425 int texture1_location;
426 int vertexOffset_location;
427 int textureSizes_location;
428 int fogModeEndScale_location;
429 int fogColor_location;
430 int alphaRef_location;
431 int ditherTex_location;
432 int chroma_color_location;
433} shader_program_key;
434
435static shader_program_key* shader_programs = NULL;
436static int number_of_programs = 0;
437static int color_combiner_key;
438static int alpha_combiner_key;
439static int texture0_combiner_key;
440static int texture1_combiner_key;
441static int texture0_combinera_key;
442static int texture1_combinera_key;
443
444void update_uniforms(shader_program_key prog)
445{
446 glUniform1i(prog.texture0_location, 0);
447 glUniform1i(prog.texture1_location, 1);
448
449 glUniform3f(prog.vertexOffset_location,widtho,heighto,inverted_culling ? -1.0f : 1.0f);
450 glUniform4f(prog.textureSizes_location,tex0_width,tex0_height,tex1_width,tex1_height);
451
452 glUniform3f(prog.fogModeEndScale_location,
453 fog_enabled != 2 ? 0.0f : 1.0f,
454 fogEnd,
455 1.0f / (fogEnd - fogStart)
456 );
457
458 if(prog.fogColor_location != -1)
459 {
460 glUniform3f(prog.fogColor_location,fogColor[0],fogColor[1],fogColor[2]);
461 }
462
463 glUniform1f(prog.alphaRef_location,alpha_test ? alpha_ref/255.0f : -1.0f);
464
465 constant_color_location = glGetUniformLocation(program_object, "constant_color");
466 glUniform4f(constant_color_location, texture_env_color[0], texture_env_color[1],
467 texture_env_color[2], texture_env_color[3]);
468
469 ccolor0_location = glGetUniformLocation(program_object, "ccolor0");
470 glUniform4f(ccolor0_location, ccolor0[0], ccolor0[1], ccolor0[2], ccolor0[3]);
471
472 ccolor1_location = glGetUniformLocation(program_object, "ccolor1");
473 glUniform4f(ccolor1_location, ccolor1[0], ccolor1[1], ccolor1[2], ccolor1[3]);
474
475 glUniform4f(prog.chroma_color_location, chroma_color[0], chroma_color[1],
476 chroma_color[2], chroma_color[3]);
477
478 if(dither_enabled)
479 {
480 glUniform1i(prog.ditherTex_location, 2);
481 }
482
483 set_lambda();
484}
485
486void disable_textureSizes()
487{
488 int textureSizes_location = glGetUniformLocation(program_object_default,"textureSizes");
489 glUniform4f(textureSizes_location,1,1,1,1);
490}
491
492void compile_shader()
493{
494 int texture0_location;
495 int texture1_location;
496 int ditherTex_location;
497 int vertexOffset_location;
498 int textureSizes_location;
499 char *fragment_shader;
500 int i;
501 int chroma_color_location;
502 int log_length;
503
504 int noalpha;
505
506 need_to_compile = 0;
507
508 for(i=0; i<number_of_programs; i++)
509 {
510 shader_program_key prog = shader_programs[i];
511 if(prog.color_combiner == color_combiner_key &&
512 prog.alpha_combiner == alpha_combiner_key &&
513 prog.texture0_combiner == texture0_combiner_key &&
514 prog.texture1_combiner == texture1_combiner_key &&
515 prog.texture0_combinera == texture0_combinera_key &&
516 prog.texture1_combinera == texture1_combinera_key &&
517 prog.fog_enabled == fog_enabled &&
518 prog.alpha_test == alpha_test && //*SEB*
519 prog.chroma_enabled == chroma_enabled &&
520 prog.dither_enabled == dither_enabled &&
521 prog.blackandwhite0 == blackandwhite0 &&
522 prog.blackandwhite1 == blackandwhite1)
523 {
524 program_object = shader_programs[i].program_object;
525 glUseProgram(program_object);
526 update_uniforms(prog);
527 return;
528 }
529 }
530
531 if(shader_programs != NULL) {
532 if ((number_of_programs+1)>1024)
533 shader_programs = (shader_program_key*)realloc(shader_programs, (number_of_programs+1)*sizeof(shader_program_key));
534 }
535 else
536 shader_programs = (shader_program_key*)malloc(sizeof(shader_program_key)*1024);
537 //printf("number of shaders %d\n", number_of_programs);
538
539 shader_programs[number_of_programs].color_combiner = color_combiner_key;
540 shader_programs[number_of_programs].alpha_combiner = alpha_combiner_key;
541 shader_programs[number_of_programs].texture0_combiner = texture0_combiner_key;
542 shader_programs[number_of_programs].texture1_combiner = texture1_combiner_key;
543 shader_programs[number_of_programs].texture0_combinera = texture0_combinera_key;
544 shader_programs[number_of_programs].texture1_combinera = texture1_combinera_key;
545 shader_programs[number_of_programs].fog_enabled = fog_enabled;
546 shader_programs[number_of_programs].chroma_enabled = chroma_enabled;
547 shader_programs[number_of_programs].dither_enabled = dither_enabled;
548 shader_programs[number_of_programs].blackandwhite0 = blackandwhite0;
549 shader_programs[number_of_programs].blackandwhite1 = blackandwhite1;
550 shader_programs[number_of_programs].alpha_test = alpha_test; //*SEB*
551
552 if(chroma_enabled)
553 {
554 strcat(fragment_shader_texture1, "test_chroma(ctexture1); \n");
555 compile_chroma_shader();
556 }
557
558 fragment_shader = (char*)malloc(4096);
559
560 strcpy(fragment_shader, fragment_shader_header);
561 if(dither_enabled) strcat(fragment_shader, fragment_shader_dither);
562 switch (blackandwhite0) {
563 case 1: strcat(fragment_shader, fragment_shader_readtex0bw); break;
564 case 2: strcat(fragment_shader, fragment_shader_readtex0bw_2); break;
565 default: strcat(fragment_shader, fragment_shader_readtex0color);
566 }
567 switch (blackandwhite1) {
568 case 1: strcat(fragment_shader, fragment_shader_readtex1bw); break;
569 case 2: strcat(fragment_shader, fragment_shader_readtex1bw_2); break;
570 default: strcat(fragment_shader, fragment_shader_readtex1color);
571 }
572 strcat(fragment_shader, fragment_shader_texture0);
573 strcat(fragment_shader, fragment_shader_texture1);
574 strcat(fragment_shader, fragment_shader_color_combiner);
575 strcat(fragment_shader, fragment_shader_alpha_combiner);
576 if(fog_enabled) strcat(fragment_shader, fragment_shader_fog);
577 if (alpha_test)
578 strcat(fragment_shader, fragment_shader_end);
579 else
580 strcat(fragment_shader, fragment_shader_alt_end); //*SEB*
581 if(chroma_enabled) strcat(fragment_shader, fragment_shader_chroma);
582
583 shader_programs[number_of_programs].fragment_shader_object = glCreateShader(GL_FRAGMENT_SHADER);
584 glShaderSource(shader_programs[number_of_programs].fragment_shader_object, 1, (const GLchar**)&fragment_shader, NULL);
585
586 glCompileShader(shader_programs[number_of_programs].fragment_shader_object);
587 check_compile(shader_programs[number_of_programs].fragment_shader_object);
588
589 program_object = glCreateProgram();
590 shader_programs[number_of_programs].program_object = program_object;
591
592 glBindAttribLocation(program_object,POSITION_ATTR,"aPosition");
593 glBindAttribLocation(program_object,COLOUR_ATTR,"aColor");
594 glBindAttribLocation(program_object,TEXCOORD_0_ATTR,"aMultiTexCoord0");
595 glBindAttribLocation(program_object,TEXCOORD_1_ATTR,"aMultiTexCoord1");
596 glBindAttribLocation(program_object,FOG_ATTR,"aFog");
597
598 glAttachShader(program_object, shader_programs[number_of_programs].fragment_shader_object);
599 glAttachShader(program_object, vertex_shader_object);
600
601 glLinkProgram(program_object);
602 check_link(program_object);
603 glUseProgram(program_object);
604
605
606 shader_programs[number_of_programs].texture0_location = glGetUniformLocation(program_object, "texture0");
607 shader_programs[number_of_programs].texture1_location = glGetUniformLocation(program_object, "texture1");
608 shader_programs[number_of_programs].vertexOffset_location = glGetUniformLocation(program_object, "vertexOffset");
609 shader_programs[number_of_programs].textureSizes_location = glGetUniformLocation(program_object, "textureSizes");
610 shader_programs[number_of_programs].fogModeEndScale_location = glGetUniformLocation(program_object, "fogModeEndScale");
611 shader_programs[number_of_programs].fogColor_location = glGetUniformLocation(program_object, "fogColor");
612 shader_programs[number_of_programs].alphaRef_location = glGetUniformLocation(program_object, "alphaRef");
613
614 update_uniforms(shader_programs[number_of_programs]);
615
616 number_of_programs++;
617}
618
619void free_combiners()
620{
621 free(shader_programs);
622 shader_programs = NULL;
623 number_of_programs = 0;
624}
625
626void set_copy_shader()
627{
628 int texture0_location;
629 int alphaRef_location;
630
631 glUseProgram(program_object_default);
632 texture0_location = glGetUniformLocation(program_object_default, "texture0");
633 glUniform1i(texture0_location, 0);
634
635 alphaRef_location = glGetUniformLocation(program_object_default, "alphaRef");
636 if(alphaRef_location != -1)
637 glUniform1f(alphaRef_location,alpha_test ? alpha_ref/255.0f : -1.0f);
638}
639
640void set_depth_shader()
641{
642 int texture0_location;
643 int alphaRef_location;
644
645 glUseProgram(program_object_depth);
646 texture0_location = glGetUniformLocation(program_object_depth, "texture0");
647 glUniform1i(texture0_location, 0);
648
649 alphaRef_location = glGetUniformLocation(program_object_depth, "alphaRef");
650 if(alphaRef_location != -1)
651 glUniform1f(alphaRef_location,alpha_test ? alpha_ref/255.0f : -1.0f);
652}
653
654void set_lambda()
655{
656 int lambda_location = glGetUniformLocation(program_object, "lambda");
657 glUniform1f(lambda_location, lambda);
658}
659
660FX_ENTRY void FX_CALL
661grConstantColorValue( GrColor_t value )
662{
663 LOG("grConstantColorValue(%d)\r\n", value);
664 switch(lfb_color_fmt)
665 {
666 case GR_COLORFORMAT_ARGB:
667 texture_env_color[3] = ((value >> 24) & 0xFF) / 255.0f;
668 texture_env_color[0] = ((value >> 16) & 0xFF) / 255.0f;
669 texture_env_color[1] = ((value >> 8) & 0xFF) / 255.0f;
670 texture_env_color[2] = (value & 0xFF) / 255.0f;
671 break;
672 case GR_COLORFORMAT_RGBA:
673 texture_env_color[0] = ((value >> 24) & 0xFF) / 255.0f;
674 texture_env_color[1] = ((value >> 16) & 0xFF) / 255.0f;
675 texture_env_color[2] = ((value >> 8) & 0xFF) / 255.0f;
676 texture_env_color[3] = (value & 0xFF) / 255.0f;
677 break;
678 default:
679 display_warning("grConstantColorValue: unknown color format : %x", lfb_color_fmt);
680 }
681
682 vbo_draw();
683
684 constant_color_location = glGetUniformLocation(program_object, "constant_color");
685 glUniform4f(constant_color_location, texture_env_color[0], texture_env_color[1],
686 texture_env_color[2], texture_env_color[3]);
687}
688
689void writeGLSLColorOther(int other)
690{
691 switch(other)
692 {
693 case GR_COMBINE_OTHER_ITERATED:
694 strcat(fragment_shader_color_combiner, "vec4 color_other = gl_Color; \n");
695 break;
696 case GR_COMBINE_OTHER_TEXTURE:
697 strcat(fragment_shader_color_combiner, "vec4 color_other = ctexture1; \n");
698 break;
699 case GR_COMBINE_OTHER_CONSTANT:
700 strcat(fragment_shader_color_combiner, "vec4 color_other = constant_color; \n");
701 break;
702 default:
703 display_warning("unknown writeGLSLColorOther : %x", other);
704 }
705}
706
707void writeGLSLColorLocal(int local)
708{
709 switch(local)
710 {
711 case GR_COMBINE_LOCAL_ITERATED:
712 strcat(fragment_shader_color_combiner, "vec4 color_local = gl_Color; \n");
713 break;
714 case GR_COMBINE_LOCAL_CONSTANT:
715 strcat(fragment_shader_color_combiner, "vec4 color_local = constant_color; \n");
716 break;
717 default:
718 display_warning("unknown writeGLSLColorLocal : %x", local);
719 }
720}
721
722void writeGLSLColorFactor(int factor, int local, int need_local, int other, int need_other)
723{
724 switch(factor)
725 {
726 case GR_COMBINE_FACTOR_ZERO:
727 strcat(fragment_shader_color_combiner, "vec4 color_factor = vec4(0.0); \n");
728 break;
729 case GR_COMBINE_FACTOR_LOCAL:
730 if(need_local) writeGLSLColorLocal(local);
731 strcat(fragment_shader_color_combiner, "vec4 color_factor = color_local; \n");
732 break;
733 case GR_COMBINE_FACTOR_OTHER_ALPHA:
734 if(need_other) writeGLSLColorOther(other);
735 strcat(fragment_shader_color_combiner, "vec4 color_factor = vec4(color_other.a); \n");
736 break;
737 case GR_COMBINE_FACTOR_LOCAL_ALPHA:
738 if(need_local) writeGLSLColorLocal(local);
739 strcat(fragment_shader_color_combiner, "vec4 color_factor = vec4(color_local.a); \n");
740 break;
741 case GR_COMBINE_FACTOR_TEXTURE_ALPHA:
742 strcat(fragment_shader_color_combiner, "vec4 color_factor = vec4(ctexture1.a); \n");
743 break;
744 case GR_COMBINE_FACTOR_TEXTURE_RGB:
745 strcat(fragment_shader_color_combiner, "vec4 color_factor = ctexture1; \n");
746 break;
747 case GR_COMBINE_FACTOR_ONE:
748 strcat(fragment_shader_color_combiner, "vec4 color_factor = vec4(1.0); \n");
749 break;
750 case GR_COMBINE_FACTOR_ONE_MINUS_LOCAL:
751 if(need_local) writeGLSLColorLocal(local);
752 strcat(fragment_shader_color_combiner, "vec4 color_factor = vec4(1.0) - color_local; \n");
753 break;
754 case GR_COMBINE_FACTOR_ONE_MINUS_OTHER_ALPHA:
755 if(need_other) writeGLSLColorOther(other);
756 strcat(fragment_shader_color_combiner, "vec4 color_factor = vec4(1.0) - vec4(color_other.a); \n");
757 break;
758 case GR_COMBINE_FACTOR_ONE_MINUS_LOCAL_ALPHA:
759 if(need_local) writeGLSLColorLocal(local);
760 strcat(fragment_shader_color_combiner, "vec4 color_factor = vec4(1.0) - vec4(color_local.a); \n");
761 break;
762 case GR_COMBINE_FACTOR_ONE_MINUS_TEXTURE_ALPHA:
763 strcat(fragment_shader_color_combiner, "vec4 color_factor = vec4(1.0) - vec4(ctexture1.a); \n");
764 break;
765 default:
766 display_warning("unknown writeGLSLColorFactor : %x", factor);
767 }
768}
769
770FX_ENTRY void FX_CALL
771grColorCombine(
772 GrCombineFunction_t function, GrCombineFactor_t factor,
773 GrCombineLocal_t local, GrCombineOther_t other,
774 FxBool invert )
775{
776 LOG("grColorCombine(%d,%d,%d,%d,%d)\r\n", function, factor, local, other, invert);
777 static int last_function = 0;
778 static int last_factor = 0;
779 static int last_local = 0;
780 static int last_other = 0;
781
782 if(last_function == function && last_factor == factor &&
783 last_local == local && last_other == other && first_color == 0 && !c_combiner_ext) return;
784 first_color = 0;
785 c_combiner_ext = 0;
786
787 last_function = function;
788 last_factor = factor;
789 last_local = local;
790 last_other = other;
791
792 if (invert) display_warning("grColorCombine : inverted result");
793
794 color_combiner_key = function | (factor << 4) | (local << 8) | (other << 10);
795 chroma_other_color = other;
796
797 strcpy(fragment_shader_color_combiner, "");
798 switch(function)
799 {
800 case GR_COMBINE_FUNCTION_ZERO:
801 strcat(fragment_shader_color_combiner, "gl_FragColor = vec4(0.0); \n");
802 break;
803 case GR_COMBINE_FUNCTION_LOCAL:
804 writeGLSLColorLocal(local);
805 strcat(fragment_shader_color_combiner, "gl_FragColor = color_local; \n");
806 break;
807 case GR_COMBINE_FUNCTION_LOCAL_ALPHA:
808 writeGLSLColorLocal(local);
809 strcat(fragment_shader_color_combiner, "gl_FragColor = vec4(color_local.a); \n");
810 break;
811 case GR_COMBINE_FUNCTION_SCALE_OTHER:
812 writeGLSLColorOther(other);
813 writeGLSLColorFactor(factor,local,1,other,0);
814 strcat(fragment_shader_color_combiner, "gl_FragColor = color_factor * color_other; \n");
815 break;
816 case GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL:
817 writeGLSLColorLocal(local);
818 writeGLSLColorOther(other);
819 writeGLSLColorFactor(factor,local,0,other,0);
820 strcat(fragment_shader_color_combiner, "gl_FragColor = color_factor * color_other + color_local; \n");
821 break;
822 case GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL_ALPHA:
823 writeGLSLColorLocal(local);
824 writeGLSLColorOther(other);
825 writeGLSLColorFactor(factor,local,0,other,0);
826 strcat(fragment_shader_color_combiner, "gl_FragColor = color_factor * color_other + vec4(color_local.a); \n");
827 break;
828 case GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL:
829 writeGLSLColorLocal(local);
830 writeGLSLColorOther(other);
831 writeGLSLColorFactor(factor,local,0,other,0);
832 strcat(fragment_shader_color_combiner, "gl_FragColor = color_factor * (color_other - color_local); \n");
833 break;
834 case GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL:
835 writeGLSLColorLocal(local);
836 writeGLSLColorOther(other);
837 writeGLSLColorFactor(factor,local,0,other,0);
838 strcat(fragment_shader_color_combiner, "gl_FragColor = color_factor * (color_other - color_local) + color_local; \n");
839 break;
840 case GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL_ALPHA:
841 writeGLSLColorLocal(local);
842 writeGLSLColorOther(other);
843 writeGLSLColorFactor(factor,local,0,other,0);
844 strcat(fragment_shader_color_combiner, "gl_FragColor = color_factor * (color_other - color_local) + vec4(color_local.a); \n");
845 break;
846 case GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL:
847 writeGLSLColorLocal(local);
848 writeGLSLColorFactor(factor,local,0,other,1);
849 strcat(fragment_shader_color_combiner, "gl_FragColor = color_factor * (-color_local) + color_local; \n");
850 break;
851 case GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL_ALPHA:
852 writeGLSLColorLocal(local);
853 writeGLSLColorFactor(factor,local,0,other,1);
854 strcat(fragment_shader_color_combiner, "gl_FragColor = color_factor * (-color_local) + vec4(color_local.a); \n");
855 break;
856 default:
857 strcpy(fragment_shader_color_combiner, fragment_shader_default);
858 display_warning("grColorCombine : unknown function : %x", function);
859 }
860 //compile_shader();
861 need_to_compile = 1;
862}
863
864/*
865int setOtherAlphaSource(int other)
866{
867 switch(other)
868 {
869 case GR_COMBINE_OTHER_ITERATED:
870 return GL_PRIMARY_COLOR_ARB;
871 break;
872 case GR_COMBINE_OTHER_TEXTURE:
873 return GL_PREVIOUS_ARB;
874 break;
875 case GR_COMBINE_OTHER_CONSTANT:
876 return GL_CONSTANT_ARB;
877 break;
878 default:
879 display_warning("unknwown other alpha source : %x", other);
880 }
881 return 0;
882}
883
884int setLocalAlphaSource(int local)
885{
886 switch(local)
887 {
888 case GR_COMBINE_LOCAL_ITERATED:
889 return GL_PRIMARY_COLOR_ARB;
890 break;
891 case GR_COMBINE_LOCAL_CONSTANT:
892 return GL_CONSTANT_ARB;
893 break;
894 default:
895 display_warning("unknwown local alpha source : %x", local);
896 }
897 return 0;
898}
899*/
900
901void writeGLSLAlphaOther(int other)
902{
903 switch(other)
904 {
905 case GR_COMBINE_OTHER_ITERATED:
906 strcat(fragment_shader_alpha_combiner, "float alpha_other = gl_Color.a; \n");
907 break;
908 case GR_COMBINE_OTHER_TEXTURE:
909 strcat(fragment_shader_alpha_combiner, "float alpha_other = ctexture1.a; \n");
910 break;
911 case GR_COMBINE_OTHER_CONSTANT:
912 strcat(fragment_shader_alpha_combiner, "float alpha_other = constant_color.a; \n");
913 break;
914 default:
915 display_warning("unknown writeGLSLAlphaOther : %x", other);
916 }
917}
918
919void writeGLSLAlphaLocal(int local)
920{
921 switch(local)
922 {
923 case GR_COMBINE_LOCAL_ITERATED:
924 strcat(fragment_shader_alpha_combiner, "float alpha_local = gl_Color.a; \n");
925 break;
926 case GR_COMBINE_LOCAL_CONSTANT:
927 strcat(fragment_shader_alpha_combiner, "float alpha_local = constant_color.a; \n");
928 break;
929 default:
930 display_warning("unknown writeGLSLAlphaLocal : %x", local);
931 }
932}
933
934void writeGLSLAlphaFactor(int factor, int local, int need_local, int other, int need_other)
935{
936 switch(factor)
937 {
938 case GR_COMBINE_FACTOR_ZERO:
939 strcat(fragment_shader_alpha_combiner, "float alpha_factor = 0.0; \n");
940 break;
941 case GR_COMBINE_FACTOR_LOCAL:
942 if(need_local) writeGLSLAlphaLocal(local);
943 strcat(fragment_shader_alpha_combiner, "float alpha_factor = alpha_local; \n");
944 break;
945 case GR_COMBINE_FACTOR_OTHER_ALPHA:
946 if(need_other) writeGLSLAlphaOther(other);
947 strcat(fragment_shader_alpha_combiner, "float alpha_factor = alpha_other; \n");
948 break;
949 case GR_COMBINE_FACTOR_LOCAL_ALPHA:
950 if(need_local) writeGLSLAlphaLocal(local);
951 strcat(fragment_shader_alpha_combiner, "float alpha_factor = alpha_local; \n");
952 break;
953 case GR_COMBINE_FACTOR_TEXTURE_ALPHA:
954 strcat(fragment_shader_alpha_combiner, "float alpha_factor = ctexture1.a; \n");
955 break;
956 case GR_COMBINE_FACTOR_ONE:
957 strcat(fragment_shader_alpha_combiner, "float alpha_factor = 1.0; \n");
958 break;
959 case GR_COMBINE_FACTOR_ONE_MINUS_LOCAL:
960 if(need_local) writeGLSLAlphaLocal(local);
961 strcat(fragment_shader_alpha_combiner, "float alpha_factor = 1.0 - alpha_local; \n");
962 break;
963 case GR_COMBINE_FACTOR_ONE_MINUS_OTHER_ALPHA:
964 if(need_other) writeGLSLAlphaOther(other);
965 strcat(fragment_shader_alpha_combiner, "float alpha_factor = 1.0 - alpha_other; \n");
966 break;
967 case GR_COMBINE_FACTOR_ONE_MINUS_LOCAL_ALPHA:
968 if(need_local) writeGLSLAlphaLocal(local);
969 strcat(fragment_shader_alpha_combiner, "float alpha_factor = 1.0 - alpha_local; \n");
970 break;
971 case GR_COMBINE_FACTOR_ONE_MINUS_TEXTURE_ALPHA:
972 strcat(fragment_shader_alpha_combiner, "float alpha_factor = 1.0 - ctexture1.a; \n");
973 break;
974 default:
975 display_warning("unknown writeGLSLAlphaFactor : %x", factor);
976 }
977}
978
979FX_ENTRY void FX_CALL
980grAlphaCombine(
981 GrCombineFunction_t function, GrCombineFactor_t factor,
982 GrCombineLocal_t local, GrCombineOther_t other,
983 FxBool invert
984 )
985{
986 LOG("grAlphaCombine(%d,%d,%d,%d,%d)\r\n", function, factor, local, other, invert);
987 static int last_function = 0;
988 static int last_factor = 0;
989 static int last_local = 0;
990 static int last_other = 0;
991
992 if(last_function == function && last_factor == factor &&
993 last_local == local && last_other == other && first_alpha == 0 && !a_combiner_ext) return;
994 first_alpha = 0;
995 a_combiner_ext = 0;
996
997 last_function = function;
998 last_factor = factor;
999 last_local = local;
1000 last_other = other;
1001
1002 if (invert) display_warning("grAlphaCombine : inverted result");
1003
1004 alpha_combiner_key = function | (factor << 4) | (local << 8) | (other << 10);
1005 chroma_other_alpha = other;
1006
1007 strcpy(fragment_shader_alpha_combiner, "");
1008
1009 switch(function)
1010 {
1011 case GR_COMBINE_FUNCTION_ZERO:
1012 strcat(fragment_shader_alpha_combiner, "gl_FragColor.a = 0.0; \n");
1013 break;
1014 case GR_COMBINE_FUNCTION_LOCAL:
1015 writeGLSLAlphaLocal(local);
1016 strcat(fragment_shader_alpha_combiner, "gl_FragColor.a = alpha_local; \n");
1017 break;
1018 case GR_COMBINE_FUNCTION_LOCAL_ALPHA:
1019 writeGLSLAlphaLocal(local);
1020 strcat(fragment_shader_alpha_combiner, "gl_FragColor.a = alpha_local; \n");
1021 break;
1022 case GR_COMBINE_FUNCTION_SCALE_OTHER:
1023 writeGLSLAlphaOther(other);
1024 writeGLSLAlphaFactor(factor,local,1,other,0);
1025 strcat(fragment_shader_alpha_combiner, "gl_FragColor.a = alpha_factor * alpha_other; \n");
1026 break;
1027 case GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL:
1028 writeGLSLAlphaLocal(local);
1029 writeGLSLAlphaOther(other);
1030 writeGLSLAlphaFactor(factor,local,0,other,0);
1031 strcat(fragment_shader_alpha_combiner, "gl_FragColor.a = alpha_factor * alpha_other + alpha_local; \n");
1032 break;
1033 case GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL_ALPHA:
1034 writeGLSLAlphaLocal(local);
1035 writeGLSLAlphaOther(other);
1036 writeGLSLAlphaFactor(factor,local,0,other,0);
1037 strcat(fragment_shader_alpha_combiner, "gl_FragColor.a = alpha_factor * alpha_other + alpha_local; \n");
1038 break;
1039 case GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL:
1040 writeGLSLAlphaLocal(local);
1041 writeGLSLAlphaOther(other);
1042 writeGLSLAlphaFactor(factor,local,0,other,0);
1043 strcat(fragment_shader_alpha_combiner, "gl_FragColor.a = alpha_factor * (alpha_other - alpha_local); \n");
1044 break;
1045 case GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL:
1046 writeGLSLAlphaLocal(local);
1047 writeGLSLAlphaOther(other);
1048 writeGLSLAlphaFactor(factor,local,0,other,0);
1049 strcat(fragment_shader_alpha_combiner, "gl_FragColor.a = alpha_factor * (alpha_other - alpha_local) + alpha_local; \n");
1050 break;
1051 case GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL_ALPHA:
1052 writeGLSLAlphaLocal(local);
1053 writeGLSLAlphaOther(other);
1054 writeGLSLAlphaFactor(factor,local,0,other,0);
1055 strcat(fragment_shader_alpha_combiner, "gl_FragColor.a = alpha_factor * (alpha_other - alpha_local) + alpha_local; \n");
1056 break;
1057 case GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL:
1058 writeGLSLAlphaLocal(local);
1059 writeGLSLAlphaFactor(factor,local,0,other,1);
1060 strcat(fragment_shader_alpha_combiner, "gl_FragColor.a = alpha_factor * (-alpha_local) + alpha_local; \n");
1061 break;
1062 case GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL_ALPHA:
1063 writeGLSLAlphaLocal(local);
1064 writeGLSLAlphaFactor(factor,local,0,other,1);
1065 strcat(fragment_shader_alpha_combiner, "gl_FragColor.a = alpha_factor * (-alpha_local) + alpha_local; \n");
1066 break;
1067 default:
1068 display_warning("grAlphaCombine : unknown function : %x", function);
1069 }
1070
1071 //compile_shader();
1072 need_to_compile = 1;
1073}
1074
1075void writeGLSLTextureColorFactor(int num_tex, int factor)
1076{
1077 switch(factor)
1078 {
1079 case GR_COMBINE_FACTOR_ZERO:
1080 if(num_tex == 0)
1081 strcat(fragment_shader_texture0, "vec4 texture0_color_factor = vec4(0.0); \n");
1082 else
1083 strcat(fragment_shader_texture1, "vec4 texture1_color_factor = vec4(0.0); \n");
1084 break;
1085 case GR_COMBINE_FACTOR_LOCAL:
1086 if(num_tex == 0)
1087 strcat(fragment_shader_texture0, "vec4 texture0_color_factor = readtex0; \n");
1088 else
1089 strcat(fragment_shader_texture1, "vec4 texture1_color_factor = readtex1; \n");
1090 break;
1091 case GR_COMBINE_FACTOR_OTHER_ALPHA:
1092 if(num_tex == 0)
1093 strcat(fragment_shader_texture0, "vec4 texture0_color_factor = vec4(0.0); \n");
1094 else
1095 strcat(fragment_shader_texture1, "vec4 texture1_color_factor = vec4(ctexture0.a); \n");
1096 break;
1097 case GR_COMBINE_FACTOR_LOCAL_ALPHA:
1098 if(num_tex == 0)
1099 strcat(fragment_shader_texture0, "vec4 texture0_color_factor = vec4(readtex0.a); \n");
1100 else
1101 strcat(fragment_shader_texture1, "vec4 texture1_color_factor = vec4(readtex1.a); \n");
1102 break;
1103 case GR_COMBINE_FACTOR_DETAIL_FACTOR:
1104 if(num_tex == 0)
1105 strcat(fragment_shader_texture0, "vec4 texture0_color_factor = vec4(lambda); \n");
1106 else
1107 strcat(fragment_shader_texture1, "vec4 texture1_color_factor = vec4(lambda); \n");
1108 break;
1109 case GR_COMBINE_FACTOR_ONE:
1110 if(num_tex == 0)
1111 strcat(fragment_shader_texture0, "vec4 texture0_color_factor = vec4(1.0); \n");
1112 else
1113 strcat(fragment_shader_texture1, "vec4 texture1_color_factor = vec4(1.0); \n");
1114 break;
1115 case GR_COMBINE_FACTOR_ONE_MINUS_LOCAL:
1116 if(num_tex == 0)
1117 strcat(fragment_shader_texture0, "vec4 texture0_color_factor = vec4(1.0) - readtex0; \n");
1118 else
1119 strcat(fragment_shader_texture1, "vec4 texture1_color_factor = vec4(1.0) - readtex1; \n");
1120 break;
1121 case GR_COMBINE_FACTOR_ONE_MINUS_OTHER_ALPHA:
1122 if(num_tex == 0)
1123 strcat(fragment_shader_texture0, "vec4 texture0_color_factor = vec4(1.0) - vec4(0.0); \n");
1124 else
1125 strcat(fragment_shader_texture1, "vec4 texture1_color_factor = vec4(1.0) - vec4(ctexture0.a); \n");
1126 break;
1127 case GR_COMBINE_FACTOR_ONE_MINUS_LOCAL_ALPHA:
1128 if(num_tex == 0)
1129 strcat(fragment_shader_texture0, "vec4 texture0_color_factor = vec4(1.0) - vec4(readtex0.a); \n");
1130 else
1131 strcat(fragment_shader_texture1, "vec4 texture1_color_factor = vec4(1.0) - vec4(readtex1.a); \n");
1132 break;
1133 case GR_COMBINE_FACTOR_ONE_MINUS_DETAIL_FACTOR:
1134 if(num_tex == 0)
1135 strcat(fragment_shader_texture0, "vec4 texture0_color_factor = vec4(1.0) - vec4(lambda); \n");
1136 else
1137 strcat(fragment_shader_texture1, "vec4 texture1_color_factor = vec4(1.0) - vec4(lambda); \n");
1138 break;
1139 default:
1140 display_warning("unknown writeGLSLTextureColorFactor : %x", factor);
1141 }
1142}
1143
1144void writeGLSLTextureAlphaFactor(int num_tex, int factor)
1145{
1146 switch(factor)
1147 {
1148 case GR_COMBINE_FACTOR_ZERO:
1149 if(num_tex == 0)
1150 strcat(fragment_shader_texture0, "float texture0_alpha_factor = 0.0; \n");
1151 else
1152 strcat(fragment_shader_texture1, "float texture1_alpha_factor = 0.0; \n");
1153 break;
1154 case GR_COMBINE_FACTOR_LOCAL:
1155 if(num_tex == 0)
1156 strcat(fragment_shader_texture0, "float texture0_alpha_factor = readtex0.a; \n");
1157 else
1158 strcat(fragment_shader_texture1, "float texture1_alpha_factor = readtex1.a; \n");
1159 break;
1160 case GR_COMBINE_FACTOR_OTHER_ALPHA:
1161 if(num_tex == 0)
1162 strcat(fragment_shader_texture0, "float texture0_alpha_factor = 0.0; \n");
1163 else
1164 strcat(fragment_shader_texture1, "float texture1_alpha_factor = ctexture0.a; \n");
1165 break;
1166 case GR_COMBINE_FACTOR_LOCAL_ALPHA:
1167 if(num_tex == 0)
1168 strcat(fragment_shader_texture0, "float texture0_alpha_factor = readtex0.a; \n");
1169 else
1170 strcat(fragment_shader_texture1, "float texture1_alpha_factor = readtex1.a; \n");
1171 break;
1172 case GR_COMBINE_FACTOR_DETAIL_FACTOR:
1173 if(num_tex == 0)
1174 strcat(fragment_shader_texture0, "float texture0_alpha_factor = lambda; \n");
1175 else
1176 strcat(fragment_shader_texture1, "float texture1_alpha_factor = lambda; \n");
1177 break;
1178 case GR_COMBINE_FACTOR_ONE:
1179 if(num_tex == 0)
1180 strcat(fragment_shader_texture0, "float texture0_alpha_factor = 1.0; \n");
1181 else
1182 strcat(fragment_shader_texture1, "float texture1_alpha_factor = 1.0; \n");
1183 break;
1184 case GR_COMBINE_FACTOR_ONE_MINUS_LOCAL:
1185 if(num_tex == 0)
1186 strcat(fragment_shader_texture0, "float texture0_alpha_factor = 1.0 - readtex0.a; \n");
1187 else
1188 strcat(fragment_shader_texture1, "float texture1_alpha_factor = 1.0 - readtex1.a; \n");
1189 break;
1190 case GR_COMBINE_FACTOR_ONE_MINUS_OTHER_ALPHA:
1191 if(num_tex == 0)
1192 strcat(fragment_shader_texture0, "float texture0_alpha_factor = 1.0 - 0.0; \n");
1193 else
1194 strcat(fragment_shader_texture1, "float texture1_alpha_factor = 1.0 - ctexture0.a; \n");
1195 break;
1196 case GR_COMBINE_FACTOR_ONE_MINUS_LOCAL_ALPHA:
1197 if(num_tex == 0)
1198 strcat(fragment_shader_texture0, "float texture0_alpha_factor = 1.0 - readtex0.a; \n");
1199 else
1200 strcat(fragment_shader_texture1, "float texture1_alpha_factor = 1.0 - readtex1.a; \n");
1201 break;
1202 case GR_COMBINE_FACTOR_ONE_MINUS_DETAIL_FACTOR:
1203 if(num_tex == 0)
1204 strcat(fragment_shader_texture0, "float texture0_alpha_factor = 1.0 - lambda; \n");
1205 else
1206 strcat(fragment_shader_texture1, "float texture1_alpha_factor = 1.0 - lambda; \n");
1207 break;
1208 default:
1209 display_warning("unknown writeGLSLTextureAlphaFactor : %x", factor);
1210 }
1211}
1212
1213FX_ENTRY void FX_CALL
1214grTexCombine(
1215 GrChipID_t tmu,
1216 GrCombineFunction_t rgb_function,
1217 GrCombineFactor_t rgb_factor,
1218 GrCombineFunction_t alpha_function,
1219 GrCombineFactor_t alpha_factor,
1220 FxBool rgb_invert,
1221 FxBool alpha_invert
1222 )
1223{
1224 LOG("grTexCombine(%d,%d,%d,%d,%d,%d,%d)\r\n", tmu, rgb_function, rgb_factor, alpha_function, alpha_factor, rgb_invert, alpha_invert);
1225 int num_tex;
1226
1227 if (tmu == GR_TMU0) num_tex = 1;
1228 else num_tex = 0;
1229
1230 if(num_tex == 0)
1231 {
1232 static int last_function = 0;
1233 static int last_factor = 0;
1234 static int last_afunction = 0;
1235 static int last_afactor = 0;
1236 static int last_rgb_invert = 0;
1237
1238 if(last_function == rgb_function && last_factor == rgb_factor &&
1239 last_afunction == alpha_function && last_afactor == alpha_factor &&
1240 last_rgb_invert == rgb_invert && first_texture0 == 0 && !tex0_combiner_ext) return;
1241 first_texture0 = 0;
1242 tex0_combiner_ext = 0;
1243
1244 last_function = rgb_function;
1245 last_factor = rgb_factor;
1246 last_afunction = alpha_function;
1247 last_afactor = alpha_factor;
1248 last_rgb_invert= rgb_invert;
1249 texture0_combiner_key = rgb_function | (rgb_factor << 4) |
1250 (alpha_function << 8) | (alpha_factor << 12) |
1251 (rgb_invert << 16);
1252 texture0_combinera_key = 0;
1253 strcpy(fragment_shader_texture0, "");
1254 }
1255 else
1256 {
1257 static int last_function = 0;
1258 static int last_factor = 0;
1259 static int last_afunction = 0;
1260 static int last_afactor = 0;
1261 static int last_rgb_invert = 0;
1262
1263 if(last_function == rgb_function && last_factor == rgb_factor &&
1264 last_afunction == alpha_function && last_afactor == alpha_factor &&
1265 last_rgb_invert == rgb_invert && first_texture1 == 0 && !tex1_combiner_ext) return;
1266 first_texture1 = 0;
1267 tex1_combiner_ext = 0;
1268
1269 last_function = rgb_function;
1270 last_factor = rgb_factor;
1271 last_afunction = alpha_function;
1272 last_afactor = alpha_factor;
1273 last_rgb_invert = rgb_invert;
1274
1275 texture1_combiner_key = rgb_function | (rgb_factor << 4) |
1276 (alpha_function << 8) | (alpha_factor << 12) |
1277 (rgb_invert << 16);
1278 texture1_combinera_key = 0;
1279 strcpy(fragment_shader_texture1, "");
1280 }
1281
1282 switch(rgb_function)
1283 {
1284 case GR_COMBINE_FUNCTION_ZERO:
1285 if(num_tex == 0)
1286 strcat(fragment_shader_texture0, "vec4 ctexture0 = vec4(0.0); \n");
1287 else
1288 strcat(fragment_shader_texture1, "vec4 ctexture1 = vec4(0.0); \n");
1289 break;
1290 case GR_COMBINE_FUNCTION_LOCAL:
1291 if(num_tex == 0)
1292 strcat(fragment_shader_texture0, "vec4 ctexture0 = readtex0; \n");
1293 else
1294 strcat(fragment_shader_texture1, "vec4 ctexture1 = readtex1; \n");
1295 break;
1296 case GR_COMBINE_FUNCTION_LOCAL_ALPHA:
1297 if(num_tex == 0)
1298 strcat(fragment_shader_texture0, "vec4 ctexture0 = vec4(readtex0.a); \n");
1299 else
1300 strcat(fragment_shader_texture1, "vec4 ctexture1 = vec4(readtex1.a); \n");
1301 break;
1302 case GR_COMBINE_FUNCTION_SCALE_OTHER:
1303 writeGLSLTextureColorFactor(num_tex, rgb_factor);
1304 if(num_tex == 0)
1305 strcat(fragment_shader_texture0, "vec4 ctexture0 = texture0_color_factor * vec4(0.0); \n");
1306 else
1307 strcat(fragment_shader_texture1, "vec4 ctexture1 = texture1_color_factor * ctexture0; \n");
1308 break;
1309 case GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL:
1310 writeGLSLTextureColorFactor(num_tex, rgb_factor);
1311 if(num_tex == 0)
1312 strcat(fragment_shader_texture0, "vec4 ctexture0 = texture0_color_factor * vec4(0.0) + readtex0; \n");
1313 else
1314 strcat(fragment_shader_texture1, "vec4 ctexture1 = texture1_color_factor * ctexture0 + readtex1; \n");
1315 break;
1316 case GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL_ALPHA:
1317 writeGLSLTextureColorFactor(num_tex, rgb_factor);
1318 if(num_tex == 0)
1319 strcat(fragment_shader_texture0, "vec4 ctexture0 = texture0_color_factor * vec4(0.0) + vec4(readtex0.a); \n");
1320 else
1321 strcat(fragment_shader_texture1, "vec4 ctexture1 = texture1_color_factor * ctexture0 + vec4(readtex1.a); \n");
1322 break;
1323 case GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL:
1324 writeGLSLTextureColorFactor(num_tex, rgb_factor);
1325 if(num_tex == 0)
1326 strcat(fragment_shader_texture0, "vec4 ctexture0 = texture0_color_factor * (vec4(0.0) - readtex0); \n");
1327 else
1328 strcat(fragment_shader_texture1, "vec4 ctexture1 = texture1_color_factor * (ctexture0 - readtex1); \n");
1329 break;
1330 case GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL:
1331 writeGLSLTextureColorFactor(num_tex, rgb_factor);
1332 if(num_tex == 0)
1333 strcat(fragment_shader_texture0, "vec4 ctexture0 = texture0_color_factor * (vec4(0.0) - readtex0) + readtex0; \n");
1334 else
1335 strcat(fragment_shader_texture1, "vec4 ctexture1 = texture1_color_factor * (ctexture0 - readtex1) + readtex1; \n");
1336 break;
1337 case GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL_ALPHA:
1338 writeGLSLTextureColorFactor(num_tex, rgb_factor);
1339 if(num_tex == 0)
1340 strcat(fragment_shader_texture0, "vec4 ctexture0 = texture0_color_factor * (vec4(0.0) - readtex0) + vec4(readtex0.a); \n");
1341 else
1342 strcat(fragment_shader_texture1, "vec4 ctexture1 = texture1_color_factor * (ctexture0 - readtex1) + vec4(readtex1.a); \n");
1343 break;
1344 case GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL:
1345 writeGLSLTextureColorFactor(num_tex, rgb_factor);
1346 if(num_tex == 0)
1347 strcat(fragment_shader_texture0, "vec4 ctexture0 = texture0_color_factor * (-readtex0) + readtex0; \n");
1348 else
1349 strcat(fragment_shader_texture1, "vec4 ctexture1 = texture1_color_factor * (-readtex1) + readtex1; \n");
1350 break;
1351 case GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL_ALPHA:
1352 writeGLSLTextureColorFactor(num_tex, rgb_factor);
1353 if(num_tex == 0)
1354 strcat(fragment_shader_texture0, "vec4 ctexture0 = texture0_color_factor * (-readtex0) + vec4(readtex0.a); \n");
1355 else
1356 strcat(fragment_shader_texture1, "vec4 ctexture1 = texture1_color_factor * (-readtex1) + vec4(readtex1.a); \n");
1357 break;
1358 default:
1359 if(num_tex == 0)
1360 strcat(fragment_shader_texture0, "vec4 ctexture0 = readtex0; \n");
1361 else
1362 strcat(fragment_shader_texture1, "vec4 ctexture1 = readtex1; \n");
1363 display_warning("grTextCombine : unknown rgb function : %x", rgb_function);
1364 }
1365
1366 if (rgb_invert)
1367 {
1368 if(num_tex == 0)
1369 strcat(fragment_shader_texture0, "ctexture0 = vec4(1.0) - ctexture0; \n");
1370 else
1371 strcat(fragment_shader_texture1, "ctexture1 = vec4(1.0) - ctexture1; \n");
1372 }
1373
1374 switch(alpha_function)
1375 {
1376 case GR_COMBINE_FACTOR_ZERO:
1377 if(num_tex == 0)
1378 strcat(fragment_shader_texture0, "ctexture0.a = 0.0; \n");
1379 else
1380 strcat(fragment_shader_texture1, "ctexture1.a = 0.0; \n");
1381 break;
1382 case GR_COMBINE_FUNCTION_LOCAL:
1383 if(num_tex == 0)
1384 strcat(fragment_shader_texture0, "ctexture0.a = readtex0.a; \n");
1385 else
1386 strcat(fragment_shader_texture1, "ctexture1.a = readtex1.a; \n");
1387 break;
1388 case GR_COMBINE_FUNCTION_LOCAL_ALPHA:
1389 if(num_tex == 0)
1390 strcat(fragment_shader_texture0, "ctexture0.a = readtex0.a; \n");
1391 else
1392 strcat(fragment_shader_texture1, "ctexture1.a = readtex1.a; \n");
1393 break;
1394 case GR_COMBINE_FUNCTION_SCALE_OTHER:
1395 writeGLSLTextureAlphaFactor(num_tex, alpha_factor);
1396 if(num_tex == 0)
1397 strcat(fragment_shader_texture0, "ctexture0.a = texture0_alpha_factor * 0.0; \n");
1398 else
1399 strcat(fragment_shader_texture1, "ctexture1.a = texture1_alpha_factor * ctexture0.a; \n");
1400 break;
1401 case GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL:
1402 writeGLSLTextureAlphaFactor(num_tex, alpha_factor);
1403 if(num_tex == 0)
1404 strcat(fragment_shader_texture0, "ctexture0.a = texture0_alpha_factor * 0.0 + readtex0.a; \n");
1405 else
1406 strcat(fragment_shader_texture1, "ctexture1.a = texture1_alpha_factor * ctexture0.a + readtex1.a; \n");
1407 break;
1408 case GR_COMBINE_FUNCTION_SCALE_OTHER_ADD_LOCAL_ALPHA:
1409 writeGLSLTextureAlphaFactor(num_tex, alpha_factor);
1410 if(num_tex == 0)
1411 strcat(fragment_shader_texture0, "ctexture0.a = texture0_alpha_factor * 0.0 + readtex0.a; \n");
1412 else
1413 strcat(fragment_shader_texture1, "ctexture1.a = texture1_alpha_factor * ctexture0.a + readtex1.a; \n");
1414 break;
1415 case GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL:
1416 writeGLSLTextureAlphaFactor(num_tex, alpha_factor);
1417 if(num_tex == 0)
1418 strcat(fragment_shader_texture0, "ctexture0.a = texture0_alpha_factor * (0.0 - readtex0.a); \n");
1419 else
1420 strcat(fragment_shader_texture1, "ctexture1.a = texture1_alpha_factor * (ctexture0.a - readtex1.a); \n");
1421 break;
1422 case GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL:
1423 writeGLSLTextureAlphaFactor(num_tex, alpha_factor);
1424 if(num_tex == 0)
1425 strcat(fragment_shader_texture0, "ctexture0.a = texture0_alpha_factor * (0.0 - readtex0.a) + readtex0.a; \n");
1426 else
1427 strcat(fragment_shader_texture1, "ctexture1.a = texture1_alpha_factor * (ctexture0.a - readtex1.a) + readtex1.a; \n");
1428 break;
1429 case GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL_ALPHA:
1430 writeGLSLTextureAlphaFactor(num_tex, alpha_factor);
1431 if(num_tex == 0)
1432 strcat(fragment_shader_texture0, "ctexture0.a = texture0_alpha_factor * (0.0 - readtex0.a) + readtex0.a; \n");
1433 else
1434 strcat(fragment_shader_texture1, "ctexture1.a = texture1_alpha_factor * (ctexture0.a - readtex1.a) + readtex1.a; \n");
1435 break;
1436 case GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL:
1437 writeGLSLTextureAlphaFactor(num_tex, alpha_factor);
1438 if(num_tex == 0)
1439 strcat(fragment_shader_texture0, "ctexture0.a = texture0_alpha_factor * (-readtex0.a) + readtex0.a; \n");
1440 else
1441 strcat(fragment_shader_texture1, "ctexture1.a = texture1_alpha_factor * (-readtex1.a) + readtex1.a; \n");
1442 break;
1443 case GR_COMBINE_FUNCTION_SCALE_MINUS_LOCAL_ADD_LOCAL_ALPHA:
1444 writeGLSLTextureAlphaFactor(num_tex, alpha_factor);
1445 if(num_tex == 0)
1446 strcat(fragment_shader_texture0, "ctexture0.a = texture0_alpha_factor * (-readtex0.a) + readtex0.a; \n");
1447 else
1448 strcat(fragment_shader_texture1, "ctexture1.a = texture1_alpha_factor * (-readtex1.a) + readtex1.a; \n");
1449 break;
1450 default:
1451 if(num_tex == 0)
1452 strcat(fragment_shader_texture0, "ctexture0.a = readtex0.a; \n");
1453 else
1454 strcat(fragment_shader_texture1, "ctexture1.a = ctexture0.a; \n");
1455 display_warning("grTextCombine : unknown alpha function : %x", alpha_function);
1456 }
1457
1458 if (alpha_invert)
1459 {
1460 if(num_tex == 0)
1461 strcat(fragment_shader_texture0, "ctexture0.a = 1.0 - ctexture0.a; \n");
1462 else
1463 strcat(fragment_shader_texture1, "ctexture1.a = 1.0 - ctexture1.a; \n");
1464 }
1465 need_to_compile = 1;
1466}
1467
1468FX_ENTRY void FX_CALL
1469grAlphaBlendFunction(
1470 GrAlphaBlendFnc_t rgb_sf, GrAlphaBlendFnc_t rgb_df,
1471 GrAlphaBlendFnc_t alpha_sf, GrAlphaBlendFnc_t alpha_df
1472 )
1473{
1474 int sfactorRGB = 0, dfactorRGB = 0, sfactorAlpha = 0, dfactorAlpha = 0;
1475 LOG("grAlphaBlendFunction(%d,%d,%d,%d)\r\n", rgb_sf, rgb_df, alpha_sf, alpha_df);
1476
1477 switch(rgb_sf)
1478 {
1479 case GR_BLEND_ZERO:
1480 sfactorRGB = GL_ZERO;
1481 break;
1482 case GR_BLEND_SRC_ALPHA:
1483 sfactorRGB = GL_SRC_ALPHA;
1484 break;
1485 case GR_BLEND_ONE:
1486 sfactorRGB = GL_ONE;
1487 break;
1488 case GR_BLEND_ONE_MINUS_SRC_ALPHA:
1489 sfactorRGB = GL_ONE_MINUS_SRC_ALPHA;
1490 break;
1491 default:
1492 display_warning("grAlphaBlendFunction : rgb_sf = %x", rgb_sf);
1493 }
1494
1495 switch(rgb_df)
1496 {
1497 case GR_BLEND_ZERO:
1498 dfactorRGB = GL_ZERO;
1499 break;
1500 case GR_BLEND_SRC_ALPHA:
1501 dfactorRGB = GL_SRC_ALPHA;
1502 break;
1503 case GR_BLEND_ONE:
1504 dfactorRGB = GL_ONE;
1505 break;
1506 case GR_BLEND_ONE_MINUS_SRC_ALPHA:
1507 dfactorRGB = GL_ONE_MINUS_SRC_ALPHA;
1508 break;
1509 default:
1510 display_warning("grAlphaBlendFunction : rgb_df = %x", rgb_df);
1511 }
1512
1513 switch(alpha_sf)
1514 {
1515 case GR_BLEND_ZERO:
1516 sfactorAlpha = GL_ZERO;
1517 break;
1518 case GR_BLEND_ONE:
1519 sfactorAlpha = GL_ONE;
1520 break;
1521 default:
1522 display_warning("grAlphaBlendFunction : alpha_sf = %x", alpha_sf);
1523 }
1524
1525 switch(alpha_df)
1526 {
1527 case GR_BLEND_ZERO:
1528 dfactorAlpha = GL_ZERO;
1529 break;
1530 case GR_BLEND_ONE:
1531 dfactorAlpha = GL_ONE;
1532 break;
1533 default:
1534 display_warning("grAlphaBlendFunction : alpha_df = %x", alpha_df);
1535 }
1536 glEnable(GL_BLEND);
1537 glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
1538/*
1539 if (blend_func_separate_support)
1540 glBlendFuncSeparateEXT(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
1541 else
1542 glBlendFunc(sfactorRGB, dfactorRGB);
1543*/
1544}
1545
1546FX_ENTRY void FX_CALL
1547grAlphaTestReferenceValue( GrAlpha_t value )
1548{
1549 LOG("grAlphaTestReferenceValue(%d)\r\n", value);
1550 alpha_ref = value;
1551 grAlphaTestFunction(alpha_func);
1552}
1553
1554FX_ENTRY void FX_CALL
1555grAlphaTestFunction( GrCmpFnc_t function )
1556{
1557 LOG("grAlphaTestFunction(%d)\r\n", function);
1558 alpha_func = function;
1559 switch(function)
1560 {
1561 case GR_CMP_GREATER:
1562 //glAlphaFunc(GL_GREATER, alpha_ref/255.0f);
1563 break;
1564 case GR_CMP_GEQUAL:
1565 //glAlphaFunc(GL_GEQUAL, alpha_ref/255.0f);
1566 break;
1567 case GR_CMP_ALWAYS:
1568 //glAlphaFunc(GL_ALWAYS, alpha_ref/255.0f);
1569 //glDisable(GL_ALPHA_TEST);
1570 alpha_test = false;
1571 return;
1572 break;
1573 default:
1574 display_warning("grAlphaTestFunction : unknown function : %x", function);
1575 }
1576 //glEnable(GL_ALPHA_TEST);
1577 alpha_test = true;
1578}
1579
1580// fog
1581
1582FX_ENTRY void FX_CALL
1583grFogMode( GrFogMode_t mode )
1584{
1585 LOG("grFogMode(%d)\r\n", mode);
1586 switch(mode)
1587 {
1588 case GR_FOG_DISABLE:
1589 //glDisable(GL_FOG);
1590 fog_enabled = 0;
1591 break;
1592 case GR_FOG_WITH_TABLE_ON_Q:
1593 //glEnable(GL_FOG);
1594 //glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
1595 fog_enabled = 1;
1596 break;
1597 case GR_FOG_WITH_TABLE_ON_FOGCOORD_EXT:
1598 //glEnable(GL_FOG);
1599 //glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
1600 fog_enabled = 2;
1601 break;
1602 default:
1603 display_warning("grFogMode : unknown mode : %x", mode);
1604 }
1605 need_to_compile = 1;
1606}
1607
1608FX_ENTRY float FX_CALL
1609guFogTableIndexToW( int i )
1610{
1611 LOG("guFogTableIndexToW(%d)\r\n", i);
1612 return (float)(pow(2.0, 3.0+(double)(i>>2)) / (8-(i&3)));
1613}
1614
1615FX_ENTRY void FX_CALL
1616guFogGenerateLinear(GrFog_t *fogtable,
1617 float nearZ, float farZ )
1618{
1619 LOG("guFogGenerateLinear(%f,%f)\r\n", nearZ, farZ);
1620/*
1621 glFogi(GL_FOG_MODE, GL_LINEAR);
1622 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
1623 glFogf(GL_FOG_START, nearZ / 255.0f);
1624 glFogf(GL_FOG_END, farZ / 255.0f);
1625*/
1626 fogStart = nearZ / 255.0f;
1627 fogEnd = farZ / 255.0f;
1628}
1629
1630FX_ENTRY void FX_CALL
1631grFogTable( const GrFog_t ft[] )
1632{
1633 LOG("grFogTable()\r\n");
1634}
1635
1636FX_ENTRY void FX_CALL
1637grFogColorValue( GrColor_t fogcolor )
1638{
1639 LOG("grFogColorValue(%x)\r\n", fogcolor);
1640
1641 switch(lfb_color_fmt)
1642 {
1643 case GR_COLORFORMAT_ARGB:
1644 fogColor[3] = ((fogcolor >> 24) & 0xFF) / 255.0f;
1645 fogColor[0] = ((fogcolor >> 16) & 0xFF) / 255.0f;
1646 fogColor[1] = ((fogcolor >> 8) & 0xFF) / 255.0f;
1647 fogColor[2] = (fogcolor & 0xFF) / 255.0f;
1648 break;
1649 case GR_COLORFORMAT_RGBA:
1650 fogColor[0] = ((fogcolor >> 24) & 0xFF) / 255.0f;
1651 fogColor[1] = ((fogcolor >> 16) & 0xFF) / 255.0f;
1652 fogColor[2] = ((fogcolor >> 8) & 0xFF) / 255.0f;
1653 fogColor[3] = (fogcolor & 0xFF) / 255.0f;
1654 break;
1655 default:
1656 display_warning("grFogColorValue: unknown color format : %x", lfb_color_fmt);
1657 }
1658
1659 //glFogfv(GL_FOG_COLOR, color);
1660}
1661
1662// chroma
1663
1664FX_ENTRY void FX_CALL
1665grChromakeyMode( GrChromakeyMode_t mode )
1666{
1667 LOG("grChromakeyMode(%d)\r\n", mode);
1668 switch(mode)
1669 {
1670 case GR_CHROMAKEY_DISABLE:
1671 chroma_enabled = 0;
1672 break;
1673 case GR_CHROMAKEY_ENABLE:
1674 chroma_enabled = 1;
1675 break;
1676 default:
1677 display_warning("grChromakeyMode : unknown mode : %x", mode);
1678 }
1679 need_to_compile = 1;
1680}
1681
1682FX_ENTRY void FX_CALL
1683grChromakeyValue( GrColor_t value )
1684{
1685 LOG("grChromakeyValue(%x)\r\n", value);
1686 int chroma_color_location;
1687
1688 switch(lfb_color_fmt)
1689 {
1690 case GR_COLORFORMAT_ARGB:
1691 chroma_color[3] = 1.0;//((value >> 24) & 0xFF) / 255.0f;
1692 chroma_color[0] = ((value >> 16) & 0xFF) / 255.0f;
1693 chroma_color[1] = ((value >> 8) & 0xFF) / 255.0f;
1694 chroma_color[2] = (value & 0xFF) / 255.0f;
1695 break;
1696 case GR_COLORFORMAT_RGBA:
1697 chroma_color[0] = ((value >> 24) & 0xFF) / 255.0f;
1698 chroma_color[1] = ((value >> 16) & 0xFF) / 255.0f;
1699 chroma_color[2] = ((value >> 8) & 0xFF) / 255.0f;
1700 chroma_color[3] = 1.0;//(value & 0xFF) / 255.0f;
1701 break;
1702 default:
1703 display_warning("grChromakeyValue: unknown color format : %x", lfb_color_fmt);
1704 }
1705 vbo_draw();
1706 chroma_color_location = glGetUniformLocation(program_object, "chroma_color");
1707 glUniform4f(chroma_color_location, chroma_color[0], chroma_color[1],
1708 chroma_color[2], chroma_color[3]);
1709}
1710
1711static void setPattern()
1712{
1713 int i;
1714 GLubyte stip[32*4];
1715 for(i=0; i<32; i++)
1716 {
1717 unsigned int val = (rand() << 17) | ((rand() & 1) << 16) | (rand() << 1) | (rand() & 1);
1718 stip[i*4+0] = (val >> 24) & 0xFF;
1719 stip[i*4+1] = (val >> 16) & 0xFF;
1720 stip[i*4+2] = (val >> 8) & 0xFF;
1721 stip[i*4+3] = val & 0xFF;
1722 }
1723 GLubyte texture[32*32*4];
1724 for(i=0; i<32; i++)
1725 {
1726 int j;
1727 for(j=0; j<4; j++)
1728 {
1729 texture[(i*32+j*8+0)*4+3] = ((stip[i*4+j] >> 7) & 1) ? 255 : 0;
1730 texture[(i*32+j*8+1)*4+3] = ((stip[i*4+j] >> 6) & 1) ? 255 : 0;
1731 texture[(i*32+j*8+2)*4+3] = ((stip[i*4+j] >> 5) & 1) ? 255 : 0;
1732 texture[(i*32+j*8+3)*4+3] = ((stip[i*4+j] >> 4) & 1) ? 255 : 0;
1733 texture[(i*32+j*8+4)*4+3] = ((stip[i*4+j] >> 3) & 1) ? 255 : 0;
1734 texture[(i*32+j*8+5)*4+3] = ((stip[i*4+j] >> 2) & 1) ? 255 : 0;
1735 texture[(i*32+j*8+6)*4+3] = ((stip[i*4+j] >> 1) & 1) ? 255 : 0;
1736 texture[(i*32+j*8+7)*4+3] = ((stip[i*4+j] >> 0) & 1) ? 255 : 0;
1737 }
1738 }
1739 glActiveTexture(GL_TEXTURE2);
1740 glEnable(GL_TEXTURE_2D);
1741 glBindTexture(GL_TEXTURE_2D, 33*1024*1024);
1742 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
1743 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1744 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1745 glDisable(GL_TEXTURE_2D);
1746}
1747
1748FX_ENTRY void FX_CALL
1749grStipplePattern(
1750 GrStipplePattern_t stipple)
1751{
1752 LOG("grStipplePattern(%x)\r\n", stipple);
1753 srand(stipple);
1754 setPattern();
1755}
1756
1757FX_ENTRY void FX_CALL
1758grStippleMode( GrStippleMode_t mode )
1759{
1760 LOG("grStippleMode(%d)\r\n", mode);
1761 switch(mode)
1762 {
1763 case GR_STIPPLE_DISABLE:
1764 dither_enabled = 0;
1765 glActiveTexture(GL_TEXTURE2);
1766 glDisable(GL_TEXTURE_2D);
1767 break;
1768 case GR_STIPPLE_PATTERN:
1769 setPattern();
1770 dither_enabled = 1;
1771 glActiveTexture(GL_TEXTURE2);
1772 glEnable(GL_TEXTURE_2D);
1773 break;
1774 case GR_STIPPLE_ROTATE:
1775 setPattern();
1776 dither_enabled = 1;
1777 glActiveTexture(GL_TEXTURE2);
1778 glEnable(GL_TEXTURE_2D);
1779 break;
1780 default:
1781 display_warning("grStippleMode:%x", mode);
1782 }
1783 need_to_compile = 1;
1784}
1785
1786FX_ENTRY void FX_CALL
1787grColorCombineExt(GrCCUColor_t a, GrCombineMode_t a_mode,
1788 GrCCUColor_t b, GrCombineMode_t b_mode,
1789 GrCCUColor_t c, FxBool c_invert,
1790 GrCCUColor_t d, FxBool d_invert,
1791 FxU32 shift, FxBool invert)
1792{
1793 LOG("grColorCombineExt(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\r\n", a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
1794 if (invert) display_warning("grColorCombineExt : inverted result");
1795 if (shift) display_warning("grColorCombineExt : shift = %d", shift);
1796
1797 color_combiner_key = 0x80000000 | (a & 0x1F) | ((a_mode & 3) << 5) |
1798 ((b & 0x1F) << 7) | ((b_mode & 3) << 12) |
1799 ((c & 0x1F) << 14) | ((c_invert & 1) << 19) |
1800 ((d & 0x1F) << 20) | ((d_invert & 1) << 25);
1801 c_combiner_ext = 1;
1802 strcpy(fragment_shader_color_combiner, "");
1803
1804 switch(a)
1805 {
1806 case GR_CMBX_ZERO:
1807 strcat(fragment_shader_color_combiner, "vec4 cs_a = vec4(0.0); \n");
1808 break;
1809 case GR_CMBX_TEXTURE_ALPHA:
1810 strcat(fragment_shader_color_combiner, "vec4 cs_a = vec4(ctexture1.a); \n");
1811 break;
1812 case GR_CMBX_CONSTANT_ALPHA:
1813 strcat(fragment_shader_color_combiner, "vec4 cs_a = vec4(constant_color.a); \n");
1814 break;
1815 case GR_CMBX_CONSTANT_COLOR:
1816 strcat(fragment_shader_color_combiner, "vec4 cs_a = constant_color; \n");
1817 break;
1818 case GR_CMBX_ITALPHA:
1819 strcat(fragment_shader_color_combiner, "vec4 cs_a = vec4(gl_Color.a); \n");
1820 break;
1821 case GR_CMBX_ITRGB:
1822 strcat(fragment_shader_color_combiner, "vec4 cs_a = gl_Color; \n");
1823 break;
1824 case GR_CMBX_TEXTURE_RGB:
1825 strcat(fragment_shader_color_combiner, "vec4 cs_a = ctexture1; \n");
1826 break;
1827 default:
1828 display_warning("grColorCombineExt : a = %x", a);
1829 strcat(fragment_shader_color_combiner, "vec4 cs_a = vec4(0.0); \n");
1830 }
1831
1832 switch(a_mode)
1833 {
1834 case GR_FUNC_MODE_ZERO:
1835 strcat(fragment_shader_color_combiner, "vec4 c_a = vec4(0.0); \n");
1836 break;
1837 case GR_FUNC_MODE_X:
1838 strcat(fragment_shader_color_combiner, "vec4 c_a = cs_a; \n");
1839 break;
1840 case GR_FUNC_MODE_ONE_MINUS_X:
1841 strcat(fragment_shader_color_combiner, "vec4 c_a = vec4(1.0) - cs_a; \n");
1842 break;
1843 case GR_FUNC_MODE_NEGATIVE_X:
1844 strcat(fragment_shader_color_combiner, "vec4 c_a = -cs_a; \n");
1845 break;
1846 default:
1847 display_warning("grColorCombineExt : a_mode = %x", a_mode);
1848 strcat(fragment_shader_color_combiner, "vec4 c_a = vec4(0.0); \n");
1849 }
1850
1851 switch(b)
1852 {
1853 case GR_CMBX_ZERO:
1854 strcat(fragment_shader_color_combiner, "vec4 cs_b = vec4(0.0); \n");
1855 break;
1856 case GR_CMBX_TEXTURE_ALPHA:
1857 strcat(fragment_shader_color_combiner, "vec4 cs_b = vec4(ctexture1.a); \n");
1858 break;
1859 case GR_CMBX_CONSTANT_ALPHA:
1860 strcat(fragment_shader_color_combiner, "vec4 cs_b = vec4(constant_color.a); \n");
1861 break;
1862 case GR_CMBX_CONSTANT_COLOR:
1863 strcat(fragment_shader_color_combiner, "vec4 cs_b = constant_color; \n");
1864 break;
1865 case GR_CMBX_ITALPHA:
1866 strcat(fragment_shader_color_combiner, "vec4 cs_b = vec4(gl_Color.a); \n");
1867 break;
1868 case GR_CMBX_ITRGB:
1869 strcat(fragment_shader_color_combiner, "vec4 cs_b = gl_Color; \n");
1870 break;
1871 case GR_CMBX_TEXTURE_RGB:
1872 strcat(fragment_shader_color_combiner, "vec4 cs_b = ctexture1; \n");
1873 break;
1874 default:
1875 display_warning("grColorCombineExt : b = %x", b);
1876 strcat(fragment_shader_color_combiner, "vec4 cs_b = vec4(0.0); \n");
1877 }
1878
1879 switch(b_mode)
1880 {
1881 case GR_FUNC_MODE_ZERO:
1882 strcat(fragment_shader_color_combiner, "vec4 c_b = vec4(0.0); \n");
1883 break;
1884 case GR_FUNC_MODE_X:
1885 strcat(fragment_shader_color_combiner, "vec4 c_b = cs_b; \n");
1886 break;
1887 case GR_FUNC_MODE_ONE_MINUS_X:
1888 strcat(fragment_shader_color_combiner, "vec4 c_b = vec4(1.0) - cs_b; \n");
1889 break;
1890 case GR_FUNC_MODE_NEGATIVE_X:
1891 strcat(fragment_shader_color_combiner, "vec4 c_b = -cs_b; \n");
1892 break;
1893 default:
1894 display_warning("grColorCombineExt : b_mode = %x", b_mode);
1895 strcat(fragment_shader_color_combiner, "vec4 c_b = vec4(0.0); \n");
1896 }
1897
1898 switch(c)
1899 {
1900 case GR_CMBX_ZERO:
1901 strcat(fragment_shader_color_combiner, "vec4 c_c = vec4(0.0); \n");
1902 break;
1903 case GR_CMBX_TEXTURE_ALPHA:
1904 strcat(fragment_shader_color_combiner, "vec4 c_c = vec4(ctexture1.a); \n");
1905 break;
1906 case GR_CMBX_ALOCAL:
1907 strcat(fragment_shader_color_combiner, "vec4 c_c = vec4(c_b.a); \n");
1908 break;
1909 case GR_CMBX_AOTHER:
1910 strcat(fragment_shader_color_combiner, "vec4 c_c = vec4(c_a.a); \n");
1911 break;
1912 case GR_CMBX_B:
1913 strcat(fragment_shader_color_combiner, "vec4 c_c = cs_b; \n");
1914 break;
1915 case GR_CMBX_CONSTANT_ALPHA:
1916 strcat(fragment_shader_color_combiner, "vec4 c_c = vec4(constant_color.a); \n");
1917 break;
1918 case GR_CMBX_CONSTANT_COLOR:
1919 strcat(fragment_shader_color_combiner, "vec4 c_c = constant_color; \n");
1920 break;
1921 case GR_CMBX_ITALPHA:
1922 strcat(fragment_shader_color_combiner, "vec4 c_c = vec4(gl_Color.a); \n");
1923 break;
1924 case GR_CMBX_ITRGB:
1925 strcat(fragment_shader_color_combiner, "vec4 c_c = gl_Color; \n");
1926 break;
1927 case GR_CMBX_TEXTURE_RGB:
1928 strcat(fragment_shader_color_combiner, "vec4 c_c = ctexture1; \n");
1929 break;
1930 default:
1931 display_warning("grColorCombineExt : c = %x", c);
1932 strcat(fragment_shader_color_combiner, "vec4 c_c = vec4(0.0); \n");
1933 }
1934
1935 if(c_invert)
1936 strcat(fragment_shader_color_combiner, "c_c = vec4(1.0) - c_c; \n");
1937
1938 switch(d)
1939 {
1940 case GR_CMBX_ZERO:
1941 strcat(fragment_shader_color_combiner, "vec4 c_d = vec4(0.0); \n");
1942 break;
1943 case GR_CMBX_ALOCAL:
1944 strcat(fragment_shader_color_combiner, "vec4 c_d = vec4(c_b.a); \n");
1945 break;
1946 case GR_CMBX_B:
1947 strcat(fragment_shader_color_combiner, "vec4 c_d = cs_b; \n");
1948 break;
1949 case GR_CMBX_TEXTURE_RGB:
1950 strcat(fragment_shader_color_combiner, "vec4 c_d = ctexture1; \n");
1951 break;
1952 case GR_CMBX_ITRGB:
1953 strcat(fragment_shader_color_combiner, "vec4 c_d = gl_Color; \n");
1954 break;
1955 default:
1956 display_warning("grColorCombineExt : d = %x", d);
1957 strcat(fragment_shader_color_combiner, "vec4 c_d = vec4(0.0); \n");
1958 }
1959
1960 if(d_invert)
1961 strcat(fragment_shader_color_combiner, "c_d = vec4(1.0) - c_d; \n");
1962
1963 strcat(fragment_shader_color_combiner, "gl_FragColor = (c_a + c_b) * c_c + c_d; \n");
1964
1965 need_to_compile = 1;
1966}
1967
1968FX_ENTRY void FX_CALL
1969grAlphaCombineExt(GrACUColor_t a, GrCombineMode_t a_mode,
1970 GrACUColor_t b, GrCombineMode_t b_mode,
1971 GrACUColor_t c, FxBool c_invert,
1972 GrACUColor_t d, FxBool d_invert,
1973 FxU32 shift, FxBool invert)
1974{
1975 LOG("grAlphaCombineExt(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)\r\n", a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
1976 if (invert) display_warning("grAlphaCombineExt : inverted result");
1977 if (shift) display_warning("grAlphaCombineExt : shift = %d", shift);
1978
1979 alpha_combiner_key = 0x80000000 | (a & 0x1F) | ((a_mode & 3) << 5) |
1980 ((b & 0x1F) << 7) | ((b_mode & 3) << 12) |
1981 ((c & 0x1F) << 14) | ((c_invert & 1) << 19) |
1982 ((d & 0x1F) << 20) | ((d_invert & 1) << 25);
1983 a_combiner_ext = 1;
1984 strcpy(fragment_shader_alpha_combiner, "");
1985
1986 switch(a)
1987 {
1988 case GR_CMBX_ZERO:
1989 strcat(fragment_shader_alpha_combiner, "float as_a = 0.0; \n");
1990 break;
1991 case GR_CMBX_TEXTURE_ALPHA:
1992 strcat(fragment_shader_alpha_combiner, "float as_a = ctexture1.a; \n");
1993 break;
1994 case GR_CMBX_CONSTANT_ALPHA:
1995 strcat(fragment_shader_alpha_combiner, "float as_a = constant_color.a; \n");
1996 break;
1997 case GR_CMBX_ITALPHA:
1998 strcat(fragment_shader_alpha_combiner, "float as_a = gl_Color.a; \n");
1999 break;
2000 default:
2001 display_warning("grAlphaCombineExt : a = %x", a);
2002 strcat(fragment_shader_alpha_combiner, "float as_a = 0.0; \n");
2003 }
2004
2005 switch(a_mode)
2006 {
2007 case GR_FUNC_MODE_ZERO:
2008 strcat(fragment_shader_alpha_combiner, "float a_a = 0.0; \n");
2009 break;
2010 case GR_FUNC_MODE_X:
2011 strcat(fragment_shader_alpha_combiner, "float a_a = as_a; \n");
2012 break;
2013 case GR_FUNC_MODE_ONE_MINUS_X:
2014 strcat(fragment_shader_alpha_combiner, "float a_a = 1.0 - as_a; \n");
2015 break;
2016 case GR_FUNC_MODE_NEGATIVE_X:
2017 strcat(fragment_shader_alpha_combiner, "float a_a = -as_a; \n");
2018 break;
2019 default:
2020 display_warning("grAlphaCombineExt : a_mode = %x", a_mode);
2021 strcat(fragment_shader_alpha_combiner, "float a_a = 0.0; \n");
2022 }
2023
2024 switch(b)
2025 {
2026 case GR_CMBX_ZERO:
2027 strcat(fragment_shader_alpha_combiner, "float as_b = 0.0; \n");
2028 break;
2029 case GR_CMBX_TEXTURE_ALPHA:
2030 strcat(fragment_shader_alpha_combiner, "float as_b = ctexture1.a; \n");
2031 break;
2032 case GR_CMBX_CONSTANT_ALPHA:
2033 strcat(fragment_shader_alpha_combiner, "float as_b = constant_color.a; \n");
2034 break;
2035 case GR_CMBX_ITALPHA:
2036 strcat(fragment_shader_alpha_combiner, "float as_b = gl_Color.a; \n");
2037 break;
2038 default:
2039 display_warning("grAlphaCombineExt : b = %x", b);
2040 strcat(fragment_shader_alpha_combiner, "float as_b = 0.0; \n");
2041 }
2042
2043 switch(b_mode)
2044 {
2045 case GR_FUNC_MODE_ZERO:
2046 strcat(fragment_shader_alpha_combiner, "float a_b = 0.0; \n");
2047 break;
2048 case GR_FUNC_MODE_X:
2049 strcat(fragment_shader_alpha_combiner, "float a_b = as_b; \n");
2050 break;
2051 case GR_FUNC_MODE_ONE_MINUS_X:
2052 strcat(fragment_shader_alpha_combiner, "float a_b = 1.0 - as_b; \n");
2053 break;
2054 case GR_FUNC_MODE_NEGATIVE_X:
2055 strcat(fragment_shader_alpha_combiner, "float a_b = -as_b; \n");
2056 break;
2057 default:
2058 display_warning("grAlphaCombineExt : b_mode = %x", b_mode);
2059 strcat(fragment_shader_alpha_combiner, "float a_b = 0.0; \n");
2060 }
2061
2062 switch(c)
2063 {
2064 case GR_CMBX_ZERO:
2065 strcat(fragment_shader_alpha_combiner, "float a_c = 0.0; \n");
2066 break;
2067 case GR_CMBX_TEXTURE_ALPHA:
2068 strcat(fragment_shader_alpha_combiner, "float a_c = ctexture1.a; \n");
2069 break;
2070 case GR_CMBX_ALOCAL:
2071 strcat(fragment_shader_alpha_combiner, "float a_c = as_b; \n");
2072 break;
2073 case GR_CMBX_AOTHER:
2074 strcat(fragment_shader_alpha_combiner, "float a_c = as_a; \n");
2075 break;
2076 case GR_CMBX_B:
2077 strcat(fragment_shader_alpha_combiner, "float a_c = as_b; \n");
2078 break;
2079 case GR_CMBX_CONSTANT_ALPHA:
2080 strcat(fragment_shader_alpha_combiner, "float a_c = constant_color.a; \n");
2081 break;
2082 case GR_CMBX_ITALPHA:
2083 strcat(fragment_shader_alpha_combiner, "float a_c = gl_Color.a; \n");
2084 break;
2085 default:
2086 display_warning("grAlphaCombineExt : c = %x", c);
2087 strcat(fragment_shader_alpha_combiner, "float a_c = 0.0; \n");
2088 }
2089
2090 if(c_invert)
2091 strcat(fragment_shader_alpha_combiner, "a_c = 1.0 - a_c; \n");
2092
2093 switch(d)
2094 {
2095 case GR_CMBX_ZERO:
2096 strcat(fragment_shader_alpha_combiner, "float a_d = 0.0; \n");
2097 break;
2098 case GR_CMBX_TEXTURE_ALPHA:
2099 strcat(fragment_shader_alpha_combiner, "float a_d = ctexture1.a; \n");
2100 break;
2101 case GR_CMBX_ALOCAL:
2102 strcat(fragment_shader_alpha_combiner, "float a_d = as_b; \n");
2103 break;
2104 case GR_CMBX_B:
2105 strcat(fragment_shader_alpha_combiner, "float a_d = as_b; \n");
2106 break;
2107 default:
2108 display_warning("grAlphaCombineExt : d = %x", d);
2109 strcat(fragment_shader_alpha_combiner, "float a_d = 0.0; \n");
2110 }
2111
2112 if(d_invert)
2113 strcat(fragment_shader_alpha_combiner, "a_d = 1.0 - a_d; \n");
2114
2115 strcat(fragment_shader_alpha_combiner, "gl_FragColor.a = (a_a + a_b) * a_c + a_d; \n");
2116
2117 need_to_compile = 1;
2118}
2119
2120FX_ENTRY void FX_CALL
2121grTexColorCombineExt(GrChipID_t tmu,
2122 GrTCCUColor_t a, GrCombineMode_t a_mode,
2123 GrTCCUColor_t b, GrCombineMode_t b_mode,
2124 GrTCCUColor_t c, FxBool c_invert,
2125 GrTCCUColor_t d, FxBool d_invert,
2126 FxU32 shift, FxBool invert)
2127{
2128 int num_tex;
2129 LOG("grTexColorCombineExt(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)\r\n", tmu, a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
2130
2131 if (invert) display_warning("grTexColorCombineExt : inverted result");
2132 if (shift) display_warning("grTexColorCombineExt : shift = %d", shift);
2133
2134 if (tmu == GR_TMU0) num_tex = 1;
2135 else num_tex = 0;
2136
2137 if(num_tex == 0)
2138 {
2139 texture0_combiner_key = 0x80000000 | (a & 0x1F) | ((a_mode & 3) << 5) |
2140 ((b & 0x1F) << 7) | ((b_mode & 3) << 12) |
2141 ((c & 0x1F) << 14) | ((c_invert & 1) << 19) |
2142 ((d & 0x1F) << 20) | ((d_invert & 1) << 25);
2143 tex0_combiner_ext = 1;
2144 strcpy(fragment_shader_texture0, "");
2145 }
2146 else
2147 {
2148 texture1_combiner_key = 0x80000000 | (a & 0x1F) | ((a_mode & 3) << 5) |
2149 ((b & 0x1F) << 7) | ((b_mode & 3) << 12) |
2150 ((c & 0x1F) << 14) | ((c_invert & 1) << 19) |
2151 ((d & 0x1F) << 20) | ((d_invert & 1) << 25);
2152 tex1_combiner_ext = 1;
2153 strcpy(fragment_shader_texture1, "");
2154 }
2155
2156 switch(a)
2157 {
2158 case GR_CMBX_ZERO:
2159 if(num_tex == 0)
2160 strcat(fragment_shader_texture0, "vec4 ctex0s_a = vec4(0.0); \n");
2161 else
2162 strcat(fragment_shader_texture1, "vec4 ctex1s_a = vec4(0.0); \n");
2163 break;
2164 case GR_CMBX_ITALPHA:
2165 if(num_tex == 0)
2166 strcat(fragment_shader_texture0, "vec4 ctex0s_a = vec4(gl_Color.a); \n");
2167 else
2168 strcat(fragment_shader_texture1, "vec4 ctex1s_a = vec4(gl_Color.a); \n");
2169 break;
2170 case GR_CMBX_ITRGB:
2171 if(num_tex == 0)
2172 strcat(fragment_shader_texture0, "vec4 ctex0s_a = gl_Color; \n");
2173 else
2174 strcat(fragment_shader_texture1, "vec4 ctex1s_a = gl_Color; \n");
2175 break;
2176 case GR_CMBX_LOCAL_TEXTURE_ALPHA:
2177 if(num_tex == 0)
2178 strcat(fragment_shader_texture0, "vec4 ctex0s_a = vec4(readtex0.a); \n");
2179 else
2180 strcat(fragment_shader_texture1, "vec4 ctex1s_a = vec4(readtex1.a); \n");
2181 break;
2182 case GR_CMBX_LOCAL_TEXTURE_RGB:
2183 if(num_tex == 0)
2184 strcat(fragment_shader_texture0, "vec4 ctex0s_a = readtex0; \n");
2185 else
2186 strcat(fragment_shader_texture1, "vec4 ctex1s_a = readtex1; \n");
2187 break;
2188 case GR_CMBX_OTHER_TEXTURE_ALPHA:
2189 if(num_tex == 0)
2190 strcat(fragment_shader_texture0, "vec4 ctex0s_a = vec4(0.0); \n");
2191 else
2192 strcat(fragment_shader_texture1, "vec4 ctex1s_a = vec4(ctexture0.a); \n");
2193 break;
2194 case GR_CMBX_OTHER_TEXTURE_RGB:
2195 if(num_tex == 0)
2196 strcat(fragment_shader_texture0, "vec4 ctex0s_a = vec4(0.0); \n");
2197 else
2198 strcat(fragment_shader_texture1, "vec4 ctex1s_a = ctexture0; \n");
2199 break;
2200 case GR_CMBX_TMU_CCOLOR:
2201 if(num_tex == 0)
2202 strcat(fragment_shader_texture0, "vec4 ctex0s_a = ccolor0; \n");
2203 else
2204 strcat(fragment_shader_texture1, "vec4 ctex1s_a = ccolor1; \n");
2205 break;
2206 case GR_CMBX_TMU_CALPHA:
2207 if(num_tex == 0)
2208 strcat(fragment_shader_texture0, "vec4 ctex0s_a = vec4(ccolor0.a); \n");
2209 else
2210 strcat(fragment_shader_texture1, "vec4 ctex1s_a = vec4(ccolor1.a); \n");
2211 break;
2212 default:
2213 display_warning("grTexColorCombineExt : a = %x", a);
2214 if(num_tex == 0)
2215 strcat(fragment_shader_texture0, "vec4 ctex0s_a = vec4(0.0); \n");
2216 else
2217 strcat(fragment_shader_texture1, "vec4 ctex1s_a = vec4(0.0); \n");
2218 }
2219
2220 switch(a_mode)
2221 {
2222 case GR_FUNC_MODE_ZERO:
2223 if(num_tex == 0)
2224 strcat(fragment_shader_texture0, "vec4 ctex0_a = vec4(0.0); \n");
2225 else
2226 strcat(fragment_shader_texture1, "vec4 ctex1_a = vec4(0.0); \n");
2227 break;
2228 case GR_FUNC_MODE_X:
2229 if(num_tex == 0)
2230 strcat(fragment_shader_texture0, "vec4 ctex0_a = ctex0s_a; \n");
2231 else
2232 strcat(fragment_shader_texture1, "vec4 ctex1_a = ctex1s_a; \n");
2233 break;
2234 case GR_FUNC_MODE_ONE_MINUS_X:
2235 if(num_tex == 0)
2236 strcat(fragment_shader_texture0, "vec4 ctex0_a = vec4(1.0) - ctex0s_a; \n");
2237 else
2238 strcat(fragment_shader_texture1, "vec4 ctex1_a = vec4(1.0) - ctex1s_a; \n");
2239 break;
2240 case GR_FUNC_MODE_NEGATIVE_X:
2241 if(num_tex == 0)
2242 strcat(fragment_shader_texture0, "vec4 ctex0_a = -ctex0s_a; \n");
2243 else
2244 strcat(fragment_shader_texture1, "vec4 ctex1_a = -ctex1s_a; \n");
2245 break;
2246 default:
2247 display_warning("grTexColorCombineExt : a_mode = %x", a_mode);
2248 if(num_tex == 0)
2249 strcat(fragment_shader_texture0, "vec4 ctex0_a = vec4(0.0); \n");
2250 else
2251 strcat(fragment_shader_texture1, "vec4 ctex1_a = vec4(0.0); \n");
2252 }
2253
2254 switch(b)
2255 {
2256 case GR_CMBX_ZERO:
2257 if(num_tex == 0)
2258 strcat(fragment_shader_texture0, "vec4 ctex0s_b = vec4(0.0); \n");
2259 else
2260 strcat(fragment_shader_texture1, "vec4 ctex1s_b = vec4(0.0); \n");
2261 break;
2262 case GR_CMBX_ITALPHA:
2263 if(num_tex == 0)
2264 strcat(fragment_shader_texture0, "vec4 ctex0s_b = vec4(gl_Color.a); \n");
2265 else
2266 strcat(fragment_shader_texture1, "vec4 ctex1s_b = vec4(gl_Color.a); \n");
2267 break;
2268 case GR_CMBX_ITRGB:
2269 if(num_tex == 0)
2270 strcat(fragment_shader_texture0, "vec4 ctex0s_b = gl_Color; \n");
2271 else
2272 strcat(fragment_shader_texture1, "vec4 ctex1s_b = gl_Color; \n");
2273 break;
2274 case GR_CMBX_LOCAL_TEXTURE_ALPHA:
2275 if(num_tex == 0)
2276 strcat(fragment_shader_texture0, "vec4 ctex0s_b = vec4(readtex0.a); \n");
2277 else
2278 strcat(fragment_shader_texture1, "vec4 ctex1s_b = vec4(readtex1.a); \n");
2279 break;
2280 case GR_CMBX_LOCAL_TEXTURE_RGB:
2281 if(num_tex == 0)
2282 strcat(fragment_shader_texture0, "vec4 ctex0s_b = readtex0; \n");
2283 else
2284 strcat(fragment_shader_texture1, "vec4 ctex1s_b = readtex1; \n");
2285 break;
2286 case GR_CMBX_OTHER_TEXTURE_ALPHA:
2287 if(num_tex == 0)
2288 strcat(fragment_shader_texture0, "vec4 ctex0s_b = vec4(0.0); \n");
2289 else
2290 strcat(fragment_shader_texture1, "vec4 ctex1s_b = vec4(ctexture0.a); \n");
2291 break;
2292 case GR_CMBX_OTHER_TEXTURE_RGB:
2293 if(num_tex == 0)
2294 strcat(fragment_shader_texture0, "vec4 ctex0s_b = vec4(0.0); \n");
2295 else
2296 strcat(fragment_shader_texture1, "vec4 ctex1s_b = ctexture0; \n");
2297 break;
2298 case GR_CMBX_TMU_CALPHA:
2299 if(num_tex == 0)
2300 strcat(fragment_shader_texture0, "vec4 ctex0s_b = vec4(ccolor0.a); \n");
2301 else
2302 strcat(fragment_shader_texture1, "vec4 ctex1s_b = vec4(ccolor1.a); \n");
2303 break;
2304 case GR_CMBX_TMU_CCOLOR:
2305 if(num_tex == 0)
2306 strcat(fragment_shader_texture0, "vec4 ctex0s_b = ccolor0; \n");
2307 else
2308 strcat(fragment_shader_texture1, "vec4 ctex1s_b = ccolor1; \n");
2309 break;
2310 default:
2311 display_warning("grTexColorCombineExt : b = %x", b);
2312 if(num_tex == 0)
2313 strcat(fragment_shader_texture0, "vec4 ctex0s_b = vec4(0.0); \n");
2314 else
2315 strcat(fragment_shader_texture1, "vec4 ctex1s_b = vec4(0.0); \n");
2316 }
2317
2318 switch(b_mode)
2319 {
2320 case GR_FUNC_MODE_ZERO:
2321 if(num_tex == 0)
2322 strcat(fragment_shader_texture0, "vec4 ctex0_b = vec4(0.0); \n");
2323 else
2324 strcat(fragment_shader_texture1, "vec4 ctex1_b = vec4(0.0); \n");
2325 break;
2326 case GR_FUNC_MODE_X:
2327 if(num_tex == 0)
2328 strcat(fragment_shader_texture0, "vec4 ctex0_b = ctex0s_b; \n");
2329 else
2330 strcat(fragment_shader_texture1, "vec4 ctex1_b = ctex1s_b; \n");
2331 break;
2332 case GR_FUNC_MODE_ONE_MINUS_X:
2333 if(num_tex == 0)
2334 strcat(fragment_shader_texture0, "vec4 ctex0_b = vec4(1.0) - ctex0s_b; \n");
2335 else
2336 strcat(fragment_shader_texture1, "vec4 ctex1_b = vec4(1.0) - ctex1s_b; \n");
2337 break;
2338 case GR_FUNC_MODE_NEGATIVE_X:
2339 if(num_tex == 0)
2340 strcat(fragment_shader_texture0, "vec4 ctex0_b = -ctex0s_b; \n");
2341 else
2342 strcat(fragment_shader_texture1, "vec4 ctex1_b = -ctex1s_b; \n");
2343 break;
2344 default:
2345 display_warning("grTexColorCombineExt : b_mode = %x", b_mode);
2346 if(num_tex == 0)
2347 strcat(fragment_shader_texture0, "vec4 ctex0_b = vec4(0.0); \n");
2348 else
2349 strcat(fragment_shader_texture1, "vec4 ctex1_b = vec4(0.0); \n");
2350 }
2351
2352 switch(c)
2353 {
2354 case GR_CMBX_ZERO:
2355 if(num_tex == 0)
2356 strcat(fragment_shader_texture0, "vec4 ctex0_c = vec4(0.0); \n");
2357 else
2358 strcat(fragment_shader_texture1, "vec4 ctex1_c = vec4(0.0); \n");
2359 break;
2360 case GR_CMBX_B:
2361 if(num_tex == 0)
2362 strcat(fragment_shader_texture0, "vec4 ctex0_c = ctex0s_b; \n");
2363 else
2364 strcat(fragment_shader_texture1, "vec4 ctex1_c = ctex1s_b; \n");
2365 break;
2366 case GR_CMBX_DETAIL_FACTOR:
2367 if(num_tex == 0)
2368 strcat(fragment_shader_texture0, "vec4 ctex0_c = vec4(lambda); \n");
2369 else
2370 strcat(fragment_shader_texture1, "vec4 ctex1_c = vec4(lambda); \n");
2371 break;
2372 case GR_CMBX_ITRGB:
2373 if(num_tex == 0)
2374 strcat(fragment_shader_texture0, "vec4 ctex0_c = gl_Color; \n");
2375 else
2376 strcat(fragment_shader_texture1, "vec4 ctex1_c = gl_Color; \n");
2377 break;
2378 case GR_CMBX_ITALPHA:
2379 if(num_tex == 0)
2380 strcat(fragment_shader_texture0, "vec4 ctex0_c = vec4(gl_Color.a); \n");
2381 else
2382 strcat(fragment_shader_texture1, "vec4 ctex1_c = vec4(gl_Color.a); \n");
2383 break;
2384 case GR_CMBX_LOCAL_TEXTURE_ALPHA:
2385 if(num_tex == 0)
2386 strcat(fragment_shader_texture0, "vec4 ctex0_c = vec4(readtex0.a); \n");
2387 else
2388 strcat(fragment_shader_texture1, "vec4 ctex1_c = vec4(readtex1.a); \n");
2389 break;
2390 case GR_CMBX_LOCAL_TEXTURE_RGB:
2391 if(num_tex == 0)
2392 strcat(fragment_shader_texture0, "vec4 ctex0_c = readtex0; \n");
2393 else
2394 strcat(fragment_shader_texture1, "vec4 ctex1_c = readtex1; \n");
2395 break;
2396 case GR_CMBX_OTHER_TEXTURE_ALPHA:
2397 if(num_tex == 0)
2398 strcat(fragment_shader_texture0, "vec4 ctex0_c = vec4(0.0); \n");
2399 else
2400 strcat(fragment_shader_texture1, "vec4 ctex1_c = vec4(ctexture0.a); \n");
2401 break;
2402 case GR_CMBX_OTHER_TEXTURE_RGB:
2403 if(num_tex == 0)
2404 strcat(fragment_shader_texture0, "vec4 ctex0_c = vec4(0.0); \n");
2405 else
2406 strcat(fragment_shader_texture1, "vec4 ctex1_c = ctexture0; \n");
2407 break;
2408 case GR_CMBX_TMU_CALPHA:
2409 if(num_tex == 0)
2410 strcat(fragment_shader_texture0, "vec4 ctex0_c = vec4(ccolor0.a); \n");
2411 else
2412 strcat(fragment_shader_texture1, "vec4 ctex1_c = vec4(ccolor1.a); \n");
2413 break;
2414 case GR_CMBX_TMU_CCOLOR:
2415 if(num_tex == 0)
2416 strcat(fragment_shader_texture0, "vec4 ctex0_c = ccolor0; \n");
2417 else
2418 strcat(fragment_shader_texture1, "vec4 ctex1_c = ccolor1; \n");
2419 break;
2420 default:
2421 display_warning("grTexColorCombineExt : c = %x", c);
2422 if(num_tex == 0)
2423 strcat(fragment_shader_texture0, "vec4 ctex0_c = vec4(0.0); \n");
2424 else
2425 strcat(fragment_shader_texture1, "vec4 ctex1_c = vec4(0.0); \n");
2426 }
2427
2428 if(c_invert)
2429 {
2430 if(num_tex == 0)
2431 strcat(fragment_shader_texture0, "ctex0_c = vec4(1.0) - ctex0_c; \n");
2432 else
2433 strcat(fragment_shader_texture1, "ctex1_c = vec4(1.0) - ctex1_c; \n");
2434 }
2435
2436 switch(d)
2437 {
2438 case GR_CMBX_ZERO:
2439 if(num_tex == 0)
2440 strcat(fragment_shader_texture0, "vec4 ctex0_d = vec4(0.0); \n");
2441 else
2442 strcat(fragment_shader_texture1, "vec4 ctex1_d = vec4(0.0); \n");
2443 break;
2444 case GR_CMBX_B:
2445 if(num_tex == 0)
2446 strcat(fragment_shader_texture0, "vec4 ctex0_d = ctex0s_b; \n");
2447 else
2448 strcat(fragment_shader_texture1, "vec4 ctex1_d = ctex1s_b; \n");
2449 break;
2450 case GR_CMBX_ITRGB:
2451 if(num_tex == 0)
2452 strcat(fragment_shader_texture0, "vec4 ctex0_d = gl_Color; \n");
2453 else
2454 strcat(fragment_shader_texture1, "vec4 ctex1_d = gl_Color; \n");
2455 break;
2456 case GR_CMBX_LOCAL_TEXTURE_ALPHA:
2457 if(num_tex == 0)
2458 strcat(fragment_shader_texture0, "vec4 ctex0_d = vec4(readtex0.a); \n");
2459 else
2460 strcat(fragment_shader_texture1, "vec4 ctex1_d = vec4(readtex1.a); \n");
2461 break;
2462 default:
2463 display_warning("grTexColorCombineExt : d = %x", d);
2464 if(num_tex == 0)
2465 strcat(fragment_shader_texture0, "vec4 ctex0_d = vec4(0.0); \n");
2466 else
2467 strcat(fragment_shader_texture1, "vec4 ctex1_d = vec4(0.0); \n");
2468 }
2469
2470 if(d_invert)
2471 {
2472 if(num_tex == 0)
2473 strcat(fragment_shader_texture0, "ctex0_d = vec4(1.0) - ctex0_d; \n");
2474 else
2475 strcat(fragment_shader_texture1, "ctex1_d = vec4(1.0) - ctex1_d; \n");
2476 }
2477
2478 if(num_tex == 0)
2479 strcat(fragment_shader_texture0, "vec4 ctexture0 = (ctex0_a + ctex0_b) * ctex0_c + ctex0_d; \n");
2480 else
2481 strcat(fragment_shader_texture1, "vec4 ctexture1 = (ctex1_a + ctex1_b) * ctex1_c + ctex1_d; \n");
2482 need_to_compile = 1;
2483}
2484
2485FX_ENTRY void FX_CALL
2486grTexAlphaCombineExt(GrChipID_t tmu,
2487 GrTACUColor_t a, GrCombineMode_t a_mode,
2488 GrTACUColor_t b, GrCombineMode_t b_mode,
2489 GrTACUColor_t c, FxBool c_invert,
2490 GrTACUColor_t d, FxBool d_invert,
2491 FxU32 shift, FxBool invert)
2492{
2493 int num_tex;
2494 LOG("grTexAlphaCombineExt(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)\r\n", tmu, a, a_mode, b, b_mode, c, c_invert, d, d_invert, shift, invert);
2495
2496 if (invert) display_warning("grTexAlphaCombineExt : inverted result");
2497 if (shift) display_warning("grTexAlphaCombineExt : shift = %d", shift);
2498
2499 if (tmu == GR_TMU0) num_tex = 1;
2500 else num_tex = 0;
2501
2502 if(num_tex == 0)
2503 {
2504 texture0_combinera_key = 0x80000000 | (a & 0x1F) | ((a_mode & 3) << 5) |
2505 ((b & 0x1F) << 7) | ((b_mode & 3) << 12) |
2506 ((c & 0x1F) << 14) | ((c_invert & 1) << 19) |
2507 ((d & 0x1F) << 20) | ((d_invert & 1) << 25);
2508 }
2509 else
2510 {
2511 texture1_combinera_key = 0x80000000 | (a & 0x1F) | ((a_mode & 3) << 5) |
2512 ((b & 0x1F) << 7) | ((b_mode & 3) << 12) |
2513 ((c & 0x1F) << 14) | ((c_invert & 1) << 19) |
2514 ((d & 0x1F) << 20) | ((d_invert & 1) << 25);
2515 }
2516
2517 switch(a)
2518 {
2519 case GR_CMBX_ITALPHA:
2520 if(num_tex == 0)
2521 strcat(fragment_shader_texture0, "ctex0s_a.a = gl_Color.a; \n");
2522 else
2523 strcat(fragment_shader_texture1, "ctex1s_a.a = gl_Color.a; \n");
2524 break;
2525 case GR_CMBX_LOCAL_TEXTURE_ALPHA:
2526 if(num_tex == 0)
2527 strcat(fragment_shader_texture0, "ctex0s_a.a = readtex0.a; \n");
2528 else
2529 strcat(fragment_shader_texture1, "ctex1s_a.a = readtex1.a; \n");
2530 break;
2531 case GR_CMBX_OTHER_TEXTURE_ALPHA:
2532 if(num_tex == 0)
2533 strcat(fragment_shader_texture0, "ctex0s_a.a = 0.0; \n");
2534 else
2535 strcat(fragment_shader_texture1, "ctex1s_a.a = ctexture0.a; \n");
2536 break;
2537 case GR_CMBX_TMU_CALPHA:
2538 if(num_tex == 0)
2539 strcat(fragment_shader_texture0, "ctex0s_a.a = ccolor0.a; \n");
2540 else
2541 strcat(fragment_shader_texture1, "ctex1s_a.a = ccolor1.a; \n");
2542 break;
2543 default:
2544 display_warning("grTexAlphaCombineExt : a = %x", a);
2545 if(num_tex == 0)
2546 strcat(fragment_shader_texture0, "ctex0s_a.a = 0.0; \n");
2547 else
2548 strcat(fragment_shader_texture1, "ctex1s_a.a = 0.0; \n");
2549 }
2550
2551 switch(a_mode)
2552 {
2553 case GR_FUNC_MODE_ZERO:
2554 if(num_tex == 0)
2555 strcat(fragment_shader_texture0, "ctex0_a.a = 0.0; \n");
2556 else
2557 strcat(fragment_shader_texture1, "ctex1_a.a = 0.0; \n");
2558 break;
2559 case GR_FUNC_MODE_X:
2560 if(num_tex == 0)
2561 strcat(fragment_shader_texture0, "ctex0_a.a = ctex0s_a.a; \n");
2562 else
2563 strcat(fragment_shader_texture1, "ctex1_a.a = ctex1s_a.a; \n");
2564 break;
2565 case GR_FUNC_MODE_ONE_MINUS_X:
2566 if(num_tex == 0)
2567 strcat(fragment_shader_texture0, "ctex0_a.a = 1.0 - ctex0s_a.a; \n");
2568 else
2569 strcat(fragment_shader_texture1, "ctex1_a.a = 1.0 - ctex1s_a.a; \n");
2570 break;
2571 case GR_FUNC_MODE_NEGATIVE_X:
2572 if(num_tex == 0)
2573 strcat(fragment_shader_texture0, "ctex0_a.a = -ctex0s_a.a; \n");
2574 else
2575 strcat(fragment_shader_texture1, "ctex1_a.a = -ctex1s_a.a; \n");
2576 break;
2577 default:
2578 display_warning("grTexAlphaCombineExt : a_mode = %x", a_mode);
2579 if(num_tex == 0)
2580 strcat(fragment_shader_texture0, "ctex0_a.a = 0.0; \n");
2581 else
2582 strcat(fragment_shader_texture1, "ctex1_a.a = 0.0; \n");
2583 }
2584
2585 switch(b)
2586 {
2587 case GR_CMBX_ITALPHA:
2588 if(num_tex == 0)
2589 strcat(fragment_shader_texture0, "ctex0s_b.a = gl_Color.a; \n");
2590 else
2591 strcat(fragment_shader_texture1, "ctex1s_b.a = gl_Color.a; \n");
2592 break;
2593 case GR_CMBX_LOCAL_TEXTURE_ALPHA:
2594 if(num_tex == 0)
2595 strcat(fragment_shader_texture0, "ctex0s_b.a = readtex0.a; \n");
2596 else
2597 strcat(fragment_shader_texture1, "ctex1s_b.a = readtex1.a; \n");
2598 break;
2599 case GR_CMBX_OTHER_TEXTURE_ALPHA:
2600 if(num_tex == 0)
2601 strcat(fragment_shader_texture0, "ctex0s_b.a = 0.0; \n");
2602 else
2603 strcat(fragment_shader_texture1, "ctex1s_b.a = ctexture0.a; \n");
2604 break;
2605 case GR_CMBX_TMU_CALPHA:
2606 if(num_tex == 0)
2607 strcat(fragment_shader_texture0, "ctex0s_b.a = ccolor0.a; \n");
2608 else
2609 strcat(fragment_shader_texture1, "ctex1s_b.a = ccolor1.a; \n");
2610 break;
2611 default:
2612 display_warning("grTexAlphaCombineExt : b = %x", b);
2613 if(num_tex == 0)
2614 strcat(fragment_shader_texture0, "ctex0s_b.a = 0.0; \n");
2615 else
2616 strcat(fragment_shader_texture1, "ctex1s_b.a = 0.0; \n");
2617 }
2618
2619 switch(b_mode)
2620 {
2621 case GR_FUNC_MODE_ZERO:
2622 if(num_tex == 0)
2623 strcat(fragment_shader_texture0, "ctex0_b.a = 0.0; \n");
2624 else
2625 strcat(fragment_shader_texture1, "ctex1_b.a = 0.0; \n");
2626 break;
2627 case GR_FUNC_MODE_X:
2628 if(num_tex == 0)
2629 strcat(fragment_shader_texture0, "ctex0_b.a = ctex0s_b.a; \n");
2630 else
2631 strcat(fragment_shader_texture1, "ctex1_b.a = ctex1s_b.a; \n");
2632 break;
2633 case GR_FUNC_MODE_ONE_MINUS_X:
2634 if(num_tex == 0)
2635 strcat(fragment_shader_texture0, "ctex0_b.a = 1.0 - ctex0s_b.a; \n");
2636 else
2637 strcat(fragment_shader_texture1, "ctex1_b.a = 1.0 - ctex1s_b.a; \n");
2638 break;
2639 case GR_FUNC_MODE_NEGATIVE_X:
2640 if(num_tex == 0)
2641 strcat(fragment_shader_texture0, "ctex0_b.a = -ctex0s_b.a; \n");
2642 else
2643 strcat(fragment_shader_texture1, "ctex1_b.a = -ctex1s_b.a; \n");
2644 break;
2645 default:
2646 display_warning("grTexAlphaCombineExt : b_mode = %x", b_mode);
2647 if(num_tex == 0)
2648 strcat(fragment_shader_texture0, "ctex0_b.a = 0.0; \n");
2649 else
2650 strcat(fragment_shader_texture1, "ctex1_b.a = 0.0; \n");
2651 }
2652
2653 switch(c)
2654 {
2655 case GR_CMBX_ZERO:
2656 if(num_tex == 0)
2657 strcat(fragment_shader_texture0, "ctex0_c.a = 0.0; \n");
2658 else
2659 strcat(fragment_shader_texture1, "ctex1_c.a = 0.0; \n");
2660 break;
2661 case GR_CMBX_B:
2662 if(num_tex == 0)
2663 strcat(fragment_shader_texture0, "ctex0_c.a = ctex0s_b.a; \n");
2664 else
2665 strcat(fragment_shader_texture1, "ctex1_c.a = ctex1s_b.a; \n");
2666 break;
2667 case GR_CMBX_DETAIL_FACTOR:
2668 if(num_tex == 0)
2669 strcat(fragment_shader_texture0, "ctex0_c.a = lambda; \n");
2670 else
2671 strcat(fragment_shader_texture1, "ctex1_c.a = lambda; \n");
2672 break;
2673 case GR_CMBX_ITALPHA:
2674 if(num_tex == 0)
2675 strcat(fragment_shader_texture0, "ctex0_c.a = gl_Color.a; \n");
2676 else
2677 strcat(fragment_shader_texture1, "ctex1_c.a = gl_Color.a; \n");
2678 break;
2679 case GR_CMBX_LOCAL_TEXTURE_ALPHA:
2680 if(num_tex == 0)
2681 strcat(fragment_shader_texture0, "ctex0_c.a = readtex0.a; \n");
2682 else
2683 strcat(fragment_shader_texture1, "ctex1_c.a = readtex1.a; \n");
2684 break;
2685 case GR_CMBX_OTHER_TEXTURE_ALPHA:
2686 if(num_tex == 0)
2687 strcat(fragment_shader_texture0, "ctex0_c.a = 0.0; \n");
2688 else
2689 strcat(fragment_shader_texture1, "ctex1_c.a = ctexture0.a; \n");
2690 break;
2691 case GR_CMBX_TMU_CALPHA:
2692 if(num_tex == 0)
2693 strcat(fragment_shader_texture0, "ctex0_c.a = ccolor0.a; \n");
2694 else
2695 strcat(fragment_shader_texture1, "ctex1_c.a = ccolor1.a; \n");
2696 break;
2697 default:
2698 display_warning("grTexAlphaCombineExt : c = %x", c);
2699 if(num_tex == 0)
2700 strcat(fragment_shader_texture0, "ctex0_c.a = 0.0; \n");
2701 else
2702 strcat(fragment_shader_texture1, "ctex1_c.a = 0.0; \n");
2703 }
2704
2705 if(c_invert)
2706 {
2707 if(num_tex == 0)
2708 strcat(fragment_shader_texture0, "ctex0_c.a = 1.0 - ctex0_c.a; \n");
2709 else
2710 strcat(fragment_shader_texture1, "ctex1_c.a = 1.0 - ctex1_c.a; \n");
2711 }
2712
2713 switch(d)
2714 {
2715 case GR_CMBX_ZERO:
2716 if(num_tex == 0)
2717 strcat(fragment_shader_texture0, "ctex0_d.a = 0.0; \n");
2718 else
2719 strcat(fragment_shader_texture1, "ctex1_d.a = 0.0; \n");
2720 break;
2721 case GR_CMBX_B:
2722 if(num_tex == 0)
2723 strcat(fragment_shader_texture0, "ctex0_d.a = ctex0s_b.a; \n");
2724 else
2725 strcat(fragment_shader_texture1, "ctex1_d.a = ctex1s_b.a; \n");
2726 break;
2727 case GR_CMBX_ITALPHA:
2728 if(num_tex == 0)
2729 strcat(fragment_shader_texture0, "ctex0_d.a = gl_Color.a; \n");
2730 else
2731 strcat(fragment_shader_texture1, "ctex1_d.a = gl_Color.a; \n");
2732 break;
2733 case GR_CMBX_ITRGB:
2734 if(num_tex == 0)
2735 strcat(fragment_shader_texture0, "ctex0_d.a = gl_Color.a; \n");
2736 else
2737 strcat(fragment_shader_texture1, "ctex1_d.a = gl_Color.a; \n");
2738 break;
2739 case GR_CMBX_LOCAL_TEXTURE_ALPHA:
2740 if(num_tex == 0)
2741 strcat(fragment_shader_texture0, "ctex0_d.a = readtex0.a; \n");
2742 else
2743 strcat(fragment_shader_texture1, "ctex1_d.a = readtex1.a; \n");
2744 break;
2745 default:
2746 display_warning("grTexAlphaCombineExt : d = %x", d);
2747 if(num_tex == 0)
2748 strcat(fragment_shader_texture0, "ctex0_d.a = 0.0; \n");
2749 else
2750 strcat(fragment_shader_texture1, "ctex1_d.a = 0.0; \n");
2751 }
2752
2753 if(d_invert)
2754 {
2755 if(num_tex == 0)
2756 strcat(fragment_shader_texture0, "ctex0_d.a = 1.0 - ctex0_d.a; \n");
2757 else
2758 strcat(fragment_shader_texture1, "ctex1_d.a = 1.0 - ctex1_d.a; \n");
2759 }
2760
2761 if(num_tex == 0)
2762 strcat(fragment_shader_texture0, "ctexture0.a = (ctex0_a.a + ctex0_b.a) * ctex0_c.a + ctex0_d.a; \n");
2763 else
2764 strcat(fragment_shader_texture1, "ctexture1.a = (ctex1_a.a + ctex1_b.a) * ctex1_c.a + ctex1_d.a; \n");
2765
2766 need_to_compile = 1;
2767}
2768
2769FX_ENTRY void FX_CALL
2770grConstantColorValueExt(GrChipID_t tmu,
2771 GrColor_t value)
2772{
2773 int num_tex;
2774 LOG("grConstantColorValueExt(%d,%d)\r\n", tmu, value);
2775
2776 if (tmu == GR_TMU0) num_tex = 1;
2777 else num_tex = 0;
2778
2779 switch(lfb_color_fmt)
2780 {
2781 case GR_COLORFORMAT_ARGB:
2782 if(num_tex == 0)
2783 {
2784 ccolor0[3] = ((value >> 24) & 0xFF) / 255.0f;
2785 ccolor0[0] = ((value >> 16) & 0xFF) / 255.0f;
2786 ccolor0[1] = ((value >> 8) & 0xFF) / 255.0f;
2787 ccolor0[2] = (value & 0xFF) / 255.0f;
2788 }
2789 else
2790 {
2791 ccolor1[3] = ((value >> 24) & 0xFF) / 255.0f;
2792 ccolor1[0] = ((value >> 16) & 0xFF) / 255.0f;
2793 ccolor1[1] = ((value >> 8) & 0xFF) / 255.0f;
2794 ccolor1[2] = (value & 0xFF) / 255.0f;
2795 }
2796 break;
2797 case GR_COLORFORMAT_RGBA:
2798 if(num_tex == 0)
2799 {
2800 ccolor0[0] = ((value >> 24) & 0xFF) / 255.0f;
2801 ccolor0[1] = ((value >> 16) & 0xFF) / 255.0f;
2802 ccolor0[2] = ((value >> 8) & 0xFF) / 255.0f;
2803 ccolor0[3] = (value & 0xFF) / 255.0f;
2804 }
2805 else
2806 {
2807 ccolor1[0] = ((value >> 24) & 0xFF) / 255.0f;
2808 ccolor1[1] = ((value >> 16) & 0xFF) / 255.0f;
2809 ccolor1[2] = ((value >> 8) & 0xFF) / 255.0f;
2810 ccolor1[3] = (value & 0xFF) / 255.0f;
2811 }
2812 break;
2813 default:
2814 display_warning("grConstantColorValue: unknown color format : %x", lfb_color_fmt);
2815 }
2816
2817 vbo_draw();
2818 if(num_tex == 0)
2819 {
2820 ccolor0_location = glGetUniformLocation(program_object, "ccolor0");
2821 glUniform4f(ccolor0_location, ccolor0[0], ccolor0[1], ccolor0[2], ccolor0[3]);
2822 }
2823 else
2824 {
2825 ccolor1_location = glGetUniformLocation(program_object, "ccolor1");
2826 glUniform4f(ccolor1_location, ccolor1[0], ccolor1[1], ccolor1[2], ccolor1[3]);
2827 }
2828}
Unnamed repository; edit this file 'description' to name the repository.