source: trunk/neercs/video/render.cpp @ 1482 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;
extern char const *lolfx_text;

#define DEBUG 1            // debug flag //#if defined(_DEBUG)
#define SHADER 1           // shader flag
#define FUCK 1             // test flag
#define PID M_PI/180.0f    // pi ratio
#define CR 1.0f/256.0f     // color ratio

bool done = false;

/*
 * Various variables
 */

int keys[256];             // keyboard array
int active = true;         // window active flag
bool fullscreen = DEBUG?false:true; // fullscreen flag
bool paused = 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
/* window variable */
ivec2 screen_size;         // screen size
int window_color = 32;     // color depth
vec3 screen_color;         // screen color
/* object variable */
float main_angle;          // main angle
float part_angle;          // part angle
float fx_angle;            // current angle
/* text variable */
char const *name = "cacaShell";
/* 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
/* 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_m;                 // margin
vec3 dos_color;            // color value
int dos_vtx[8];            // vertex array
ivec2 ratio_2d(2,4);       // 2d ratio
ivec2 map_size(256,256);   // texture map size
ivec2 font_size(8,8);      // font size
vec2 car_size(1.0f/map_size.x*font_size.x, 1.0f/map_size.y*font_size.y);
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 */
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_blur_h, *shader_blur_v;
Shader *shader_glow, *shader_radial, *shader_postfx;
// shader variables
ShaderUniform shader_simple_texture;
ShaderUniform shader_blur_h_texture,
              shader_blur_h_screen_size,
              shader_blur_h_time,
              shader_blur_h_value;
ShaderUniform shader_blur_v_texture,
              shader_blur_v_screen_size,
              shader_blur_v_time,
              shader_blur_v_value;
ShaderUniform shader_glow_texture,
              shader_glow_texture_prv,
              shader_glow_screen_size,
              shader_glow_time,
              shader_glow_step,
              shader_glow_value1,
              shader_glow_value2;
ShaderUniform shader_radial_texture,
              shader_radial_screen_size,
              shader_radial_time,
              shader_radial_value1,
              shader_radial_value2,
              shader_radial_color;
ShaderUniform shader_postfx_texture,
              shader_postfx_texture_2d,
              shader_postfx_screen_size,
              shader_postfx_time,
              shader_postfx_flash,
              shader_postfx_value,
              shader_postfx_deform,
              shader_postfx_scanline,
              shader_postfx_sync;

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

/*
 * Text rendering interface
 */
struct TextRender
{
    TextRender(caca_canvas_t *caca)
      : m_caca(caca),
        m_width(caca_get_canvas_width(m_caca)),
        m_height(caca_get_canvas_height(m_caca))
    {
        for (int j = 0; j < m_height; j++)
        for (int i = 0; i < m_width; i++)
            m_vertices << vec2(5.1 / 128.0 * i - 0.91, 0.75 - 0.0525 * j);
    }

    void Init()
    {
        m_shader = Shader::Create(lolfx_text);
        m_coord = m_shader->GetAttribLocation("in_Position",
                                              VertexUsage::Position, 0);
        m_color = m_shader->GetAttribLocation("in_Attr",
                                              VertexUsage::Color, 0);
        m_char = m_shader->GetAttribLocation("in_Char",
                                             VertexUsage::Color, 1);
        m_texture = m_shader->GetUniformLocation("in_Texture");
        m_vdecl
          = new VertexDeclaration(VertexStream<vec2>(VertexUsage::Position),
                                  VertexStream<uint32_t>(VertexUsage::Color),
                                  VertexStream<uint32_t>(VertexUsage::Color));

        m_vbo1 = new VertexBuffer(m_vertices.Bytes());
        void *vertices = m_vbo1->Lock(0, 0);
        memcpy(vertices, &m_vertices[0], m_vertices.Bytes());
        m_vbo1->Unlock();

        m_vbo2 = new VertexBuffer(m_width * m_height * sizeof(int32_t));
        m_vbo3 = new VertexBuffer(m_width * m_height * sizeof(int32_t));
    }

