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

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

neercs: font blitting is now pixel perfect.

File size: 27.6 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_text, *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()
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
210    void Blit(ivec2 screen_size, ivec2 font_size)
211    {
212        /* Transform matrix for the scene:
213         *  - translate to the centre of the glyph
214         *  - scale by 2.f * font_size / screen_size
215         *  - translate to the upper left corner */
216        mat4 xform = mat4::translate(-1.f, 1.f, 0.f)
217                   * mat4::scale(vec3(2.f * font_size / (screen_size), 1.f)
218                                  * vec3(1.f, -1.f, 1.f))
219                   * mat4::translate(0.5f, 0.5f, 0.f);
220
221        /* Upload libcaca canvas contents to the vertex buffers */
222        uint32_t *colors = (uint32_t *)m_vbo2->Lock(0, 0);
223        for (int j = 0; j < m_height; j++)
224        for (int i = 0; i < m_width; i++)
225        {
226            uint32_t attr = caca_get_attr(m_caca, i, j);
227            uint16_t fg = caca_attr_to_rgb12_fg(attr);
228            uint16_t bg = caca_attr_to_rgb12_bg(attr);
229            caca_set_color_argb(m_caca, fg, bg);
230            attr = caca_get_attr(m_caca, -1, -1);
231            caca_put_attr(m_caca, i, j, attr);
232            uint32_t a2 = caca_get_attr(m_caca, i, j);
233        }
234        memcpy(colors, caca_get_canvas_attrs(m_caca),
235               m_width * m_height * sizeof(uint32_t));
236        m_vbo2->Unlock();
237
238        uint32_t *chars = (uint32_t *)m_vbo3->Lock(0, 0);
239        memcpy(chars, caca_get_canvas_chars(m_caca),
240               m_width * m_height * sizeof(uint32_t));
241        m_vbo3->Unlock();
242
243        glEnable(GL_POINT_SPRITE);
244        //glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
245        glDisable(GL_POINT_SMOOTH);
246        glPointSize((float)max(font_size.x, font_size.y));
247        m_shader->Bind();
248        tex_map->Bind();
249        m_shader->SetUniform(m_texture, 0);
250        m_shader->SetUniform(m_transform, xform);
251        m_vdecl->SetStream(m_vbo1, m_coord);
252        m_vdecl->SetStream(m_vbo2, m_color);
253        m_vdecl->SetStream(m_vbo3, m_char);
254        m_vdecl->Bind();
255        m_vdecl->DrawElements(MeshPrimitive::Points, 0, m_width * m_height);
256        m_vdecl->Unbind();
257        tex_map->Unbind();
258        m_shader->Unbind();
259        glDisable(GL_POINT_SPRITE);
260    }
261
262private:
263    caca_canvas_t *m_caca;
264    int m_width, m_height;
265
266    Array<vec2> m_vertices;
267    Shader *m_shader;
268    ShaderAttrib m_coord, m_color, m_char;
269    ShaderUniform m_texture, m_transform;
270    VertexDeclaration *m_vdecl;
271    VertexBuffer *m_vbo1, *m_vbo2, *m_vbo3;
272};
273
274TextRender *text_render;
275
276void init_viewport(int type)
277{
278    glViewport(0, 0, screen_size.x, screen_size.y);
279    glMatrixMode(GL_PROJECTION);
280    glLoadIdentity();
281    mat4 m;
282    if (type == 0)
283        m = mat4::perspective(70, (float)screen_size.x, (float)screen_size.y,
284                              nearplane, farplane);
285    else
286        m = mat4::ortho(0, screen_size.x, screen_size.y, 0, -1.f, 1.f);
287    glLoadMatrixf(&m[0][0]);
288    glMatrixMode(GL_MODELVIEW);
289}
290
291#if SHADER
292void init_shader()
293{
294    glDisable(GL_BLEND);
295    glVertexPointer(4, GL_FLOAT, 0, fs_quad_vtx);
296    glTexCoordPointer(2, GL_FLOAT, 0, fs_quad_tex);
297}
298
299void fs_quad()
300{
301    glLoadIdentity();
302    glDrawArrays(GL_QUADS, 0, 4);
303}
304
305void draw_shader_simple(FrameBuffer *fbo_output, int n)
306{
307    shader_simple->Bind();
308    shader_simple->SetTexture(shader_simple_texture, fbo_output->GetTexture(), n);
309    fs_quad();
310    shader_simple->Unbind();
311}
312#endif
313
314void rectangle(int x, int y, int w, int h)
315{
316    glLoadIdentity();
317    glBegin(GL_QUADS);
318        glVertex2i(x+w, y  );
319        glVertex2i(x  , y  );
320        glVertex2i(x  , y+h);
321        glVertex2i(x+w, y+h);
322    glEnd();
323}
324
325void corner()
326{
327    float vertex[2+corner_n*2];
328    vertex[0] = 0;
329    vertex[1] = 0;
330    for (int i = 1; i < corner_n + 1; i++)
331    {
332        int j = i*2;
333        float a = PID*90.0f/(corner_n-1)*(i-1);
334        vertex[j  ] = corner_w-corner_w*cosf(a);
335        vertex[j+1] = corner_w-corner_w*sinf(a);
336    }
337    for (int i = 0; i < corner_n; i++)
338    {
339        int j = i*6;
340        int k = i*2;
341        corner_vtx[j  ] = (int)vertex[0];
342        corner_vtx[j+1] = (int)vertex[1];
343        corner_vtx[j+2] = (int)vertex[2+k];
344        corner_vtx[j+3] = (int)vertex[3+k];
345        corner_vtx[j+4] = (int)vertex[4+k];
346        corner_vtx[j+5] = (int)vertex[5+k];
347    }
348}
349
350void screen()
351{
352    part_angle = main_angle;
353    dos_flag = true;
354    dos_color = CR * vec3(48, 56, 64);
355    screen_color = dos_color;
356    /*-------------------------*/
357    shader_effect_flag = true;
358    shader_glow_flag = true;
359    glow_color = 1;
360    glow_smoothstep = 0;//.025f;
361    glow_mix_ratio1 = 0.5f;
362    glow_mix_ratio2 = 0.5f;
363    shader_radial_flag = false;
364    radial_value1 = 2.0f;
365    radial_value2 = 0.8f;
366    radial_color = 0;
367    postfx_deform = 0.5f;
368    /*-------------------------*/
369    flash_speed = 1.5f;
370    fade_speed = 0.2f;
371    sync_flag = false;
372    sync_value = 1.0f;
373    sync_speed = 1.0f;
374    beat_speed = 2.0f;
375    /*-------------------------*/
376    glClearColor(screen_color.r, screen_color.g, screen_color.b, 1.0f);
377}
378
379int InitGL(void)
380{
381    glClearDepth(1.0f);                                // set depth buffer
382    glDepthMask(GL_TRUE);                            // do not write z-buffer
383    glEnable(GL_CULL_FACE);                        // disable cull face
384    glCullFace(GL_BACK);                            // don't draw front face
385    // load texture
386    tex_map = new TileSet("neercs/video/resource/map.png", ivec2(256, 256), ivec2(1));
387    // initialize some variable
388    screen();
389#if SHADER
390    if (shader_flag)
391    {
392        fbo_text = new FrameBuffer(screen_size);
393        fbo_back = new FrameBuffer(screen_size);
394        fbo_front = new FrameBuffer(screen_size);
395        fbo_blur_h = new FrameBuffer(screen_size / glow_fbo_size);
396        fbo_blur_v = new FrameBuffer(screen_size / glow_fbo_size);
397        fbo_ping = new FrameBuffer(screen_size);
398        fbo_pong = new FrameBuffer(screen_size);
399        // shader simple
400        shader_simple = Shader::Create(lolfx_simple);
401        shader_simple_texture = shader_simple->GetUniformLocation("texture");
402        // shader blur horizontal
403        shader_blur_h = Shader::Create(lolfx_blurh);
404        shader_blur_h_texture = shader_blur_h->GetUniformLocation("texture");
405        shader_blur_h_screen_size = shader_blur_h->GetUniformLocation("screen_size");
406        shader_blur_h_time = shader_blur_h->GetUniformLocation("time");
407        shader_blur_h_value = shader_blur_h->GetUniformLocation("value");
408        // shader blur vertical
409        shader_blur_v = Shader::Create(lolfx_blurv);
410        shader_blur_v_texture = shader_blur_v->GetUniformLocation("texture");
411        shader_blur_v_screen_size = shader_blur_v->GetUniformLocation("screen_size");
412        shader_blur_v_time = shader_blur_v->GetUniformLocation("time");
413        shader_blur_v_value = shader_blur_v->GetUniformLocation("value");
414        // shader glow
415        shader_glow = Shader::Create(lolfx_glow);
416        shader_glow_texture = shader_glow->GetUniformLocation("texture");
417        shader_glow_texture_prv = shader_glow->GetUniformLocation("texture_prv");
418        shader_glow_screen_size = shader_glow->GetUniformLocation("screen_size");
419        shader_glow_time = shader_glow->GetUniformLocation("time");
420        shader_glow_step = shader_glow->GetUniformLocation("step");
421        shader_glow_value1 = shader_glow->GetUniformLocation("value1");
422        shader_glow_value2 = shader_glow->GetUniformLocation("value2");
423        // shader radial
424        shader_radial = Shader::Create(lolfx_radial);
425        shader_radial_texture = shader_radial->GetUniformLocation("texture");
426        shader_radial_screen_size = shader_radial->GetUniformLocation("screen_size");
427        shader_radial_time = shader_radial->GetUniformLocation("time");
428        shader_radial_value1 = shader_radial->GetUniformLocation("value1");
429        shader_radial_value2 = shader_radial->GetUniformLocation("value2");
430        shader_radial_color = shader_radial->GetUniformLocation("color");
431        // shader postfx
432        shader_postfx = Shader::Create(lolfx_postfx);
433        shader_postfx_texture = shader_postfx->GetUniformLocation("texture");
434        shader_postfx_texture_2d = shader_postfx->GetUniformLocation("texture_2d");
435        shader_postfx_screen_size = shader_postfx->GetUniformLocation("screen_size");
436        shader_postfx_time = shader_postfx->GetUniformLocation("time");
437        shader_postfx_flash = shader_postfx->GetUniformLocation("flash");
438        shader_postfx_value = shader_postfx->GetUniformLocation("value");
439        shader_postfx_deform = shader_postfx->GetUniformLocation("deform");
440        shader_postfx_scanline = shader_postfx->GetUniformLocation("scanline");
441        shader_postfx_sync = shader_postfx->GetUniformLocation("sync");
442    }
443#endif
444    return true;
445}
446
447int CreateGLWindow(char const *title)
448{
449    screen_size = Video::GetSize();
450    corner_w = 16*ratio_2d.x;
451    corner();
452    dos_m=12*ratio_2d.x;
453    dos_vtx[0]=font_size.x*ratio_2d.x/2.0f;
454    dos_vtx[1]=font_size.y*ratio_2d.y/2.0f;
455    dos_vtx[2]=font_size.x*ratio_2d.x/2.0f;
456    dos_vtx[3]=-font_size.y*ratio_2d.y/2.0f;
457    dos_vtx[4]=-font_size.x*ratio_2d.x/2.0f;
458    dos_vtx[5]=-font_size.y*ratio_2d.y/2.0f;
459    dos_vtx[6]=-font_size.x*ratio_2d.x/2.0f;
460    dos_vtx[7]=font_size.y*ratio_2d.y/2.0f;
461    shell_vtx[0]=dos_m+58*ratio_2d.x;
462    shell_vtx[1]=dos_m+(font_size.y+1)*ratio_2d.y;
463    shell_vtx[2]=dos_m+58*ratio_2d.x;
464    shell_vtx[3]=dos_m+ratio_2d.y;
465    shell_vtx[4]=dos_m+2*ratio_2d.x;
466    shell_vtx[5]=dos_m+ratio_2d.y;
467    shell_vtx[6]=dos_m+2*ratio_2d.x;
468    shell_vtx[7]=dos_m+(font_size.y+1)*ratio_2d.y;
469    InitGL();
470    return true;
471}
472
473Render::Render(caca_canvas_t *caca)
474  : m_caca(caca)
475{
476    text_render = new TextRender(m_caca);
477}
478
479void Render::TickGame(float seconds)
480{
481    Entity::TickGame(seconds);
482}
483
484void Render::TickDraw(float seconds)
485{
486    Entity::TickDraw(seconds);
487
488    static int todo = 1;
489    if (todo)
490    {
491        CreateGLWindow("LOL");
492        todo = 0;
493        text_render->Init();
494    }
495
496    // timer
497    if(!paused)
498        main_angle += seconds * 100.0f * PID;
499    if(sync_flag)
500    {
501        angle=(main_angle-sync_angle)*sync_speed;
502        sync_value=1.0f-sinf(angle);
503        if(angle>90.0f*PID)
504        {
505            sync_value=0;
506            sync_flag=false;
507        }
508    }
509    if(beat_flag)
510    {
511        angle=(main_angle-beat_angle)*beat_speed;
512        beat_value=1.0f-sinf(angle);
513        if(angle>90.0f*PID)
514        {
515            beat_value=0;
516            beat_flag=false;
517        }
518    }
519    if(flash_flag)
520    {
521        angle=(main_angle-flash_angle)*flash_speed;
522        flash_value=1.0f-sinf(angle);
523        if(angle>90.0f*PID)
524        {
525            flash_value=0;
526            flash_flag=false;
527        }
528    }
529    if(fade_flag)
530    {
531        angle=(main_angle-fade_angle)*fade_speed;
532        fade_value=1.0f-sinf(angle);
533        if(angle>90.0f*PID)
534        {
535            fade_value=0;
536            fade_flag=false;
537        }
538    }
539
540    Draw2D();
541    Draw3D();
542}
543
544void Render::Draw2D()
545{
546#if SHADER
547    /* Draw text in an offline buffer */
548    fbo_text->Bind();
549    text_render->Blit(screen_size, ivec2(8, 8));
550    fbo_text->Unbind();
551#endif
552
553    /* Clear the back buffer */
554#if SHADER
555    if(shader_flag)
556    {
557        fbo_back->Bind();
558        fbo_back->Clear(vec4(screen_color, 0.0f), 1.0f);
559    }
560    else
561    {
562        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
563    }
564#else
565    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
566#endif
567
568    /* FIXME: when SHADER is true, we should blit the offline
569     * buffer instead, but for some reason it doesn't work yet. */
570    text_render->Blit(screen_size, ivec2(8, 8));
571
572    glEnableClientState(GL_VERTEX_ARRAY);
573    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
574
575    glEnable(GL_BLEND);
576    //if(polygon) glEnable(GL_LINE_SMOOTH); else glDisable(GL_LINE_SMOOTH);
577    glLineWidth((polygon)?2.0f:1.0f);
578    fx_angle=main_angle-part_angle;
579    if(polygon) glEnable(GL_TEXTURE_2D);
580
581    init_viewport(1);
582
583#if 0
584    /* Render text buffer to the current buffer */
585    glEnable(GL_BLEND);
586    glEnable(GL_TEXTURE_2D);
587    glBlendFunc(GL_ONE, GL_ONE);
588    glVertexPointer(2, GL_INT, 0, shell_vtx);
589    glTexCoordPointer(2, GL_FLOAT, 0, shell_tex);
590    shader_simple->Bind();
591    shader_simple->SetTexture(shader_simple_texture, fbo_text->GetTexture(), 0);
592    fs_quad();
593    shader_simple->Unbind();
594#endif
595
596    tex_map->Bind();
597    glEnable(GL_BLEND);
598    // draw dos
599    if(dos_flag)
600    {
601        glDisable(GL_TEXTURE_2D);
602        glDisable(GL_BLEND);
603        glColor3f(1.0f,1.0f,1.0f);
604        rectangle(dos_m,dos_m,screen_size.x-53*ratio_2d.x-dos_m*2,(font_size.y+2)*ratio_2d.y);
605        rectangle(screen_size.x-51*ratio_2d.x-dos_m,dos_m,22*ratio_2d.x,(font_size.y+2)*ratio_2d.y);
606        rectangle(screen_size.x-27*ratio_2d.x-dos_m,dos_m,22*ratio_2d.x,(font_size.y+2)*ratio_2d.y);
607        rectangle(screen_size.x-3*ratio_2d.x-dos_m,dos_m,3*ratio_2d.x,(font_size.y+2)*ratio_2d.y);
608        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);
609        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);
610        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);
611        glColor3f(dos_color.x,dos_color.y,dos_color.z);
612        rectangle(dos_m+2*ratio_2d.x,dos_m+ratio_2d.y,56*ratio_2d.x,font_size.y*ratio_2d.y);
613        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);
614        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);
615        rectangle(screen_size.x-49*ratio_2d.x-dos_m,dos_m+ratio_2d.y,14*ratio_2d.x,6*ratio_2d.y);
616        glColor3f(1.0f,1.0f,1.0f);
617        rectangle(screen_size.x-47*ratio_2d.x-dos_m,dos_m+2*ratio_2d.y,10*ratio_2d.x,4*ratio_2d.y);
618        glColor3f(0,0,0);
619        rectangle(screen_size.x-45*ratio_2d.x-dos_m,dos_m+3*ratio_2d.y,14*ratio_2d.x,6*ratio_2d.y);
620        rectangle(screen_size.x-25*ratio_2d.x-dos_m,dos_m+1*ratio_2d.y,14*ratio_2d.x,6*ratio_2d.y);
621        glColor3f(dos_color.x,dos_color.y,dos_color.z);
622        rectangle(screen_size.x-21*ratio_2d.x-dos_m,dos_m+2*ratio_2d.y,14*ratio_2d.x,7*ratio_2d.y);
623        glColor3f(1.0f,1.0f,1.0f);
624        rectangle(screen_size.x-19*ratio_2d.x-dos_m,dos_m+3*ratio_2d.y,10*ratio_2d.x,5*ratio_2d.y);
625        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);
626        glColor3f(dos_color.x,dos_color.y,dos_color.z);
627        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);
628        glColor3f(1.0f,1.0f,1.0f);
629        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);
630        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);
631        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);
632        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);
633        glEnable(GL_BLEND);
634        if(polygon) glEnable(GL_TEXTURE_2D);
635        glBlendFunc(GL_ONE, GL_ONE);
636        glVertexPointer(2, GL_INT, 0, shell_vtx);
637        glTexCoordPointer(2, GL_FLOAT, 0, shell_tex);
638        glDrawArrays(GL_QUADS, 0, 4);
639    }
640    // draw corner
641    glDisable(GL_TEXTURE_2D);
642    glDisable(GL_BLEND);
643    glVertexPointer(2, GL_INT, 0, corner_vtx);
644    glLoadIdentity();
645    glColor3f(0, 0, 0);
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    glTranslated(screen_size.y, 0, 0);
651    glRotated(90.0f, 0, 0, 1.0f);
652    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
653    glTranslated(screen_size.x, 0, 0);
654    glRotated(90.0f, 0, 0, 1.0f);
655    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
656    glEnable(GL_BLEND);
657    tex_map->Unbind();
658
659    glDisableClientState(GL_VERTEX_ARRAY);
660    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
661}
662
663void Render::Draw3D()
664{
665    //init_viewport(0);
666    glDisable(GL_DEPTH_TEST);
667
668#if SHADER
669    if (!shader_flag)
670        return;
671
672    glEnableClientState(GL_VERTEX_ARRAY);
673    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
674
675    init_shader();
676    fbo_back->Unbind();
677    if (shader_effect_flag && shader_blur_flag)
678    {
679        // shader blur horizontal
680        fbo_ping->Bind();
681        shader_blur_h->Bind();
682        shader_blur_h->SetTexture(shader_blur_h_texture, fbo_back->GetTexture(), 0);
683        shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f));
684        shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
685        shader_blur_h->SetUniform(shader_blur_h_value, 0.5f/screen_size.x);
686        fs_quad();
687        shader_blur_h->Unbind();
688        fbo_ping->Unbind();
689        // shader blur vertical
690        fbo_front->Bind();
691        shader_blur_v->Bind();
692        shader_blur_v->SetTexture(shader_blur_v_texture, fbo_ping->GetTexture(), 0);
693        shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f));
694        shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
695        shader_blur_v->SetUniform(shader_blur_v_value, 0.5f/screen_size.y);
696        fs_quad();
697        shader_blur_v->Unbind();
698    }
699    else
700    {
701        // shader simple
702        fbo_front->Bind();
703        draw_shader_simple(fbo_back, 0);
704    }
705    fbo_front->Unbind();
706    // shader glow
707    if(shader_effect_flag&&shader_glow_flag)
708    {
709        // shader blur horizontal
710        fbo_blur_h->Bind();
711        shader_blur_h->Bind();
712        shader_blur_h->SetTexture(shader_blur_h_texture, fbo_ping->GetTexture(), 0);
713        shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f / glow_fbo_size));
714        shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
715        shader_blur_h->SetUniform(shader_blur_h_value, 2.5f/screen_size.x);
716        fs_quad();
717        shader_blur_h->Unbind();
718        fbo_blur_h->Unbind();
719        // shader blur vertical
720        fbo_blur_v->Bind();
721        shader_blur_v->Bind();
722        shader_blur_v->SetTexture(shader_blur_v_texture, fbo_blur_h->GetTexture(), 0);
723        shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f / glow_fbo_size));
724        shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
725        shader_blur_v->SetUniform(shader_blur_h_value, 2.5f/screen_size.y);
726        fs_quad();
727        shader_blur_v->Unbind();
728        fbo_blur_v->Unbind();
729        // shader blur horizontal
730        fbo_blur_h->Bind();
731        shader_blur_h->Bind();
732        shader_blur_h->SetTexture(shader_blur_h_texture, fbo_blur_v->GetTexture(), 0);
733        shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f / glow_fbo_size));
734        shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
735        shader_blur_h->SetUniform(shader_blur_h_value, 1.0f/screen_size.x);
736        fs_quad();
737        shader_blur_h->Unbind();
738        fbo_blur_h->Unbind();
739        // shader blur vertical
740        fbo_blur_v->Bind();
741        shader_blur_v->Bind();
742        shader_blur_v->SetTexture(shader_blur_v_texture, fbo_blur_h->GetTexture(), 0);
743        shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f / glow_fbo_size));
744        shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
745        shader_blur_v->SetUniform(shader_blur_h_value, 1.0f/screen_size.y);
746        fs_quad();
747        shader_blur_v->Unbind();
748        fbo_blur_v->Unbind();
749        // shader glow
750        fbo_pong->Bind();
751        shader_glow->Bind();
752        shader_glow->SetTexture(shader_glow_texture, fbo_blur_v->GetTexture(), 0);
753        shader_glow->SetTexture(shader_glow_texture_prv, fbo_front->GetTexture(), 1);
754        shader_glow->SetUniform(shader_glow_screen_size, vec2(1.0f));
755        shader_glow->SetUniform(shader_glow_time, fx_angle);
756        shader_glow->SetUniform(shader_glow_step, glow_smoothstep);
757        shader_glow->SetUniform(shader_glow_value1, glow_mix_ratio1);
758        shader_glow->SetUniform(shader_glow_value2, glow_mix_ratio2);
759        fs_quad();
760        shader_glow->Unbind();
761    }
762    if(!shader_effect_flag)
763    {
764        // shader simple
765        fbo_pong->Bind();
766        draw_shader_simple(fbo_front, 0);
767    }
768    fbo_pong->Unbind();
769    if(shader_postfx_flag)
770    {
771        // shader postfx
772        shader_postfx->Bind();
773        shader_postfx->SetTexture(shader_postfx_texture, fbo_pong->GetTexture(), 0);
774        shader_postfx->SetUniform(shader_postfx_screen_size, (vec2)screen_size);
775        shader_postfx->SetUniform(shader_postfx_time, fx_angle);
776        shader_postfx->SetUniform(shader_postfx_flash, flash_value);
777        shader_postfx->SetUniform(shader_postfx_value, 4.0f);
778        shader_postfx->SetUniform(shader_postfx_deform, postfx_deform);
779        shader_postfx->SetUniform(shader_postfx_scanline, postfx_scanline);
780        shader_postfx->SetUniform(shader_postfx_sync, (float)fabs(beat_value*cosf((main_angle-beat_angle)*8.0f)));
781        fs_quad();
782        shader_postfx->Unbind();
783    }
784    else
785    {
786        // shader simple
787        draw_shader_simple(fbo_pong, 0);
788    }
789
790    glDisableClientState(GL_VERTEX_ARRAY);
791    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
792#endif
793}
794
795Render::~Render()
796{
797}
798
Note: See TracBrowser for help on using the repository browser.