source: trunk/neercs/video/render.cpp @ 1459

Last change on this file since 1459 was 1459, checked in by sam, 8 years ago

neercs: some refactoring.

File size: 27.5 KB
Line 
1//
2// Neercs
3//
4
5#if defined HAVE_CONFIG_H
6#   include "config.h"
7#endif
8
9#if defined _XBOX
10#   define _USE_MATH_DEFINES /* for M_PI */
11#   include <xtl.h>
12#elif defined _WIN32
13#   define _USE_MATH_DEFINES /* for M_PI */
14#   define WIN32_LEAN_AND_MEAN
15#   include <windows.h>
16#endif
17
18#include <cmath>
19#include <cstdio>
20#include <cstdlib>
21#include <ctime>
22#include <string>
23
24#include "core.h"
25#include "lolgl.h"
26
27using namespace std;
28using namespace lol;
29
30#include "../neercs.h"
31#include "render.h"
32
33extern char const *lolfx_blurh;
34extern char const *lolfx_blurv;
35extern char const *lolfx_glow;
36extern char const *lolfx_postfx;
37extern char const *lolfx_radial;
38extern char const *lolfx_simple;
39
40#define WIN32_LEAN_AND_MEAN
41#define DEBUG 1            // debug flag //#if defined(_DEBUG)
42#define SHADER 1           // shader flag
43#define PI 3.1415926535f   // pi
44#define PID PI/180.0f      // pi ratio
45#define CR 1.0f/256.0f     // color ratio
46
47bool done = false;
48
49Timer *timer;
50
51//char *param=GetCommandLine();
52
53int keys[256];             // keyboard array
54int active = true;         // window active flag
55bool fullscreen = DEBUG?false:true;    // fullscreen flag
56bool pause = false;        // pause flag
57float nearplane = 0.1f;    // nearplane
58float farplane = 1000.0f;  // farplane
59bool polygon = true;       // polygon mode
60int polygon_fillmode = GL_FILL; // fill mode
61int ratio_2d = 4;          // 2d ratio
62/* window variable */
63int base_w = 800;          // base width
64int base_h = 600;          // base height
65int window_w = base_w;     // width
66int window_h = base_h;     // height
67ivec2 screen_size;         // screen size
68int window_color = 32;     // color depth
69float screen_r;            // color red
70float screen_g;            // color green
71float screen_b;            // color blue
72/* object variable */
73float main_angle;          // main angle
74float part_angle;          // part angle
75float fx_angle;            // current angle
76/* liner variable */
77int car;                   // ascii code
78int car_cursor = 126;      // cursor ascii code
79int liner_length;          // text length
80int liner_line_n;          // line number
81int liner_line;            // line increment
82int liner_max;             // line max length
83int liner_i;               // char increment
84int liner_count;           // counter
85/* text variable */
86char *name = "cacaShell";
87std::string txt("");
88/* fs_quad variable */
89float fs_quad_vtx[] = {-1.0f, 1.0f, 0, 1.0f, -1.0f, -1.0f, 0, 1.0f, 1.0f, -1.0f, 0, 1.0f, 1.0f, 1.0f, 0, 1.0f};
90float fs_quad_tex[] = {0, 1.0f, 0, 0, 1.0f, 0, 1.0f, 1.0f};
91/* flash variable */
92bool flash_flag = false;   // flag
93float flash_angle = 0;     // angle
94float flash_value = 0;     // value
95float flash_speed;         // speed
96/* fade variable */
97bool fade_flag = false;    // flag
98float fade_angle = 0;      // angle
99float fade_value = 0;      // value
100float fade_speed;          // speed
101/* debug variable */
102bool debug_flag = false;   // flag
103int debug_x;               // position x
104int debug_y;               // position y
105int debug_w;               // width
106int debug_h;               // height
107int debug_vtx[8];          // vertex array
108/* sync variable */
109bool sync_flag = false;    // flag
110float sync_angle = 0;      // angle
111float sync_value = 0;      // value
112float sync_speed;          // speed
113/* beat variable */
114bool beat_flag = false;    // flag
115float beat_angle = 0;      // angle
116float beat_value = 0;      // value
117float beat_speed;          // speed
118/* corner variable */
119const int corner_n = 10;   // polygon number
120int corner_w = 24;         // radius
121int corner_vtx[corner_n*6];// vertex array
122/* dos variable */
123bool dos_flag = false;     // flag
124int dos_w;                 // width
125int dos_h;                 // height
126int dos_m;                 // margin
127float dos_r;               // red value
128float dos_g;               // green value
129float dos_b;               // blue value
130int dos_vtx[8];            // vertex array
131int shell_vtx[8];          // vertex array
132float shell_tex[] = {1.0f, 0.96875f, 1.0f, 1.0f, 0.78125f, 1.0f, 0.78125f, 0.96875f};
133/* keyboard variable */
134int key_code = 0;          // keyboard code
135/* common variable */
136int i, j, k, l;
137float x, y, z, w, h;
138float r, g, b, c;
139float value, angle, radius, scale, speed;
140TileSet *tex_map;
141/* shader variable */
142bool shader_flag = SHADER?true:false;
143bool shader_blur_flag = SHADER?true:false;
144bool shader_effect_flag = SHADER?true:false;
145bool shader_glow_flag = true;
146int glow_fbo_size = 2;     // glow fbo size
147int glow_color;            // 0 = color/1 = alpha
148float glow_smoothstep;     // glow smoothstep value
149float glow_mix_ratio1;     // glow mixing ratio
150float glow_mix_ratio2;     // source mixing ratio
151bool shader_radial_flag = false;
152float radial_value1;
153float radial_value2;
154float radial_color;        // color
155bool shader_postfx_flag = SHADER?true:false;
156bool postfx_scanline = true;
157float postfx_deform;       // deformation ratio
158#if SHADER
159Shader *shader_simple, *shader_blur_h, *shader_blur_v;
160Shader *shader_glow, *shader_radial, *shader_postfx;
161// shader variables
162ShaderUniform shader_simple_texture;
163ShaderUniform shader_blur_h_texture,
164              shader_blur_h_screen_size,
165              shader_blur_h_time,
166              shader_blur_h_value;
167ShaderUniform shader_blur_v_texture,
168              shader_blur_v_screen_size,
169              shader_blur_v_time,
170              shader_blur_v_value;
171ShaderUniform shader_glow_texture,
172              shader_glow_texture_prv,
173              shader_glow_screen_size,
174              shader_glow_time,
175              shader_glow_step,
176              shader_glow_value1,
177              shader_glow_value2;
178ShaderUniform shader_radial_texture,
179              shader_radial_screen_size,
180              shader_radial_time,
181              shader_radial_value1,
182              shader_radial_value2,
183              shader_radial_color;
184ShaderUniform shader_postfx_texture,
185              shader_postfx_texture_2d,
186              shader_postfx_screen_size,
187              shader_postfx_time,
188              shader_postfx_flash,
189              shader_postfx_value,
190              shader_postfx_deform,
191              shader_postfx_scanline,
192              shader_postfx_sync;
193
194FrameBuffer *fbo_back, *fbo_front, *fbo_blur_h, *fbo_blur_v;
195FrameBuffer *fbo_ping, *fbo_pong;
196#endif
197
198void init_viewport(int type)
199{
200    glViewport(0, 0, screen_size.x, screen_size.y);
201    glMatrixMode(GL_PROJECTION);
202    glLoadIdentity();
203    mat4 proj = (type == 0) ? mat4::perspective(70, (float)screen_size.x, (float)screen_size.y, nearplane, farplane) : mat4::ortho(0, screen_size.x, screen_size.y, 0);
204    glLoadMatrixf(&proj[0][0]);
205    glMatrixMode(GL_MODELVIEW);
206}
207
208#if SHADER
209void init_shader()
210{
211    glDisable(GL_BLEND);
212    glVertexPointer(4, GL_FLOAT, 0, fs_quad_vtx);
213    glTexCoordPointer(2, GL_FLOAT, 0, fs_quad_tex);
214}
215
216void fs_quad()
217{
218    glLoadIdentity();
219    glDrawArrays(GL_QUADS, 0, 4);
220}
221
222void draw_shader_simple(FrameBuffer *fbo_output, int n)
223{
224    shader_simple->Bind();
225    shader_simple->SetTexture(shader_simple_texture, fbo_output->GetTexture(), n);
226    fs_quad();
227    shader_simple->Unbind();
228}
229#endif
230
231void calc_txt()
232{
233    liner_length = txt.length();
234    liner_count = 0;
235    liner_line_n = 0;
236    liner_max = 0;
237    liner_i = 0;
238    for(i = 0;i<liner_length;i++)
239    {
240        if((unsigned char)txt[i] != 13)
241        {
242            liner_i++;
243        }
244        else
245        {
246            if(liner_i>liner_max) liner_max = liner_i;
247            liner_line_n++;
248            liner_i = 0;
249        }
250    }
251    if(liner_i>liner_max) liner_max = liner_i;
252}
253
254void rectangle(int x, int y, int w, int h)
255{
256    glLoadIdentity();
257    glBegin(GL_QUADS);
258        glVertex2i(x+w, y  );
259        glVertex2i(x  , y  );
260        glVertex2i(x  , y+h);
261        glVertex2i(x+w, y+h);
262    glEnd();
263}
264
265void corner()
266{
267    float vertex[2+corner_n*2];
268    vertex[0] = 0;
269    vertex[1] = 0;
270    for(i = 1;i<corner_n+1;i++)
271    {
272        j = i*2;
273        float a = PID*90.0f/(corner_n-1)*(i-1);
274        vertex[j  ] = corner_w-corner_w*cosf(a);
275        vertex[j+1] = corner_w-corner_w*sinf(a);
276    }
277    for(i = 0;i<corner_n;i++)
278    {
279        j = i*6;
280        k = i*2;
281        corner_vtx[j  ] = (int)vertex[0];
282        corner_vtx[j+1] = (int)vertex[1];
283        corner_vtx[j+2] = (int)vertex[2+k];
284        corner_vtx[j+3] = (int)vertex[3+k];
285        corner_vtx[j+4] = (int)vertex[4+k];
286        corner_vtx[j+5] = (int)vertex[5+k];
287    }
288}
289
290void screen()
291{
292    part_angle = main_angle;
293    dos_flag = true;
294    dos_r = CR*48;
295    dos_g = CR*56;
296    dos_b = CR*64;
297    screen_r = dos_r;
298    screen_g = dos_g;
299    screen_b = dos_b;
300    txt = "\rCopyright \x05e 2012 cacaShell v0.1\r ";
301    calc_txt();
302    /*-------------------------*/
303    shader_effect_flag = true;
304    shader_glow_flag = true;
305    glow_color = 1;
306    glow_smoothstep = 0;//.025f;
307    glow_mix_ratio1 = 0.5f;
308    glow_mix_ratio2 = 0.5f;
309    shader_radial_flag = false;
310    radial_value1 = 2.0f;
311    radial_value2 = 0.8f;
312    radial_color = 0;
313    postfx_deform = 0.5f;
314    /*-------------------------*/
315    flash_speed = 1.5f;
316    fade_speed = 0.2f;
317    sync_flag = false;
318    sync_value = 1.0f;
319    sync_speed = 1.0f;
320    beat_speed = 2.0f;
321    /*-------------------------*/
322    glClearColor(screen_r, screen_g, screen_b, 1.0f);
323}
324
325int InitGL(void)
326{
327    glClearDepth(1.0f);                                // set depth buffer
328    glDepthMask(GL_TRUE);                            // do not write z-buffer
329    glEnable(GL_CULL_FACE);                        // disable cull face
330    glCullFace(GL_BACK);                            // don't draw front face
331    glEnableClientState(GL_VERTEX_ARRAY);
332    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
333    // load texture
334    tex_map = new TileSet("neercs/video/resource/map.png", ivec2(256, 256), ivec2(1));
335    // initialize some variable
336    timer = new Timer();
337    screen();
338    /*-PATACODE----------------------------------------------------------------*/
339#if SHADER
340    if (shader_flag)
341    {
342        fbo_back = new FrameBuffer(screen_size);
343        fbo_front = new FrameBuffer(screen_size);
344        fbo_blur_h = new FrameBuffer(screen_size / glow_fbo_size);
345        fbo_blur_v = new FrameBuffer(screen_size / glow_fbo_size);
346        fbo_ping = new FrameBuffer(screen_size);
347        fbo_pong = new FrameBuffer(screen_size);
348        // shader simple
349        shader_simple = Shader::Create(lolfx_simple);
350        shader_simple_texture = shader_simple->GetUniformLocation("texture");
351        // shader blur horizontal
352        shader_blur_h = Shader::Create(lolfx_blurh);
353        shader_blur_h_texture = shader_blur_h->GetUniformLocation("texture");
354        shader_blur_h_screen_size = shader_blur_h->GetUniformLocation("screen_size");
355        shader_blur_h_time = shader_blur_h->GetUniformLocation("time");
356        shader_blur_h_value = shader_blur_h->GetUniformLocation("value");
357        // shader blur vertical
358        shader_blur_v = Shader::Create(lolfx_blurv);
359        shader_blur_v_texture = shader_blur_v->GetUniformLocation("texture");
360        shader_blur_v_screen_size = shader_blur_v->GetUniformLocation("screen_size");
361        shader_blur_v_time = shader_blur_v->GetUniformLocation("time");
362        shader_blur_v_value = shader_blur_v->GetUniformLocation("value");
363        // shader glow
364        shader_glow = Shader::Create(lolfx_glow);
365        shader_glow_texture = shader_glow->GetUniformLocation("texture");
366        shader_glow_texture_prv = shader_glow->GetUniformLocation("texture_prv");
367        shader_glow_screen_size = shader_glow->GetUniformLocation("screen_size");
368        shader_glow_time = shader_glow->GetUniformLocation("time");
369        shader_glow_step = shader_glow->GetUniformLocation("step");
370        shader_glow_value1 = shader_glow->GetUniformLocation("value1");
371        shader_glow_value2 = shader_glow->GetUniformLocation("value2");
372        // shader radial
373        shader_radial = Shader::Create(lolfx_radial);
374        shader_radial_texture = shader_radial->GetUniformLocation("texture");
375        shader_radial_screen_size = shader_radial->GetUniformLocation("screen_size");
376        shader_radial_time = shader_radial->GetUniformLocation("time");
377        shader_radial_value1 = shader_radial->GetUniformLocation("value1");
378        shader_radial_value2 = shader_radial->GetUniformLocation("value2");
379        shader_radial_color = shader_radial->GetUniformLocation("color");
380        // shader postfx
381        shader_postfx = Shader::Create(lolfx_postfx);
382        shader_postfx_texture = shader_postfx->GetUniformLocation("texture");
383        shader_postfx_texture_2d = shader_postfx->GetUniformLocation("texture_2d");
384        shader_postfx_screen_size = shader_postfx->GetUniformLocation("screen_size");
385        shader_postfx_time = shader_postfx->GetUniformLocation("time");
386        shader_postfx_flash = shader_postfx->GetUniformLocation("flash");
387        shader_postfx_value = shader_postfx->GetUniformLocation("value");
388        shader_postfx_deform = shader_postfx->GetUniformLocation("deform");
389        shader_postfx_scanline = shader_postfx->GetUniformLocation("scanline");
390        shader_postfx_sync = shader_postfx->GetUniformLocation("sync");
391    }
392#endif
393    /*-/PATACODE---------------------------------------------------------------*/
394    return true;
395}
396
397int CreateGLWindow(char* title)
398{
399    screen_size = Video::GetSize();
400    //ratio_2d = (int)(screen_size.x/400); if(ratio_2d<2) ratio_2d = 2;
401    corner_w = 16*ratio_2d;
402    corner();
403    dos_w = 2*ratio_2d;
404    dos_h = 4*ratio_2d;
405    dos_m = 12*ratio_2d;
406    dos_vtx[0] = dos_w;
407    dos_vtx[1] = dos_h;
408    dos_vtx[2] = dos_w;
409    dos_vtx[3] = -dos_h;
410    dos_vtx[4] = -dos_w;
411    dos_vtx[5] = -dos_h;
412    dos_vtx[6] = -dos_w;
413    dos_vtx[7] = dos_h;
414    shell_vtx[0] = dos_m+29*ratio_2d;
415    shell_vtx[1] = dos_m+9*ratio_2d;
416    shell_vtx[2] = dos_m+29*ratio_2d;
417    shell_vtx[3] = dos_m+1*ratio_2d;
418    shell_vtx[4] = dos_m+1*ratio_2d;
419    shell_vtx[5] = dos_m+1*ratio_2d;
420    shell_vtx[6] = dos_m+1*ratio_2d;
421    shell_vtx[7] = dos_m+9*ratio_2d;
422    debug_w = 5*ratio_2d;
423    debug_h = 5*ratio_2d;
424    debug_x = 10*ratio_2d;
425    debug_y = 28*ratio_2d;
426    debug_vtx[0] = debug_w;
427    debug_vtx[1] = debug_h;
428    debug_vtx[2] = debug_w;
429    debug_vtx[3] = -debug_h;
430    debug_vtx[4] = -debug_w;
431    debug_vtx[5] = -debug_h;
432    debug_vtx[6] = -debug_w;
433    debug_vtx[7] = debug_h;
434    InitGL();
435    return true;
436}
437
438Render::Render()
439{
440}
441
442void Render::TickGame(float seconds)
443{
444    Entity::TickGame(seconds);
445}
446
447void Render::TickDraw(float seconds)
448{
449    Entity::TickDraw(seconds);
450
451    static int todo = 1;
452    if (todo)
453    {
454        CreateGLWindow("LOL");
455        todo = 0;
456    }
457
458    // timer
459    if(!pause)
460        main_angle += timer->Get() * 100.0f * PID;
461    if(sync_flag)
462    {
463        angle=(main_angle-sync_angle)*sync_speed;
464        sync_value=1.0f-sinf(angle);
465        if(angle>90.0f*PID)
466        {
467            sync_value=0;
468            sync_flag=false;
469        }
470    }
471    if(beat_flag)
472    {
473        angle=(main_angle-beat_angle)*beat_speed;
474        beat_value=1.0f-sinf(angle);
475        if(angle>90.0f*PID)
476        {
477            beat_value=0;
478            beat_flag=false;
479        }
480    }
481    if(flash_flag)
482    {
483        angle=(main_angle-flash_angle)*flash_speed;
484        flash_value=1.0f-sinf(angle);
485        if(angle>90.0f*PID)
486        {
487            flash_value=0;
488            flash_flag=false;
489        }
490    }
491    if(fade_flag)
492    {
493        angle=(main_angle-fade_angle)*fade_speed;
494        fade_value=1.0f-sinf(angle);
495        if(angle>90.0f*PID)
496        {
497            fade_value=0;
498            fade_flag=false;
499        }
500    }
501    /*-PATACODE----------------------------------------------------------------*/
502    #if SHADER
503    if(shader_flag)
504    {
505        fbo_back->Bind();
506        fbo_back->Clear(vec4(screen_r, screen_g, screen_b, 0.0f), 1.0f);
507    }
508    else
509    {
510        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
511    }
512    #else
513    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
514    #endif
515    /*-/PATACODE---------------------------------------------------------------*/
516    glEnable(GL_BLEND);
517    //if(polygon) glEnable(GL_LINE_SMOOTH); else glDisable(GL_LINE_SMOOTH);
518    glLineWidth((polygon)?2.0f:1.0f);
519    fx_angle=main_angle-part_angle;
520    if(polygon) glEnable(GL_TEXTURE_2D);
521    /* .-------------------. */
522    /* | DRAW SOME 2D HERE | */
523    /* °-------------------° */
524    init_viewport(1);
525    tex_map->Bind();
526    glEnable(GL_BLEND);
527    // draw dos
528    if(dos_flag)
529    {
530        glDisable(GL_TEXTURE_2D);
531        glDisable(GL_BLEND);
532        glColor3f(1.0f, 1.0f, 1.0f);
533        rectangle(dos_m, dos_m, screen_size.x-(int)(26.5f*ratio_2d)-dos_m*2, 10*ratio_2d);
534        rectangle(screen_size.x-(int)(25.5f*ratio_2d)-dos_m, dos_m, 11*ratio_2d, 10*ratio_2d);
535        rectangle(screen_size.x-(int)(13.5f*ratio_2d)-dos_m, dos_m, 11*ratio_2d, 10*ratio_2d);
536        rectangle(screen_size.x-(int)(1.5f*ratio_2d)-dos_m, dos_m, (int)(1.5f*ratio_2d), 10*ratio_2d);
537        rectangle(dos_m, dos_m+10*ratio_2d, 1*ratio_2d, screen_size.y-10*ratio_2d-dos_m*2);
538        rectangle(screen_size.x-1*ratio_2d-dos_m, dos_m+10*ratio_2d, 1*ratio_2d, screen_size.y-10*ratio_2d-dos_m*2);
539        rectangle(dos_m+1*ratio_2d, screen_size.y-1*ratio_2d-dos_m, screen_size.x-2*ratio_2d-dos_m*2, 1*ratio_2d);
540        glColor3f(dos_r, dos_g, dos_b);
541        rectangle(dos_m+1*ratio_2d, dos_m+1*ratio_2d, 28*ratio_2d, 8*ratio_2d);
542        rectangle(dos_m+(int)(30.5f*ratio_2d), dos_m+2*ratio_2d, screen_size.x-(int)(58.5f*ratio_2d)-dos_m*2, 2*ratio_2d);
543        rectangle(dos_m+(int)(30.5f*ratio_2d), dos_m+6*ratio_2d, screen_size.x-(int)(58.5f*ratio_2d)-dos_m*2, 2*ratio_2d);
544        rectangle(screen_size.x-(int)(24.5f*ratio_2d)-dos_m, dos_m+1*ratio_2d, 7*ratio_2d, 6*ratio_2d);
545        glColor3f(1.0f, 1.0f, 1.0f);
546        rectangle(screen_size.x-(int)(23.5f*ratio_2d)-dos_m, dos_m+2*ratio_2d, 5*ratio_2d, 4*ratio_2d);
547        glColor3f(0, 0, 0);
548        rectangle(screen_size.x-(int)(22.5f*ratio_2d)-dos_m, dos_m+3*ratio_2d, 7*ratio_2d, 6*ratio_2d);
549        rectangle(screen_size.x-(int)(12.5f*ratio_2d)-dos_m, dos_m+1*ratio_2d, 7*ratio_2d, 6*ratio_2d);
550        glColor3f(dos_r, dos_g, dos_b);
551        rectangle(screen_size.x-(int)(10.5f*ratio_2d)-dos_m, dos_m+2*ratio_2d, 7*ratio_2d, 7*ratio_2d);
552        glColor3f(1.0f, 1.0f, 1.0f);
553        rectangle(screen_size.x-(int)(9.5f*ratio_2d)-dos_m, dos_m+3*ratio_2d, 5*ratio_2d, 5*ratio_2d);
554        rectangle(screen_size.x-8*ratio_2d-dos_m, screen_size.y-9*ratio_2d-dos_m, 7*ratio_2d, 8*ratio_2d);
555        glColor3f(dos_r, dos_g, dos_b);
556        rectangle(screen_size.x-7*ratio_2d-dos_m, screen_size.y-8*ratio_2d-dos_m, 6*ratio_2d, 7*ratio_2d);
557        glColor3f(1.0f, 1.0f, 1.0f);
558        rectangle(screen_size.x-4*ratio_2d-dos_m, screen_size.y-8*ratio_2d-dos_m, 4*ratio_2d, 2*ratio_2d);
559        rectangle(screen_size.x-7*ratio_2d-dos_m, screen_size.y-5*ratio_2d-dos_m, 2*ratio_2d, 5*ratio_2d);
560        rectangle(screen_size.x-6*ratio_2d-dos_m, screen_size.y-7*ratio_2d-dos_m, 1*ratio_2d, 1*ratio_2d);
561        rectangle(screen_size.x-4*ratio_2d-dos_m, screen_size.y-5*ratio_2d-dos_m, 2*ratio_2d, 3*ratio_2d);
562        glEnable(GL_BLEND);
563        if(polygon) glEnable(GL_TEXTURE_2D);
564        glBlendFunc(GL_ONE, GL_ONE);
565        glVertexPointer(2, GL_INT, 0, shell_vtx);
566        glTexCoordPointer(2, GL_FLOAT, 0, shell_tex);
567        glDrawArrays(GL_QUADS, 0, 4);
568        // draw dos text
569        glVertexPointer(2, GL_INT, 0, dos_vtx);
570        j=0;
571        liner_line=-1;
572        for(i=1;i<liner_length+1;i++)
573        {
574            j++;
575            car=(unsigned char)txt[i-1];
576            if(i==liner_length) car=car_cursor;
577            if(car>32)
578            {
579                glLoadIdentity();
580                glTranslated(x+j*(dos_w+2*ratio_2d), y, 0);
581                float l_w=(car%16)*0.03125f;
582                float l_h=(car-car%16)*0.001953125f;
583                float dos_tex[]={l_w+0.03125f, 0.5f-l_h-0.03125f, l_w+0.03125f, 0.5f-l_h, l_w, 0.5f-l_h, l_w, 0.5f-l_h-0.03125f};
584                glTexCoordPointer(2, GL_FLOAT, 0, dos_tex);
585                if(car==car_cursor) glColor3f(CR*(dos_r+64), CR*(dos_g+48), CR*(dos_b+48));
586                glDrawArrays(GL_QUADS, 0, 4);
587                if(car==car_cursor) glColor3f(1.0f, 1.0f, 1.0f);
588            }
589            if(car==13)
590            {
591                j=0;
592                liner_line++;
593                x=dos_m;
594                y=dos_m+(float)(15*ratio_2d+liner_line*(dos_h+4*ratio_2d));
595                if(y+dos_h>screen_size.y-dos_m) break;
596            }
597        }
598    }
599    // draw debug
600    //#if DEBUG
601    if(debug_flag)
602    {
603        char debug[512];
604        sprintf(debug, "width=%d\rheight=%d\rratio=%dx\rbeat=%-02.1f\rsync=%-02.1f\rkey code=%03d\r", screen_size.x, screen_size.y, ratio_2d, beat_value, sync_value, key_code);
605        float l_v=0.0390625f;
606        float l_j=0.001953125f;
607        glVertexPointer(2, GL_INT, 0, debug_vtx);
608        glLoadIdentity();
609        glBlendFunc(GL_ONE, GL_ONE);
610        glColor3f(0.625f, 0.25f, 0.0f);
611        glTranslated(debug_x, debug_y, 0);
612        j=0;
613        for(i=0;i<(int)strlen(debug);i++)
614        {
615            j++;
616            car=(unsigned char)debug[i];
617            if(car==13)
618            {
619                glTranslated(-j*(debug_w-ratio_2d)*2, (debug_h-ratio_2d)*2, 0);
620                j=0;
621            }
622            glTranslated((debug_w-ratio_2d)*2, 0, 0);
623            if(car>32)
624            {
625                float l_w=(car%16)*0.03515625f;
626                float l_h=(car-car%16)*0.00244140625f;
627                float debug_tex[]={l_w+l_v-l_j, 1.0f-l_h-l_v, l_w+l_v-l_j, 1.0f-l_h, l_w-l_j, 1.0f-l_h, l_w-l_j, 1.0f-l_h-l_v};
628                glTexCoordPointer(2, GL_FLOAT, 0, debug_tex);
629                glDrawArrays(GL_QUADS, 0, 4);
630            }
631        }
632    }
633    //#endif
634    // draw corner
635    glDisable(GL_TEXTURE_2D);
636    glDisable(GL_BLEND);
637    glVertexPointer(2, GL_INT, 0, corner_vtx);
638    glLoadIdentity();
639    glColor3f(0, 0, 0);
640    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
641    glTranslated(screen_size.x, 0, 0);
642    glRotated(90.0f, 0, 0, 1.0f);
643    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
644    glTranslated(screen_size.y, 0, 0);
645    glRotated(90.0f, 0, 0, 1.0f);
646    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
647    glTranslated(screen_size.x, 0, 0);
648    glRotated(90.0f, 0, 0, 1.0f);
649    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
650    glEnable(GL_BLEND);
651    /* .-------------------. */
652    /* | DRAW SOME 3D HERE | */
653    /* °-------------------° */
654    //init_viewport(0);
655    /*-PATACODE----------------------------------------------------------------*/
656    #if SHADER
657    if (shader_flag)
658    {
659        init_shader();
660        fbo_back->Unbind();
661        if (shader_effect_flag && shader_blur_flag)
662        {
663            // shader blur horizontal
664            fbo_ping->Bind();
665            shader_blur_h->Bind();
666            shader_blur_h->SetTexture(shader_blur_h_texture, fbo_back->GetTexture(), 0);
667            shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f));
668            shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
669            shader_blur_h->SetUniform(shader_blur_h_value, 0.5f/screen_size.x);
670            fs_quad();
671            shader_blur_h->Unbind();
672            fbo_ping->Unbind();
673            // shader blur vertical
674            fbo_front->Bind();
675            shader_blur_v->Bind();
676            shader_blur_v->SetTexture(shader_blur_v_texture, fbo_ping->GetTexture(), 0);
677            shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f));
678            shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
679            shader_blur_v->SetUniform(shader_blur_v_value, 0.5f/screen_size.y);
680            fs_quad();
681            shader_blur_v->Unbind();
682        }
683        else
684        {
685            // shader simple
686            fbo_front->Bind();
687            draw_shader_simple(fbo_back, 0);
688        }
689        fbo_front->Unbind();
690        // shader glow
691        if(shader_effect_flag&&shader_glow_flag)
692        {
693            // shader blur horizontal
694            fbo_blur_h->Bind();
695            shader_blur_h->Bind();
696            shader_blur_h->SetTexture(shader_blur_h_texture, fbo_ping->GetTexture(), 0);
697            shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f / glow_fbo_size));
698            shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
699            shader_blur_h->SetUniform(shader_blur_h_value, 2.5f/screen_size.x);
700            fs_quad();
701            shader_blur_h->Unbind();
702            fbo_blur_h->Unbind();
703            // shader blur vertical
704            fbo_blur_v->Bind();
705            shader_blur_v->Bind();
706            shader_blur_v->SetTexture(shader_blur_v_texture, fbo_blur_h->GetTexture(), 0);
707            shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f / glow_fbo_size));
708            shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
709            shader_blur_v->SetUniform(shader_blur_h_value, 2.5f/screen_size.y);
710            fs_quad();
711            shader_blur_v->Unbind();
712            fbo_blur_v->Unbind();
713            // shader blur horizontal
714            fbo_blur_h->Bind();
715            shader_blur_h->Bind();
716            shader_blur_h->SetTexture(shader_blur_h_texture, fbo_blur_v->GetTexture(), 0);
717            shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f / glow_fbo_size));
718            shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
719            shader_blur_h->SetUniform(shader_blur_h_value, 1.0f/screen_size.x);
720            fs_quad();
721            shader_blur_h->Unbind();
722            fbo_blur_h->Unbind();
723            // shader blur vertical
724            fbo_blur_v->Bind();
725            shader_blur_v->Bind();
726            shader_blur_v->SetTexture(shader_blur_v_texture, fbo_blur_h->GetTexture(), 0);
727            shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f / glow_fbo_size));
728            shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
729            shader_blur_v->SetUniform(shader_blur_h_value, 1.0f/screen_size.y);
730            fs_quad();
731            shader_blur_v->Unbind();
732            fbo_blur_v->Unbind();
733            // shader glow
734            fbo_pong->Bind();
735            shader_glow->Bind();
736            shader_glow->SetTexture(shader_glow_texture, fbo_blur_v->GetTexture(), 0);
737            shader_glow->SetTexture(shader_glow_texture_prv, fbo_front->GetTexture(), 1);
738            shader_glow->SetUniform(shader_glow_screen_size, vec2(1.0f));
739            shader_glow->SetUniform(shader_glow_time, fx_angle);
740            shader_glow->SetUniform(shader_glow_step, glow_smoothstep);
741            shader_glow->SetUniform(shader_glow_value1, glow_mix_ratio1);
742            shader_glow->SetUniform(shader_glow_value2, glow_mix_ratio2);
743            fs_quad();
744            shader_glow->Unbind();
745        }
746        if(!shader_effect_flag)
747        {
748            // shader simple
749            fbo_pong->Bind();
750            draw_shader_simple(fbo_front, 0);
751        }
752        fbo_pong->Unbind();
753        if(shader_postfx_flag)
754        {
755            // shader postfx
756            shader_postfx->Bind();
757            shader_postfx->SetTexture(shader_postfx_texture, fbo_pong->GetTexture(), 0);
758            shader_postfx->SetUniform(shader_postfx_screen_size, (vec2)screen_size);
759            shader_postfx->SetUniform(shader_postfx_time, fx_angle);
760            shader_postfx->SetUniform(shader_postfx_flash, flash_value);
761            shader_postfx->SetUniform(shader_postfx_value, 4.0f);
762            shader_postfx->SetUniform(shader_postfx_deform, postfx_deform);
763            shader_postfx->SetUniform(shader_postfx_scanline, postfx_scanline);
764            shader_postfx->SetUniform(shader_postfx_sync, (float)fabs(beat_value*cosf((main_angle-beat_angle)*8.0f)));
765            fs_quad();
766            shader_postfx->Unbind();
767        }
768        else
769        {
770            // shader simple
771            draw_shader_simple(fbo_pong, 0);
772        }
773    }
774    #endif
775    /*-/PATACODE---------------------------------------------------------------*/
776}
777
778Render::~Render()
779{
780}
781
Note: See TracBrowser for help on using the repository browser.