    void Blit()
    {
        uint32_t *colors = (uint32_t *)m_vbo2->Lock(0, 0);
        for (int j = 0; j < m_height; j++)
        for (int i = 0; i < m_width; i++)
        {
            uint32_t attr = caca_get_attr(m_caca, i, j);
            uint16_t fg = caca_attr_to_rgb12_fg(attr);
            uint16_t bg = caca_attr_to_rgb12_bg(attr);
            caca_set_color_argb(m_caca, fg, bg);
            attr = caca_get_attr(m_caca, -1, -1);
            caca_put_attr(m_caca, i, j, attr);
            uint32_t a2 = caca_get_attr(m_caca, i, j);
        }
        memcpy(colors, caca_get_canvas_attrs(m_caca),
               m_width * m_height * sizeof(uint32_t));
        m_vbo2->Unlock();

        uint32_t *chars = (uint32_t *)m_vbo3->Lock(0, 0);
        memcpy(chars, caca_get_canvas_chars(m_caca),
               m_width * m_height * sizeof(uint32_t));
        m_vbo3->Unlock();

        glEnable(GL_POINT_SPRITE);
        //glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
        glDisable(GL_POINT_SMOOTH);
        glPointSize(16.f);
        m_shader->Bind();
        tex_map->Bind();
        m_shader->SetUniform(m_texture, 0);
        m_vdecl->SetStream(m_vbo1, m_coord);
        m_vdecl->SetStream(m_vbo2, m_color);
        m_vdecl->SetStream(m_vbo3, m_char);
        m_vdecl->Bind();
        m_vdecl->DrawElements(MeshPrimitive::Points, 0, m_width * m_height);
        m_vdecl->Unbind();
        tex_map->Unbind();
        m_shader->Unbind();
        glDisable(GL_POINT_SPRITE);
    }

private:
    caca_canvas_t *m_caca;
    int m_width, m_height;

    Array<vec2> m_vertices;
    Shader *m_shader;
    ShaderAttrib m_coord, m_color, m_char;
    ShaderUniform m_texture;
    VertexDeclaration *m_vdecl;
    VertexBuffer *m_vbo1, *m_vbo2, *m_vbo3;
};

TextRender *text_render;

