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

Last change on this file since 1487 was 1487, checked in by sam, 9 years ago

neercs: remove useless alpha test that was causing rendering errors.

File size: 27.8 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;
39extern char const *lolfx_text;
40
41#define DEBUG 1            // debug flag //#if defined(_DEBUG)
42#define SHADER 1           // shader flag
43#define PID M_PI/180.0f    // pi ratio
44#define CR 1.0f/256.0f     // color ratio
45
46bool done = false;
47
48/*
49 * Various variables
50 */
51
52int keys[256];             // keyboard array
53int active = true;         // window active flag
54bool fullscreen = DEBUG?false:true; // fullscreen flag
55bool paused = false;       // pause flag
56float nearplane = 0.1f;    // nearplane
57float farplane = 1000.0f;  // farplane
58bool polygon = true;       // polygon mode
59int polygon_fillmode = GL_FILL; // fill mode
60/* window variable */
61ivec2 screen_size;         // screen size
62int window_color = 32;     // color depth
63vec3 screen_color;         // screen color
64/* object variable */
65float main_angle;          // main angle
66float part_angle;          // part angle
67float fx_angle;            // current angle
68/* text variable */
69char const *name = "cacaShell";
70/* fs_quad variable */
71float 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};
72float fs_quad_tex[] = {0, 1.0f, 0, 0, 1.0f, 0, 1.0f, 1.0f};
73/* flash variable */
74bool flash_flag = false;   // flag
75float flash_angle = 0;     // angle
76float flash_value = 0;     // value
77float flash_speed;         // speed
78/* fade variable */
79bool fade_flag = false;    // flag
80float fade_angle = 0;      // angle
81float fade_value = 0;      // value
82float fade_speed;          // speed
83/* sync variable */
84bool sync_flag = false;    // flag
85float sync_angle = 0;      // angle
86float sync_value = 0;      // value
87float sync_speed;          // speed
88/* beat variable */
89bool beat_flag = false;    // flag
90float beat_angle = 0;      // angle
91float beat_value = 0;      // value
92float beat_speed;          // speed
93/* corner variable */
94const int corner_n = 10;   // polygon number
95int corner_w = 24;         // radius
96int corner_vtx[corner_n*6];// vertex array
97/* dos variable */
98bool dos_flag = false;     // flag
99int dos_m;                 // margin
100vec3 dos_color;            // color value
101int dos_vtx[8];            // vertex array
102ivec2 ratio_2d(2,4);       // 2d ratio
103ivec2 map_size(256,256);   // texture map size
104ivec2 font_size(8,8);      // font size
105vec2 car_size(1.0f/map_size.x*font_size.x, 1.0f/map_size.y*font_size.y);
106int shell_vtx[8];          // vertex array
107float shell_tex[] = {1.0f, 0.96875f, 1.0f, 1.0f, 0.78125f, 1.0f, 0.78125f, 0.96875f};
108/* keyboard variable */
109int key_code = 0;          // keyboard code
110/* common variable */
111float value, angle, radius, scale, speed;
112TileSet *tex_map;
113/* shader variable */
114bool shader_flag = SHADER?true:false;
115bool shader_blur_flag = SHADER?true:false;
116bool shader_effect_flag = SHADER?true:false;
117bool shader_glow_flag = true;
118int glow_fbo_size = 2;     // glow fbo size
119int glow_color;            // 0 = color / 1 = alpha
120float glow_smoothstep;     // glow smoothstep value
121float glow_mix_ratio1;     // glow mixing ratio
122float glow_mix_ratio2;     // source mixing ratio
123bool shader_radial_flag = false;
124float radial_value1;
125float radial_value2;
126float radial_color;        // color
127bool shader_postfx_flag = SHADER?true:false;
128bool postfx_scanline = true;
129float postfx_deform;       // deformation ratio
130#if SHADER
131Shader *shader_simple, *shader_blur_h, *shader_blur_v;
132Shader *shader_glow, *shader_radial, *shader_postfx;
133// shader variables
134ShaderUniform shader_simple_texture;
135ShaderUniform shader_blur_h_texture,
136              shader_blur_h_screen_size,
137              shader_blur_h_time,
138              shader_blur_h_value;
139ShaderUniform shader_blur_v_texture,
140              shader_blur_v_screen_size,
141              shader_blur_v_time,
142              shader_blur_v_value;
143ShaderUniform shader_glow_texture,
144              shader_glow_texture_prv,
145              shader_glow_screen_size,
146              shader_glow_time,
147              shader_glow_step,
148              shader_glow_value1,
149              shader_glow_value2;
150ShaderUniform shader_radial_texture,
151              shader_radial_screen_size,
152              shader_radial_time,
153              shader_radial_value1,
154              shader_radial_value2,
155              shader_radial_color;
156ShaderUniform shader_postfx_texture,
157              shader_postfx_texture_2d,
158              shader_postfx_screen_size,
159              shader_postfx_time,
160              shader_postfx_flash,
161              shader_postfx_value,
162              shader_postfx_deform,
163              shader_postfx_scanline,
164              shader_postfx_sync;
165
166FrameBuffer *fbo_back, *fbo_front;
167FrameBuffer *fbo_blur_h, *fbo_blur_v, *fbo_ping, *fbo_pong;
168#endif
169
170/*
171 * Text rendering interface
172 */
173struct TextRender
174{
175    TextRender(caca_canvas_t *caca)
176      : m_caca(caca),
177        m_width(caca_get_canvas_width(m_caca)),
178        m_height(caca_get_canvas_height(m_caca))
179    {
180        for (int j = 0; j < m_height; j++)
181        for (int i = 0; i < m_width; i++)
182            m_vertices << vec2(i, j);
183    }
184
185    void Init(ivec2 screen_size, ivec2 font_size)
186    {
187        m_shader = Shader::Create(lolfx_text);
188        m_coord = m_shader->GetAttribLocation("in_Position",
189                                              VertexUsage::Position, 0);
190        m_color = m_shader->GetAttribLocation("in_Attr",
191                                              VertexUsage::Color, 0);
192        m_char = m_shader->GetAttribLocation("in_Char",
193                                             VertexUsage::Color, 1);
194        m_texture = m_shader->GetUniformLocation("in_Texture");
195        m_transform = m_shader->GetUniformLocation("in_Transform");
196        m_vdecl
197          = new VertexDeclaration(VertexStream<vec2>(VertexUsage::Position),
198                                  VertexStream<uint32_t>(VertexUsage::Color),
199                                  VertexStream<uint32_t>(VertexUsage::Color));
200
201        m_vbo1 = new VertexBuffer(m_vertices.Bytes());
202        void *vertices = m_vbo1->Lock(0, 0);
203        memcpy(vertices, &m_vertices[0], m_vertices.Bytes());
204        m_vbo1->Unlock();
205
206        m_vbo2 = new VertexBuffer(m_width * m_height * sizeof(int32_t));
207        m_vbo3 = new VertexBuffer(m_width * m_height * sizeof(int32_t));
208
209        m_fbo = new FrameBuffer(screen_size);
210    }
211
212    void Render(ivec2 screen_size, ivec2 font_size)
213    {
214        /* Transform matrix for the scene:
215         *  - translate to the centre of the glyph
216         *  - scale by 2.f * font_size / screen_size
217         *  - translate to the upper left corner */
218        mat4 xform = mat4::translate(-1.f, 1.f, 0.f)
219                   * mat4::scale(vec3(2.f * font_size / (screen_size), 1.f)
220                                  * vec3(1.f, -1.f, 1.f))
221                   * mat4::translate(0.5f, 0.5f, 0.f);
222
223        /* Upload libcaca canvas contents to the vertex buffers */
224        uint32_t *colors = (uint32_t *)m_vbo2->Lock(0, 0);
225        for (int j = 0; j < m_height; j++)
226        for (int i = 0; i < m_width; i++)
227        {
228            uint32_t attr = caca_get_attr(m_caca, i, j);
229            uint16_t fg = caca_attr_to_rgb12_fg(attr);
230            uint16_t bg = caca_attr_to_rgb12_bg(attr);
231            caca_set_color_argb(m_caca, fg, bg);
232            attr = caca_get_attr(m_caca, -1, -1);
233            caca_put_attr(m_caca, i, j, attr);
234            uint32_t a2 = caca_get_attr(m_caca, i, j);
235        }
236        memcpy(colors, caca_get_canvas_attrs(m_caca),
237               m_width * m_height * sizeof(uint32_t));
238        m_vbo2->Unlock();
239
240        uint32_t *chars = (uint32_t *)m_vbo3->Lock(0, 0);
241        memcpy(chars, caca_get_canvas_chars(m_caca),
242               m_width * m_height * sizeof(uint32_t));
243        m_vbo3->Unlock();
244
245        m_fbo->Bind();
246        glDisable(GL_DEPTH_TEST);
247        glEnable(GL_POINT_SPRITE);
248        //glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
249        glDisable(GL_POINT_SMOOTH);
250        glPointSize((float)max(font_size.x, font_size.y));
251        m_shader->Bind();
252        tex_map->Bind();
253        m_shader->SetUniform(m_texture, 0);
254        m_shader->SetUniform(m_transform, xform);
255        m_vdecl->SetStream(m_vbo1, m_coord);
256        m_vdecl->SetStream(m_vbo2, m_color);
257        m_vdecl->SetStream(m_vbo3, m_char);
258        m_vdecl->Bind();
259        m_vdecl->DrawElements(MeshPrimitive::Points, 0, m_width * m_height);
260        m_vdecl->Unbind();
261        tex_map->Unbind();
262        m_shader->Unbind();
263        glDisable(GL_POINT_SPRITE);
264        m_fbo->Unbind();
265    }
266
267    void Blit()
268    {
269        /* FIXME: scaling is wrong */
270        glDisable(GL_BLEND);
271        glEnable(GL_TEXTURE_2D);
272        glBindTexture(GL_TEXTURE_2D, m_fbo->GetTexture());
273        glColor3f(1.0f,1.0f,1.0f);
274
275        int x = dos_m;
276        int y = dos_m + (font_size.y + 2) * ratio_2d.y;
277        int w = screen_size.x - dos_m * 2;
278        int h = screen_size.y - dos_m * 2 - (font_size.y + 2) * ratio_2d.y;
279
280        glLoadIdentity();
281        glBegin(GL_QUADS);
282            glTexCoord2f(1.0f, 1.0f);
283            glVertex2i(x+w, y  );
284            glTexCoord2f(0.0f, 1.0f);
285            glVertex2i(x  , y  );
286            glTexCoord2f(0.0f, 0.0f);
287            glVertex2i(x  , y+h);
288            glTexCoord2f(1.0f, 0.0f);
289            glVertex2i(x+w, y+h);
290        glEnd();
291    }
292
293private:
294    caca_canvas_t *m_caca;
295    int m_width, m_height;
296
297    Array<vec2> m_vertices;
298    Shader *m_shader;
299    ShaderAttrib m_coord, m_color, m_char;
300    ShaderUniform m_texture, m_transform;
301    VertexDeclaration *m_vdecl;
302    VertexBuffer *m_vbo1, *m_vbo2, *m_vbo3;
303    FrameBuffer *m_fbo;
304};
305
306TextRender *text_render;
307
308void init_viewport(int type)
309{
310    glViewport(0, 0, screen_size.x, screen_size.y);
311    glMatrixMode(GL_PROJECTION);
312    glLoadIdentity();
313    mat4 m;
314    if (type == 0)
315        m = mat4::perspective(70, (float)screen_size.x, (float)screen_size.y,
316                              nearplane, farplane);
317    else
318        m = mat4::ortho(0, screen_size.x, screen_size.y, 0, -1.f, 1.f);
319    glLoadMatrixf(&m[0][0]);
320    glMatrixMode(GL_MODELVIEW);
321}
322
323#if SHADER
324void init_shader()
325{
326    glDisable(GL_BLEND);
327    glVertexPointer(4, GL_FLOAT, 0, fs_quad_vtx);
328    glTexCoordPointer(2, GL_FLOAT, 0, fs_quad_tex);
329}
330
331void fs_quad()
332{
333    glLoadIdentity();
334    glDrawArrays(GL_QUADS, 0, 4);
335}
336
337void draw_shader_simple(FrameBuffer *fbo_output, int n)
338{
339    shader_simple->Bind();
340    shader_simple->SetTexture(shader_simple_texture, fbo_output->GetTexture(), n);
341    fs_quad();
342    shader_simple->Unbind();
343}
344#endif
345
346void rectangle(int x, int y, int w, int h)
347{
348    glLoadIdentity();
349    glBegin(GL_QUADS);
350        glVertex2i(x+w, y  );
351        glVertex2i(x  , y  );
352        glVertex2i(x  , y+h);
353        glVertex2i(x+w, y+h);
354    glEnd();
355}
356
357void corner()
358{
359    float vertex[2+corner_n*2];
360    vertex[0] = 0;
361    vertex[1] = 0;
362    for (int i = 1; i < corner_n + 1; i++)
363    {
364        int j = i*2;
365        float a = PID*90.0f/(corner_n-1)*(i-1);
366        vertex[j  ] = corner_w-corner_w*cosf(a);
367        vertex[j+1] = corner_w-corner_w*sinf(a);
368    }
369    for (int i = 0; i < corner_n; i++)
370    {
371        int j = i*6;
372        int k = i*2;
373        corner_vtx[j  ] = (int)vertex[0];
374        corner_vtx[j+1] = (int)vertex[1];
375        corner_vtx[j+2] = (int)vertex[2+k];
376        corner_vtx[j+3] = (int)vertex[3+k];
377        corner_vtx[j+4] = (int)vertex[4+k];
378        corner_vtx[j+5] = (int)vertex[5+k];
379    }
380}
381
382void screen()
383{
384    part_angle = main_angle;
385    dos_flag = true;
386    dos_color = CR * vec3(48, 56, 64);
387    screen_color = dos_color;
388    /*-------------------------*/
389    shader_effect_flag = true;
390    shader_glow_flag = true;
391    glow_color = 1;
392    glow_smoothstep = 0;//.025f;
393    glow_mix_ratio1 = 0.5f;
394    glow_mix_ratio2 = 0.5f;
395    shader_radial_flag = false;
396    radial_value1 = 2.0f;
397    radial_value2 = 0.8f;
398    radial_color = 0;
399    postfx_deform = 0.5f;
400    /*-------------------------*/
401    flash_speed = 1.5f;
402    fade_speed = 0.2f;
403    sync_flag = false;
404    sync_value = 1.0f;
405    sync_speed = 1.0f;
406    beat_speed = 2.0f;
407    /*-------------------------*/
408}
409
410int InitGL(void)
411{
412    glDepthMask(GL_TRUE);                            // do not write z-buffer
413    glEnable(GL_CULL_FACE);                        // disable cull face
414    glCullFace(GL_BACK);                            // don't draw front face
415    // load texture
416    tex_map = new TileSet("neercs/video/resource/map.png", ivec2(256, 256), ivec2(1));
417    // initialize some variable
418    screen();
419
420#if SHADER
421    if (shader_flag)
422    {
423        /* Initialise framebuffer objects */
424        fbo_back = new FrameBuffer(screen_size);
425        fbo_front = new FrameBuffer(screen_size);
426        fbo_blur_h = new FrameBuffer(screen_size / glow_fbo_size);
427        fbo_blur_v = new FrameBuffer(screen_size / glow_fbo_size);
428        fbo_ping = new FrameBuffer(screen_size);
429        fbo_pong = new FrameBuffer(screen_size);
430        // shader simple
431        shader_simple = Shader::Create(lolfx_simple);
432        shader_simple_texture = shader_simple->GetUniformLocation("texture");
433        // shader blur horizontal
434        shader_blur_h = Shader::Create(lolfx_blurh);
435        shader_blur_h_texture = shader_blur_h->GetUniformLocation("texture");
436        shader_blur_h_screen_size = shader_blur_h->GetUniformLocation("screen_size");
437        shader_blur_h_time = shader_blur_h->GetUniformLocation("time");
438        shader_blur_h_value = shader_blur_h->GetUniformLocation("value");
439        // shader blur vertical
440        shader_blur_v = Shader::Create(lolfx_blurv);
441        shader_blur_v_texture = shader_blur_v->GetUniformLocation("texture");
442        shader_blur_v_screen_size = shader_blur_v->GetUniformLocation("screen_size");
443        shader_blur_v_time = shader_blur_v->GetUniformLocation("time");
444        shader_blur_v_value = shader_blur_v->GetUniformLocation("value");
445        // shader glow
446        shader_glow = Shader::Create(lolfx_glow);
447        shader_glow_texture = shader_glow->GetUniformLocation("texture");
448        shader_glow_texture_prv = shader_glow->GetUniformLocation("texture_prv");
449        shader_glow_screen_size = shader_glow->GetUniformLocation("screen_size");
450        shader_glow_time = shader_glow->GetUniformLocation("time");
451        shader_glow_step = shader_glow->GetUniformLocation("step");
452        shader_glow_value1 = shader_glow->GetUniformLocation("value1");
453        shader_glow_value2 = shader_glow->GetUniformLocation("value2");
454        // shader radial
455        shader_radial = Shader::Create(lolfx_radial);
456        shader_radial_texture = shader_radial->GetUniformLocation("texture");
457        shader_radial_screen_size = shader_radial->GetUniformLocation("screen_size");
458        shader_radial_time = shader_radial->GetUniformLocation("time");
459        shader_radial_value1 = shader_radial->GetUniformLocation("value1");
460        shader_radial_value2 = shader_radial->GetUniformLocation("value2");
461        shader_radial_color = shader_radial->GetUniformLocation("color");
462        // shader postfx
463        shader_postfx = Shader::Create(lolfx_postfx);
464        shader_postfx_texture = shader_postfx->GetUniformLocation("texture");
465        shader_postfx_texture_2d = shader_postfx->GetUniformLocation("texture_2d");
466        shader_postfx_screen_size = shader_postfx->GetUniformLocation("screen_size");
467        shader_postfx_time = shader_postfx->GetUniformLocation("time");
468        shader_postfx_flash = shader_postfx->GetUniformLocation("flash");
469        shader_postfx_value = shader_postfx->GetUniformLocation("value");
470        shader_postfx_deform = shader_postfx->GetUniformLocation("deform");
471        shader_postfx_scanline = shader_postfx->GetUniformLocation("scanline");
472        shader_postfx_sync = shader_postfx->GetUniformLocation("sync");
473    }
474#endif
475    return true;
476}
477
478int CreateGLWindow(char const *title)
479{
480    screen_size = Video::GetSize();
481    corner_w = 16*ratio_2d.x;
482    corner();
483    dos_m=12*ratio_2d.x;
484    dos_vtx[0]=font_size.x*ratio_2d.x/2.0f;
485    dos_vtx[1]=font_size.y*ratio_2d.y/2.0f;
486    dos_vtx[2]=font_size.x*ratio_2d.x/2.0f;
487    dos_vtx[3]=-font_size.y*ratio_2d.y/2.0f;
488    dos_vtx[4]=-font_size.x*ratio_2d.x/2.0f;
489    dos_vtx[5]=-font_size.y*ratio_2d.y/2.0f;
490    dos_vtx[6]=-font_size.x*ratio_2d.x/2.0f;
491    dos_vtx[7]=font_size.y*ratio_2d.y/2.0f;
492    shell_vtx[0]=dos_m+58*ratio_2d.x;
493    shell_vtx[1]=dos_m+(font_size.y+1)*ratio_2d.y;
494    shell_vtx[2]=dos_m+58*ratio_2d.x;
495    shell_vtx[3]=dos_m+ratio_2d.y;
496    shell_vtx[4]=dos_m+2*ratio_2d.x;
497    shell_vtx[5]=dos_m+ratio_2d.y;
498    shell_vtx[6]=dos_m+2*ratio_2d.x;
499    shell_vtx[7]=dos_m+(font_size.y+1)*ratio_2d.y;
500    InitGL();
501    return true;
502}
503
504Render::Render(caca_canvas_t *caca)
505  : m_caca(caca),
506    m_ready(false)
507{
508    text_render = new TextRender(m_caca);
509}
510
511void Render::TickGame(float seconds)
512{
513    Entity::TickGame(seconds);
514}
515
516void Render::TickDraw(float seconds)
517{
518    Entity::TickDraw(seconds);
519
520    if (!m_ready)
521    {
522        CreateGLWindow("LOL");
523        text_render->Init(screen_size, ivec2(8, 8));
524
525        m_ready = true;
526    }
527
528    // timer
529    if(!paused)
530        main_angle += seconds * 100.0f * PID;
531    if(sync_flag)
532    {
533        angle=(main_angle-sync_angle)*sync_speed;
534        sync_value=1.0f-sinf(angle);
535        if(angle>90.0f*PID)
536        {
537            sync_value=0;
538            sync_flag=false;
539        }
540    }
541    if(beat_flag)
542    {
543        angle=(main_angle-beat_angle)*beat_speed;
544        beat_value=1.0f-sinf(angle);
545        if(angle>90.0f*PID)
546        {
547            beat_value=0;
548            beat_flag=false;
549        }
550    }
551    if(flash_flag)
552    {
553        angle=(main_angle-flash_angle)*flash_speed;
554        flash_value=1.0f-sinf(angle);
555        if(angle>90.0f*PID)
556        {
557            flash_value=0;
558            flash_flag=false;
559        }
560    }
561    if(fade_flag)
562    {
563        angle=(main_angle-fade_angle)*fade_speed;
564        fade_value=1.0f-sinf(angle);
565        if(angle>90.0f*PID)
566        {
567            fade_value=0;
568            fade_flag=false;
569        }
570    }
571
572    Draw2D();
573    Draw3D();
574}
575
576void Render::Draw2D()
577{
578    /* Draw text in an offline buffer */
579    text_render->Render(screen_size, ivec2(8, 8));
580
581#if SHADER
582    if(shader_flag)
583        fbo_back->Bind();
584#endif
585
586    /* Clear the back buffer */
587    glClearColor(screen_color.r, screen_color.g, screen_color.b, 1.0f);
588    glClearDepth(1.0f); // set depth buffer
589    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
590
591    text_render->Blit();
592
593    glEnableClientState(GL_VERTEX_ARRAY);
594    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
595
596    glEnable(GL_BLEND);
597    //if(polygon) glEnable(GL_LINE_SMOOTH); else glDisable(GL_LINE_SMOOTH);
598    glLineWidth((polygon)?2.0f:1.0f);
599    fx_angle=main_angle-part_angle;
600    if(polygon) glEnable(GL_TEXTURE_2D);
601
602    init_viewport(1);
603
604    tex_map->Bind();
605    glEnable(GL_BLEND);
606    // draw dos
607    if(dos_flag)
608    {
609        glDisable(GL_TEXTURE_2D);
610        glDisable(GL_BLEND);
611        glColor3f(1.0f,1.0f,1.0f);
612        rectangle(dos_m,dos_m,screen_size.x-53*ratio_2d.x-dos_m*2,(font_size.y+2)*ratio_2d.y);
613        rectangle(screen_size.x-51*ratio_2d.x-dos_m,dos_m,22*ratio_2d.x,(font_size.y+2)*ratio_2d.y);
614        rectangle(screen_size.x-27*ratio_2d.x-dos_m,dos_m,22*ratio_2d.x,(font_size.y+2)*ratio_2d.y);
615        rectangle(screen_size.x-3*ratio_2d.x-dos_m,dos_m,3*ratio_2d.x,(font_size.y+2)*ratio_2d.y);
616        rectangle(dos_m,dos_m+(font_size.y+2)*ratio_2d.y,2*ratio_2d.x,screen_size.y-(font_size.y+2)*ratio_2d.y-dos_m*2);
617        rectangle(screen_size.x-2*ratio_2d.x-dos_m,dos_m+(font_size.y+2)*ratio_2d.y,2*ratio_2d.x,screen_size.y-(font_size.y+2)*ratio_2d.y-dos_m*2);
618        rectangle(dos_m+2*ratio_2d.x,screen_size.y-ratio_2d.y-dos_m,screen_size.x-4*ratio_2d.x-dos_m*2,ratio_2d.y);
619        glColor3f(dos_color.x,dos_color.y,dos_color.z);
620        rectangle(dos_m+2*ratio_2d.x,dos_m+ratio_2d.y,56*ratio_2d.x,font_size.y*ratio_2d.y);
621        rectangle(dos_m+60*ratio_2d.x,dos_m+2*ratio_2d.y,screen_size.x-115*ratio_2d.x-dos_m*2,2*ratio_2d.y);
622        rectangle(dos_m+60*ratio_2d.x,dos_m+6*ratio_2d.y,screen_size.x-115*ratio_2d.x-dos_m*2,2*ratio_2d.y);
623        rectangle(screen_size.x-49*ratio_2d.x-dos_m,dos_m+ratio_2d.y,14*ratio_2d.x,6*ratio_2d.y);
624        glColor3f(1.0f,1.0f,1.0f);
625        rectangle(screen_size.x-47*ratio_2d.x-dos_m,dos_m+2*ratio_2d.y,10*ratio_2d.x,4*ratio_2d.y);
626        glColor3f(0,0,0);
627        rectangle(screen_size.x-45*ratio_2d.x-dos_m,dos_m+3*ratio_2d.y,14*ratio_2d.x,6*ratio_2d.y);
628        rectangle(screen_size.x-25*ratio_2d.x-dos_m,dos_m+1*ratio_2d.y,14*ratio_2d.x,6*ratio_2d.y);
629        glColor3f(dos_color.x,dos_color.y,dos_color.z);
630        rectangle(screen_size.x-21*ratio_2d.x-dos_m,dos_m+2*ratio_2d.y,14*ratio_2d.x,7*ratio_2d.y);
631        glColor3f(1.0f,1.0f,1.0f);
632        rectangle(screen_size.x-19*ratio_2d.x-dos_m,dos_m+3*ratio_2d.y,10*ratio_2d.x,5*ratio_2d.y);
633        rectangle(screen_size.x-16*ratio_2d.x-dos_m,screen_size.y-9*ratio_2d.y-dos_m,14*ratio_2d.x,8*ratio_2d.y);
634        glColor3f(dos_color.x,dos_color.y,dos_color.z);
635        rectangle(screen_size.x-14*ratio_2d.x-dos_m,screen_size.y-8*ratio_2d.y-dos_m,12*ratio_2d.x,7*ratio_2d.y);
636        glColor3f(1.0f,1.0f,1.0f);
637        rectangle(screen_size.x-8*ratio_2d.x-dos_m,screen_size.y-8*ratio_2d.y-dos_m,8*ratio_2d.x,2*ratio_2d.y);
638        rectangle(screen_size.x-14*ratio_2d.x-dos_m,screen_size.y-5*ratio_2d.y-dos_m,4*ratio_2d.x,5*ratio_2d.y);
639        rectangle(screen_size.x-12*ratio_2d.x-dos_m,screen_size.y-7*ratio_2d.y-dos_m,2*ratio_2d.x,1*ratio_2d.y);
640        rectangle(screen_size.x-8*ratio_2d.x-dos_m,screen_size.y-5*ratio_2d.y-dos_m,4*ratio_2d.x,3*ratio_2d.y);
641        glEnable(GL_BLEND);
642        if(polygon) glEnable(GL_TEXTURE_2D);
643        glBlendFunc(GL_ONE, GL_ONE);
644        glVertexPointer(2, GL_INT, 0, shell_vtx);
645        glTexCoordPointer(2, GL_FLOAT, 0, shell_tex);
646        glDrawArrays(GL_QUADS, 0, 4);
647    }
648    // draw corner
649    glDisable(GL_TEXTURE_2D);
650    glDisable(GL_BLEND);
651    glVertexPointer(2, GL_INT, 0, corner_vtx);
652    glLoadIdentity();
653    glColor3f(0, 0, 0);
654    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
655    glTranslated(screen_size.x, 0, 0);
656    glRotated(90.0f, 0, 0, 1.0f);
657    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
658    glTranslated(screen_size.y, 0, 0);
659    glRotated(90.0f, 0, 0, 1.0f);
660    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
661    glTranslated(screen_size.x, 0, 0);
662    glRotated(90.0f, 0, 0, 1.0f);
663    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
664    glEnable(GL_BLEND);
665    tex_map->Unbind();
666
667    glDisableClientState(GL_VERTEX_ARRAY);
668    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
669}
670
671void Render::Draw3D()
672{
673    //init_viewport(0);
674    glDisable(GL_DEPTH_TEST);
675
676#if SHADER
677    if (!shader_flag)
678        return;
679
680    glEnableClientState(GL_VERTEX_ARRAY);
681    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
682
683    init_shader();
684    fbo_back->Unbind();
685    if (shader_effect_flag && shader_blur_flag)
686    {
687        // shader blur horizontal
688        fbo_ping->Bind();
689        shader_blur_h->Bind();
690        shader_blur_h->SetTexture(shader_blur_h_texture, fbo_back->GetTexture(), 0);
691        shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f));
692        shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
693        shader_blur_h->SetUniform(shader_blur_h_value, 0.5f/screen_size.x);
694        fs_quad();
695        shader_blur_h->Unbind();
696        fbo_ping->Unbind();
697        // shader blur vertical
698        fbo_front->Bind();
699        shader_blur_v->Bind();
700        shader_blur_v->SetTexture(shader_blur_v_texture, fbo_ping->GetTexture(), 0);
701        shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f));
702        shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
703        shader_blur_v->SetUniform(shader_blur_v_value, 0.5f/screen_size.y);
704        fs_quad();
705        shader_blur_v->Unbind();
706    }
707    else
708    {
709        // shader simple
710        fbo_front->Bind();
711        draw_shader_simple(fbo_back, 0);
712    }
713    fbo_front->Unbind();
714    // shader glow
715    if(shader_effect_flag&&shader_glow_flag)
716    {
717        // shader blur horizontal
718        fbo_blur_h->Bind();
719        shader_blur_h->Bind();
720        shader_blur_h->SetTexture(shader_blur_h_texture, fbo_ping->GetTexture(), 0);
721        shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f / glow_fbo_size));
722        shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
723        shader_blur_h->SetUniform(shader_blur_h_value, 2.5f/screen_size.x);
724        fs_quad();
725        shader_blur_h->Unbind();
726        fbo_blur_h->Unbind();
727        // shader blur vertical
728        fbo_blur_v->Bind();
729        shader_blur_v->Bind();
730        shader_blur_v->SetTexture(shader_blur_v_texture, fbo_blur_h->GetTexture(), 0);
731        shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f / glow_fbo_size));
732        shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
733        shader_blur_v->SetUniform(shader_blur_h_value, 2.5f/screen_size.y);
734        fs_quad();
735        shader_blur_v->Unbind();
736        fbo_blur_v->Unbind();
737        // shader blur horizontal
738        fbo_blur_h->Bind();
739        shader_blur_h->Bind();
740        shader_blur_h->SetTexture(shader_blur_h_texture, fbo_blur_v->GetTexture(), 0);
741        shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f / glow_fbo_size));
742        shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
743        shader_blur_h->SetUniform(shader_blur_h_value, 1.0f/screen_size.x);
744        fs_quad();
745        shader_blur_h->Unbind();
746        fbo_blur_h->Unbind();
747        // shader blur vertical
748        fbo_blur_v->Bind();
749        shader_blur_v->Bind();
750        shader_blur_v->SetTexture(shader_blur_v_texture, fbo_blur_h->GetTexture(), 0);
751        shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f / glow_fbo_size));
752        shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
753        shader_blur_v->SetUniform(shader_blur_h_value, 1.0f/screen_size.y);
754        fs_quad();
755        shader_blur_v->Unbind();
756        fbo_blur_v->Unbind();
757        // shader glow
758        fbo_pong->Bind();
759        shader_glow->Bind();
760        shader_glow->SetTexture(shader_glow_texture, fbo_blur_v->GetTexture(), 0);
761        shader_glow->SetTexture(shader_glow_texture_prv, fbo_front->GetTexture(), 1);
762        shader_glow->SetUniform(shader_glow_screen_size, vec2(1.0f));
763        shader_glow->SetUniform(shader_glow_time, fx_angle);
764        shader_glow->SetUniform(shader_glow_step, glow_smoothstep);
765        shader_glow->SetUniform(shader_glow_value1, glow_mix_ratio1);
766        shader_glow->SetUniform(shader_glow_value2, glow_mix_ratio2);
767        fs_quad();
768        shader_glow->Unbind();
769    }
770    if(!shader_effect_flag)
771    {
772        // shader simple
773        fbo_pong->Bind();
774        draw_shader_simple(fbo_front, 0);
775    }
776    fbo_pong->Unbind();
777    if(shader_postfx_flag)
778    {
779        // shader postfx
780        shader_postfx->Bind();
781        shader_postfx->SetTexture(shader_postfx_texture, fbo_pong->GetTexture(), 0);
782        shader_postfx->SetUniform(shader_postfx_screen_size, (vec2)screen_size);
783        shader_postfx->SetUniform(shader_postfx_time, fx_angle);
784        shader_postfx->SetUniform(shader_postfx_flash, flash_value);
785        shader_postfx->SetUniform(shader_postfx_value, 4.0f);
786        shader_postfx->SetUniform(shader_postfx_deform, postfx_deform);
787        shader_postfx->SetUniform(shader_postfx_scanline, postfx_scanline);
788        shader_postfx->SetUniform(shader_postfx_sync, (float)fabs(beat_value*cosf((main_angle-beat_angle)*8.0f)));
789        fs_quad();
790        shader_postfx->Unbind();
791    }
792    else
793    {
794        // shader simple
795        draw_shader_simple(fbo_pong, 0);
796    }
797
798    glDisableClientState(GL_VERTEX_ARRAY);
799    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
800#endif
801}
802
803Render::~Render()
804{
805}
806
Note: See TracBrowser for help on using the repository browser.