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

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

neercs: remove some unused variables.

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