source: trunk/tools/neercs/video/render.cpp @ 1625

Last change on this file since 1625 was 1625, checked in by rez, 10 years ago

updated border autoresize + canvas resize

File size: 17.1 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#include "text-render.h"
33
34extern char const *lolfx_blurh;
35extern char const *lolfx_blurv;
36extern char const *lolfx_glow;
37extern char const *lolfx_postfx;
38extern char const *lolfx_radial;
39extern char const *lolfx_simple;
40
41#define PID M_PI/180.0f    // pi ratio
42#define CR 1.0f/256.0f     // color ratio
43
44/*
45 * Various variables
46 */
47
48int active = true;         // window active flag
49float nearplane = 0.1f;    // nearplane
50float farplane = 1000.0f;  // farplane
51int polygon_fillmode = GL_FILL; // fill mode
52bool key_state = 0;      // key state
53/* window variable */
54ivec2 screen_size;         // screen size
55vec3 screen_color = CR * vec3(48, 56, 64); // screen color
56/* object variable */
57float main_angle = 0.0f;   // main angle
58float part_angle = 0.0f;   // part angle
59float fx_angle;            // current angle
60/* fs_quad variable */
61float 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};
62float fs_quad_tex[] = {0, 1.0f, 0, 0, 1.0f, 0, 1.0f, 1.0f};
63/* flash variable */
64bool flash_flag = false;   // flag
65float flash_angle = 0;     // angle
66float flash_value = 0;     // value
67float flash_speed = 1.5f;  // speed
68/* fade variable */
69bool fade_flag = false;    // flag
70float fade_angle = 0;      // angle
71float fade_value = 0;      // value
72float fade_speed = 0.2f;   // speed
73/* sync variable */
74bool sync_flag = false;    // flag
75float sync_angle = 0;      // angle
76float sync_value = 1.0f;   // value
77float sync_speed = 1.0f;   // speed
78/* beat variable */
79bool beat_flag = false;    // flag
80float beat_angle = 0;      // angle
81float beat_value = 0;      // value
82float beat_speed = 2.0f;   // speed
83/* window variable */
84ivec2 border;              // border width
85/* text variable */
86ivec2 ratio_2d(2,2);       // 2d ratio
87ivec2 map_size(256,256);   // texture map size
88ivec2 font_size(8,8);      // font size
89ivec2 canvas_char(0,0);    // canvas char number
90ivec2 canvas_size(0,0);    // caca size
91/* common variable */
92float value, angle, radius, scale, speed;
93/* shader variable */
94int glow_fbo_size = 2;        // glow fbo size
95float glow_smoothstep = 0.0f; // glow smoothstep value (try 0.025f)
96float glow_mix_ratio1 = 0.5f; // glow mixing ratio
97float glow_mix_ratio2 = 0.5f; // source mixing ratio
98float radial_value1 = 2.0f;
99float radial_value2 = 0.8f;
100float radial_color = 0;       // color
101bool postfx_scanline = true;
102float postfx_deform = 0.5f;   // deformation ratio
103
104Shader *shader_simple, *shader_blur_h, *shader_blur_v;
105Shader *shader_glow, *shader_radial, *shader_postfx;
106// shader variables
107ShaderUniform shader_simple_texture;
108ShaderUniform shader_blur_h_texture,
109              shader_blur_h_screen_size,
110              shader_blur_h_time,
111              shader_blur_h_value;
112ShaderUniform shader_blur_v_texture,
113              shader_blur_v_screen_size,
114              shader_blur_v_time,
115              shader_blur_v_value;
116ShaderUniform shader_glow_texture,
117              shader_glow_texture_prv,
118              shader_glow_screen_size,
119              shader_glow_time,
120              shader_glow_step,
121              shader_glow_value1,
122              shader_glow_value2;
123ShaderUniform shader_radial_texture,
124              shader_radial_screen_size,
125              shader_radial_time,
126              shader_radial_value1,
127              shader_radial_value2,
128              shader_radial_color;
129ShaderUniform shader_postfx_texture,
130              shader_postfx_texture_2d,
131              shader_postfx_screen_size,
132              shader_postfx_time,
133              shader_postfx_flash,
134              shader_postfx_value,
135              shader_postfx_deform,
136              shader_postfx_scanline,
137              shader_postfx_sync;
138
139FrameBuffer *fbo_back, *fbo_front;
140FrameBuffer *fbo_blur_h, *fbo_blur_v, *fbo_ping, *fbo_pong;
141
142TextRender *text_render;
143
144void fs_quad()
145{
146    glLoadIdentity();
147    glDrawArrays(GL_QUADS, 0, 4);
148}
149
150void draw_shader_simple(FrameBuffer *fbo_output, int n)
151{
152    shader_simple->Bind();
153    shader_simple->SetTexture(shader_simple_texture, fbo_output->GetTexture(), n);
154    fs_quad();
155    shader_simple->Unbind();
156}
157
158void rectangle(int x, int y, int w, int h)
159{
160    glLoadIdentity();
161    glBegin(GL_QUADS);
162        glVertex2i(x+w, y  );
163        glVertex2i(x  , y  );
164        glVertex2i(x  , y+h);
165        glVertex2i(x+w, y+h);
166    glEnd();
167}
168
169int Render::InitDraw(void)
170{
171    glDepthMask(GL_TRUE);     // do not write z-buffer
172    glEnable(GL_CULL_FACE);   // disable cull face
173    glCullFace(GL_BACK);      // don't draw front face
174
175    if (m_shader)
176    {
177        /* Initialise framebuffer objects */
178        fbo_back = new FrameBuffer(screen_size);
179        fbo_front = new FrameBuffer(screen_size);
180        fbo_blur_h = new FrameBuffer(screen_size / glow_fbo_size);
181        fbo_blur_v = new FrameBuffer(screen_size / glow_fbo_size);
182        fbo_ping = new FrameBuffer(screen_size);
183        fbo_pong = new FrameBuffer(screen_size);
184        // shader simple
185        shader_simple = Shader::Create(lolfx_simple);
186        shader_simple_texture = shader_simple->GetUniformLocation("texture");
187        // shader blur horizontal
188        shader_blur_h = Shader::Create(lolfx_blurh);
189        shader_blur_h_texture = shader_blur_h->GetUniformLocation("texture");
190        shader_blur_h_screen_size = shader_blur_h->GetUniformLocation("screen_size");
191        shader_blur_h_time = shader_blur_h->GetUniformLocation("time");
192        shader_blur_h_value = shader_blur_h->GetUniformLocation("value");
193        // shader blur vertical
194        shader_blur_v = Shader::Create(lolfx_blurv);
195        shader_blur_v_texture = shader_blur_v->GetUniformLocation("texture");
196        shader_blur_v_screen_size = shader_blur_v->GetUniformLocation("screen_size");
197        shader_blur_v_time = shader_blur_v->GetUniformLocation("time");
198        shader_blur_v_value = shader_blur_v->GetUniformLocation("value");
199        // shader glow
200        shader_glow = Shader::Create(lolfx_glow);
201        shader_glow_texture = shader_glow->GetUniformLocation("texture");
202        shader_glow_texture_prv = shader_glow->GetUniformLocation("texture_prv");
203        shader_glow_screen_size = shader_glow->GetUniformLocation("screen_size");
204        shader_glow_time = shader_glow->GetUniformLocation("time");
205        shader_glow_step = shader_glow->GetUniformLocation("step");
206        shader_glow_value1 = shader_glow->GetUniformLocation("value1");
207        shader_glow_value2 = shader_glow->GetUniformLocation("value2");
208        // shader radial
209        shader_radial = Shader::Create(lolfx_radial);
210        shader_radial_texture = shader_radial->GetUniformLocation("texture");
211        shader_radial_screen_size = shader_radial->GetUniformLocation("screen_size");
212        shader_radial_time = shader_radial->GetUniformLocation("time");
213        shader_radial_value1 = shader_radial->GetUniformLocation("value1");
214        shader_radial_value2 = shader_radial->GetUniformLocation("value2");
215        shader_radial_color = shader_radial->GetUniformLocation("color");
216        // shader postfx
217        shader_postfx = Shader::Create(lolfx_postfx);
218        shader_postfx_texture = shader_postfx->GetUniformLocation("texture");
219        shader_postfx_texture_2d = shader_postfx->GetUniformLocation("texture_2d");
220        shader_postfx_screen_size = shader_postfx->GetUniformLocation("screen_size");
221        shader_postfx_time = shader_postfx->GetUniformLocation("time");
222        shader_postfx_flash = shader_postfx->GetUniformLocation("flash");
223        shader_postfx_value = shader_postfx->GetUniformLocation("value");
224        shader_postfx_deform = shader_postfx->GetUniformLocation("deform");
225        shader_postfx_scanline = shader_postfx->GetUniformLocation("scanline");
226        shader_postfx_sync = shader_postfx->GetUniformLocation("sync");
227    }
228
229    return true;
230}
231
232int Render::CreateGLWindow()
233{
234    screen_size = Video::GetSize();
235    border = 12 * ratio_2d;
236    canvas_char = (screen_size - border * 2) / (font_size * ratio_2d);
237    canvas_size = canvas_char * font_size * ratio_2d;
238
239    border = (screen_size - canvas_size) / 2;
240
241    caca_set_canvas_size(m_caca, canvas_char.x, canvas_char.y);
242
243    InitDraw();
244    return true;
245}
246
247Render::Render(caca_canvas_t *caca)
248  : m_caca(caca),
249    m_ready(false),
250    m_pause(false),
251    m_polygon(true),
252    m_shader(false),
253    m_shader_blur(true),
254    m_shader_glow(true),
255    m_shader_fx(true),
256    m_shader_postfx(true)
257{
258    text_render = new TextRender(m_caca, font_size);
259}
260
261void Render::TickGame(float seconds)
262{
263    Entity::TickGame(seconds);
264}
265
266void Render::Pause()
267{
268    m_pause=!m_pause;
269}
270
271void Render::TickDraw(float seconds)
272{
273    /* keyboard manager */
274    if (Input::GetButtonState(27/*SDLK_ESCAPE*/))
275        Ticker::Shutdown();
276    //if (Input::GetButtonState(282/*SDLK_F1*/))
277    //    LEAULE();
278    if (Input::GetButtonState(283/*SDLK_F2*/))
279        {
280        m_polygon=!m_polygon;
281        polygon_fillmode=(m_polygon)?GL_FILL:GL_LINE;
282        glPolygonMode(GL_FRONT,polygon_fillmode);
283        }
284    if (Input::GetButtonState(284/*SDLK_F3*/)&&key_state!=284)
285        {
286        m_shader=!m_shader;
287        key_state=284;
288        }
289    if (Input::GetButtonState(285/*SDLK_F4*/))
290        m_shader_postfx=!m_shader_postfx;
291    if (Input::GetButtonState(286/*SDLK_F5*/))
292        Pause();
293
294    Entity::TickDraw(seconds);
295
296    if (!m_ready)
297    {
298        CreateGLWindow();
299        text_render->Init();
300        m_ready = true;
301    }
302
303    // timer
304    if(!m_pause)
305        main_angle += seconds * 100.0f * PID;
306    if(sync_flag)
307    {
308        angle=(main_angle-sync_angle)*sync_speed;
309        sync_value=1.0f-sinf(angle);
310        if(angle>90.0f*PID)
311        {
312            sync_value=0;
313            sync_flag=false;
314        }
315    }
316    if(beat_flag)
317    {
318        angle=(main_angle-beat_angle)*beat_speed;
319        beat_value=1.0f-sinf(angle);
320        if(angle>90.0f*PID)
321        {
322            beat_value=0;
323            beat_flag=false;
324        }
325    }
326    if(flash_flag)
327    {
328        angle=(main_angle-flash_angle)*flash_speed;
329        flash_value=1.0f-sinf(angle);
330        if(angle>90.0f*PID)
331        {
332            flash_value=0;
333            flash_flag=false;
334        }
335    }
336    if(fade_flag)
337    {
338        angle=(main_angle-fade_angle)*fade_speed;
339        fade_value=1.0f-sinf(angle);
340        if(angle>90.0f*PID)
341        {
342            fade_value=0;
343            fade_flag=false;
344        }
345    }
346
347    Draw2D();
348    Draw3D();
349}
350
351void Render::Draw2D()
352{
353    /* Draw text in an offline buffer */
354    text_render->Render();
355
356    if(m_shader)
357        fbo_back->Bind();
358
359    glViewport(0, 0, screen_size.x, screen_size.y);
360
361    /* Clear the back buffer */
362    glEnable(GL_BLEND);
363    glBlendFunc(GL_SRC_COLOR,GL_DST_ALPHA);
364    glClearColor(screen_color.r, screen_color.g, screen_color.b, 1.0f);
365    glClearDepth(1.0f); // set depth buffer
366    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
367
368    text_render->Blit(border, canvas_size);
369
370    //if(m_polygon) glEnable(GL_LINE_SMOOTH); else glDisable(GL_LINE_SMOOTH);
371    glLineWidth((m_polygon)?2.0f:1.0f);
372    fx_angle=main_angle-part_angle;
373    if(m_polygon) glEnable(GL_TEXTURE_2D);
374
375    glMatrixMode(GL_PROJECTION);
376    mat4 m = mat4::ortho(0, screen_size.x, screen_size.y, 0, -1.f, 1.f);
377    glLoadMatrixf(&m[0][0]);
378    glMatrixMode(GL_MODELVIEW);
379    // draw border
380    glDisable(GL_TEXTURE_2D);
381    glDisable(GL_BLEND);
382    glColor3f(1.0f,1.0f,1.0f);
383    rectangle(border.x - ratio_2d.x, border.y - ratio_2d.y, canvas_size.x + ratio_2d.x * 2, ratio_2d.y);
384    rectangle(border.x - ratio_2d.x, border.y, ratio_2d.x, canvas_size.y);
385    rectangle(border.x + canvas_size.x, border.y, ratio_2d.x, canvas_size.y);
386    rectangle(border.x - ratio_2d.x, border.y + canvas_size.y, canvas_size.x + ratio_2d.x * 2, ratio_2d.y);
387    glEnable(GL_BLEND);
388}
389
390void Render::Draw3D()
391{
392    if (!m_shader)
393        return;
394
395    glDisable(GL_DEPTH_TEST);
396    glDisable(GL_BLEND);
397
398    glEnableClientState(GL_VERTEX_ARRAY);
399    glVertexPointer(4, GL_FLOAT, 0, fs_quad_vtx);
400
401    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
402    glTexCoordPointer(2, GL_FLOAT, 0, fs_quad_tex);
403
404    fbo_back->Unbind();
405    if (m_shader_fx && m_shader_blur)
406    {
407        // shader blur horizontal
408        fbo_ping->Bind();
409        shader_blur_h->Bind();
410        shader_blur_h->SetTexture(shader_blur_h_texture, fbo_back->GetTexture(), 0);
411        shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f));
412        shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
413        shader_blur_h->SetUniform(shader_blur_h_value, 0.5f/screen_size.x);
414        fs_quad();
415        shader_blur_h->Unbind();
416        fbo_ping->Unbind();
417        // shader blur vertical
418        fbo_front->Bind();
419        shader_blur_v->Bind();
420        shader_blur_v->SetTexture(shader_blur_v_texture, fbo_ping->GetTexture(), 0);
421        shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f));
422        shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
423        shader_blur_v->SetUniform(shader_blur_v_value, 0.5f/screen_size.y);
424        fs_quad();
425        shader_blur_v->Unbind();
426    }
427    else
428    {
429        // shader simple
430        fbo_front->Bind();
431        draw_shader_simple(fbo_back, 0);
432    }
433    fbo_front->Unbind();
434    // shader glow
435    if(m_shader_fx && m_shader_glow)
436    {
437        // shader blur horizontal
438        fbo_blur_h->Bind();
439        shader_blur_h->Bind();
440        shader_blur_h->SetTexture(shader_blur_h_texture, fbo_ping->GetTexture(), 0);
441        shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f / glow_fbo_size));
442        shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
443        shader_blur_h->SetUniform(shader_blur_h_value, 2.5f/screen_size.x);
444        fs_quad();
445        shader_blur_h->Unbind();
446        fbo_blur_h->Unbind();
447        // shader blur vertical
448        fbo_blur_v->Bind();
449        shader_blur_v->Bind();
450        shader_blur_v->SetTexture(shader_blur_v_texture, fbo_blur_h->GetTexture(), 0);
451        shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f / glow_fbo_size));
452        shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
453        shader_blur_v->SetUniform(shader_blur_h_value, 2.5f/screen_size.y);
454        fs_quad();
455        shader_blur_v->Unbind();
456        fbo_blur_v->Unbind();
457        // shader blur horizontal
458        fbo_blur_h->Bind();
459        shader_blur_h->Bind();
460        shader_blur_h->SetTexture(shader_blur_h_texture, fbo_blur_v->GetTexture(), 0);
461        shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f / glow_fbo_size));
462        shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
463        shader_blur_h->SetUniform(shader_blur_h_value, 1.0f/screen_size.x);
464        fs_quad();
465        shader_blur_h->Unbind();
466        fbo_blur_h->Unbind();
467        // shader blur vertical
468        fbo_blur_v->Bind();
469        shader_blur_v->Bind();
470        shader_blur_v->SetTexture(shader_blur_v_texture, fbo_blur_h->GetTexture(), 0);
471        shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f / glow_fbo_size));
472        shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
473        shader_blur_v->SetUniform(shader_blur_h_value, 1.0f/screen_size.y);
474        fs_quad();
475        shader_blur_v->Unbind();
476        fbo_blur_v->Unbind();
477        // shader glow
478        fbo_pong->Bind();
479        shader_glow->Bind();
480        shader_glow->SetTexture(shader_glow_texture, fbo_blur_v->GetTexture(), 0);
481        shader_glow->SetTexture(shader_glow_texture_prv, fbo_front->GetTexture(), 1);
482        shader_glow->SetUniform(shader_glow_screen_size, vec2(1.0f));
483        shader_glow->SetUniform(shader_glow_time, fx_angle);
484        shader_glow->SetUniform(shader_glow_step, glow_smoothstep);
485        shader_glow->SetUniform(shader_glow_value1, glow_mix_ratio1);
486        shader_glow->SetUniform(shader_glow_value2, glow_mix_ratio2);
487        fs_quad();
488        shader_glow->Unbind();
489    }
490    if(!m_shader_fx)
491    {
492        // shader simple
493        fbo_pong->Bind();
494        draw_shader_simple(fbo_front, 0);
495    }
496    fbo_pong->Unbind();
497    if(m_shader_postfx)
498    {
499        // shader postfx
500        shader_postfx->Bind();
501        shader_postfx->SetTexture(shader_postfx_texture, fbo_pong->GetTexture(), 0);
502        shader_postfx->SetUniform(shader_postfx_screen_size, (vec2)screen_size);
503        shader_postfx->SetUniform(shader_postfx_time, fx_angle);
504        shader_postfx->SetUniform(shader_postfx_flash, flash_value);
505        shader_postfx->SetUniform(shader_postfx_value, 4.0f);
506        shader_postfx->SetUniform(shader_postfx_deform, postfx_deform);
507        shader_postfx->SetUniform(shader_postfx_scanline, postfx_scanline);
508        shader_postfx->SetUniform(shader_postfx_sync, (float)fabs(beat_value*cosf((main_angle-beat_angle)*8.0f)));
509        fs_quad();
510        shader_postfx->Unbind();
511    }
512    else
513    {
514        // shader simple
515        draw_shader_simple(fbo_pong, 0);
516    }
517
518    glDisableClientState(GL_VERTEX_ARRAY);
519    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
520}
521
522Render::~Render()
523{
524}
Note: See TracBrowser for help on using the repository browser.