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

//
// Neercs
//

#if defined HAVE_CONFIG_H
#   include "config.h"
#endif

#if defined _XBOX
#   define _USE_MATH_DEFINES /* for M_PI */
#   include <xtl.h>
#elif defined _WIN32
#   define _USE_MATH_DEFINES /* for M_PI */
#   define WIN32_LEAN_AND_MEAN
#   include <windows.h>
#endif

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <string>

#include "core.h"
#include "lolgl.h"

using namespace std;
using namespace lol;

#include "../neercs.h"
#include "render.h"

extern char const *lolfx_blurh;
extern char const *lolfx_blurv;
extern char const *lolfx_glow;
extern char const *lolfx_postfx;
extern char const *lolfx_radial;
extern char const *lolfx_simple;

#define WIN32_LEAN_AND_MEAN
#define DEBUG 1           // debug flag //#if defined(_DEBUG)
#define SHADER 1          // shader flag
#define PI 3.1415926535f  // pi
#define PID PI/180.0f     // pi ratio
#define CR 1.0f/256.0f    // color ratio

bool done=false;

Timer *timer;

//char *param=GetCommandLine();

int keys[256];             // keyboard array
int active=true;           // window active flag
bool fullscreen=DEBUG?false:true;    // fullscreen flag
bool pause=false;          // pause flag
float nearplane=0.1f;      // nearplane
float farplane=1000.0f;    // farplane
bool polygon=true;         // polygon mode
int polygon_fillmode=GL_FILL; // fill mode
int ratio_2d=4;            // 2d ratio
/* window variable */
int base_w=800;            // base width
int base_h=600;            // base height
int window_w=base_w;       // width
int window_h=base_h;       // height
int screen_w;              // screen width
int screen_h;              // screen height
int window_color=32;       // color depth
float screen_r;            // color red
float screen_g;            // color green
float screen_b;            // color blue
/* object variable */
float main_angle;          // main angle
float part_angle;          // part angle
float fx_angle;            // current angle
/* liner variable */
int car;                   // ascii code
int car_cursor=126;        // cursor ascii code
int liner_length;          // text length
int liner_line_n;          // line number
int liner_line;            // line increment
int liner_max;             // line max length
int liner_i;               // char increment
int liner_count;           // counter
/* text variable */
char *name="cacaShell";
std::string txt("");
/* fs_quad variable */
float 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};
float fs_quad_tex[]={0, 1.0f, 0, 0, 1.0f, 0, 1.0f, 1.0f};
/* flash variable */
bool flash_flag=false;     // flag
float flash_angle=0;       // angle
float flash_value=0;       // value
float flash_speed;         // speed
/* fade variable */
bool fade_flag=false;      // flag
float fade_angle=0;        // angle
float fade_value=0;        // value
float fade_speed;          // speed
/* debug variable */
bool debug_flag=false;     // flag
int debug_x;               // position x
int debug_y;               // position y
int debug_w;               // width
int debug_h;               // height
int debug_vtx[8];          // vertex array
/* sync variable */
bool sync_flag=false;      // flag
float sync_angle=0;        // angle
float sync_value=0;        // value
float sync_speed;          // speed
/* beat variable */
bool beat_flag=false;      // flag
float beat_angle=0;        // angle
float beat_value=0;        // value
float beat_speed;          // speed
/* corner variable */
const int corner_n=10;     // polygon number
int corner_w=24;           // radius
int corner_vtx[corner_n*6];// vertex array
/* dos variable */
bool dos_flag=false;       // flag
int dos_w;                 // width
int dos_h;                 // height
int dos_m;                 // margin
float dos_r;               // red value
float dos_g;               // green value
float dos_b;               // blue value
int dos_vtx[8];            // vertex array
int shell_vtx[8];          // vertex array
float shell_tex[]={1.0f, 0.96875f, 1.0f, 1.0f, 0.78125f, 1.0f, 0.78125f, 0.96875f};
/* keyboard variable */
int key_code=0;            // keyboard code
/* common variable */
int i, j, k, l;
float x, y, z, w, h;
float r, g, b, c;
float value, angle, radius, scale, speed;
TileSet *tex_map;
/* shader variable */
bool shader_flag=SHADER?true:false;
bool shader_blur_flag=SHADER?true:false;
bool shader_effect_flag=SHADER?true:false;
bool shader_glow_flag=true;
int glow_fbo_size=2;       // glow fbo size
int glow_color;            // 0=color/1=alpha
float glow_smoothstep;     // glow smoothstep value
float glow_mix_ratio1;     // glow mixing ratio
float glow_mix_ratio2;     // source mixing ratio
bool shader_radial_flag=false;
float radial_value1;
float radial_value2;
float radial_color;        // color
bool shader_postfx_flag=SHADER?true:false;
bool postfx_scanline=true;
float postfx_deform;       // deformation ratio
#if SHADER
Shader* shader_simple;
Shader* shader_blur_h;
Shader* shader_blur_v;
Shader* shader_glow;
Shader* shader_radial;
Shader* shader_postfx;
// shader variables
ShaderUniform shader_simple_texture;
ShaderUniform shader_blur_h_texture;
ShaderUniform shader_blur_h_screen_w;
ShaderUniform shader_blur_h_screen_h;
ShaderUniform shader_blur_h_time;
ShaderUniform shader_blur_h_value;
ShaderUniform shader_blur_v_texture;
ShaderUniform shader_blur_v_screen_w;
ShaderUniform shader_blur_v_screen_h;
ShaderUniform shader_blur_v_time;
ShaderUniform shader_blur_v_value;
ShaderUniform shader_glow_texture;
ShaderUniform shader_glow_texture_prv;
ShaderUniform shader_glow_screen_w;
ShaderUniform shader_glow_screen_h;
ShaderUniform shader_glow_time;
ShaderUniform shader_glow_step;
ShaderUniform shader_glow_value1;
ShaderUniform shader_glow_value2;
ShaderUniform shader_radial_texture;
ShaderUniform shader_radial_screen_w;
ShaderUniform shader_radial_screen_h;
ShaderUniform shader_radial_time;
ShaderUniform shader_radial_value1;
ShaderUniform shader_radial_value2;
ShaderUniform shader_radial_color;
ShaderUniform shader_postfx_texture;
ShaderUniform shader_postfx_texture_2d;
ShaderUniform shader_postfx_screen_w;
ShaderUniform shader_postfx_screen_h;
ShaderUniform shader_postfx_time;
ShaderUniform shader_postfx_flash;
ShaderUniform shader_postfx_value;
ShaderUniform shader_postfx_deform;
ShaderUniform shader_postfx_scanline;
ShaderUniform shader_postfx_sync;