void init_viewport(int type)
{
    glViewport(0, 0, screen_size.x, screen_size.y);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    mat4 m;
    if (type == 0)
        m = mat4::perspective(70, (float)screen_size.x, (float)screen_size.y,
                              nearplane, farplane);
    else
        m = mat4::ortho(0, screen_size.x, screen_size.y, 0, -1.f, 1.f);
    glLoadMatrixf(&m[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 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 (int i = 1; i < corner_n + 1; i++)
    {
        int 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 (int i = 0; i < corner_n; i++)
    {
        int j = i*6;
        int 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_color = CR * vec3(48, 56, 64);
    screen_color = dos_color;
    /*-------------------------*/
    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_color.r, screen_color.g, screen_color.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
    // load texture
    tex_map = new TileSet("neercs/video/resource/map.png", ivec2(256, 256), ivec2(1));
    // initialize some variable
    screen();
#if SHADER
    if (shader_flag)
    {
        fbo_back = new FrameBuffer(screen_size);
        fbo_front = new FrameBuffer(screen_size);
        fbo_blur_h = new FrameBuffer(screen_size / glow_fbo_size);
        fbo_blur_v = new FrameBuffer(screen_size / glow_fbo_size);
        fbo_ping = new FrameBuffer(screen_size);
        fbo_pong = new FrameBuffer(screen_size);
        // 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_size = shader_blur_h->GetUniformLocation("screen_size");
        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_size = shader_blur_v->GetUniformLocation("screen_size");
        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_size = shader_glow->GetUniformLocation("screen_size");
        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_size = shader_radial->GetUniformLocation("screen_size");
        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_size = shader_postfx->GetUniformLocation("screen_size");
        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
    return true;
}

int CreateGLWindow(char const *title)
{
    screen_size = Video::GetSize();
    corner_w = 16*ratio_2d.x;
    corner();
    dos_m=12*ratio_2d.x;
    dos_vtx[0]=font_size.x*ratio_2d.x/2.0f;
    dos_vtx[1]=font_size.y*ratio_2d.y/2.0f;
    dos_vtx[2]=font_size.x*ratio_2d.x/2.0f;
    dos_vtx[3]=-font_size.y*ratio_2d.y/2.0f;
    dos_vtx[4]=-font_size.x*ratio_2d.x/2.0f;
    dos_vtx[5]=-font_size.y*ratio_2d.y/2.0f;
    dos_vtx[6]=-font_size.x*ratio_2d.x/2.0f;
    dos_vtx[7]=font_size.y*ratio_2d.y/2.0f;
    shell_vtx[0]=dos_m+58*ratio_2d.x;
    shell_vtx[1]=dos_m+(font_size.y+1)*ratio_2d.y;
    shell_vtx[2]=dos_m+58*ratio_2d.x;
    shell_vtx[3]=dos_m+ratio_2d.y;
    shell_vtx[4]=dos_m+2*ratio_2d.x;
    shell_vtx[5]=dos_m+ratio_2d.y;
    shell_vtx[6]=dos_m+2*ratio_2d.x;
    shell_vtx[7]=dos_m+(font_size.y+1)*ratio_2d.y;
    InitGL();
    return true;
}

Render::Render(caca_canvas_t *caca)
  : m_caca(caca)
{
    text_render = new TextRender(m_caca);
}

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;
        text_render->Init();
    }

    // timer
    if(!paused)
        main_angle += seconds * 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;
        }
    }

    Draw2D();
    Draw3D();
}

void Render::Draw2D()
{
#if SHADER
    if(shader_flag)
    {
        fbo_back->Bind();
        fbo_back->Clear(vec4(screen_color, 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

    text_render->Blit();

    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);

    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);

    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_size.x-53*ratio_2d.x-dos_m*2,(font_size.y+2)*ratio_2d.y);
        rectangle(screen_size.x-51*ratio_2d.x-dos_m,dos_m,22*ratio_2d.x,(font_size.y+2)*ratio_2d.y);
        rectangle(screen_size.x-27*ratio_2d.x-dos_m,dos_m,22*ratio_2d.x,(font_size.y+2)*ratio_2d.y);
        rectangle(screen_size.x-3*ratio_2d.x-dos_m,dos_m,3*ratio_2d.x,(font_size.y+2)*ratio_2d.y);
        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);
        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);
        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);
        glColor3f(dos_color.x,dos_color.y,dos_color.z);
        rectangle(dos_m+2*ratio_2d.x,dos_m+ratio_2d.y,56*ratio_2d.x,font_size.y*ratio_2d.y);
        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);
        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);
        rectangle(screen_size.x-49*ratio_2d.x-dos_m,dos_m+ratio_2d.y,14*ratio_2d.x,6*ratio_2d.y);
        glColor3f(1.0f,1.0f,1.0f);
        rectangle(screen_size.x-47*ratio_2d.x-dos_m,dos_m+2*ratio_2d.y,10*ratio_2d.x,4*ratio_2d.y);
        glColor3f(0,0,0);
        rectangle(screen_size.x-45*ratio_2d.x-dos_m,dos_m+3*ratio_2d.y,14*ratio_2d.x,6*ratio_2d.y);
        rectangle(screen_size.x-25*ratio_2d.x-dos_m,dos_m+1*ratio_2d.y,14*ratio_2d.x,6*ratio_2d.y);
        glColor3f(dos_color.x,dos_color.y,dos_color.z);
        rectangle(screen_size.x-21*ratio_2d.x-dos_m,dos_m+2*ratio_2d.y,14*ratio_2d.x,7*ratio_2d.y);
        glColor3f(1.0f,1.0f,1.0f);
        rectangle(screen_size.x-19*ratio_2d.x-dos_m,dos_m+3*ratio_2d.y,10*ratio_2d.x,5*ratio_2d.y);
        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);
        glColor3f(dos_color.x,dos_color.y,dos_color.z);
        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);
        glColor3f(1.0f,1.0f,1.0f);
        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);
        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);
        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);
        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);
        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 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_size.x, 0, 0);
    glRotated(90.0f, 0, 0, 1.0f);
    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
    glTranslated(screen_size.y, 0, 0);
    glRotated(90.0f, 0, 0, 1.0f);
    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
    glTranslated(screen_size.x, 0, 0);
    glRotated(90.0f, 0, 0, 1.0f);
    glDrawArrays(GL_TRIANGLES, 0, corner_n*3);
    glEnable(GL_BLEND);
    tex_map->Unbind();

    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}

void Render::Draw3D()
{
    //init_viewport(0);
    glDisable(GL_DEPTH_TEST);

#if SHADER
    if (!shader_flag)
        return;

    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);

    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_size, vec2(1.0f));
        shader_blur_h->SetUniform(shader_blur_h_time, fx_angle);
        shader_blur_h->SetUniform(shader_blur_h_value, 0.5f/screen_size.x);
        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_size, vec2(1.0f));
        shader_blur_v->SetUniform(shader_blur_v_time, fx_angle);
        shader_blur_v->SetUniform(shader_blur_v_value, 0.5f/screen_size.y);
        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_size, vec2(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_size.x);
        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_size, vec2(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_size.y);
        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_size, vec2(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_size.x);
        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_size, vec2(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_size.y);
        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_size, vec2(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_size, (vec2)screen_size);
        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);
    }

    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
#endif
}

Render::~Render()
{
}