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

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

new font / blur+chromatic aberration boosted on screen corners / various optimization in postfx

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