FrameBuffer *fbo_back;
FrameBuffer *fbo_front;
FrameBuffer *fbo_blur_h;
FrameBuffer *fbo_blur_v;
FrameBuffer *fbo_ping;
FrameBuffer *fbo_pong;
#endif

void init_viewport(int type)
{
    glViewport(0, 0, screen_w, screen_h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    mat4 proj = (type == 0) ? mat4::perspective(70, (float)(float)screen_w, (float)screen_h, nearplane, farplane) : mat4::ortho(0, screen_w, screen_h, 0);
    glLoadMatrixf(&proj[0][0]);
    glMatrixMode(GL_MODELVIEW);
}

#if SHADER
void init_shader()
{
    glDisable(GL_BLEND);
    glVertexPointer(4, GL_FLOAT, 0, fs_quad_vtx);
    glTexCoordPointer(2, GL_FLOAT, 0, fs_quad_tex);
}

void fs_quad()
{
    glLoadIdentity();
    glDrawArrays(GL_QUADS, 0, 4);
}

void draw_shader_simple(FrameBuffer *fbo_output, int n)
{
    shader_simple->Bind();
    shader_simple->SetTexture(shader_simple_texture, fbo_output->GetTexture(), n);
    fs_quad();
    shader_simple->Unbind();
}
#endif

void calc_txt()
{
    liner_length=txt.length();
    liner_count=0;
    liner_line_n=0;
    liner_max=0;
    liner_i=0;
    for(i=0;i<liner_length;i++)
    {
        if((unsigned char)txt[i]!=13)
        {
            liner_i++;
        }
        else
        {
            if(liner_i>liner_max) liner_max=liner_i;
            liner_line_n++;
            liner_i=0;
        }
    }
    if(liner_i>liner_max) liner_max=liner_i;
}

void flash()
{
    flash_flag=true;
    flash_angle=main_angle;
}

void fade()
{
    fade_flag=true;
    fade_angle=main_angle;
}

void sync()
{
    sync_flag=true;
    sync_angle=main_angle;
}

void beat()
{
    beat_flag=true;
    beat_angle=main_angle;
}

void rectangle(int x, int y, int w, int h)
{
    glLoadIdentity();
    glBegin(GL_QUADS);
        glVertex2i(x+w, y  );
        glVertex2i(x  , y  );
        glVertex2i(x  , y+h);
        glVertex2i(x+w, y+h);
    glEnd();
}

void corner()
{
    float vertex[2+corner_n*2];
    vertex[0]=0;
    vertex[1]=0;
    for(i=1;i<corner_n+1;i++)
    {
        j=i*2;
        float a=PID*90.0f/(corner_n-1)*(i-1);
        vertex[j  ]=corner_w-corner_w*cosf(a);
        vertex[j+1]=corner_w-corner_w*sinf(a);
    }
    for(i=0;i<corner_n;i++)
    {
        j=i*6;
        k=i*2;
        corner_vtx[j  ]=(int)vertex[0];
        corner_vtx[j+1]=(int)vertex[1];
        corner_vtx[j+2]=(int)vertex[2+k];
        corner_vtx[j+3]=(int)vertex[3+k];
        corner_vtx[j+4]=(int)vertex[4+k];
        corner_vtx[j+5]=(int)vertex[5+k];
    }
}

void screen()
{
    part_angle=main_angle;
    dos_flag=true;
    dos_r=CR*48;
    dos_g=CR*56;
    dos_b=CR*64;
    screen_r=dos_r;
    screen_g=dos_g;
    screen_b=dos_b;
    txt="\rCopyright \x05e 2012 cacaShell v0.1\r ";
    calc_txt();
    /*-------------------------*/
    shader_effect_flag=true;
    shader_glow_flag=true;
    glow_color=1;
    glow_smoothstep=0;//.025f;
    glow_mix_ratio1=0.5f;
    glow_mix_ratio2=0.5f;
    shader_radial_flag=false;
    radial_value1=2.0f;
    radial_value2=0.8f;
    radial_color=0;
    postfx_deform=0.5f;
    /*-------------------------*/
    flash_speed=1.5f;
    fade_speed=0.2f;
    sync_flag=false;
    sync_value=1.0f;
    sync_speed=1.0f;
    beat_speed=2.0f;
    /*-------------------------*/
    glClearColor(screen_r, screen_g, screen_b, 1.0f);
}

int InitGL(void)
{
    glClearDepth(1.0f);                                // set depth buffer
    glDepthMask(GL_TRUE);                            // do not write z-buffer
    glEnable(GL_CULL_FACE);                        // disable cull face
    glCullFace(GL_BACK);                            // don't draw front face
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    // load texture
     tex_map=new TileSet("neercs/video/resource/map.bmp", ivec2(256, 256), ivec2(1));
    // initialize some variable
    timer=new Timer();
    screen();
    /*-PATACODE----------------------------------------------------------------*/
    #if SHADER
    if(shader_flag)
    {
            fbo_back=new FrameBuffer(ivec2(screen_w, screen_h));
            fbo_front=new FrameBuffer(ivec2(screen_w, screen_h));
            fbo_blur_h=new FrameBuffer(ivec2(screen_w/glow_fbo_size, screen_h/glow_fbo_size));
            fbo_blur_v=new FrameBuffer(ivec2(screen_w/glow_fbo_size, screen_h/glow_fbo_size));
            fbo_ping=new FrameBuffer(ivec2(screen_w, screen_h));
            fbo_pong=new FrameBuffer(ivec2(screen_w, screen_h));
            // shader simple
            shader_simple=Shader::Create(lolfx_simple);
            shader_simple_texture=shader_simple->GetUniformLocation("texture");
            // shader blur horizontal
            shader_blur_h=Shader::Create(lolfx_blurh);
            shader_blur_h_texture=shader_blur_h->GetUniformLocation("texture");
            shader_blur_h_screen_w=shader_blur_h->GetUniformLocation("screen_w");
            shader_blur_h_screen_h=shader_blur_h->GetUniformLocation("screen_h");
            shader_blur_h_time=shader_blur_h->GetUniformLocation("time");
            shader_blur_h_value=shader_blur_h->GetUniformLocation("value");
            // shader blur vertical
            shader_blur_v=Shader::Create(lolfx_blurv);
            shader_blur_v_texture=shader_blur_v->GetUniformLocation("texture");
            shader_blur_v_screen_w=shader_blur_v->GetUniformLocation("screen_w");
            shader_blur_v_screen_h=shader_blur_v->GetUniformLocation("screen_h");
            shader_blur_v_time=shader_blur_v->GetUniformLocation("time");
            shader_blur_v_value=shader_blur_v->GetUniformLocation("value");
            // shader glow
            shader_glow=Shader::Create(lolfx_glow);
            shader_glow_texture=shader_glow->GetUniformLocation("texture");
            shader_glow_texture_prv=shader_glow->GetUniformLocation("texture_prv");
            shader_glow_screen_w=shader_glow->GetUniformLocation("screen_w");
            shader_glow_screen_h=shader_glow->GetUniformLocation("screen_h");
            shader_glow_time=shader_glow->GetUniformLocation("time");
            shader_glow_step=shader_glow->GetUniformLocation("step");
            shader_glow_value1=shader_glow->GetUniformLocation("value1");
            shader_glow_value2=shader_glow->GetUniformLocation("value2");
            // shader radial
            shader_radial=Shader::Create(lolfx_radial);
            shader_radial_texture=shader_radial->GetUniformLocation("texture");
            shader_radial_screen_w=shader_radial->GetUniformLocation("screen_w");
            shader_radial_screen_h=shader_radial->GetUniformLocation("screen_h");
            shader_radial_time=shader_radial->GetUniformLocation("time");
            shader_radial_value1=shader_radial->GetUniformLocation("value1");
            shader_radial_value2=shader_radial->GetUniformLocation("value2");
            shader_radial_color=shader_radial->GetUniformLocation("color");
            // shader postfx
            shader_postfx=Shader::Create(lolfx_postfx);
            shader_postfx_texture=shader_postfx->GetUniformLocation("texture");
            shader_postfx_texture_2d=shader_postfx->GetUniformLocation("texture_2d");
            shader_postfx_screen_w=shader_postfx->GetUniformLocation("screen_w");
            shader_postfx_screen_h=shader_postfx->GetUniformLocation("screen_h");
            shader_postfx_time=shader_postfx->GetUniformLocation("time");
            shader_postfx_flash=shader_postfx->GetUniformLocation("flash");
            shader_postfx_value=shader_postfx->GetUniformLocation("value");
            shader_postfx_deform=shader_postfx->GetUniformLocation("deform");
            shader_postfx_scanline=shader_postfx->GetUniformLocation("scanline");
            shader_postfx_sync=shader_postfx->GetUniformLocation("sync");
        }
    #endif
    /*-/PATACODE---------------------------------------------------------------*/
    return true;
}

int DrawGLScene(void) // draw scene
{
    // timer
    if(!pause) main_angle += timer->Get() * 100.0f * PID;
    if(sync_flag)
    {
        angle=(main_angle-sync_angle)*sync_speed;
        sync_value=1.0f-sinf(angle);
        if(angle>90.0f*PID)
        {
            sync_value=0;
            sync_flag=false;
        }
    }
    if(beat_flag)
    {
        angle=(main_angle-beat_angle)*beat_speed;
        beat_value=1.0f-sinf(angle);
        if(angle>90.0f*PID)
        {
            beat_value=0;
            beat_flag=false;
        }
    }
    if(flash_flag)
    {
        angle=(main_angle-flash_angle)*flash_speed;
        flash_value=1.0f-sinf(angle);
        if(angle>90.0f*PID)
        {
            flash_value=0;
            flash_flag=false;
        }
    }
    if(fade_flag)
    {
        angle=(main_angle-fade_angle)*fade_speed;
        fade_value=1.0f-sinf(angle);
        if(angle>90.0f*PID)
        {
            fade_value=0;
            fade_flag=false;
        }
    }
    /*-PATACODE----------------------------------------------------------------*/
    #if SHADER
    if(shader_flag)
    {
        fbo_back->Bind();
        fbo_back->Clear(vec4(screen_r, screen_g, screen_b, 0.0f), 1.0f);
    }
    else
    {
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    }
    #else
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    #endif
    /*-/PATACODE---------------------------------------------------------------*/
    glEnable(GL_BLEND);
    //if(polygon) glEnable(GL_LINE_SMOOTH); else glDisable(GL_LINE_SMOOTH);
    glLineWidth((polygon)?2.0f:1.0f);
    fx_angle=main_angle-part_angle;
    if(polygon) glEnable(GL_TEXTURE_2D);
    /* .-------------------. */
    /* | DRAW SOME 2D HERE | */
    /* °-------------------° */
    init_viewport(1);
    tex_map->Bind();
    glEnable(GL_BLEND);
    // draw dos
    if(dos_flag)
    {
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_BLEND);
        glColor3f(1.0f, 1.0f, 1.0f);
        rectangle(dos_m, dos_m, screen_w-(int)(26.5f*ratio_2d)-dos_m*2, 10*ratio_2d);
        rectangle(screen_w-(int)(25.5f*ratio_2d)-dos_m, dos_m, 11*ratio_2d, 10*ratio_2d);
        rectangle(screen_w-(int)(13.5f*ratio_2d)-dos_m, dos_m, 11*ratio_2d, 10*ratio_2d);
        rectangle(screen_w-(int)(1.5f*ratio_2d)-dos_m, dos_m, (int)(1.5f*ratio_2d), 10*ratio_2d);
        rectangle(dos_m, dos_m+10*ratio_2d, 1*ratio_2d, screen_h-10*ratio_2d-dos_m*2);
        rectangle(screen_w-1*ratio_2d-dos_m, dos_m+10*ratio_2d, 1*ratio_2d, screen_h-10*ratio_2d-dos_m*2);
        rectangle(dos_m+1*ratio_2d, screen_h-1*ratio_2d-dos_m, screen_w-2*ratio_2d-dos_m*2, 1*ratio_2d);
        glColor3f(dos_r, dos_g, dos_b);
        rectangle(dos_m+1*ratio_2d, dos_m+1*ratio_2d, 28*ratio_2d, 8*ratio_2d);
        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);
        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);
        rectangle(screen_w-(int)(24.5f*ratio_2d)-dos_m, dos_m+1*ratio_2d, 7*ratio_2d, 6*ratio_2d);
        glColor3f(1.0f, 1.0f, 1.0f);
        rectangle(screen_w-(int)(23.5f*ratio_2d)-dos_m, dos_m+2*ratio_2d, 5*ratio_2d, 4*ratio_2d);
        glColor3f(0, 0, 0);
        rectangle(screen_w-(int)(22.5f*ratio_2d)-dos_m, dos_m+3*ratio_2d, 7*ratio_2d, 6*ratio_2d);
        rectangle(screen_w-(int)(12.5f*ratio_2d)-dos_m, dos_m+1*ratio_2d, 7*ratio_2d, 6*ratio_2d);
        glColor3f(dos_r, dos_g, dos_b);
        rectangle(screen_w-(int)(10.5f*ratio_2d)-dos_m, dos_m+2*ratio_2d, 7*ratio_2d, 7*ratio_2d);
        glColor3f(1.0f, 1.0f, 1.0f);
        rectangle(screen_w-(int)(9.5f*ratio_2d)-dos_m, dos_m+3*ratio_2d, 5*ratio_2d, 5*ratio_2d);
        rectangle(screen_w-8*ratio_2d-dos_m, screen_h-9*ratio_2d-dos_m, 7*ratio_2d, 8*ratio_2d);
        glColor3f(dos_r, dos_g, dos_b);
        rectangle(screen_w-7*ratio_2d-dos_m, screen_h-8*ratio_2d-dos_m, 6*ratio_2d, 7*ratio_2d);
        glColor3f(1.0f, 1.0f, 1.0f);
        rectangle(screen_w-4*ratio_2d-dos_m, screen_h-8*ratio_2d-dos_m, 4*ratio_2d, 2*ratio_2d);
        rectangle(screen_w-7*ratio_2d-dos_m, screen_h-5*ratio_2d-dos_m, 2*ratio_2d, 5*ratio_2d);
        rectangle(screen_w-6*ratio_2d-dos_m, screen_h-7*ratio_2d-dos_m, 1*ratio_2d, 1*ratio_2d);
        rectangle(screen_w-4*ratio_2d-dos_m, screen_h-5*ratio_2d-dos_m, 2*ratio_2d, 3*ratio_2d);
        glEnable(GL_BLEND);
        if(polygon) glEnable(GL_TEXTURE_2D);
        glBlendFunc(GL_ONE, GL_ONE);
        glVertexPointer(2, GL_INT, 0, shell_vtx);
        glTexCoordPointer(2, GL_FLOAT, 0, shell_tex);
        glDrawArrays(GL_QUADS, 0, 4);
        // draw dos text
        glVertexPointer(2, GL_INT, 0, dos_vtx);
        j=0;
        liner_line=-1;
        for(i=1;i<liner_length+1;i++)
        {
            j++;
            car=(unsigned char)txt[i-1];
            if(i==liner_length) car=car_cursor;
            if(car>32)
            {
                glLoadIdentity();
                glTranslated(x+j*(dos_w+2*ratio_2d), y, 0);
                float l_w=(car%16)*0.03125f;
                float l_h=(car-car%16)*0.001953125f;
                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};
                glTexCoordPointer(2, GL_FLOAT, 0, dos_tex);
                if(car==car_cursor) glColor3f(CR*(dos_r+64), CR*(dos_g+48), CR*(dos_b+48));
                glDrawArrays(GL_QUADS, 0, 4);
                if(car==car_cursor) glColor3f(1.0f, 1.0f, 1.0f);
            }
            if(car==13)
            {
                j=0;
                liner_line++;
                x=dos_m;
                y=dos_m+(float)(15*ratio_2d+liner_line*(dos_h+4*ratio_2d));
                if(y+dos_h>screen_h-dos_m) break;
            }
        }
    }
    // draw debug
    //#if DEBUG
    if(debug_flag)
    {
        char debug[512];
        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);
        float l_v=0.0390625f;
        float l_j=0.001953125f;
        glVertexPointer(2, GL_INT, 0, debug_vtx);
        glLoadIdentity();
        glBlendFunc(GL_ONE, GL_ONE);
        glColor3f(0.625f, 0.25f, 0.0f);
        glTranslated(debug_x, debug_y, 0);
        j=0;
        for(i=0;i<(int)strlen(debug);i++)
        {
            j++;
            car=(unsigned char)debug[i];
            if(car==13)
            {
                glTranslated(-j*(debug_w-ratio_2d)*2, (debug_h-ratio_2d)*2, 0);
                j=0;
            }
            glTranslated((debug_w-ratio_2d)*2, 0, 0);
            if(car>32)
            {
                float l_w=(car%16)*0.03515625f;
                float l_h=(car-car%16)*0.00244140625f;
                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};
                glTexCoordPointer(2, GL_FLOAT, 0, debug_tex);
                glDrawArrays(GL_QUADS, 0, 4);
            }
        }
    }
    //#endif
    // draw corner
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_BLEND);
    glVertexPointer(2, GL_INT, 0, corner_vtx);
    glLoadIdentity();
    glColor3f(0, 0, 0);
    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
    glTranslated(screen_w, 0, 0);
    glRotated(90.0f, 0, 0, 1.0f);
    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
    glTranslated(screen_h, 0, 0);
    glRotated(90.0f, 0, 0, 1.0f);
    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
    glTranslated(screen_w, 0, 0);
    glRotated(90.0f, 0, 0, 1.0f);
    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
    glEnable(GL_BLEND);
    /* .-------------------. */
    /* | DRAW SOME 3D HERE | */
    /* °-------------------° */
    //init_viewport(0);
    /*-PATACODE----------------------------------------------------------------*/
    #if SHADER
    if(shader_flag)
    {
        init_shader();
        fbo_back->Unbind();
        if(shader_effect_flag&&shader_blur_flag)
        {
            // shader blur horizontal
            fbo_ping->Bind();
            shader_blur_h->Bind();
            shader_blur_h->SetTexture(shader_blur_h_texture, fbo_back->GetTexture(), 0);
            shader_blur_h->SetUniform(shader_blur_h_screen_w, 1.0f);
            shader_blur_h->SetUniform(shader_blur_h_screen_h, 1.0f);
            shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
            shader_blur_h->SetUniform(shader_blur_h_value, 0.5f/screen_w);
            fs_quad();
            shader_blur_h->Unbind();
            fbo_ping->Unbind();
            // shader blur vertical
            fbo_front->Bind();
            shader_blur_v->Bind();
            shader_blur_v->SetTexture(shader_blur_v_texture, fbo_ping->GetTexture(), 0);
            shader_blur_v->SetUniform(shader_blur_v_screen_w, 1.0f);
            shader_blur_v->SetUniform(shader_blur_v_screen_h, 1.0f);
            shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
            shader_blur_v->SetUniform(shader_blur_v_value, 0.5f/screen_h);
            fs_quad();
            shader_blur_v->Unbind();
        }
        else
        {
            // shader simple
            fbo_front->Bind();
            draw_shader_simple(fbo_back, 0);
        }
        fbo_front->Unbind();
        // shader glow
        if(shader_effect_flag&&shader_glow_flag)
        {
            // shader blur horizontal
            fbo_blur_h->Bind();
            shader_blur_h->Bind();
            shader_blur_h->SetTexture(shader_blur_h_texture, fbo_ping->GetTexture(), 0);
            shader_blur_h->SetUniform(shader_blur_h_screen_w, 1.0f/glow_fbo_size);
            shader_blur_h->SetUniform(shader_blur_h_screen_h, 1.0f/glow_fbo_size);
            shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
            shader_blur_h->SetUniform(shader_blur_h_value, 2.5f/screen_w);
            fs_quad();
            shader_blur_h->Unbind();
            fbo_blur_h->Unbind();
            // shader blur vertical
            fbo_blur_v->Bind();
            shader_blur_v->Bind();
            shader_blur_v->SetTexture(shader_blur_v_texture, fbo_blur_h->GetTexture(), 0);
            shader_blur_v->SetUniform(shader_blur_v_screen_w, 1.0f/glow_fbo_size);
            shader_blur_v->SetUniform(shader_blur_v_screen_h, 1.0f/glow_fbo_size);
            shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
            shader_blur_v->SetUniform(shader_blur_h_value, 2.5f/screen_h);
            fs_quad();
            shader_blur_v->Unbind();
            fbo_blur_v->Unbind();
            // shader blur horizontal
            fbo_blur_h->Bind();
            shader_blur_h->Bind();
            shader_blur_h->SetTexture(shader_blur_h_texture, fbo_blur_v->GetTexture(), 0);
            shader_blur_h->SetUniform(shader_blur_h_screen_w, 1.0f/glow_fbo_size);
            shader_blur_h->SetUniform(shader_blur_h_screen_h, 1.0f/glow_fbo_size);
            shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
            shader_blur_h->SetUniform(shader_blur_h_value, 1.0f/screen_w);
            fs_quad();
            shader_blur_h->Unbind();
            fbo_blur_h->Unbind();
            // shader blur vertical
            fbo_blur_v->Bind();
            shader_blur_v->Bind();
            shader_blur_v->SetTexture(shader_blur_v_texture, fbo_blur_h->GetTexture(), 0);
            shader_blur_v->SetUniform(shader_blur_v_screen_w, 1.0f/glow_fbo_size);
            shader_blur_v->SetUniform(shader_blur_v_screen_h, 1.0f/glow_fbo_size);
            shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
            shader_blur_v->SetUniform(shader_blur_h_value, 1.0f/screen_h);
            fs_quad();
            shader_blur_v->Unbind();
            fbo_blur_v->Unbind();
            // shader glow
            fbo_pong->Bind();
            shader_glow->Bind();
            shader_glow->SetTexture(shader_glow_texture, fbo_blur_v->GetTexture(), 0);
            shader_glow->SetTexture(shader_glow_texture_prv, fbo_front->GetTexture(), 1);
            shader_glow->SetUniform(shader_glow_screen_w, 1.0f);
            shader_glow->SetUniform(shader_glow_screen_h, 1.0f);
            shader_glow->SetUniform(shader_glow_time, fx_angle);
            shader_glow->SetUniform(shader_glow_step, glow_smoothstep);
            shader_glow->SetUniform(shader_glow_value1, glow_mix_ratio1);
            shader_glow->SetUniform(shader_glow_value2, glow_mix_ratio2);
            fs_quad();
            shader_glow->Unbind();
        }
        if(!shader_effect_flag)
        {
            // shader simple
            fbo_pong->Bind();
            draw_shader_simple(fbo_front, 0);
        }
        fbo_pong->Unbind();
        if(shader_postfx_flag)
        {
            // shader postfx
            shader_postfx->Bind();
            shader_postfx->SetTexture(shader_postfx_texture, fbo_pong->GetTexture(), 0);
            shader_postfx->SetUniform(shader_postfx_screen_w, screen_w);
            shader_postfx->SetUniform(shader_postfx_screen_h, screen_h);
            shader_postfx->SetUniform(shader_postfx_time, fx_angle);
            shader_postfx->SetUniform(shader_postfx_flash, flash_value);
            shader_postfx->SetUniform(shader_postfx_value, 4.0f);
            shader_postfx->SetUniform(shader_postfx_deform, postfx_deform);
            shader_postfx->SetUniform(shader_postfx_scanline, postfx_scanline);
            shader_postfx->SetUniform(shader_postfx_sync, (float)fabs(beat_value*cosf((main_angle-beat_angle)*8.0f)));
            fs_quad();
            shader_postfx->Unbind();
        }
        else
        {
            // shader simple
            draw_shader_simple(fbo_pong, 0);
        }
    }
    #endif
    /*-/PATACODE---------------------------------------------------------------*/
    return true;
}

