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 | |
---|
27 | using namespace std; |
---|
28 | using namespace lol; |
---|
29 | |
---|
30 | #include "../neercs.h" |
---|
31 | #include "render.h" |
---|
32 | |
---|
33 | extern char const *lolfx_blurh; |
---|
34 | extern char const *lolfx_blurv; |
---|
35 | extern char const *lolfx_glow; |
---|
36 | extern char const *lolfx_postfx; |
---|
37 | extern char const *lolfx_radial; |
---|
38 | extern char const *lolfx_simple; |
---|
39 | extern char const *lolfx_text; |
---|
40 | |
---|
41 | #define DEBUG 1 // debug flag //#if defined(_DEBUG) |
---|
42 | #define SHADER 1 // shader flag |
---|
43 | #define PID M_PI/180.0f // pi ratio |
---|
44 | #define CR 1.0f/256.0f // color ratio |
---|
45 | |
---|
46 | bool done = false; |
---|
47 | |
---|
48 | /* |
---|
49 | * Various variables |
---|
50 | */ |
---|
51 | |
---|
52 | int keys[256]; // keyboard array |
---|
53 | int active = true; // window active flag |
---|
54 | bool fullscreen = DEBUG?false:true; // fullscreen flag |
---|
55 | bool paused = false; // pause flag |
---|
56 | float nearplane = 0.1f; // nearplane |
---|
57 | float farplane = 1000.0f; // farplane |
---|
58 | bool polygon = true; // polygon mode |
---|
59 | int polygon_fillmode = GL_FILL; // fill mode |
---|
60 | /* window variable */ |
---|
61 | ivec2 screen_size; // screen size |
---|
62 | int window_color = 32; // color depth |
---|
63 | vec3 screen_color; // screen color |
---|
64 | /* object variable */ |
---|
65 | float main_angle; // main angle |
---|
66 | float part_angle; // part angle |
---|
67 | float fx_angle; // current angle |
---|
68 | /* text variable */ |
---|
69 | char const *name = "cacaShell"; |
---|
70 | /* fs_quad variable */ |
---|
71 | 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}; |
---|
72 | float fs_quad_tex[] = {0, 1.0f, 0, 0, 1.0f, 0, 1.0f, 1.0f}; |
---|
73 | /* flash variable */ |
---|
74 | bool flash_flag = false; // flag |
---|
75 | float flash_angle = 0; // angle |
---|
76 | float flash_value = 0; // value |
---|
77 | float flash_speed; // speed |
---|
78 | /* fade variable */ |
---|
79 | bool fade_flag = false; // flag |
---|
80 | float fade_angle = 0; // angle |
---|
81 | float fade_value = 0; // value |
---|
82 | float fade_speed; // speed |
---|
83 | /* sync variable */ |
---|
84 | bool sync_flag = false; // flag |
---|
85 | float sync_angle = 0; // angle |
---|
86 | float sync_value = 0; // value |
---|
87 | float sync_speed; // speed |
---|
88 | /* beat variable */ |
---|
89 | bool beat_flag = false; // flag |
---|
90 | float beat_angle = 0; // angle |
---|
91 | float beat_value = 0; // value |
---|
92 | float beat_speed; // speed |
---|
93 | /* corner variable */ |
---|
94 | const int corner_n = 10; // polygon number |
---|
95 | int corner_w = 24; // radius |
---|
96 | int corner_vtx[corner_n*6];// vertex array |
---|
97 | /* dos variable */ |
---|
98 | bool dos_flag = false; // flag |
---|
99 | int dos_m; // margin |
---|
100 | vec3 dos_color; // color value |
---|
101 | int dos_vtx[8]; // vertex array |
---|
102 | ivec2 ratio_2d(2,4); // 2d ratio |
---|
103 | ivec2 map_size(256,256); // texture map size |
---|
104 | ivec2 font_size(8,8); // font size |
---|
105 | vec2 car_size(1.0f/map_size.x*font_size.x, 1.0f/map_size.y*font_size.y); |
---|
106 | int shell_vtx[8]; // vertex array |
---|
107 | float shell_tex[] = {1.0f, 0.96875f, 1.0f, 1.0f, 0.78125f, 1.0f, 0.78125f, 0.96875f}; |
---|
108 | /* keyboard variable */ |
---|
109 | int key_code = 0; // keyboard code |
---|
110 | /* common variable */ |
---|
111 | float value, angle, radius, scale, speed; |
---|
112 | TileSet *tex_map; |
---|
113 | /* shader variable */ |
---|
114 | bool shader_flag = SHADER?true:false; |
---|
115 | bool shader_blur_flag = SHADER?true:false; |
---|
116 | bool shader_effect_flag = SHADER?true:false; |
---|
117 | bool shader_glow_flag = true; |
---|
118 | int glow_fbo_size = 2; // glow fbo size |
---|
119 | int glow_color; // 0 = color / 1 = alpha |
---|
120 | float glow_smoothstep; // glow smoothstep value |
---|
121 | float glow_mix_ratio1; // glow mixing ratio |
---|
122 | float glow_mix_ratio2; // source mixing ratio |
---|
123 | bool shader_radial_flag = false; |
---|
124 | float radial_value1; |
---|
125 | float radial_value2; |
---|
126 | float radial_color; // color |
---|
127 | bool shader_postfx_flag = SHADER?true:false; |
---|
128 | bool postfx_scanline = true; |
---|
129 | float postfx_deform; // deformation ratio |
---|
130 | #if SHADER |
---|
131 | Shader *shader_simple, *shader_blur_h, *shader_blur_v; |
---|
132 | Shader *shader_glow, *shader_radial, *shader_postfx; |
---|
133 | // shader variables |
---|
134 | ShaderUniform shader_simple_texture; |
---|
135 | ShaderUniform shader_blur_h_texture, |
---|
136 | shader_blur_h_screen_size, |
---|
137 | shader_blur_h_time, |
---|
138 | shader_blur_h_value; |
---|
139 | ShaderUniform shader_blur_v_texture, |
---|
140 | shader_blur_v_screen_size, |
---|
141 | shader_blur_v_time, |
---|
142 | shader_blur_v_value; |
---|
143 | ShaderUniform shader_glow_texture, |
---|
144 | shader_glow_texture_prv, |
---|
145 | shader_glow_screen_size, |
---|
146 | shader_glow_time, |
---|
147 | shader_glow_step, |
---|
148 | shader_glow_value1, |
---|
149 | shader_glow_value2; |
---|
150 | ShaderUniform shader_radial_texture, |
---|
151 | shader_radial_screen_size, |
---|
152 | shader_radial_time, |
---|
153 | shader_radial_value1, |
---|
154 | shader_radial_value2, |
---|
155 | shader_radial_color; |
---|
156 | ShaderUniform shader_postfx_texture, |
---|
157 | shader_postfx_texture_2d, |
---|
158 | shader_postfx_screen_size, |
---|
159 | shader_postfx_time, |
---|
160 | shader_postfx_flash, |
---|
161 | shader_postfx_value, |
---|
162 | shader_postfx_deform, |
---|
163 | shader_postfx_scanline, |
---|
164 | shader_postfx_sync; |
---|
165 | |
---|
166 | FrameBuffer *fbo_back, *fbo_front; |
---|
167 | FrameBuffer *fbo_blur_h, *fbo_blur_v, *fbo_ping, *fbo_pong; |
---|
168 | #endif |
---|
169 | |
---|
170 | /* |
---|
171 | * Text rendering interface |
---|
172 | */ |
---|
173 | struct TextRender |
---|
174 | { |
---|
175 | TextRender(caca_canvas_t *caca) |
---|
176 | : m_caca(caca), |
---|
177 | m_width(caca_get_canvas_width(m_caca)), |
---|
178 | m_height(caca_get_canvas_height(m_caca)) |
---|
179 | { |
---|
180 | for (int j = 0; j < m_height; j++) |
---|
181 | for (int i = 0; i < m_width; i++) |
---|
182 | m_vertices << vec2(i, j); |
---|
183 | } |
---|
184 | |
---|
185 | void Init(ivec2 screen_size, ivec2 font_size) |
---|
186 | { |
---|
187 | m_shader = Shader::Create(lolfx_text); |
---|
188 | m_coord = m_shader->GetAttribLocation("in_Position", |
---|
189 | VertexUsage::Position, 0); |
---|
190 | m_color = m_shader->GetAttribLocation("in_Attr", |
---|
191 | VertexUsage::Color, 0); |
---|
192 | m_char = m_shader->GetAttribLocation("in_Char", |
---|
193 | VertexUsage::Color, 1); |
---|
194 | m_texture = m_shader->GetUniformLocation("in_Texture"); |
---|
195 | m_transform = m_shader->GetUniformLocation("in_Transform"); |
---|
196 | m_vdecl |
---|
197 | = new VertexDeclaration(VertexStream<vec2>(VertexUsage::Position), |
---|
198 | VertexStream<uint32_t>(VertexUsage::Color), |
---|
199 | VertexStream<uint32_t>(VertexUsage::Color)); |
---|
200 | |
---|
201 | m_vbo1 = new VertexBuffer(m_vertices.Bytes()); |
---|
202 | void *vertices = m_vbo1->Lock(0, 0); |
---|
203 | memcpy(vertices, &m_vertices[0], m_vertices.Bytes()); |
---|
204 | m_vbo1->Unlock(); |
---|
205 | |
---|
206 | m_vbo2 = new VertexBuffer(m_width * m_height * sizeof(int32_t)); |
---|
207 | m_vbo3 = new VertexBuffer(m_width * m_height * sizeof(int32_t)); |
---|
208 | |
---|
209 | m_fbo = new FrameBuffer(screen_size); |
---|
210 | } |
---|
211 | |
---|
212 | void Render(ivec2 screen_size, ivec2 font_size) |
---|
213 | { |
---|
214 | /* Transform matrix for the scene: |
---|
215 | * - translate to the centre of the glyph |
---|
216 | * - scale by 2.f * font_size / screen_size |
---|
217 | * - translate to the upper left corner */ |
---|
218 | mat4 xform = mat4::translate(-1.f, 1.f, 0.f) |
---|
219 | * mat4::scale(vec3(2.f * font_size / (screen_size), 1.f) |
---|
220 | * vec3(1.f, -1.f, 1.f)) |
---|
221 | * mat4::translate(0.5f, 0.5f, 0.f); |
---|
222 | |
---|
223 | /* Upload libcaca canvas contents to the vertex buffers */ |
---|
224 | uint32_t *colors = (uint32_t *)m_vbo2->Lock(0, 0); |
---|
225 | for (int j = 0; j < m_height; j++) |
---|
226 | for (int i = 0; i < m_width; i++) |
---|
227 | { |
---|
228 | uint32_t attr = caca_get_attr(m_caca, i, j); |
---|
229 | uint16_t fg = caca_attr_to_rgb12_fg(attr); |
---|
230 | uint16_t bg = caca_attr_to_rgb12_bg(attr); |
---|
231 | caca_set_color_argb(m_caca, fg, bg); |
---|
232 | attr = caca_get_attr(m_caca, -1, -1); |
---|
233 | caca_put_attr(m_caca, i, j, attr); |
---|
234 | uint32_t a2 = caca_get_attr(m_caca, i, j); |
---|
235 | } |
---|
236 | memcpy(colors, caca_get_canvas_attrs(m_caca), |
---|
237 | m_width * m_height * sizeof(uint32_t)); |
---|
238 | m_vbo2->Unlock(); |
---|
239 | |
---|
240 | uint32_t *chars = (uint32_t *)m_vbo3->Lock(0, 0); |
---|
241 | memcpy(chars, caca_get_canvas_chars(m_caca), |
---|
242 | m_width * m_height * sizeof(uint32_t)); |
---|
243 | m_vbo3->Unlock(); |
---|
244 | |
---|
245 | m_fbo->Bind(); |
---|
246 | glDisable(GL_DEPTH_TEST); |
---|
247 | glEnable(GL_POINT_SPRITE); |
---|
248 | //glEnable(GL_VERTEX_PROGRAM_POINT_SIZE); |
---|
249 | glDisable(GL_POINT_SMOOTH); |
---|
250 | glPointSize((float)max(font_size.x, font_size.y)); |
---|
251 | m_shader->Bind(); |
---|
252 | tex_map->Bind(); |
---|
253 | m_shader->SetUniform(m_texture, 0); |
---|
254 | m_shader->SetUniform(m_transform, xform); |
---|
255 | m_vdecl->SetStream(m_vbo1, m_coord); |
---|
256 | m_vdecl->SetStream(m_vbo2, m_color); |
---|
257 | m_vdecl->SetStream(m_vbo3, m_char); |
---|
258 | m_vdecl->Bind(); |
---|
259 | m_vdecl->DrawElements(MeshPrimitive::Points, 0, m_width * m_height); |
---|
260 | m_vdecl->Unbind(); |
---|
261 | tex_map->Unbind(); |
---|
262 | m_shader->Unbind(); |
---|
263 | glDisable(GL_POINT_SPRITE); |
---|
264 | m_fbo->Unbind(); |
---|
265 | } |
---|
266 | |
---|
267 | void Blit() |
---|
268 | { |
---|
269 | /* FIXME: scaling is wrong */ |
---|
270 | glDisable(GL_BLEND); |
---|
271 | glEnable(GL_TEXTURE_2D); |
---|
272 | glBindTexture(GL_TEXTURE_2D, m_fbo->GetTexture()); |
---|
273 | glColor3f(1.0f,1.0f,1.0f); |
---|
274 | |
---|
275 | int x = dos_m; |
---|
276 | int y = dos_m + (font_size.y + 2) * ratio_2d.y; |
---|
277 | int w = screen_size.x - dos_m * 2; |
---|
278 | int h = screen_size.y - dos_m * 2 - (font_size.y + 2) * ratio_2d.y; |
---|
279 | |
---|
280 | glLoadIdentity(); |
---|
281 | glBegin(GL_QUADS); |
---|
282 | glTexCoord2f(1.0f, 1.0f); |
---|
283 | glVertex2i(x+w, y ); |
---|
284 | glTexCoord2f(0.0f, 1.0f); |
---|
285 | glVertex2i(x , y ); |
---|
286 | glTexCoord2f(0.0f, 0.0f); |
---|
287 | glVertex2i(x , y+h); |
---|
288 | glTexCoord2f(1.0f, 0.0f); |
---|
289 | glVertex2i(x+w, y+h); |
---|
290 | glEnd(); |
---|
291 | } |
---|
292 | |
---|
293 | private: |
---|
294 | caca_canvas_t *m_caca; |
---|
295 | int m_width, m_height; |
---|
296 | |
---|
297 | Array<vec2> m_vertices; |
---|
298 | Shader *m_shader; |
---|
299 | ShaderAttrib m_coord, m_color, m_char; |
---|
300 | ShaderUniform m_texture, m_transform; |
---|
301 | VertexDeclaration *m_vdecl; |
---|
302 | VertexBuffer *m_vbo1, *m_vbo2, *m_vbo3; |
---|
303 | FrameBuffer *m_fbo; |
---|
304 | }; |
---|
305 | |
---|
306 | TextRender *text_render; |
---|
307 | |
---|
308 | void init_viewport(int type) |
---|
309 | { |
---|
310 | glViewport(0, 0, screen_size.x, screen_size.y); |
---|
311 | glMatrixMode(GL_PROJECTION); |
---|
312 | glLoadIdentity(); |
---|
313 | mat4 m; |
---|
314 | if (type == 0) |
---|
315 | m = mat4::perspective(70, (float)screen_size.x, (float)screen_size.y, |
---|
316 | nearplane, farplane); |
---|
317 | else |
---|
318 | m = mat4::ortho(0, screen_size.x, screen_size.y, 0, -1.f, 1.f); |
---|
319 | glLoadMatrixf(&m[0][0]); |
---|
320 | glMatrixMode(GL_MODELVIEW); |
---|
321 | } |
---|
322 | |
---|
323 | #if SHADER |
---|
324 | void init_shader() |
---|
325 | { |
---|
326 | glDisable(GL_BLEND); |
---|
327 | glVertexPointer(4, GL_FLOAT, 0, fs_quad_vtx); |
---|
328 | glTexCoordPointer(2, GL_FLOAT, 0, fs_quad_tex); |
---|
329 | } |
---|
330 | |
---|
331 | void fs_quad() |
---|
332 | { |
---|
333 | glLoadIdentity(); |
---|
334 | glDrawArrays(GL_QUADS, 0, 4); |
---|
335 | } |
---|
336 | |
---|
337 | void draw_shader_simple(FrameBuffer *fbo_output, int n) |
---|
338 | { |
---|
339 | shader_simple->Bind(); |
---|
340 | shader_simple->SetTexture(shader_simple_texture, fbo_output->GetTexture(), n); |
---|
341 | fs_quad(); |
---|
342 | shader_simple->Unbind(); |
---|
343 | } |
---|
344 | #endif |
---|
345 | |
---|
346 | void rectangle(int x, int y, int w, int h) |
---|
347 | { |
---|
348 | glLoadIdentity(); |
---|
349 | glBegin(GL_QUADS); |
---|
350 | glVertex2i(x+w, y ); |
---|
351 | glVertex2i(x , y ); |
---|
352 | glVertex2i(x , y+h); |
---|
353 | glVertex2i(x+w, y+h); |
---|
354 | glEnd(); |
---|
355 | } |
---|
356 | |
---|
357 | void corner() |
---|
358 | { |
---|
359 | float vertex[2+corner_n*2]; |
---|
360 | vertex[0] = 0; |
---|
361 | vertex[1] = 0; |
---|
362 | for (int i = 1; i < corner_n + 1; i++) |
---|
363 | { |
---|
364 | int j = i*2; |
---|
365 | float a = PID*90.0f/(corner_n-1)*(i-1); |
---|
366 | vertex[j ] = corner_w-corner_w*cosf(a); |
---|
367 | vertex[j+1] = corner_w-corner_w*sinf(a); |
---|
368 | } |
---|
369 | for (int i = 0; i < corner_n; i++) |
---|
370 | { |
---|
371 | int j = i*6; |
---|
372 | int k = i*2; |
---|
373 | corner_vtx[j ] = (int)vertex[0]; |
---|
374 | corner_vtx[j+1] = (int)vertex[1]; |
---|
375 | corner_vtx[j+2] = (int)vertex[2+k]; |
---|
376 | corner_vtx[j+3] = (int)vertex[3+k]; |
---|
377 | corner_vtx[j+4] = (int)vertex[4+k]; |
---|
378 | corner_vtx[j+5] = (int)vertex[5+k]; |
---|
379 | } |
---|
380 | } |
---|
381 | |
---|
382 | void screen() |
---|
383 | { |
---|
384 | part_angle = main_angle; |
---|
385 | dos_flag = true; |
---|
386 | dos_color = CR * vec3(48, 56, 64); |
---|
387 | screen_color = dos_color; |
---|
388 | /*-------------------------*/ |
---|
389 | shader_effect_flag = true; |
---|
390 | shader_glow_flag = true; |
---|
391 | glow_color = 1; |
---|
392 | glow_smoothstep = 0;//.025f; |
---|
393 | glow_mix_ratio1 = 0.5f; |
---|
394 | glow_mix_ratio2 = 0.5f; |
---|
395 | shader_radial_flag = false; |
---|
396 | radial_value1 = 2.0f; |
---|
397 | radial_value2 = 0.8f; |
---|
398 | radial_color = 0; |
---|
399 | postfx_deform = 0.5f; |
---|
400 | /*-------------------------*/ |
---|
401 | flash_speed = 1.5f; |
---|
402 | fade_speed = 0.2f; |
---|
403 | sync_flag = false; |
---|
404 | sync_value = 1.0f; |
---|
405 | sync_speed = 1.0f; |
---|
406 | beat_speed = 2.0f; |
---|
407 | /*-------------------------*/ |
---|
408 | } |
---|
409 | |
---|
410 | int InitGL(void) |
---|
411 | { |
---|
412 | glDepthMask(GL_TRUE); // do not write z-buffer |
---|
413 | glEnable(GL_CULL_FACE); // disable cull face |
---|
414 | glCullFace(GL_BACK); // don't draw front face |
---|
415 | // load texture |
---|
416 | tex_map = new TileSet("neercs/video/resource/map.png", ivec2(256, 256), ivec2(1)); |
---|
417 | // initialize some variable |
---|
418 | screen(); |
---|
419 | |
---|
420 | #if SHADER |
---|
421 | if (shader_flag) |
---|
422 | { |
---|
423 | /* Initialise framebuffer objects */ |
---|
424 | fbo_back = new FrameBuffer(screen_size); |
---|
425 | fbo_front = new FrameBuffer(screen_size); |
---|
426 | fbo_blur_h = new FrameBuffer(screen_size / glow_fbo_size); |
---|
427 | fbo_blur_v = new FrameBuffer(screen_size / glow_fbo_size); |
---|
428 | fbo_ping = new FrameBuffer(screen_size); |
---|
429 | fbo_pong = new FrameBuffer(screen_size); |
---|
430 | // shader simple |
---|
431 | shader_simple = Shader::Create(lolfx_simple); |
---|
432 | shader_simple_texture = shader_simple->GetUniformLocation("texture"); |
---|
433 | // shader blur horizontal |
---|
434 | shader_blur_h = Shader::Create(lolfx_blurh); |
---|
435 | shader_blur_h_texture = shader_blur_h->GetUniformLocation("texture"); |
---|
436 | shader_blur_h_screen_size = shader_blur_h->GetUniformLocation("screen_size"); |
---|
437 | shader_blur_h_time = shader_blur_h->GetUniformLocation("time"); |
---|
438 | shader_blur_h_value = shader_blur_h->GetUniformLocation("value"); |
---|
439 | // shader blur vertical |
---|
440 | shader_blur_v = Shader::Create(lolfx_blurv); |
---|
441 | shader_blur_v_texture = shader_blur_v->GetUniformLocation("texture"); |
---|
442 | shader_blur_v_screen_size = shader_blur_v->GetUniformLocation("screen_size"); |
---|
443 | shader_blur_v_time = shader_blur_v->GetUniformLocation("time"); |
---|
444 | shader_blur_v_value = shader_blur_v->GetUniformLocation("value"); |
---|
445 | // shader glow |
---|
446 | shader_glow = Shader::Create(lolfx_glow); |
---|
447 | shader_glow_texture = shader_glow->GetUniformLocation("texture"); |
---|
448 | shader_glow_texture_prv = shader_glow->GetUniformLocation("texture_prv"); |
---|
449 | shader_glow_screen_size = shader_glow->GetUniformLocation("screen_size"); |
---|
450 | shader_glow_time = shader_glow->GetUniformLocation("time"); |
---|
451 | shader_glow_step = shader_glow->GetUniformLocation("step"); |
---|
452 | shader_glow_value1 = shader_glow->GetUniformLocation("value1"); |
---|
453 | shader_glow_value2 = shader_glow->GetUniformLocation("value2"); |
---|
454 | // shader radial |
---|
455 | shader_radial = Shader::Create(lolfx_radial); |
---|
456 | shader_radial_texture = shader_radial->GetUniformLocation("texture"); |
---|
457 | shader_radial_screen_size = shader_radial->GetUniformLocation("screen_size"); |
---|
458 | shader_radial_time = shader_radial->GetUniformLocation("time"); |
---|
459 | shader_radial_value1 = shader_radial->GetUniformLocation("value1"); |
---|
460 | shader_radial_value2 = shader_radial->GetUniformLocation("value2"); |
---|
461 | shader_radial_color = shader_radial->GetUniformLocation("color"); |
---|
462 | // shader postfx |
---|
463 | shader_postfx = Shader::Create(lolfx_postfx); |
---|
464 | shader_postfx_texture = shader_postfx->GetUniformLocation("texture"); |
---|
465 | shader_postfx_texture_2d = shader_postfx->GetUniformLocation("texture_2d"); |
---|
466 | shader_postfx_screen_size = shader_postfx->GetUniformLocation("screen_size"); |
---|
467 | shader_postfx_time = shader_postfx->GetUniformLocation("time"); |
---|
468 | shader_postfx_flash = shader_postfx->GetUniformLocation("flash"); |
---|
469 | shader_postfx_value = shader_postfx->GetUniformLocation("value"); |
---|
470 | shader_postfx_deform = shader_postfx->GetUniformLocation("deform"); |
---|
471 | shader_postfx_scanline = shader_postfx->GetUniformLocation("scanline"); |
---|
472 | shader_postfx_sync = shader_postfx->GetUniformLocation("sync"); |
---|
473 | } |
---|
474 | #endif |
---|
475 | return true; |
---|
476 | } |
---|
477 | |
---|
478 | int CreateGLWindow(char const *title) |
---|
479 | { |
---|
480 | screen_size = Video::GetSize(); |
---|
481 | corner_w = 16*ratio_2d.x; |
---|
482 | corner(); |
---|
483 | dos_m=12*ratio_2d.x; |
---|
484 | dos_vtx[0]=font_size.x*ratio_2d.x/2.0f; |
---|
485 | dos_vtx[1]=font_size.y*ratio_2d.y/2.0f; |
---|
486 | dos_vtx[2]=font_size.x*ratio_2d.x/2.0f; |
---|
487 | dos_vtx[3]=-font_size.y*ratio_2d.y/2.0f; |
---|
488 | dos_vtx[4]=-font_size.x*ratio_2d.x/2.0f; |
---|
489 | dos_vtx[5]=-font_size.y*ratio_2d.y/2.0f; |
---|
490 | dos_vtx[6]=-font_size.x*ratio_2d.x/2.0f; |
---|
491 | dos_vtx[7]=font_size.y*ratio_2d.y/2.0f; |
---|
492 | shell_vtx[0]=dos_m+58*ratio_2d.x; |
---|
493 | shell_vtx[1]=dos_m+(font_size.y+1)*ratio_2d.y; |
---|
494 | shell_vtx[2]=dos_m+58*ratio_2d.x; |
---|
495 | shell_vtx[3]=dos_m+ratio_2d.y; |
---|
496 | shell_vtx[4]=dos_m+2*ratio_2d.x; |
---|
497 | shell_vtx[5]=dos_m+ratio_2d.y; |
---|
498 | shell_vtx[6]=dos_m+2*ratio_2d.x; |
---|
499 | shell_vtx[7]=dos_m+(font_size.y+1)*ratio_2d.y; |
---|
500 | InitGL(); |
---|
501 | return true; |
---|
502 | } |
---|
503 | |
---|
504 | Render::Render(caca_canvas_t *caca) |
---|
505 | : m_caca(caca), |
---|
506 | m_ready(false) |
---|
507 | { |
---|
508 | text_render = new TextRender(m_caca); |
---|
509 | } |
---|
510 | |
---|
511 | void Render::TickGame(float seconds) |
---|
512 | { |
---|
513 | Entity::TickGame(seconds); |
---|
514 | } |
---|
515 | |
---|
516 | void Render::TickDraw(float seconds) |
---|
517 | { |
---|
518 | Entity::TickDraw(seconds); |
---|
519 | |
---|
520 | if (!m_ready) |
---|
521 | { |
---|
522 | CreateGLWindow("LOL"); |
---|
523 | text_render->Init(screen_size, ivec2(8, 8)); |
---|
524 | |
---|
525 | m_ready = true; |
---|
526 | } |
---|
527 | |
---|
528 | // timer |
---|
529 | if(!paused) |
---|
530 | main_angle += seconds * 100.0f * PID; |
---|
531 | if(sync_flag) |
---|
532 | { |
---|
533 | angle=(main_angle-sync_angle)*sync_speed; |
---|
534 | sync_value=1.0f-sinf(angle); |
---|
535 | if(angle>90.0f*PID) |
---|
536 | { |
---|
537 | sync_value=0; |
---|
538 | sync_flag=false; |
---|
539 | } |
---|
540 | } |
---|
541 | if(beat_flag) |
---|
542 | { |
---|
543 | angle=(main_angle-beat_angle)*beat_speed; |
---|
544 | beat_value=1.0f-sinf(angle); |
---|
545 | if(angle>90.0f*PID) |
---|
546 | { |
---|
547 | beat_value=0; |
---|
548 | beat_flag=false; |
---|
549 | } |
---|
550 | } |
---|
551 | if(flash_flag) |
---|
552 | { |
---|
553 | angle=(main_angle-flash_angle)*flash_speed; |
---|
554 | flash_value=1.0f-sinf(angle); |
---|
555 | if(angle>90.0f*PID) |
---|
556 | { |
---|
557 | flash_value=0; |
---|
558 | flash_flag=false; |
---|
559 | } |
---|
560 | } |
---|
561 | if(fade_flag) |
---|
562 | { |
---|
563 | angle=(main_angle-fade_angle)*fade_speed; |
---|
564 | fade_value=1.0f-sinf(angle); |
---|
565 | if(angle>90.0f*PID) |
---|
566 | { |
---|
567 | fade_value=0; |
---|
568 | fade_flag=false; |
---|
569 | } |
---|
570 | } |
---|
571 | |
---|
572 | Draw2D(); |
---|
573 | Draw3D(); |
---|
574 | } |
---|
575 | |
---|
576 | void Render::Draw2D() |
---|
577 | { |
---|
578 | /* Draw text in an offline buffer */ |
---|
579 | text_render->Render(screen_size, ivec2(8, 8)); |
---|
580 | |
---|
581 | #if SHADER |
---|
582 | if(shader_flag) |
---|
583 | fbo_back->Bind(); |
---|
584 | #endif |
---|
585 | |
---|
586 | /* Clear the back buffer */ |
---|
587 | glClearColor(screen_color.r, screen_color.g, screen_color.b, 1.0f); |
---|
588 | glClearDepth(1.0f); // set depth buffer |
---|
589 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); |
---|
590 | |
---|
591 | text_render->Blit(); |
---|
592 | |
---|
593 | glEnableClientState(GL_VERTEX_ARRAY); |
---|
594 | glEnableClientState(GL_TEXTURE_COORD_ARRAY); |
---|
595 | |
---|
596 | glEnable(GL_BLEND); |
---|
597 | //if(polygon) glEnable(GL_LINE_SMOOTH); else glDisable(GL_LINE_SMOOTH); |
---|
598 | glLineWidth((polygon)?2.0f:1.0f); |
---|
599 | fx_angle=main_angle-part_angle; |
---|
600 | if(polygon) glEnable(GL_TEXTURE_2D); |
---|
601 | |
---|
602 | init_viewport(1); |
---|
603 | |
---|
604 | tex_map->Bind(); |
---|
605 | glEnable(GL_BLEND); |
---|
606 | // draw dos |
---|
607 | if(dos_flag) |
---|
608 | { |
---|
609 | glDisable(GL_TEXTURE_2D); |
---|
610 | glDisable(GL_BLEND); |
---|
611 | glColor3f(1.0f,1.0f,1.0f); |
---|
612 | rectangle(dos_m,dos_m,screen_size.x-53*ratio_2d.x-dos_m*2,(font_size.y+2)*ratio_2d.y); |
---|
613 | rectangle(screen_size.x-51*ratio_2d.x-dos_m,dos_m,22*ratio_2d.x,(font_size.y+2)*ratio_2d.y); |
---|
614 | rectangle(screen_size.x-27*ratio_2d.x-dos_m,dos_m,22*ratio_2d.x,(font_size.y+2)*ratio_2d.y); |
---|
615 | rectangle(screen_size.x-3*ratio_2d.x-dos_m,dos_m,3*ratio_2d.x,(font_size.y+2)*ratio_2d.y); |
---|
616 | 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); |
---|
617 | 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); |
---|
618 | 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); |
---|
619 | glColor3f(dos_color.x,dos_color.y,dos_color.z); |
---|
620 | rectangle(dos_m+2*ratio_2d.x,dos_m+ratio_2d.y,56*ratio_2d.x,font_size.y*ratio_2d.y); |
---|
621 | 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); |
---|
622 | 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); |
---|
623 | rectangle(screen_size.x-49*ratio_2d.x-dos_m,dos_m+ratio_2d.y,14*ratio_2d.x,6*ratio_2d.y); |
---|
624 | glColor3f(1.0f,1.0f,1.0f); |
---|
625 | rectangle(screen_size.x-47*ratio_2d.x-dos_m,dos_m+2*ratio_2d.y,10*ratio_2d.x,4*ratio_2d.y); |
---|
626 | glColor3f(0,0,0); |
---|
627 | rectangle(screen_size.x-45*ratio_2d.x-dos_m,dos_m+3*ratio_2d.y,14*ratio_2d.x,6*ratio_2d.y); |
---|
628 | rectangle(screen_size.x-25*ratio_2d.x-dos_m,dos_m+1*ratio_2d.y,14*ratio_2d.x,6*ratio_2d.y); |
---|
629 | glColor3f(dos_color.x,dos_color.y,dos_color.z); |
---|
630 | rectangle(screen_size.x-21*ratio_2d.x-dos_m,dos_m+2*ratio_2d.y,14*ratio_2d.x,7*ratio_2d.y); |
---|
631 | glColor3f(1.0f,1.0f,1.0f); |
---|
632 | rectangle(screen_size.x-19*ratio_2d.x-dos_m,dos_m+3*ratio_2d.y,10*ratio_2d.x,5*ratio_2d.y); |
---|
633 | 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); |
---|
634 | glColor3f(dos_color.x,dos_color.y,dos_color.z); |
---|
635 | 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); |
---|
636 | glColor3f(1.0f,1.0f,1.0f); |
---|
637 | 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); |
---|
638 | 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); |
---|
639 | 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); |
---|
640 | 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); |
---|
641 | glEnable(GL_BLEND); |
---|
642 | if(polygon) glEnable(GL_TEXTURE_2D); |
---|
643 | glBlendFunc(GL_ONE, GL_ONE); |
---|
644 | glVertexPointer(2, GL_INT, 0, shell_vtx); |
---|
645 | glTexCoordPointer(2, GL_FLOAT, 0, shell_tex); |
---|
646 | glDrawArrays(GL_QUADS, 0, 4); |
---|
647 | } |
---|
648 | // draw corner |
---|
649 | glDisable(GL_TEXTURE_2D); |
---|
650 | glDisable(GL_BLEND); |
---|
651 | glVertexPointer(2, GL_INT, 0, corner_vtx); |
---|
652 | glLoadIdentity(); |
---|
653 | glColor3f(0, 0, 0); |
---|
654 | glDrawArrays(GL_TRIANGLES, 0, corner_n*3); |
---|
655 | glTranslated(screen_size.x, 0, 0); |
---|
656 | glRotated(90.0f, 0, 0, 1.0f); |
---|
657 | glDrawArrays(GL_TRIANGLES, 0, corner_n*3); |
---|
658 | glTranslated(screen_size.y, 0, 0); |
---|
659 | glRotated(90.0f, 0, 0, 1.0f); |
---|
660 | glDrawArrays(GL_TRIANGLES, 0, corner_n*3); |
---|
661 | glTranslated(screen_size.x, 0, 0); |
---|
662 | glRotated(90.0f, 0, 0, 1.0f); |
---|
663 | glDrawArrays(GL_TRIANGLES, 0, corner_n*3); |
---|
664 | glEnable(GL_BLEND); |
---|
665 | tex_map->Unbind(); |
---|
666 | |
---|
667 | glDisableClientState(GL_VERTEX_ARRAY); |
---|
668 | glDisableClientState(GL_TEXTURE_COORD_ARRAY); |
---|
669 | } |
---|
670 | |
---|
671 | void Render::Draw3D() |
---|
672 | { |
---|
673 | //init_viewport(0); |
---|
674 | glDisable(GL_DEPTH_TEST); |
---|
675 | |
---|
676 | #if SHADER |
---|
677 | if (!shader_flag) |
---|
678 | return; |
---|
679 | |
---|
680 | glEnableClientState(GL_VERTEX_ARRAY); |
---|
681 | glEnableClientState(GL_TEXTURE_COORD_ARRAY); |
---|
682 | |
---|
683 | init_shader(); |
---|
684 | fbo_back->Unbind(); |
---|
685 | if (shader_effect_flag && shader_blur_flag) |
---|
686 | { |
---|
687 | // shader blur horizontal |
---|
688 | fbo_ping->Bind(); |
---|
689 | shader_blur_h->Bind(); |
---|
690 | shader_blur_h->SetTexture(shader_blur_h_texture, fbo_back->GetTexture(), 0); |
---|
691 | shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f)); |
---|
692 | shader_blur_h->SetUniform(shader_blur_h_time, fx_angle); |
---|
693 | shader_blur_h->SetUniform(shader_blur_h_value, 0.5f/screen_size.x); |
---|
694 | fs_quad(); |
---|
695 | shader_blur_h->Unbind(); |
---|
696 | fbo_ping->Unbind(); |
---|
697 | // shader blur vertical |
---|
698 | fbo_front->Bind(); |
---|
699 | shader_blur_v->Bind(); |
---|
700 | shader_blur_v->SetTexture(shader_blur_v_texture, fbo_ping->GetTexture(), 0); |
---|
701 | shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f)); |
---|
702 | shader_blur_v->SetUniform(shader_blur_v_time, fx_angle); |
---|
703 | shader_blur_v->SetUniform(shader_blur_v_value, 0.5f/screen_size.y); |
---|
704 | fs_quad(); |
---|
705 | shader_blur_v->Unbind(); |
---|
706 | } |
---|
707 | else |
---|
708 | { |
---|
709 | // shader simple |
---|
710 | fbo_front->Bind(); |
---|
711 | draw_shader_simple(fbo_back, 0); |
---|
712 | } |
---|
713 | fbo_front->Unbind(); |
---|
714 | // shader glow |
---|
715 | if(shader_effect_flag&&shader_glow_flag) |
---|
716 | { |
---|
717 | // shader blur horizontal |
---|
718 | fbo_blur_h->Bind(); |
---|
719 | shader_blur_h->Bind(); |
---|
720 | shader_blur_h->SetTexture(shader_blur_h_texture, fbo_ping->GetTexture(), 0); |
---|
721 | shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f / glow_fbo_size)); |
---|
722 | shader_blur_h->SetUniform(shader_blur_h_time, fx_angle); |
---|
723 | shader_blur_h->SetUniform(shader_blur_h_value, 2.5f/screen_size.x); |
---|
724 | fs_quad(); |
---|
725 | shader_blur_h->Unbind(); |
---|
726 | fbo_blur_h->Unbind(); |
---|
727 | // shader blur vertical |
---|
728 | fbo_blur_v->Bind(); |
---|
729 | shader_blur_v->Bind(); |
---|
730 | shader_blur_v->SetTexture(shader_blur_v_texture, fbo_blur_h->GetTexture(), 0); |
---|
731 | shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f / glow_fbo_size)); |
---|
732 | shader_blur_v->SetUniform(shader_blur_v_time, fx_angle); |
---|
733 | shader_blur_v->SetUniform(shader_blur_h_value, 2.5f/screen_size.y); |
---|
734 | fs_quad(); |
---|
735 | shader_blur_v->Unbind(); |
---|
736 | fbo_blur_v->Unbind(); |
---|
737 | // shader blur horizontal |
---|
738 | fbo_blur_h->Bind(); |
---|
739 | shader_blur_h->Bind(); |
---|
740 | shader_blur_h->SetTexture(shader_blur_h_texture, fbo_blur_v->GetTexture(), 0); |
---|
741 | shader_blur_h->SetUniform(shader_blur_h_screen_size, vec2(1.0f / glow_fbo_size)); |
---|
742 | shader_blur_h->SetUniform(shader_blur_h_time, fx_angle); |
---|
743 | shader_blur_h->SetUniform(shader_blur_h_value, 1.0f/screen_size.x); |
---|
744 | fs_quad(); |
---|
745 | shader_blur_h->Unbind(); |
---|
746 | fbo_blur_h->Unbind(); |
---|
747 | // shader blur vertical |
---|
748 | fbo_blur_v->Bind(); |
---|
749 | shader_blur_v->Bind(); |
---|
750 | shader_blur_v->SetTexture(shader_blur_v_texture, fbo_blur_h->GetTexture(), 0); |
---|
751 | shader_blur_v->SetUniform(shader_blur_v_screen_size, vec2(1.0f / glow_fbo_size)); |
---|
752 | shader_blur_v->SetUniform(shader_blur_v_time, fx_angle); |
---|
753 | shader_blur_v->SetUniform(shader_blur_h_value, 1.0f/screen_size.y); |
---|
754 | fs_quad(); |
---|
755 | shader_blur_v->Unbind(); |
---|
756 | fbo_blur_v->Unbind(); |
---|
757 | // shader glow |
---|
758 | fbo_pong->Bind(); |
---|
759 | shader_glow->Bind(); |
---|
760 | shader_glow->SetTexture(shader_glow_texture, fbo_blur_v->GetTexture(), 0); |
---|
761 | shader_glow->SetTexture(shader_glow_texture_prv, fbo_front->GetTexture(), 1); |
---|
762 | shader_glow->SetUniform(shader_glow_screen_size, vec2(1.0f)); |
---|
763 | shader_glow->SetUniform(shader_glow_time, fx_angle); |
---|
764 | shader_glow->SetUniform(shader_glow_step, glow_smoothstep); |
---|
765 | shader_glow->SetUniform(shader_glow_value1, glow_mix_ratio1); |
---|
766 | shader_glow->SetUniform(shader_glow_value2, glow_mix_ratio2); |
---|
767 | fs_quad(); |
---|
768 | shader_glow->Unbind(); |
---|
769 | } |
---|
770 | if(!shader_effect_flag) |
---|
771 | { |
---|
772 | // shader simple |
---|
773 | fbo_pong->Bind(); |
---|
774 | draw_shader_simple(fbo_front, 0); |
---|
775 | } |
---|
776 | fbo_pong->Unbind(); |
---|
777 | if(shader_postfx_flag) |
---|
778 | { |
---|
779 | // shader postfx |
---|
780 | shader_postfx->Bind(); |
---|
781 | shader_postfx->SetTexture(shader_postfx_texture, fbo_pong->GetTexture(), 0); |
---|
782 | shader_postfx->SetUniform(shader_postfx_screen_size, (vec2)screen_size); |
---|
783 | shader_postfx->SetUniform(shader_postfx_time, fx_angle); |
---|
784 | shader_postfx->SetUniform(shader_postfx_flash, flash_value); |
---|
785 | shader_postfx->SetUniform(shader_postfx_value, 4.0f); |
---|
786 | shader_postfx->SetUniform(shader_postfx_deform, postfx_deform); |
---|
787 | shader_postfx->SetUniform(shader_postfx_scanline, postfx_scanline); |
---|
788 | shader_postfx->SetUniform(shader_postfx_sync, (float)fabs(beat_value*cosf((main_angle-beat_angle)*8.0f))); |
---|
789 | fs_quad(); |
---|
790 | shader_postfx->Unbind(); |
---|
791 | } |
---|
792 | else |
---|
793 | { |
---|
794 | // shader simple |
---|
795 | draw_shader_simple(fbo_pong, 0); |
---|
796 | } |
---|
797 | |
---|
798 | glDisableClientState(GL_VERTEX_ARRAY); |
---|
799 | glDisableClientState(GL_TEXTURE_COORD_ARRAY); |
---|
800 | #endif |
---|
801 | } |
---|
802 | |
---|
803 | Render::~Render() |
---|
804 | { |
---|
805 | } |
---|
806 | |
---|