int CreateGLWindow(char* title)
{
    GLuint pixelFormat;    // pixel format result
    uint32_t dwExStyle;        // window extended style
    uint32_t dwStyle;            // window style
    screen_w=Video::GetSize().x;
    screen_h=Video::GetSize().y;
    //ratio_2d=(int)(screen_w/400); if(ratio_2d<2) ratio_2d=2;
    corner_w=16*ratio_2d;
    corner();
    dos_w=2*ratio_2d;
    dos_h=4*ratio_2d;
    dos_m=12*ratio_2d;
    dos_vtx[0]=dos_w;
    dos_vtx[1]=dos_h;
    dos_vtx[2]=dos_w;
    dos_vtx[3]=-dos_h;
    dos_vtx[4]=-dos_w;
    dos_vtx[5]=-dos_h;
    dos_vtx[6]=-dos_w;
    dos_vtx[7]=dos_h;
    shell_vtx[0]=dos_m+29*ratio_2d;
    shell_vtx[1]=dos_m+9*ratio_2d;
    shell_vtx[2]=dos_m+29*ratio_2d;
    shell_vtx[3]=dos_m+1*ratio_2d;
    shell_vtx[4]=dos_m+1*ratio_2d;
    shell_vtx[5]=dos_m+1*ratio_2d;
    shell_vtx[6]=dos_m+1*ratio_2d;
    shell_vtx[7]=dos_m+9*ratio_2d;
    debug_w=5*ratio_2d;
    debug_h=5*ratio_2d;
    debug_x=10*ratio_2d;
    debug_y=28*ratio_2d;
    debug_vtx[0]=debug_w;
    debug_vtx[1]=debug_h;
    debug_vtx[2]=debug_w;
    debug_vtx[3]=-debug_h;
    debug_vtx[4]=-debug_w;
    debug_vtx[5]=-debug_h;
    debug_vtx[6]=-debug_w;
    debug_vtx[7]=debug_h;
    InitGL();
    return true;
}

Render::Render()
{
}

void Render::TickGame(float seconds)
{
    Entity::TickGame(seconds);
}

void Render::TickDraw(float seconds)
{
    Entity::TickDraw(seconds);

    static int todo = 1;
    if (todo)
    {
        CreateGLWindow("LOL");
        todo = 0;
    }
    DrawGLScene();
}

Render::~Render()
{
}