Mercurial > hg > forks > bilotrip-mj12
annotate src/main.c @ 37:1db62040204e
Combine some headers to single mplatform.h
author | Matti Hamalainen <ccr@tnsp.org> |
---|---|
date | Mon, 05 Aug 2013 21:53:33 +0300 |
parents | de2ee75a142f |
children | 78c981f2ff2d |
rev | line source |
---|---|
0 | 1 // MIDISYS-ENGINE for windows and osx |
2 | |
3 #include <stdio.h> | |
4 #include <stdlib.h> | |
5 #include <string.h> | |
6 #include <math.h> | |
7 #include <fstream> | |
8 #include <map> | |
9 #include <wchar.h> | |
10 #include <time.h> | |
11 | |
37
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
12 #include "bass.h" |
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
13 #include "mplatform.h" |
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
14 |
0 | 15 #include "freetype-gl.h" |
16 #include "vertex-buffer.h" | |
17 #include "markup.h" | |
18 #include "shader.h" | |
19 #include "mat4.h" | |
20 | |
21 #include "midifile.h" | |
22 #include "midiutil.h" | |
23 | |
37
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
24 #ifdef __APPLE__ |
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
25 #include "glew.h" |
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
26 #include <OpenGL/OpenGL.h> |
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
27 #include <OpenGL/glu.h> |
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
28 #include "freeglut.h" |
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
29 #else |
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
30 #include <GL/glew.h> |
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
31 #include <GL/glu.h> |
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
32 #include <GL/freeglut.h> |
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
33 #endif |
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
34 |
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
35 |
0 | 36 int quitflag = 0; |
37 | |
38 // GLUT window handle (1 for windowed display, 0 for fullscreen gamemode) | |
39 GLuint window = 0; | |
40 // demo running speed multiplier | |
41 float demo_speed_x = 1.0f; | |
42 | |
43 // remove for non-debug build | |
44 int debugmode = 0; | |
45 // jump to demo position; 0 for whole demo | |
46 int jump_to = 0; | |
47 // some debugging flags | |
48 bool load_textures = true; | |
49 | |
50 // midi sync | |
51 | |
52 MIDI_MSG timeline[64][100000] = {NULL}; | |
53 char timeline_trackname[64][512] = {-1}; | |
54 int timeline_trackindex[64] = { 0 }; | |
55 int timeline_tracklength[64] = { -1 }; | |
56 int timeline_trackcount = 0; | |
57 | |
58 // midi track number of mapping data | |
59 int mapping_tracknum[1000] = {-1}; | |
60 // midi to shader param map from mapping.txt | |
61 int mapping_paramnum[1000] = {-1}; | |
62 // track to map from | |
63 char mapping_trackname[1000][512] = {-1}; | |
64 // map type: 0 == trig (noteon / off), 1 == param (modwheel / cc value) | |
65 int mapping_type[1000] = {-1}; | |
66 // number of active mappings from midi to shader param | |
67 int mapping_count = 0; | |
68 | |
69 // current shader param values | |
70 int scene_shader_params[16] = {-1}; | |
71 int scene_shader_param_type[16] = {-1}; | |
72 | |
73 float millis = 0; | |
74 | |
75 // scene globals | |
76 // vhs | |
77 float vhsbeat = 0.0; | |
78 float vhsbeat_start = 0; | |
79 | |
80 #include <assimp/Importer.hpp> | |
81 #include <assimp/postprocess.h> | |
82 #include <assimp/scene.h> | |
83 #include <assimp/DefaultLogger.hpp> | |
84 #include <assimp/LogStream.hpp> | |
85 | |
37
1db62040204e
Combine some headers to single mplatform.h
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
86 |
0 | 87 #include "stb_image.c" |
88 | |
89 | |
90 #include <oggplayer.h> | |
91 #include <algorithm> | |
92 | |
93 #include "ggets.h" | |
94 #include "ggets.c" | |
95 | |
96 // fbo | |
97 | |
98 GLuint fb; | |
99 GLuint fb_tex; | |
100 GLuint fb2; | |
101 GLuint fb_tex2; | |
102 | |
103 GLuint fake_framebuffer; | |
104 GLuint fake_framebuffer_tex; | |
105 | |
106 | |
107 #define KEYEVENTS_COUNT 507 | |
108 unsigned char keyrec[507] = {98,105,108,111,116,114,105,112,32,111,112,101,114,97,116,105,110,103,32,115,121,115,116,101,109,32,52,46,50,48,13,97,108,108,32,108,101,102,116,115,32,97,110,100,32,114,105,103,104,116,115,32,114,101,118,101,114,115,101,100,13,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,13,99,97,116,32,110,111,116,101,46,116,120,116,13,49,54,58,51,48,32,98,101,32,97,116,32,116,104,101,32,97,103,114,101,101,100,32,112,108,97,99,101,13,49,56,58,51,48,32,115,119,97,108,108,111,119,32,99,97,112,115,117,108,101,115,13,97,102,116,101,114,32,101,102,102,101,99,116,58,32,112,114,111,101,99,8,8,116,101,120,8,99,116,32,109,101,116,97,108,115,13,119,97,105,116,32,102,111,114,32,97,109,97,115,8,8,8,8,109,97,115,107,32,115,105,103,110,97,108,13,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,13,99,97,116,32,98,105,108,111,116,114,105,112,95,99,114,101,100,105,116,115,46,116,120,116,13,97,101,103,105,115,13,100,101,112,13,101,101,118,8,8,118,101,97,103,101,110,8,8,8,110,103,101,108,13,104,97,100,100,97,115,13,111,97,115,105,122,13,112,97,104,97,109,111,107,97,13,115,112,105,105,107,107,105,13,118,105,115,121,13,122,111,118,13,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,69,68,69,83,8,65,57,65,105,39,109,13,103,101,116,116,105,110,103,32,115,111,109,101,116,104,105,110,103,32,110,111,119,13,105,8,46,46,46,105,39,109,32,102,101,101,108,105,110,103,32,105,116,32,116,111,111,46,13,105,116,39,115,46,46,46,46,32,105,116,39,115,46,46,46,46,46,46,46,46,46,13,105,116,39,115,32,107,105,99,107,107,107,105,105,105,105,105,105,105,105,105,105,110,110,110,110,110,110,110,110,110,110,103,103,103,103,103,103,103,103,105,105,105,105,105,105,105,105,105,110,110,110,110,110,110,110,110,110,13}; | |
109 int keymillis[507] = {0,84,133,278,414,574,624,667,780,1045,1104,1185,1249,1329,1456,1537,1701,1753,1801,1891,2009,2099,2205,2672,2762,2905,3013,3103,3204,3317,3593,3837,3945,4079,4202,4273,4359,4429,4574,4610,4648,4729,4858,4905,4986,5080,5180,5253,5366,5440,5689,5820,6004,6079,6238,6299,6416,6495,6624,6796,7149,7291,7814,7845,7878,7910,7942,7975,8007,8040,8071,8104,8137,8169,8204,8237,8269,8301,8334,8367,8398,8431,8465,8496,8528,8561,8591,8623,8656,8688,8719,9198,9403,9460,9667,9777,9938,10014,10051,10089,10279,10618,10774,10873,11230,15891,16480,16917,17262,17987,18708,21302,21803,21920,22036,22135,22216,22353,22491,22549,22706,22821,22939,23096,23150,23303,23400,23454,23891,23930,23956,24016,24077,24387,28893,29377,29730,29985,30654,30829,33772,34315,34383,34521,34655,34791,34877,34972,35140,35179,35220,35322,35413,35498,35551,35627,36409,43630,44014,44155,44228,44372,44460,44596,44661,44794,44840,44950,45009,45217,45280,45398,45456,45610,45713,45846,46112,46237,46286,46340,46702,46935,47033,47087,47160,47284,47324,47393,47463,47519,47636,47790,49371,49417,49446,49539,49612,49721,49769,49867,49926,49998,50091,50164,50245,50420,50544,50669,50780,50856,50899,50921,51003,51075,51352,51420,51568,51663,51717,51844,52608,52905,53437,53469,53501,53533,53567,53598,53631,53663,53694,53728,53759,53792,53823,53855,53889,53920,53954,53987,54019,54051,54082,54115,54146,54179,54211,54244,54544,54700,54893,55387,56136,56247,56430,56502,56766,56831,56896,57004,57070,57206,57249,57271,57667,57831,57975,58045,58209,58315,58384,58444,58630,58736,58822,58927,59433,59758,59833,59952,60038,60133,60697,60984,61047,61106,61560,61885,62091,62106,62626,62757,62786,62832,63009,63115,63211,63228,63557,63679,63805,63980,64059,64099,64215,64663,65414,65494,65620,65795,65820,65902,66303,66604,66666,66725,66845,66929,67443,67820,67886,68047,68105,68236,68290,68416,68496,68865,69309,69422,69535,69677,69846,69965,70153,70608,71440,71520,71620,71718,71943,72258,72359,72941,73284,73559,74087,74120,74151,74183,74214,74249,74281,74315,74347,74378,74411,74442,74578,74703,74820,75021,75184,75338,75491,75983,76650,76976,77252,77294,77624,78108,78162,78932,79324,79777,80101,80598,80997,81157,81230,81367,81487,81976,82114,82182,82253,82550,82641,82690,82765,83021,83131,83184,83374,83422,83518,83829,83895,84017,84901,85534,85972,86047,86189,86325,86642,87409,87637,87710,87790,87866,87986,88086,88134,88307,88350,88405,88894,89235,89320,89406,89571,89715,90247,91658,91929,92036,92609,92713,93112,93263,93393,93539,94091,94249,94433,94711,94806,95220,95405,95541,95707,95992,96150,96306,96442,96600,97012,98638,98805,99329,99462,100393,100771,101191,102156,102308,102553,102984,103505,103675,103864,104079,104212,104361,104545,104890,105043,105235,105456,105682,105811,105979,106157,106330,106509,106670,106838,106997,107165,107573,107753,107952,108102,108259,108415,108591,108696,108847,108987,109123,109261,109418,109553,109665,109864,109969,110112,110232,110372,110506,110648,110781,110936,111062,111063}; | |
110 | |
111 | |
112 #define KEYEVENTS_COUNT2 212 | |
113 unsigned char keyrec2[212] = {85,115,32,104,105,103,104,32,112,114,101,99,105,115,105,111,110,32,116,111,111,115,108,44,32,101,8,8,8,8,8,108,115,32,44,8,8,44,32,101,110,103,105,110,101,101,114,101,100,32,116,111,32,101,120,101,99,117,116,101,13,116,104,101,32,115,104,111,114,116,45,115,105,103,8,103,104,116,101,100,32,105,100,101,111,108,111,103,105,99,97,108,32,102,108,97,118,111,117,114,32,111,102,32,116,111,100,97,121,13,65,115,32,108,111,110,103,32,97,115,32,116,104,101,114,101,32,105,115,32,97,32,99,111,109,109,111,110,32,101,118,8,110,121,8,101,109,121,32,116,111,32,117,110,105,116,101,32,117,115,13,119,101,39,108,108,32,107,101,101,108,8,112,32,109,97,114,99,104,105,110,103,44,32,108,105,107,101,32,97,32,119,101,108,108,45,111,105,108,101,100,32,109,97,99,104,105,110,101,46,46,46}; | |
114 int keymillis2[212] = {0,157,253,413,518,573,654,794,940,1045,1110,1315,1406,1502,1599,1666,2283,2362,2972,3058,3189,3358,3459,3677,3747,3859,4049,4184,4320,4475,4589,4628,4677,4762,4907,5201,5327,5375,5456,5556,5802,5911,6008,6244,6380,6536,6855,6920,7061,7142,7254,7338,7535,8560,8680,8812,9067,9201,9284,9357,10544,11841,11961,12027,12091,12216,12402,12514,12634,12791,12933,13357,13472,13589,13857,14062,14490,14688,14751,15278,15395,15707,15812,15893,15953,16162,16316,16359,16463,16577,16632,16762,16899,17085,17180,17643,17815,17911,17972,18791,18888,19011,19219,19303,19516,19628,19771,19876,19895,20575,21102,21344,21518,21926,22072,22158,22208,22559,22659,22756,22866,23123,23290,23374,23457,23539,23605,23691,23767,23859,23955,24060,24357,24433,24502,24651,24700,24839,24981,25542,25672,25903,26080,26194,26632,26738,26835,26920,27000,27101,27164,27233,27448,27785,27899,27969,28050,28118,28234,28355,28892,29245,29372,29555,29730,29871,29973,30140,30219,30360,30476,30773,30817,30886,31118,31193,31264,31454,31494,31542,31893,31955,32193,32267,32405,32485,32638,32661,32745,32834,32927,33070,33166,33273,33401,33648,33995,34047,34253,34327,34421,34500,34629,34725,34861,34936,34999,35231,35315,35415,35515,35615}; | |
115 | |
116 | |
117 | |
118 const int __SIGNAL_ACTIVATE__ = 0; | |
119 const int __SIGNAL_COMPLETE__ = 1; | |
120 const int __SIGNAL_HISTORY_NEXT__ = 2; | |
121 const int __SIGNAL_HISTORY_PREV__ = 3; | |
122 #define MAX_LINE_LENGTH 511 | |
123 | |
124 | |
125 const int MARKUP_NORMAL = 0; | |
126 const int MARKUP_DEFAULT = 0; | |
127 const int MARKUP_ERROR = 1; | |
128 const int MARKUP_WARNING = 2; | |
129 const int MARKUP_OUTPUT = 3; | |
130 const int MARKUP_BOLD = 4; | |
131 const int MARKUP_ITALIC = 5; | |
132 const int MARKUP_BOLD_ITALIC = 6; | |
133 const int MARKUP_FAINT = 7; | |
134 #define MARKUP_COUNT 8 | |
135 | |
136 | |
137 // ------------------------------------------------------- typedef & struct --- | |
138 typedef struct { | |
139 float x, y, z; | |
140 float s, t; | |
141 float r, g, b, a; | |
142 } vertex_t; | |
143 | |
144 struct _console_t { | |
145 vector_t * lines; | |
146 wchar_t * prompt; | |
147 wchar_t killring[MAX_LINE_LENGTH+1]; | |
148 wchar_t input[MAX_LINE_LENGTH+1]; | |
149 size_t cursor; | |
150 markup_t markup[MARKUP_COUNT]; | |
151 vertex_buffer_t * buffer; | |
152 vec2 pen; | |
153 void (*handlers[4])( struct _console_t *, wchar_t * ); | |
154 }; | |
155 typedef struct _console_t console_t; | |
156 | |
157 // ------------------------------------------------------- global variables --- | |
158 static console_t * console; | |
159 texture_atlas_t *atlas; | |
160 GLuint shader; | |
161 mat4 model, view, projection; | |
162 | |
163 | |
164 // ------------------------------------------------------------ console_new --- | |
165 console_t * | |
166 console_new( void ) | |
167 { | |
168 console_t *self = (console_t *) malloc( sizeof(console_t) ); | |
169 if( !self ) | |
170 { | |
171 return self; | |
172 } | |
173 self->lines = vector_new( sizeof(wchar_t *) ); | |
174 self->prompt = (wchar_t *) wcsdup( L"" ); | |
175 self->cursor = 0; | |
176 self->buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" ); | |
177 self->input[0] = L'\0'; | |
178 self->killring[0] = L'\0'; | |
179 self->handlers[__SIGNAL_ACTIVATE__] = 0; | |
180 self->handlers[__SIGNAL_COMPLETE__] = 0; | |
181 self->handlers[__SIGNAL_HISTORY_NEXT__] = 0; | |
182 self->handlers[__SIGNAL_HISTORY_PREV__] = 0; | |
183 self->pen.x = self->pen.y = 0; | |
184 | |
185 atlas = texture_atlas_new( 512, 512, 1 ); | |
186 | |
187 vec4 white = {{0.2,1,0.2,0.7}}; | |
188 vec4 black = {{0,0,0,1}}; | |
189 vec4 none = {{0,0,1,0}}; | |
190 | |
191 markup_t normal; | |
192 normal.family = "data/fonts/VeraMono.ttf"; | |
193 normal.size = 23.0; | |
194 normal.bold = 0; | |
195 normal.italic = 0; | |
196 normal.rise = 0.0; | |
197 normal.spacing = 0.0; | |
198 normal.gamma = 1.0; | |
199 normal.foreground_color = white; | |
200 normal.foreground_color.r = 0.45; | |
201 normal.foreground_color.g = 0.65; | |
202 normal.foreground_color.b = 0.45; | |
203 | |
204 normal.font = texture_font_new( atlas, "data/fonts/term.ttf", 33 ); | |
205 | |
206 markup_t bold = normal; | |
207 bold.bold = 1; | |
208 bold.font = texture_font_new( atlas, "data/fonts/VeraMoBd.ttf", 23 ); | |
209 | |
210 markup_t italic = normal; | |
211 italic.italic = 1; | |
212 bold.font = texture_font_new( atlas, "data/fonts/VeraMoIt.ttf", 23 ); | |
213 | |
214 markup_t bold_italic = normal; | |
215 bold.bold = 1; | |
216 italic.italic = 1; | |
217 italic.font = texture_font_new( atlas, "data/fonts/VeraMoBI.ttf", 13 ); | |
218 | |
219 markup_t faint = normal; | |
220 faint.foreground_color.r = 0.25; | |
221 faint.foreground_color.g = 0.45; | |
222 faint.foreground_color.b = 0.25; | |
223 | |
224 markup_t error = normal; | |
225 error.foreground_color.r = 1.00; | |
226 error.foreground_color.g = 0.00; | |
227 error.foreground_color.b = 0.00; | |
228 | |
229 markup_t warning = normal; | |
230 warning.foreground_color.r = 1.00; | |
231 warning.foreground_color.g = 0.50; | |
232 warning.foreground_color.b = 0.50; | |
233 | |
234 markup_t output = normal; | |
235 output.foreground_color.r = 0.00; | |
236 output.foreground_color.g = 0.00; | |
237 output.foreground_color.b = 1.00; | |
238 | |
239 self->markup[MARKUP_NORMAL] = normal; | |
240 self->markup[MARKUP_ERROR] = error; | |
241 self->markup[MARKUP_WARNING] = warning; | |
242 self->markup[MARKUP_OUTPUT] = output; | |
243 self->markup[MARKUP_FAINT] = faint; | |
244 self->markup[MARKUP_BOLD] = bold; | |
245 self->markup[MARKUP_ITALIC] = italic; | |
246 self->markup[MARKUP_BOLD_ITALIC] = bold_italic; | |
247 | |
248 return self; | |
249 } | |
250 | |
251 | |
252 | |
253 // -------------------------------------------------------- console_delete --- | |
254 void | |
255 console_delete( console_t *self ) | |
256 { } | |
257 | |
258 | |
259 | |
260 // ----------------------------------------------------- console_add_glyph --- | |
261 void | |
262 console_add_glyph( console_t *self, | |
263 wchar_t current, | |
264 wchar_t previous, | |
265 markup_t *markup ) | |
266 { | |
267 texture_glyph_t *glyph = texture_font_get_glyph( markup->font, current ); | |
268 if( previous != L'\0' ) | |
269 { | |
270 self->pen.x += texture_glyph_get_kerning( glyph, previous ); | |
271 } | |
272 float r = markup->foreground_color.r; | |
273 float g = markup->foreground_color.g; | |
274 float b = markup->foreground_color.b; | |
275 float a = markup->foreground_color.a; | |
276 float x0 = self->pen.x + glyph->offset_x; | |
277 float y0 = self->pen.y + glyph->offset_y; | |
278 float x1 = x0 + glyph->width; | |
279 float y1 = y0 - glyph->height; | |
280 float s0 = glyph->s0; | |
281 float t0 = glyph->t0; | |
282 float s1 = glyph->s1; | |
283 float t1 = glyph->t1; | |
284 | |
285 GLuint indices[] = {0,1,2, 0,2,3}; | |
286 vertex_t vertices[] = { { x0,y0,0, s0,t0, r,g,b,a }, | |
287 { x0,y1,0, s0,t1, r,g,b,a }, | |
288 { x1,y1,0, s1,t1, r,g,b,a }, | |
289 { x1,y0,0, s1,t0, r,g,b,a } }; | |
290 vertex_buffer_push_back( self->buffer, vertices, 4, indices, 6 ); | |
291 | |
292 self->pen.x += glyph->advance_x; | |
293 self->pen.y += glyph->advance_y; | |
294 } | |
295 | |
296 | |
297 | |
298 // -------------------------------------------------------- console_render --- | |
299 void | |
300 console_render( console_t *self ) | |
301 { | |
302 int viewport[4]; | |
303 glGetIntegerv( GL_VIEWPORT, viewport ); | |
304 | |
305 size_t i, index; | |
306 self->pen.x = 0; | |
307 self->pen.y = viewport[3]; | |
308 vertex_buffer_clear( console->buffer ); | |
309 | |
310 int cursor_x = self->pen.x; | |
311 int cursor_y = self->pen.y; | |
312 | |
313 markup_t markup; | |
314 | |
315 // console_t buffer | |
316 markup = self->markup[MARKUP_FAINT]; | |
317 self->pen.y -= markup.font->height; | |
318 | |
319 for( i=0; i<self->lines->size; ++i ) | |
320 { | |
321 wchar_t *text = * (wchar_t **) vector_get( self->lines, i ) ; | |
322 if( wcslen(text) > 0 ) | |
323 { | |
324 console_add_glyph( console, text[0], L'\0', &markup ); | |
325 for( index=1; index < wcslen(text)-1; ++index ) | |
326 { | |
327 console_add_glyph( console, text[index], text[index-1], &markup ); | |
328 } | |
329 } | |
330 self->pen.y -= markup.font->height - markup.font->linegap; | |
331 self->pen.x = 0; | |
332 cursor_x = self->pen.x; | |
333 cursor_y = self->pen.y; | |
334 } | |
335 | |
336 // Prompt | |
337 markup = self->markup[MARKUP_BOLD]; | |
338 if( wcslen( self->prompt ) > 0 ) | |
339 { | |
340 console_add_glyph( console, self->prompt[0], L'\0', &markup ); | |
341 for( index=1; index < wcslen(self->prompt); ++index ) | |
342 { | |
343 console_add_glyph( console, self->prompt[index], self->prompt[index-1], &markup ); | |
344 } | |
345 } | |
346 cursor_x = (int) self->pen.x; | |
347 | |
348 // Input | |
349 markup = self->markup[MARKUP_NORMAL]; | |
350 if( wcslen(self->input) > 0 ) | |
351 { | |
352 console_add_glyph( console, self->input[0], L'\0', &markup ); | |
353 if( self->cursor > 0) | |
354 { | |
355 cursor_x = (int) self->pen.x; | |
356 } | |
357 for( index=1; index < wcslen(self->input); ++index ) | |
358 { | |
359 console_add_glyph( console, self->input[index], self->input[index-1], &markup ); | |
360 if( index < self->cursor ) | |
361 { | |
362 cursor_x = (int) self->pen.x; | |
363 } | |
364 } | |
365 } | |
366 | |
367 float cursorblink = 0.7+abs(cos(millis*0.05)+0.3); | |
368 | |
369 // Cursor (we use the black character (-1) as texture ) | |
370 texture_glyph_t *glyph = texture_font_get_glyph( markup.font, -1 ); | |
371 float r = markup.foreground_color.r; | |
372 float g = markup.foreground_color.g; | |
373 float b = markup.foreground_color.b; | |
374 float a = markup.foreground_color.a*cursorblink; | |
375 float x0 = cursor_x+1; | |
376 float y0 = cursor_y + markup.font->descender; | |
377 float x1 = cursor_x+14; | |
378 float y1 = y0 + markup.font->height - markup.font->linegap; | |
379 | |
380 if (y0 == 714) { y0 = 648+33; y1 = y0 + markup.font->height - markup.font->linegap; } | |
381 | |
382 float s0 = glyph->s0; | |
383 float t0 = glyph->t0; | |
384 float s1 = glyph->s1; | |
385 float t1 = glyph->t1; | |
386 GLuint indices[] = {0,1,2, 0,2,3}; | |
387 vertex_t vertices[] = { { x0,y0,0, s0,t0, r,g,b,a }, | |
388 { x0,y1,0, s0,t1, r,g,b,a }, | |
389 { x1,y1,0, s1,t1, r,g,b,a }, | |
390 { x1,y0,0, s1,t0, r,g,b,a } }; | |
391 vertex_buffer_push_back( self->buffer, vertices, 4, indices, 6 ); | |
392 glEnable( GL_TEXTURE_2D ); | |
393 glEnable(GL_BLEND); | |
394 glActiveTexture(GL_TEXTURE0); | |
395 glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); | |
396 glBindTexture(GL_TEXTURE_2D, atlas->id); | |
397 | |
398 glUseProgram( shader ); | |
399 { | |
400 glUniform1i( glGetUniformLocation( shader, "texture" ), | |
401 0 ); | |
402 glUniformMatrix4fv( glGetUniformLocation( shader, "model" ), | |
403 1, 0, model.data); | |
404 glUniformMatrix4fv( glGetUniformLocation( shader, "view" ), | |
405 1, 0, view.data); | |
406 glUniformMatrix4fv( glGetUniformLocation( shader, "projection" ), | |
407 1, 0, projection.data); | |
408 vertex_buffer_render( console->buffer, GL_TRIANGLES ); | |
409 } | |
410 | |
411 | |
412 } | |
413 | |
414 | |
415 | |
416 // ------------------------------------------------------- console_connect --- | |
417 void | |
418 console_connect( console_t *self, | |
419 const char *signal, | |
420 void (*handler)(console_t *, wchar_t *)) | |
421 { | |
422 if( strcmp( signal,"activate" ) == 0 ) | |
423 { | |
424 self->handlers[__SIGNAL_ACTIVATE__] = handler; | |
425 } | |
426 else if( strcmp( signal,"complete" ) == 0 ) | |
427 { | |
428 self->handlers[__SIGNAL_COMPLETE__] = handler; | |
429 } | |
430 else if( strcmp( signal,"history-next" ) == 0 ) | |
431 { | |
432 self->handlers[__SIGNAL_HISTORY_NEXT__] = handler; | |
433 } | |
434 else if( strcmp( signal,"history-prev" ) == 0 ) | |
435 { | |
436 self->handlers[__SIGNAL_HISTORY_PREV__] = handler; | |
437 } | |
438 } | |
439 | |
440 | |
441 | |
442 // --------------------------------------------------------- console_print --- | |
443 void | |
444 console_print( console_t *self, wchar_t *text ) | |
445 { | |
446 // Make sure there is at least one line | |
447 if( self->lines->size == 0 ) | |
448 { | |
449 wchar_t *line = wcsdup( L"" ); | |
450 vector_push_back( self->lines, &line ); | |
451 } | |
452 | |
453 if (self->lines->size > 10) | |
454 { | |
455 vector_erase(self->lines,0); | |
456 } | |
457 | |
458 // Make sure last line does not end with '\n' | |
459 wchar_t *last_line = *(wchar_t **) vector_get( self->lines, self->lines->size-1 ) ; | |
460 if( wcslen( last_line ) != 0 ) | |
461 { | |
462 if( last_line[wcslen( last_line ) - 1] == L'\n' ) | |
463 { | |
464 wchar_t *line = wcsdup( L"" ); | |
465 vector_push_back( self->lines, &line ); | |
466 } | |
467 } | |
468 last_line = *(wchar_t **) vector_get( self->lines, self->lines->size-1 ) ; | |
469 | |
470 wchar_t *start = text; | |
471 wchar_t *end = wcschr(start, L'\n'); | |
472 size_t len = wcslen( last_line ); | |
473 if( end != NULL) | |
474 { | |
475 wchar_t *line = (wchar_t *) malloc( (len + end - start + 2)*sizeof( wchar_t ) ); | |
476 wcpncpy( line, last_line, len ); | |
477 wcpncpy( line + len, text, end-start+1 ); | |
478 | |
479 line[len+end-start+1] = L'\0'; | |
480 | |
481 vector_set( self->lines, self->lines->size-1, &line ); | |
482 free( last_line ); | |
483 if( (end-start) < (wcslen( text )-1) ) | |
484 { | |
485 console_print(self, end+1 ); | |
486 } | |
487 return; | |
488 } | |
489 else | |
490 { | |
491 wchar_t *line = (wchar_t *) malloc( (len + wcslen(text) + 1) * sizeof( wchar_t ) ); | |
492 wcpncpy( line, last_line, len ); | |
493 wcpcpy( line + len, text ); | |
494 vector_set( self->lines, self->lines->size-1, &line ); | |
495 free( last_line ); | |
496 return; | |
497 } | |
498 } | |
499 | |
500 | |
501 | |
502 // ------------------------------------------------------- console_process --- | |
503 void | |
504 console_process( console_t *self, | |
505 const char *action, | |
506 const unsigned char key ) | |
507 { | |
508 size_t len = wcslen(self->input); | |
509 | |
510 //printf("console_process:%d\n", key); | |
511 | |
512 if( strcmp(action, "type") == 0 ) | |
513 { | |
514 if( len < MAX_LINE_LENGTH ) | |
515 { | |
516 memmove( self->input + self->cursor+1, | |
517 self->input + self->cursor, | |
518 (len - self->cursor+1)*sizeof(wchar_t) ); | |
519 self->input[self->cursor] = (wchar_t) key; | |
520 self->cursor++; | |
521 } | |
522 else | |
523 { | |
524 fprintf( stderr, "Input buffer is full\n" ); | |
525 } | |
526 } | |
527 else | |
528 { | |
529 if( strcmp( action, "enter" ) == 0 ) | |
530 { | |
531 if( console->handlers[__SIGNAL_ACTIVATE__] ) | |
532 { | |
533 (*console->handlers[__SIGNAL_ACTIVATE__])(console, console->input); | |
534 } | |
535 console_print( self, self->prompt ); | |
536 console_print( self, self->input ); | |
537 console_print( self, L"\n" ); | |
538 self->input[0] = L'\0'; | |
539 self->cursor = 0; | |
540 } | |
541 else if( strcmp( action, "right" ) == 0 ) | |
542 { | |
543 if( self->cursor < wcslen(self->input) ) | |
544 { | |
545 self->cursor += 1; | |
546 } | |
547 } | |
548 else if( strcmp( action, "left" ) == 0 ) | |
549 { | |
550 if( self->cursor > 0 ) | |
551 { | |
552 self->cursor -= 1; | |
553 } | |
554 } | |
555 else if( strcmp( action, "delete" ) == 0 ) | |
556 { | |
557 memmove( self->input + self->cursor, | |
558 self->input + self->cursor+1, | |
559 (len - self->cursor)*sizeof(wchar_t) ); | |
560 } | |
561 else if( strcmp( action, "backspace" ) == 0 ) | |
562 { | |
563 if( self->cursor > 0 ) | |
564 { | |
565 memmove( self->input + self->cursor-1, | |
566 self->input + self->cursor, | |
567 (len - self->cursor+1)*sizeof(wchar_t) ); | |
568 self->cursor--; | |
569 } | |
570 } | |
571 else if( strcmp( action, "kill" ) == 0 ) | |
572 { | |
573 if( self->cursor < len ) | |
574 { | |
575 wcpcpy(self->killring, self->input + self->cursor ); | |
576 self->input[self->cursor] = L'\0'; | |
577 fwprintf(stderr, L"Kill ring: %ls\n", self->killring); | |
578 } | |
579 | |
580 } | |
581 else if( strcmp( action, "yank" ) == 0 ) | |
582 { | |
583 size_t l = wcslen(self->killring); | |
584 if( (len + l) < MAX_LINE_LENGTH ) | |
585 { | |
586 memmove( self->input + self->cursor + l, | |
587 self->input + self->cursor, | |
588 (len - self->cursor)*sizeof(wchar_t) ); | |
589 memcpy( self->input + self->cursor, | |
590 self->killring, l*sizeof(wchar_t)); | |
591 self->cursor += l; | |
592 } | |
593 } | |
594 else if( strcmp( action, "home" ) == 0 ) | |
595 { | |
596 self->cursor = 0; | |
597 } | |
598 else if( strcmp( action, "end" ) == 0 ) | |
599 { | |
600 self->cursor = wcslen( self->input ); | |
601 } | |
602 else if( strcmp( action, "clear" ) == 0 ) | |
603 { | |
604 } | |
605 else if( strcmp( action, "history-prev" ) == 0 ) | |
606 { | |
607 if( console->handlers[__SIGNAL_HISTORY_PREV__] ) | |
608 { | |
609 (*console->handlers[__SIGNAL_HISTORY_PREV__])(console, console->input); | |
610 } | |
611 } | |
612 else if( strcmp( action, "history-next" ) == 0 ) | |
613 { | |
614 if( console->handlers[__SIGNAL_HISTORY_NEXT__] ) | |
615 { | |
616 (*console->handlers[__SIGNAL_HISTORY_NEXT__])(console, console->input); | |
617 } | |
618 } | |
619 else if( strcmp( action, "complete" ) == 0 ) | |
620 { | |
621 if( console->handlers[__SIGNAL_COMPLETE__] ) | |
622 { | |
623 (*console->handlers[__SIGNAL_COMPLETE__])(console, console->input); | |
624 } | |
625 } | |
626 } | |
627 } | |
628 | |
629 | |
630 | |
631 | |
632 | |
633 | |
634 | |
635 | |
636 // debug | |
637 | |
638 int mouseX; | |
639 int mouseY; | |
640 | |
641 // shaders | |
642 | |
643 GLuint shaders[10]; | |
644 const char* shaderss[] = { "data/shaders/v3f-t2f-c4f.frag", | |
645 "data/shaders/projector", | |
646 "data/shaders/eye", | |
647 "data/shaders/eye_post", | |
648 "data/shaders/fsquad", | |
649 "data/shaders/copquad", | |
650 "data/shaders/redcircle", | |
651 "data/shaders/vhs", | |
652 "data/shaders/yuv2rgb", | |
653 "data/shaders/hex"}; | |
654 enum shaderi { nannanna, projector, eye, eye_post, fsquad, copquad, redcircle, vhs, yuv2rgb, hex }; | |
655 | |
656 GLuint depth_rb = 0; | |
657 GLuint depth_rb2 = 0; | |
658 GLuint depth_rb3 = 0; | |
659 // textures | |
660 | |
661 int textures[65] = {-1}; | |
662 const char* texturess[] = {"data/gfx/scene.jpg", | |
663 "data/gfx/dude1.jpg", | |
664 "data/gfx/dude2.jpg", | |
665 "data/gfx/mask.jpg", | |
666 "data/gfx/note.jpg", | |
667 "data/gfx/exit.jpg", | |
668 "data/gfx/v0.png", | |
669 "data/gfx/v1.png", | |
670 "data/gfx/v2.png", | |
671 "data/gfx/v3.png", | |
672 "data/gfx/v4.png", | |
673 "data/gfx/v5.png", | |
674 "data/gfx/v6.png", | |
675 "data/gfx/v7.png", | |
676 "data/gfx/v8.png", | |
677 "data/gfx/v9.png", | |
678 "data/gfx/v9a.png", | |
679 "data/gfx/v9b.png", | |
680 "data/gfx/v9c.png", | |
681 "data/gfx/copkiller1.jpg", | |
682 "data/gfx/prip1.jpg", | |
683 "data/gfx/copkiller2.jpg", | |
684 "data/gfx/prip2.jpg", | |
685 "data/gfx/copkiller3.jpg", | |
686 "data/gfx/prip3.jpg", | |
687 "data/gfx/copkiller4.jpg", | |
688 "data/gfx/prip4.jpg", | |
689 "data/gfx/copkiller5.jpg", | |
690 "data/gfx/prip5.jpg", | |
691 "data/gfx/copkiller6.jpg", | |
692 "data/gfx/prip6.jpg", | |
693 "data/gfx/copkiller7.jpg", | |
694 "data/gfx/prip7.jpg", | |
695 "data/gfx/copkiller8.jpg", | |
696 "data/gfx/prip8.jpg", | |
697 "data/gfx/copkiller9.jpg", | |
698 "data/gfx/prip9.jpg", | |
699 "data/gfx/copkiller10.jpg", | |
700 "data/gfx/prip10.jpg", | |
701 "data/gfx/copkiller11.jpg", | |
702 "data/gfx/prip11.jpg", | |
703 "data/gfx/copkiller12.jpg", | |
704 "data/gfx/prip12.jpg", | |
705 "data/gfx/copkiller13.jpg", | |
706 "data/gfx/prip13.jpg", | |
707 "data/gfx/copkiller14.jpg", | |
708 "data/gfx/prip14.jpg", | |
709 "data/gfx/copkiller15.jpg", | |
710 "data/gfx/prip15.jpg", | |
711 "data/gfx/aegis.jpg", | |
712 "data/gfx/ll1.png", | |
713 "data/gfx/ll2.png", | |
714 "data/gfx/ll3.png", | |
715 "data/gfx/ll4.png", | |
716 "data/gfx/ll5.png", | |
717 "data/gfx/grayeye.jpg", | |
718 "data/gfx/room1.jpg", | |
719 "data/gfx/room2.jpg", | |
720 "data/gfx/room3.jpg", | |
721 "data/gfx/majic1.jpg", | |
722 "data/gfx/majic2.jpg", | |
723 "data/gfx/majic3.jpg", | |
724 "data/gfx/majic4.jpg", | |
725 "data/gfx/bilogon.png", | |
726 "data/gfx/noise.jpg"}; | |
727 enum texturi { tex_scene, tex_dude, tex_dude2, tex_mask, tex_note, tex_exit, | |
728 tex_v0,tex_v1,tex_v2,tex_v3,tex_v4,tex_v5,tex_v6,tex_v7,tex_v8,tex_v9,tex_v9a,tex_v9b,tex_v9c, | |
729 tex_copkiller, tex_prip, | |
730 tex_copkiller2, tex_prip2, | |
731 tex_copkiller3, tex_prip3, | |
732 tex_copkiller4, tex_prip4, | |
733 tex_copkiller5, tex_prip5, | |
734 tex_copkiller6, tex_prip6, | |
735 tex_copkiller7, tex_prip7, | |
736 tex_copkiller8, tex_prip8, | |
737 tex_copkiller9, tex_prip9, | |
738 tex_copkiller10,tex_prip10, | |
739 tex_copkiller11,tex_prip11, | |
740 tex_copkiller12,tex_prip12, | |
741 tex_copkiller13,tex_prip13, | |
742 tex_copkiller14,tex_prip14, | |
743 tex_copkiller15,tex_prip15, | |
744 | |
745 tex_aegis, tex_ll1,tex_ll2,tex_ll3,tex_ll4,tex_ll5, | |
746 tex_grayeye, tex_room, tex_room2, tex_room3, | |
747 tex_majestic1, tex_majestic2, tex_majestic3, tex_majestic4, | |
748 tex_bilogon, | |
749 tex_noise}; | |
750 | |
751 // texture switchers | |
752 | |
753 int room_texnum = 0; | |
754 | |
755 // assimp scenes | |
756 | |
757 Assimp::Importer importer[7]; | |
758 | |
759 const aiScene *kapsule, *bilothree, *brieflycase, | |
760 *bilothorn, *biloflat, *bilotetra; | |
761 | |
762 std::map<std::string, GLuint*> textureIdMap; // map image filenames to textureIds | |
763 GLuint* textureIds; // pointer to texture array | |
764 | |
765 static float kujalla_angle = 0.f; | |
766 int beatmode = -1; | |
767 | |
768 // assimp defines | |
769 | |
770 #define aisgl_min(x,y) (x<y?x:y) | |
771 #define aisgl_max(x,y) (y>x?y:x) | |
772 | |
773 // misc. gfx system | |
774 | |
775 static GLfloat g_nearPlane = 0.001; | |
776 static GLfloat g_farPlane = 1000; | |
777 static int c_Width = 640; | |
778 static int c_Height = 360; | |
779 static int g_Width = 1280; | |
780 static int g_Height = 720; | |
781 | |
782 class YUVFrame { | |
783 public: | |
784 YUVFrame(OggPlayer oggstream):ogg(oggstream) { | |
785 width = ogg.width(); height = ogg.height(); | |
786 // The textures are created when rendering the first frame | |
787 y_tex = u_tex = v_tex = -1 ; | |
788 } | |
789 ~YUVFrame() { | |
790 glDeleteTextures(1,&y_tex); | |
791 glDeleteTextures(1,&u_tex); | |
792 glDeleteTextures(1,&v_tex); | |
793 } | |
794 void play() { | |
795 ogg.play(); | |
796 } | |
797 void close() | |
798 { | |
799 ogg.close(); | |
800 } | |
801 void render() { | |
802 update(); | |
803 if(-1==y_tex) return; // not ready yet | |
804 glUseProgram(shaders[yuv2rgb]); | |
805 | |
806 GLint widthLoc5 = glGetUniformLocation(shaders[yuv2rgb], "width"); | |
807 GLint heightLoc5 = glGetUniformLocation(shaders[yuv2rgb], "height"); | |
808 glUniform1f(widthLoc5, g_Width); | |
809 glUniform1f(heightLoc5, g_Height); | |
810 | |
811 GLint y_pos = glGetUniformLocation(shaders[yuv2rgb],"y_tex"); | |
812 GLint u_pos = glGetUniformLocation(shaders[yuv2rgb],"u_tex"); | |
813 GLint v_pos = glGetUniformLocation(shaders[yuv2rgb],"v_tex"); | |
814 | |
815 glDisable(GL_BLEND); | |
816 | |
817 glActiveTexture(GL_TEXTURE0); | |
818 glBindTexture(GL_TEXTURE_2D, y_tex); | |
819 glUniform1i(y_pos, 0); | |
820 glActiveTexture(GL_TEXTURE1); | |
821 glBindTexture(GL_TEXTURE_2D, u_tex); | |
822 glUniform1i(u_pos, 1); | |
823 glActiveTexture(GL_TEXTURE2); | |
824 glBindTexture(GL_TEXTURE_2D, v_tex); | |
825 glUniform1i(v_pos, 2); | |
826 | |
827 glLoadIdentity(); | |
828 | |
829 glTranslatef(-1.2, -1.0, -1.0); | |
830 | |
831 int i=0; | |
832 int j=0; | |
833 glBegin(GL_QUADS); | |
834 glVertex2f(i, j); | |
835 glVertex2f(i + 100, j); | |
836 glVertex2f(i + 100, j + 100); | |
837 glVertex2f(i, j + 100); | |
838 glEnd(); | |
839 | |
840 } | |
841 private: | |
842 void update() { | |
843 YUVBuffer yuv; | |
844 // yuv_buffer_try_lock(...) returns false if the last read frame is | |
845 // still up to date, in this case we can simply retender the | |
846 // last frame without an update | |
847 // We don't need to call unlock unless the lock operation was successfull | |
848 if(!ogg.yuv_buffer_try_lock(&yuv)) return; | |
849 // Create the textures if needed, at this point we | |
850 // know how big the textures should be. | |
851 // The sample plyer that comes with the official SDK | |
852 // assummes uv_width=y_width/2 , uv_height=y_height/2 | |
853 // but I'm not sure whether that is always true | |
854 if(-1==y_tex){ | |
855 y_tex = gen_texture(yuv.y_width,yuv.y_height); | |
856 u_tex = gen_texture(yuv.uv_width,yuv.uv_height); | |
857 v_tex = gen_texture(yuv.uv_width,yuv.uv_height); | |
858 } | |
859 int y_offset = ogg.offset_x() + yuv.y_stride * ogg.offset_y(); | |
860 int uv_offset = ogg.offset_x()/(yuv.y_width/yuv.uv_width)+ | |
861 yuv.uv_stride * ogg.offset_y()/(yuv.y_height/yuv.uv_height); | |
862 update_texture(y_tex,yuv.y+y_offset,yuv.y_width,yuv.y_height,yuv.y_stride); | |
863 update_texture(u_tex,yuv.u+uv_offset,yuv.uv_width,yuv.uv_height,yuv.uv_stride); | |
864 update_texture(v_tex,yuv.v+uv_offset,yuv.uv_width,yuv.uv_height,yuv.uv_stride); | |
865 ogg.yuv_buffer_unlock(); | |
866 } | |
867 GLuint gen_texture(int w,int h) { | |
868 GLuint tex; | |
869 glGenTextures(1,&tex); | |
870 glBindTexture(GL_TEXTURE_2D,tex); | |
871 glTexImage2D(GL_TEXTURE_2D,0,1,w,h,0,GL_LUMINANCE,GL_UNSIGNED_BYTE,NULL); | |
872 glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); | |
873 glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); | |
874 glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT ); | |
875 glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT ); | |
876 return tex; | |
877 } | |
878 void update_texture(GLuint tex, unsigned char* buf,int w,int h, int stride) { | |
879 glPixelStorei(GL_UNPACK_ROW_LENGTH,stride); | |
880 glBindTexture(GL_TEXTURE_2D,tex); | |
881 glTexSubImage2D(GL_TEXTURE_2D,0,0,0,w,h,GL_LUMINANCE,GL_UNSIGNED_BYTE,buf); | |
882 // set GL_UNPACK_ROW_LENGTH back to 0 to avoid bugs | |
883 glPixelStorei(GL_UNPACK_ROW_LENGTH,0); | |
884 } | |
885 OggPlayer ogg; | |
886 GLuint y_tex,u_tex,v_tex; | |
887 int width,height; | |
888 }; | |
889 | |
890 YUVFrame* myVideoFrame; | |
891 | |
892 void InitFBO(); | |
893 | |
894 int frame = 0; | |
895 | |
896 // effect pointers && logic && state | |
897 | |
898 int current_scene; | |
899 | |
900 void dummy(float dt) {} | |
901 | |
902 void Loader(); | |
903 void LeadMaskScene(); | |
904 void CopScene(); | |
905 void MarssiScene(); | |
906 void LongScene(); | |
907 void EyeScene(); | |
908 void RedCircleScene(); | |
909 void BiloThreeScene(); | |
910 void KolmeDeeScene(); | |
911 | |
912 void KolmeDeeLogic(float dt); | |
913 //void LoaderLogic(float dt); | |
914 void ConsoleLogic(float dt); | |
915 void ConsoleLogic2(float dt); | |
916 | |
917 typedef void (*SceneRenderCallback)(); | |
918 SceneRenderCallback scene_render[] = { | |
919 &Loader, | |
920 &LeadMaskScene, | |
921 &CopScene, | |
922 &MarssiScene, | |
923 &LongScene, | |
924 &EyeScene, | |
925 &RedCircleScene, | |
926 &BiloThreeScene | |
927 }; | |
928 | |
929 typedef void (*SceneLogicCallback)(float); | |
930 SceneLogicCallback scene_logic[] = { | |
931 &dummy, | |
932 &ConsoleLogic, | |
933 &dummy, | |
934 &ConsoleLogic2, | |
935 &dummy, | |
936 &dummy, | |
937 &dummy, | |
938 &dummy | |
939 }; | |
940 | |
941 // audio | |
942 | |
943 float scene_start_millis = 0; | |
944 | |
945 int music_started = -1; | |
946 | |
947 DWORD music_channel = 0; | |
948 | |
949 | |
950 ///////////////////////////////////////////////////////// | |
951 //////////////////////// PLAYLIST //////////////////////// | |
952 /////////////////////////////////////////////////////////// | |
953 | |
954 void reshape(GLint width, GLint height) | |
955 { | |
956 g_Width = width; | |
957 g_Height = height; | |
958 | |
959 printf("--- MIDISYS ENGINE: reshape event: %dx%d\n", (int)width, (int)height); | |
960 | |
961 glViewport(0, 0, g_Width, g_Height); | |
962 glMatrixMode(GL_PROJECTION); | |
963 glLoadIdentity(); | |
964 gluPerspective(65.0, (float)g_Width / g_Height, g_nearPlane, g_farPlane); | |
965 glMatrixMode(GL_MODELVIEW); | |
966 | |
967 glDeleteTextures(1, &fb_tex); | |
968 glDeleteRenderbuffersEXT(1, &depth_rb); | |
969 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); | |
970 glDeleteFramebuffersEXT(1, &fb); | |
971 | |
972 glDeleteTextures(1, &fb_tex2); | |
973 glDeleteRenderbuffersEXT(1, &depth_rb2); | |
974 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); | |
975 glDeleteFramebuffersEXT(1, &fb2); | |
976 | |
977 glDeleteTextures(1, &fake_framebuffer_tex); | |
978 glDeleteRenderbuffersEXT(1, &depth_rb3); | |
979 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); | |
980 glDeleteFramebuffersEXT(1, &fake_framebuffer); | |
981 | |
982 InitFBO(); | |
983 } | |
984 | |
985 | |
986 int demo_playlist() | |
987 { | |
988 int sc = current_scene; | |
989 if (millis >= 0 && millis < 111844) // 55922 | |
990 { | |
991 current_scene = 1; // lead masks | |
992 } | |
993 else if (millis >= 111844 && millis < 148800) | |
994 { | |
995 current_scene = 2; // cops | |
996 } | |
997 else if (millis >= 148800 && millis < 184000) | |
998 { | |
999 current_scene = 3; // marssi | |
1000 } | |
1001 else if (millis >= 184000 && millis < 188737) | |
1002 { | |
1003 current_scene = 4; // "long live the new flesh" | |
1004 } | |
1005 else if (millis >= 188737 && millis < 264000) | |
1006 { | |
1007 current_scene = 5; // eye horror | |
1008 } | |
1009 else if (millis >= 264000 && millis < 300200) | |
1010 { | |
1011 current_scene = 6; // outro 1 / redcircle | |
1012 } | |
1013 else if (millis >= 300200 && millis < 320000) | |
1014 { | |
1015 current_scene = 7; // outro 2 / bilothree | |
1016 } | |
1017 | |
1018 if (sc != current_scene) | |
1019 { | |
1020 if (current_scene == 4) { | |
1021 myVideoFrame->close(); | |
1022 } | |
1023 | |
1024 if (current_scene == 6) | |
1025 { | |
1026 reshape(g_Width, g_Height); | |
1027 } | |
1028 /*if(current_scene == 1) | |
1029 { | |
1030 //printf("xx XX xxxxxxxRESHAPING HAXXXXxxxxx xxx XX xx"); | |
1031 //glutLeaveMainLoop(); | |
1032 //glutReshapeWindow(g_Width, g_Height); | |
1033 //glutFullScreen(); | |
1034 //glutMainLoop(); | |
1035 }*/ | |
1036 scene_start_millis = millis; | |
1037 vector_clear(console->lines); | |
1038 } | |
1039 } | |
1040 | |
1041 ///////////////////////////////////////////////////// HELPER FUNCTIONS | |
1042 | |
1043 void BassError(const char *text) | |
1044 { | |
1045 printf("BASS error(%d): %s\n",BASS_ErrorGetCode(),text); | |
1046 BASS_Free(); | |
1047 exit(0); | |
1048 } | |
1049 | |
1050 void InitAudio(const char *pFilename) | |
1051 { | |
1052 DWORD chan; | |
1053 QWORD pos; | |
1054 | |
1055 printf("--- MIDISYS-ENGINE: InitAudio()\n"); | |
1056 | |
1057 if (!BASS_Init(-1,44100,0,0,NULL)) BassError("InitAudio() - can't initialize device\n"); | |
1058 | |
1059 printf("\tInitAudio() - loading soundtrack from file \"%s\"\n", pFilename); | |
1060 | |
1061 int success = 0; | |
1062 | |
1063 if ((chan=BASS_StreamCreateFile(FALSE,pFilename,0,0,BASS_STREAM_PRESCAN)) | |
1064 || (chan=BASS_StreamCreateURL(pFilename,0,BASS_STREAM_PRESCAN,0,0))) { | |
1065 pos=BASS_ChannelGetLength(chan,BASS_POS_BYTE); | |
1066 if (BASS_StreamGetFilePosition(chan,BASS_FILEPOS_DOWNLOAD)!=-1) { | |
1067 // streaming from the internet | |
1068 if (pos!=-1) | |
1069 { | |
1070 printf("\tInitAudio() - streaming internet file [%I64u bytes]\n",pos); | |
1071 success = 1; | |
1072 } | |
1073 else | |
1074 { | |
1075 printf("\tstreaming internet file\n"); | |
1076 success = 1; | |
1077 } | |
1078 } else | |
1079 { | |
1080 printf("\tstreaming file [%I64u bytes]\n",pos); | |
1081 success = 1; | |
1082 } | |
1083 } | |
1084 | |
1085 if (success == 1) | |
1086 { | |
1087 music_channel = chan; | |
1088 } | |
1089 else | |
1090 { | |
1091 printf("InitAudio() error! could not load file.\n"); | |
1092 exit(1); | |
1093 } | |
1094 } | |
1095 | |
1096 void HexList(BYTE *pData, int iNumBytes) | |
1097 { | |
1098 int i; | |
1099 | |
1100 for(i=0;i<iNumBytes;i++) | |
1101 printf("%.2x ", pData[i]); | |
1102 } | |
1103 | |
1104 char *File2String(const char *path) | |
1105 { | |
1106 FILE *fd; | |
1107 long len, | |
1108 r; | |
1109 char *str; | |
1110 | |
1111 if (!(fd = fopen(path, "r"))) | |
1112 { | |
1113 fprintf(stderr, "\terror, can't open file '%s' for reading\n", path); | |
1114 return NULL; | |
1115 } | |
1116 | |
1117 fseek(fd, 0, SEEK_END); | |
1118 len = ftell(fd); | |
1119 | |
1120 #ifdef SUPERVERBOSE | |
1121 printf("\tshader source file \"%s\" is %ld bytes long\n", path, len); | |
1122 #endif | |
1123 | |
1124 fseek(fd, 0, SEEK_SET); | |
1125 | |
1126 if (!(str = (char*) malloc(len * sizeof(char)))) | |
1127 { | |
1128 fprintf(stderr, "\terror, can't malloc space for file \"%s\"\n", path); | |
1129 return NULL; | |
1130 } | |
1131 | |
1132 r = fread(str, sizeof(char), len, fd); | |
1133 | |
1134 str[r - 1] = '\0'; /* Shader sources have to term with null */ | |
1135 | |
1136 fclose(fd); | |
1137 | |
1138 return str; | |
1139 } | |
1140 | |
1141 void PrintShaderLog(GLuint obj) | |
1142 { | |
1143 int infologLength = 0; | |
1144 int maxLength; | |
1145 | |
1146 if(glIsShader(obj)) | |
1147 glGetShaderiv(obj,GL_INFO_LOG_LENGTH,&maxLength); | |
1148 else | |
1149 glGetProgramiv(obj,GL_INFO_LOG_LENGTH,&maxLength); | |
1150 | |
1151 char infoLog[maxLength]; | |
1152 | |
1153 if (glIsShader(obj)) | |
1154 glGetShaderInfoLog(obj, maxLength, &infologLength, infoLog); | |
1155 else | |
1156 glGetProgramInfoLog(obj, maxLength, &infologLength, infoLog); | |
1157 | |
1158 if (infologLength > 0) | |
1159 { | |
1160 printf("\n%s\n",infoLog); | |
1161 } | |
1162 } | |
1163 | |
1164 void DebugPrintEvent(int ev, MIDI_MSG msg) | |
1165 { | |
1166 #if 0 | |
1167 char str[128]; | |
1168 unsigned int j; | |
1169 if (muGetMIDIMsgName(str, ev)) printf("%s\t", str); | |
1170 | |
1171 switch(ev) | |
1172 { | |
1173 case msgNoteOff: | |
1174 muGetNameFromNote(str, msg.MsgData.NoteOff.iNote); | |
1175 printf("(%.2d) %s", msg.MsgData.NoteOff.iChannel, str); | |
1176 break; | |
1177 case msgNoteOn: | |
1178 muGetNameFromNote(str, msg.MsgData.NoteOn.iNote); | |
1179 printf("\t(%.2d) %s %d", msg.MsgData.NoteOn.iChannel, str, msg.MsgData.NoteOn.iVolume); | |
1180 break; | |
1181 case msgNoteKeyPressure: | |
1182 muGetNameFromNote(str, msg.MsgData.NoteKeyPressure.iNote); | |
1183 printf("(%.2d) %s %d", msg.MsgData.NoteKeyPressure.iChannel, | |
1184 str, | |
1185 msg.MsgData.NoteKeyPressure.iPressure); | |
1186 break; | |
1187 case msgSetParameter: | |
1188 muGetControlName(str, msg.MsgData.NoteParameter.iControl); | |
1189 printf("(%.2d) %s -> %d", msg.MsgData.NoteParameter.iChannel, | |
1190 str, msg.MsgData.NoteParameter.iParam); | |
1191 break; | |
1192 case msgSetProgram: | |
1193 muGetInstrumentName(str, msg.MsgData.ChangeProgram.iProgram); | |
1194 printf("(%.2d) %s", msg.MsgData.ChangeProgram.iChannel, str); | |
1195 break; | |
1196 case msgChangePressure: | |
1197 muGetControlName(str, msg.MsgData.ChangePressure.iPressure); | |
1198 printf("(%.2d) %s", msg.MsgData.ChangePressure.iChannel, str); | |
1199 break; | |
1200 case msgSetPitchWheel: | |
1201 printf("(%.2d) %d", msg.MsgData.PitchWheel.iChannel, | |
1202 msg.MsgData.PitchWheel.iPitch); | |
1203 break; | |
1204 | |
1205 case msgMetaEvent: | |
1206 printf("---- "); | |
1207 switch(msg.MsgData.MetaEvent.iType) | |
1208 { | |
1209 case metaMIDIPort: | |
1210 printf("MIDI Port = %d", msg.MsgData.MetaEvent.Data.iMIDIPort); | |
1211 break; | |
1212 | |
1213 case metaSequenceNumber: | |
1214 printf("Sequence Number = %d",msg.MsgData.MetaEvent.Data.iSequenceNumber); | |
1215 break; | |
1216 | |
1217 case metaTextEvent: | |
1218 printf("Text = '%s'",msg.MsgData.MetaEvent.Data.Text.pData); | |
1219 break; | |
1220 case metaCopyright: | |
1221 printf("Copyright = '%s'",msg.MsgData.MetaEvent.Data.Text.pData); | |
1222 break; | |
1223 case metaTrackName: | |
1224 printf("Track name = '%s'",msg.MsgData.MetaEvent.Data.Text.pData); | |
1225 break; | |
1226 case metaInstrument: | |
1227 printf("Instrument = '%s'",msg.MsgData.MetaEvent.Data.Text.pData); | |
1228 break; | |
1229 case metaLyric: | |
1230 printf("Lyric = '%s'",msg.MsgData.MetaEvent.Data.Text.pData); | |
1231 break; | |
1232 case metaMarker: | |
1233 printf("Marker = '%s'",msg.MsgData.MetaEvent.Data.Text.pData); | |
1234 break; | |
1235 case metaCuePoint: | |
1236 printf("Cue point = '%s'",msg.MsgData.MetaEvent.Data.Text.pData); | |
1237 break; | |
1238 case metaEndSequence: | |
1239 printf("End Sequence"); | |
1240 break; | |
1241 case metaSetTempo: | |
1242 printf("Tempo = %d",msg.MsgData.MetaEvent.Data.Tempo.iBPM); | |
1243 break; | |
1244 case metaSMPTEOffset: | |
1245 printf("SMPTE offset = %d:%d:%d.%d %d", | |
1246 msg.MsgData.MetaEvent.Data.SMPTE.iHours, | |
1247 msg.MsgData.MetaEvent.Data.SMPTE.iMins, | |
1248 msg.MsgData.MetaEvent.Data.SMPTE.iSecs, | |
1249 msg.MsgData.MetaEvent.Data.SMPTE.iFrames, | |
1250 msg.MsgData.MetaEvent.Data.SMPTE.iFF | |
1251 ); | |
1252 break; | |
1253 case metaTimeSig: | |
1254 printf("Time sig = %d/%d",msg.MsgData.MetaEvent.Data.TimeSig.iNom, | |
1255 msg.MsgData.MetaEvent.Data.TimeSig.iDenom/MIDI_NOTE_CROCHET); | |
1256 break; | |
1257 case metaKeySig: | |
1258 if (muGetKeySigName(str, msg.MsgData.MetaEvent.Data.KeySig.iKey)) | |
1259 printf("Key sig = %s", str); | |
1260 break; | |
1261 | |
1262 case metaSequencerSpecific: | |
1263 printf("Sequencer specific = "); | |
1264 HexList(msg.MsgData.MetaEvent.Data.Sequencer.pData, msg.MsgData.MetaEvent.Data.Sequencer.iSize); | |
1265 break; | |
1266 } | |
1267 break; | |
1268 | |
1269 case msgSysEx1: | |
1270 case msgSysEx2: | |
1271 printf("Sysex = "); | |
1272 HexList(msg.MsgData.SysEx.pData, msg.MsgData.SysEx.iSize); | |
1273 break; | |
1274 } | |
1275 | |
1276 if (ev == msgSysEx1 || ev == msgSysEx1 || (ev==msgMetaEvent && msg.MsgData.MetaEvent.iType==metaSequencerSpecific)) | |
1277 { | |
1278 /* Already done a hex dump */ | |
1279 } | |
1280 else | |
1281 { | |
1282 printf("\t["); | |
1283 if (msg.bImpliedMsg) printf("%.2x!", msg.iImpliedMsg); | |
1284 for(j=0;j<msg.iMsgSize;j++) | |
1285 printf("%.2x ", msg.data[j]); | |
1286 printf("]\n"); | |
1287 } | |
1288 #endif | |
1289 } | |
1290 | |
1291 void LoadMIDIEventList(const char *pFilename) | |
1292 { | |
1293 printf("--- MIDISYS ENGINE: LoadMIDIEventList(\"%s\")\n", pFilename); | |
1294 MIDI_FILE *mf = midiFileOpen(pFilename); | |
1295 int ev; | |
1296 | |
1297 int timeline_index = 0; | |
1298 int track_index = 0; | |
1299 MIDI_MSG msg; | |
1300 | |
1301 if (mf) | |
1302 { | |
1303 int i, iNum; | |
1304 | |
1305 midiReadInitMessage(&msg); | |
1306 iNum = midiReadGetNumTracks(mf); | |
1307 | |
1308 for(i=0;i<iNum;i++) | |
1309 { | |
1310 #ifdef SUPERVERBOSE | |
1311 printf("# Track %d\n", i); | |
1312 #endif | |
1313 while(midiReadGetNextMessage(mf, i, &msg)) | |
1314 { | |
1315 #ifdef SUPERVERBOSE | |
1316 printf(" %.6ld ", msg.dwAbsPos); | |
1317 #endif | |
1318 | |
1319 if (msg.bImpliedMsg) { ev = msg.iImpliedMsg; } | |
1320 else { ev = msg.iType; } | |
1321 | |
1322 memcpy(&timeline[track_index][timeline_index], &msg, sizeof(MIDI_MSG)); | |
1323 | |
1324 if (ev == msgMetaEvent && msg.MsgData.MetaEvent.iType == metaTrackName) | |
1325 { | |
1326 strncpy(timeline_trackname[track_index], msg.MsgData.MetaEvent.Data.Text.pData, 8); | |
1327 timeline_trackname[track_index][8] == '\0'; | |
1328 printf("track #%d, name = \"%s\"\n", track_index, timeline_trackname[track_index]); | |
1329 } | |
1330 | |
1331 #ifdef SUPERVERBOSE | |
1332 DebugPrintEvent(ev,msg); | |
1333 #endif | |
1334 | |
1335 timeline_index++; | |
1336 | |
1337 } | |
1338 printf("track length: %d\n", timeline_index); | |
1339 timeline_tracklength[track_index] = timeline_index; | |
1340 track_index++; | |
1341 timeline_index = 0; | |
1342 } | |
1343 | |
1344 timeline_trackcount = track_index; | |
1345 midiReadFreeMessage(&msg); | |
1346 | |
1347 midiFileClose(mf); | |
1348 } | |
1349 | |
1350 //timeline_length = timeline_index+1; | |
1351 printf("--- MIDISYS ENGINE: LoadMIDIEventList() success\n"); | |
1352 } | |
1353 | |
1354 void ParseMIDITimeline(const char* mappingFile) | |
1355 { | |
1356 printf("--- MIDISYS ENGINE: ParseMIDITimeline(\"%s\")\n", mappingFile); | |
1357 int cnt; | |
1358 char *line; | |
1359 | |
1360 FILE *mapfile; | |
1361 | |
1362 if ((mapfile = fopen(mappingFile, "r"))) | |
1363 { | |
1364 cnt = 0; | |
1365 while (0 == fggets(&line, mapfile)) { | |
1366 char* token = strtok(line, ","); | |
1367 int paramnum = atoi(token); | |
1368 mapping_paramnum[cnt] = paramnum; | |
1369 | |
1370 token = strtok(NULL, ","); | |
1371 sprintf(mapping_trackname[cnt],"%s",token); | |
1372 | |
1373 token = strtok(NULL, ","); | |
1374 if (strcmp("param",token) == 0) mapping_type[cnt] = 1; | |
1375 else mapping_type[cnt] = 0; | |
1376 | |
1377 // token = strtok(NULL, ","); | |
1378 // sprintf(englines[cnt],"%s",token); | |
1379 | |
1380 int i = 0; | |
1381 int found = -1; | |
1382 for (i = 0; i < timeline_trackcount; i++) | |
1383 { | |
1384 if (strcmp(timeline_trackname[i], mapping_trackname[cnt]) == 0) | |
1385 { | |
1386 printf("MIDI track #%d (\"%s\") maps to shader param %d, type: %s\n", i, mapping_trackname[cnt], mapping_paramnum[cnt], mapping_type[cnt] == 0 ? "trig" : "param"); | |
1387 mapping_tracknum[cnt] = i; | |
1388 cnt++; | |
1389 found = 1; | |
1390 } | |
1391 if (found == 1) break; | |
1392 } | |
1393 } | |
1394 mapping_count = cnt; | |
1395 } | |
1396 else | |
1397 { | |
1398 printf("ParseMIDITimeline error: MIDI mapping file \"%s\" cannot be opened\n", mappingFile); | |
1399 exit(1); | |
1400 } | |
1401 printf("--- MIDISYS ENGINE: ParseMIDITimeline() success\n"); | |
1402 } | |
1403 | |
1404 | |
1405 void stbi_flip_y(int w, int h, int comp, stbi_uc *data) | |
1406 { | |
1407 size_t y, i, stride = w * comp; | |
1408 uint8 *out = data; | |
1409 | |
1410 for (y = 0; y < (h>>1); ++y) { | |
1411 stbi_uc *p1 = out + y * stride; | |
1412 stbi_uc *p2 = out + (h-1-y) * stride; | |
1413 for (i = 0; i < stride; ++i) { | |
1414 stbi_uc t = p1[i]; | |
1415 p1[i] = p2[i]; | |
1416 p2[i] = t; | |
1417 } | |
1418 } | |
1419 } | |
1420 | |
1421 int scale_image_RGB_to_NTSC_safe(int width, int height, int channels,stbi_uc* data) { | |
1422 const float scale_lo = 16.0f - 0.499f; | |
1423 const float scale_hi = 235.0f + 0.499f; | |
1424 int i, j; | |
1425 int nc = channels; | |
1426 | |
1427 unsigned char* orig = data; | |
1428 | |
1429 unsigned char scale_LUT[256]; | |
1430 /* error check */ | |
1431 if( (width < 1) || (height < 1) || | |
1432 (channels < 1) || (orig == NULL) ) | |
1433 { | |
1434 /* nothing to do */ | |
1435 return 0; | |
1436 } | |
1437 /* set up the scaling Look Up Table */ | |
1438 for( i = 0; i < 256; ++i ) | |
1439 { | |
1440 scale_LUT[i] = (unsigned char)((scale_hi - scale_lo) * i / 255.0f + scale_lo); | |
1441 } | |
1442 /* for channels = 2 or 4, ignore the alpha component */ | |
1443 nc -= 1 - (channels & 1); | |
1444 /* OK, go through the image and scale any non-alpha components */ | |
1445 for( i = 0; i < width*height*channels; i += channels ) | |
1446 { | |
1447 for( j = 0; j < nc; ++j ) | |
1448 { | |
1449 orig[i+j] = scale_LUT[orig[i+j]]; | |
1450 } | |
1451 } | |
1452 return 1; | |
1453 } | |
1454 | |
1455 | |
1456 GLuint LoadTexture(const char* pFilename, int invert) | |
1457 { | |
1458 if(!load_textures) return; | |
1459 | |
1460 if (strcmp(pFilename,"") == 0) return 99999; | |
1461 printf(" - LoadTexture(\"%s\")", pFilename); | |
1462 GLuint tex_2d; | |
1463 unsigned char *data; | |
1464 int x, y, comp; | |
1465 | |
1466 FILE *file = fopen(pFilename, "rb"); | |
1467 if (!file) | |
1468 return 0; | |
1469 | |
1470 data = stbi_load_from_file(file, &x, &y, &comp, 0); | |
1471 fclose(file); | |
1472 //gluBuild2DMipmaps( GL_TEXTURE_2D, 4, x, y, GL_RGBA, GL_UNSIGNED_BYTE, data ); | |
1473 | |
1474 glGenTextures( 1, &tex_2d ); | |
1475 glBindTexture( GL_TEXTURE_2D, tex_2d ); | |
1476 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); | |
1477 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP ); | |
1478 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP ); | |
1479 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); | |
1480 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); | |
1481 | |
1482 | |
1483 if (invert == 1) | |
1484 { | |
1485 stbi_flip_y(x, y, comp, data); | |
1486 } | |
1487 else | |
1488 { | |
1489 } | |
1490 | |
1491 scale_image_RGB_to_NTSC_safe(x,y,comp,data); | |
1492 | |
1493 if( comp == 3 ) { | |
1494 glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, x, y, 0, GL_RGB, GL_UNSIGNED_BYTE, data ); | |
1495 } else if( comp == 4 ) { | |
1496 glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, x, y, 0, GL_RGBA, GL_UNSIGNED_BYTE, data ); | |
1497 } | |
1498 | |
1499 | |
1500 if(0 == tex_2d) | |
1501 { | |
1502 printf(" error loading texture from file \"%s\"\n", pFilename); | |
1503 exit(1); | |
1504 } | |
1505 | |
1506 printf(" success\n"); | |
1507 | |
1508 return tex_2d; | |
1509 } | |
1510 | |
1511 GLuint LoadTexture(const char* pFilename) | |
1512 { | |
1513 return LoadTexture(pFilename, 1); | |
1514 } | |
1515 | |
1516 int LoadGLTextures(const aiScene* scene) { | |
1517 | |
1518 if (scene->HasTextures()) | |
1519 { | |
1520 printf("ERROR: support for meshes with embedded textures is not implemented\n"); | |
1521 exit(1); | |
1522 } | |
1523 | |
1524 /* scan scene's materials for textures */ | |
1525 for (unsigned int m=0; m<scene->mNumMaterials; m++) | |
1526 { | |
1527 int texIndex = 0; | |
1528 aiReturn texFound = AI_SUCCESS; | |
1529 | |
1530 aiString path; // filename | |
1531 | |
1532 while (texFound == AI_SUCCESS) | |
1533 { | |
1534 texFound = scene->mMaterials[m]->GetTexture(aiTextureType_DIFFUSE, texIndex, &path); | |
1535 GLuint texnum = LoadTexture(path.data, 0); | |
1536 textureIdMap[path.data] = texnum; | |
1537 texIndex++; | |
1538 } | |
1539 } | |
1540 //return success; | |
1541 return true; | |
1542 } | |
1543 | |
1544 GLuint LoadShader(const char* pFilename) | |
1545 { | |
1546 fprintf(stdout," - LoadShader(\"%s\")", pFilename); | |
1547 | |
1548 #ifdef SUPERVERBOSE | |
1549 printf("\n"); | |
1550 #endif | |
1551 | |
1552 char vsName[256] = ""; | |
1553 strcpy(vsName, pFilename); | |
1554 strcat(vsName, ".vs"); | |
1555 | |
1556 char fsName[256] = ""; | |
1557 strcpy(fsName, pFilename); | |
1558 strcat(fsName, ".fs"); | |
1559 | |
1560 #ifdef SUPERVERBOSE | |
1561 fprintf(stdout,"\tLoadShader(\"%s\") vertex shader source file: \"%s\"\n", pFilename, vsName); | |
1562 #endif | |
1563 | |
1564 GLchar *vsSource = File2String(vsName); | |
1565 | |
1566 #ifdef SUPERVERBOSE | |
1567 fprintf(stdout,"\tLoadShader(\"%s\") vertex shader source:\n----------------------------------------------------\n%s\n----------------------------------------------------\n", pFilename, vsSource); | |
1568 #endif | |
1569 | |
1570 #ifdef SUPERVERBOSE | |
1571 fprintf(stdout,"\tLoadShader(\"%s\") fragment shader source file: \"%s\"\n", pFilename, fsName); | |
1572 #endif | |
1573 | |
1574 GLchar *fsSource = File2String(fsName); | |
1575 | |
1576 #ifdef SUPERVERBOSE | |
1577 fprintf(stdout,"\tLoadShader(\"%s\") fragment shader source:\n----------------------------------------------------\n%s\n----------------------------------------------------\n", pFilename, fsSource); | |
1578 #endif | |
1579 | |
1580 GLuint vs, fs, sp; | |
1581 | |
1582 #ifdef SUPERVERBOSE | |
1583 printf("\tLoadShader(): vs glCreateShader\n"); | |
1584 #endif | |
1585 vs = glCreateShader(GL_VERTEX_SHADER); | |
1586 PrintShaderLog(vs); | |
1587 #ifdef SUPERVERBOSE | |
1588 printf("\tLoadShader(): vs glShaderSource\n"); | |
1589 #endif | |
1590 glShaderSource(vs, 1, (const GLchar**)&vsSource, NULL); | |
1591 PrintShaderLog(vs); | |
1592 #ifdef SUPERVERBOSE | |
1593 printf("\tLoadShader(): vs glCompileShader\n"); | |
1594 #endif | |
1595 glCompileShader(vs); | |
1596 PrintShaderLog(vs); | |
1597 #ifdef SUPERVERBOSE | |
1598 printf("\tLoadShader(): vs compiled\n"); | |
1599 #endif | |
1600 | |
1601 #ifdef SUPERVERBOSE | |
1602 printf("\tLoadShader(): fs glCreateShader\n"); | |
1603 #endif | |
1604 fs = glCreateShader(GL_FRAGMENT_SHADER); | |
1605 PrintShaderLog(fs); | |
1606 #ifdef SUPERVERBOSE | |
1607 printf("\tLoadShader(): fs glShaderSource\n"); | |
1608 #endif | |
1609 glShaderSource(fs, 1, (const GLchar**)&fsSource, NULL); | |
1610 PrintShaderLog(fs); | |
1611 #ifdef SUPERVERBOSE | |
1612 printf("\tLoadShader(): fs glCompileShader\n"); | |
1613 #endif | |
1614 glCompileShader(fs); | |
1615 PrintShaderLog(fs); | |
1616 #ifdef SUPERVERBOSE | |
1617 printf("\tLoadShader(): fs compiled\n"); | |
1618 #endif | |
1619 | |
1620 free(vsSource); | |
1621 free(fsSource); | |
1622 | |
1623 #ifdef SUPERVERBOSE | |
1624 printf("\tLoadShader(): glCreateProgram\n"); | |
1625 #endif | |
1626 sp = glCreateProgram(); | |
1627 PrintShaderLog(sp); | |
1628 #ifdef SUPERVERBOSE | |
1629 printf("\tLoadShader(): glAttachShader vs\n"); | |
1630 #endif | |
1631 glAttachShader(sp, vs); | |
1632 PrintShaderLog(sp); | |
1633 #ifdef SUPERVERBOSE | |
1634 printf("\tLoadShader(): glAttachShader fs\n"); | |
1635 #endif | |
1636 glAttachShader(sp, fs); | |
1637 PrintShaderLog(sp); | |
1638 #ifdef SUPERVERBOSE | |
1639 printf("\tLoadShader(): glLinkProgram\n"); | |
1640 #endif | |
1641 glLinkProgram(sp); | |
1642 PrintShaderLog(sp); | |
1643 | |
1644 #ifdef SUPERVERBOSE | |
1645 fprintf(stdout,"--- MIDISYS ENGINE: LoadShader(\"%s\") success\n", pFilename); | |
1646 #else | |
1647 printf(" success\n"); | |
1648 #endif | |
1649 | |
1650 return sp; | |
1651 } | |
1652 | |
1653 ///////////////////////////////////////////////////////////////// EFFECTS | |
1654 ///////////////////////////////////////////////////////////////// EFFECTS | |
1655 ///////////////////////////////////////////////////////////////// EFFECTS | |
1656 ///////////////////////////////////////////////////////////////// EFFECTS | |
1657 ///////////////////////////////////////////////////////////////// EFFECTS | |
1658 | |
1659 | |
1660 // Can't send color down as a pointer to aiColor4D because AI colors are ABGR. | |
1661 void Color4f(const aiColor4D *color) | |
1662 { | |
1663 glColor4f(color->r, color->g, color->b, color->a); | |
1664 } | |
1665 | |
1666 void set_float4(float f[4], float a, float b, float c, float d) | |
1667 { | |
1668 f[0] = a; | |
1669 f[1] = b; | |
1670 f[2] = c; | |
1671 f[3] = d; | |
1672 } | |
1673 | |
1674 void color4_to_float4(const aiColor4D *c, float f[4]) | |
1675 { | |
1676 f[0] = c->r; | |
1677 f[1] = c->g; | |
1678 f[2] = c->b; | |
1679 f[3] = c->a; | |
1680 } | |
1681 | |
1682 void apply_material(const aiMaterial *mtl) | |
1683 { | |
1684 float c[4]; | |
1685 | |
1686 GLenum fill_mode; | |
1687 int ret1, ret2; | |
1688 aiColor4D diffuse; | |
1689 aiColor4D specular; | |
1690 aiColor4D ambient; | |
1691 aiColor4D emission; | |
1692 float shininess, strength; | |
1693 int two_sided; | |
1694 int wireframe; | |
1695 unsigned int max; // changed: to unsigned | |
1696 | |
1697 int texIndex = 0; | |
1698 aiString texPath; //contains filename of texture | |
1699 | |
1700 if(AI_SUCCESS == mtl->GetTexture(aiTextureType_DIFFUSE, texIndex, &texPath)) | |
1701 { | |
1702 //bind texture | |
1703 GLuint texId = textureIdMap.at(texPath.data); | |
1704 if (texId != 99999) glBindTexture(GL_TEXTURE_2D, texId); | |
1705 } | |
1706 | |
1707 set_float4(c, 0.8f, 0.8f, 0.8f, 1.0f); | |
1708 if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_DIFFUSE, &diffuse)) | |
1709 color4_to_float4(&diffuse, c); | |
1710 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, c); | |
1711 | |
1712 set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f); | |
1713 if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_SPECULAR, &specular)) | |
1714 color4_to_float4(&specular, c); | |
1715 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c); | |
1716 | |
1717 set_float4(c, 0.2f, 0.2f, 0.2f, 1.0f); | |
1718 if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_AMBIENT, &ambient)) | |
1719 color4_to_float4(&ambient, c); | |
1720 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, c); | |
1721 | |
1722 set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f); | |
1723 if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_EMISSIVE, &emission)) | |
1724 color4_to_float4(&emission, c); | |
1725 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, c); | |
1726 | |
1727 max = 1; | |
1728 ret1 = aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS, &shininess, &max); | |
1729 max = 1; | |
1730 ret2 = aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS_STRENGTH, &strength, &max); | |
1731 if((ret1 == AI_SUCCESS) && (ret2 == AI_SUCCESS)) | |
1732 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess * strength); | |
1733 else { | |
1734 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0f); | |
1735 set_float4(c, 0.0f, 0.0f, 0.0f, 0.0f); | |
1736 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c); | |
1737 } | |
1738 | |
1739 max = 1; | |
1740 if(AI_SUCCESS == aiGetMaterialIntegerArray(mtl, AI_MATKEY_ENABLE_WIREFRAME, &wireframe, &max)) | |
1741 fill_mode = wireframe ? GL_LINE : GL_FILL; | |
1742 else | |
1743 fill_mode = GL_FILL; | |
1744 glPolygonMode(GL_FRONT_AND_BACK, fill_mode); | |
1745 | |
1746 max = 1; | |
1747 if((AI_SUCCESS == aiGetMaterialIntegerArray(mtl, AI_MATKEY_TWOSIDED, &two_sided, &max)) && two_sided) | |
1748 glEnable(GL_CULL_FACE); | |
1749 else | |
1750 glDisable(GL_CULL_FACE); | |
1751 } | |
1752 | |
1753 | |
1754 void recursive_render (const struct aiScene *sc, const struct aiNode* nd, float scale) | |
1755 { | |
1756 | |
1757 unsigned int i; | |
1758 unsigned int n=0, t; | |
1759 aiMatrix4x4 m = nd->mTransformation; | |
1760 | |
1761 aiMatrix4x4 m2; | |
1762 aiMatrix4x4::Scaling(aiVector3D(scale, scale, scale), m2); | |
1763 m = m * m2; | |
1764 | |
1765 // update transform | |
1766 m.Transpose(); | |
1767 glPushMatrix(); | |
1768 glMultMatrixf((float*)&m); | |
1769 | |
1770 // draw all meshes assigned to this node | |
1771 for (; n < nd->mNumMeshes; ++n) | |
1772 { | |
1773 const struct aiMesh* mesh = sc->mMeshes[nd->mMeshes[n]]; | |
1774 | |
1775 apply_material(sc->mMaterials[mesh->mMaterialIndex]); | |
1776 | |
1777 | |
1778 if(mesh->mNormals == NULL) | |
1779 { | |
1780 glDisable(GL_LIGHTING); | |
1781 } | |
1782 else | |
1783 { | |
1784 glEnable(GL_LIGHTING); | |
1785 } | |
1786 | |
1787 if(mesh->mColors[0] != NULL) | |
1788 { | |
1789 glEnable(GL_COLOR_MATERIAL); | |
1790 } | |
1791 else | |
1792 { | |
1793 glDisable(GL_COLOR_MATERIAL); | |
1794 } | |
1795 | |
1796 | |
1797 | |
1798 for (t = 0; t < mesh->mNumFaces; ++t) { | |
1799 const struct aiFace* face = &mesh->mFaces[t]; | |
1800 GLenum face_mode; | |
1801 | |
1802 switch(face->mNumIndices) | |
1803 { | |
1804 case 1: face_mode = GL_POINTS; break; | |
1805 case 2: face_mode = GL_LINES; break; | |
1806 case 3: face_mode = GL_TRIANGLES; break; | |
1807 default: face_mode = GL_POLYGON; break; | |
1808 } | |
1809 | |
1810 glBegin(face_mode); | |
1811 | |
1812 for(i = 0; i < face->mNumIndices; i++) // go through all vertices in face | |
1813 { | |
1814 int vertexIndex = face->mIndices[i]; // get group index for current index | |
1815 if(mesh->mColors[0] != NULL) | |
1816 Color4f(&mesh->mColors[0][vertexIndex]); | |
1817 if(mesh->mNormals != NULL) | |
1818 | |
1819 if(mesh->HasTextureCoords(0)) //HasTextureCoords(texture_coordinates_set) | |
1820 { | |
1821 glTexCoord2f(mesh->mTextureCoords[0][vertexIndex].x, 1 - mesh->mTextureCoords[0][vertexIndex].y); //mTextureCoords[channel][vertex] | |
1822 } | |
1823 | |
1824 glNormal3fv(&mesh->mNormals[vertexIndex].x); | |
1825 glVertex3fv(&mesh->mVertices[vertexIndex].x); | |
1826 } | |
1827 | |
1828 glEnd(); | |
1829 | |
1830 } | |
1831 | |
1832 } | |
1833 | |
1834 | |
1835 // draw all children | |
1836 for (n = 0; n < nd->mNumChildren; ++n) | |
1837 { | |
1838 recursive_render(sc, nd->mChildren[n], scale); | |
1839 } | |
1840 | |
1841 glPopMatrix(); | |
1842 } | |
1843 float jormymillis = 0.0; | |
1844 float startti = 0; | |
1845 float startti2 = 0; | |
1846 float pantime = 0; | |
1847 void BiloThreeScene() | |
1848 { | |
1849 float mymillis = (millis-scene_start_millis); | |
1850 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
1851 glUseProgram(0); | |
1852 | |
1853 float colmy = mymillis*0.0001; | |
1854 if (colmy > 0.5) colmy = 0.5; | |
1855 | |
1856 if (millis > 302800) colmy-=((millis-302800)*0.00001); | |
1857 | |
1858 glClearColor(colmy, 0.0f, 0.0f, 0.0f); | |
1859 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
1860 | |
1861 glDisable(GL_TEXTURE_2D); | |
1862 glEnable(GL_BLEND); | |
1863 glBlendFunc(GL_SRC_COLOR, GL_ONE_MINUS_DST_COLOR); | |
1864 | |
1865 glShadeModel(GL_SMOOTH); // Enables Smooth Shading | |
1866 glEnable(GL_DEPTH_TEST); // Enables Depth Testing | |
1867 glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do | |
1868 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculation | |
1869 | |
1870 glDisable(GL_LIGHTING); | |
1871 glEnable(GL_LIGHT0); // Uses default lighting parameters | |
1872 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); | |
1873 glEnable(GL_NORMALIZE); | |
1874 | |
1875 float zoom = -300.0f+(((mymillis-jormymillis)*atan(mymillis*0.005))*0.05); | |
1876 | |
1877 if (zoom > -0.5 && startti == 0) { startti = mymillis; } | |
1878 if (zoom >= -0.5) { zoom = -0.5; jormymillis+=290;} | |
1879 | |
1880 glLoadIdentity(); | |
1881 | |
1882 if (jormymillis > 300*60 && startti2 == 0) | |
1883 { | |
1884 startti2 = mymillis; | |
1885 } | |
1886 | |
1887 if (jormymillis > 300*60) | |
1888 { | |
1889 pantime = mymillis-startti2; | |
1890 } | |
1891 | |
1892 glTranslatef(0.0f, startti2 > 0 ? -7.5f-pantime*0.0008 : -7.5f, zoom+pantime*0.001*atan(pantime*0.005)); | |
1893 if (jormymillis > 0) { | |
1894 glRotatef(jormymillis*0.0026,-1.0,0.0,0.0); | |
1895 } | |
1896 | |
1897 float zoomfactor = 2.0+jormymillis*0.0001; | |
1898 if (zoomfactor > 4.0) zoomfactor = 4.0; | |
1899 | |
1900 if (startti > 0) recursive_render(bilothree, bilothree->mRootNode, zoomfactor-0.5); | |
1901 recursive_render(bilothree, bilothree->mRootNode, zoomfactor); | |
1902 recursive_render(bilothree, bilothree->mRootNode, 6.0-zoomfactor); | |
1903 | |
1904 } | |
1905 | |
1906 | |
1907 | |
1908 | |
1909 void KolmeDeeLogic(float dt) | |
1910 { | |
1911 kujalla_angle += dt*0.01; | |
1912 } | |
1913 | |
1914 void kapsule_render() | |
1915 { | |
1916 | |
1917 glEnable(GL_BLEND); | |
1918 glUseProgram(0); | |
1919 glEnable(GL_TEXTURE_2D); | |
1920 glShadeModel(GL_SMOOTH); // Enables Smooth Shading | |
1921 glEnable(GL_DEPTH_TEST); // Enables Depth Testing | |
1922 glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do | |
1923 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculation | |
1924 | |
1925 glEnable(GL_LIGHTING); | |
1926 glEnable(GL_LIGHT0); // Uses default lighting parameters | |
1927 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); | |
1928 glEnable(GL_NORMALIZE); | |
1929 | |
1930 GLfloat LightAmbient[]= { 0.5f, 0.5f, 0.5f, 1.0f }; | |
1931 GLfloat LightDiffuse[]= { 1.0f, 1.0f, 1.0f, 1.0f }; | |
1932 GLfloat LightPosition[]= { 0.0f, 0.0f, 15.0f, 1.0f }; | |
1933 | |
1934 glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); | |
1935 glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); | |
1936 glLightfv(GL_LIGHT1, GL_POSITION, LightPosition); | |
1937 glEnable(GL_LIGHT1); | |
1938 | |
1939 glLoadIdentity(); | |
1940 | |
1941 glTranslatef(0.0f, 0.0f, -50.0f+cos(millis*0.05)*25); // Move 40 Units And Into The Screen | |
1942 glRotatef(millis*0.01,1.0,0,0); | |
1943 glRotatef(millis*0.008,0.0,0.0,1.0); | |
1944 glRotatef(millis*0.006,0.0,1.0,0.0); | |
1945 | |
1946 recursive_render(kapsule, kapsule->mRootNode, 2.5); | |
1947 glDisable(GL_DEPTH_TEST); | |
1948 glDisable(GL_LIGHTING); | |
1949 glDisable(GL_NORMALIZE); | |
1950 } | |
1951 | |
1952 float brimillis = 0.0; | |
1953 float bristart = 0.0; | |
1954 float brixrot = 0.0; | |
1955 float briyrot = 0.0; | |
1956 | |
1957 void brieflycase_render() | |
1958 { | |
1959 if (bristart == 0) {bristart = millis;} | |
1960 brimillis = millis-bristart; | |
1961 | |
1962 glEnable(GL_BLEND); | |
1963 glUseProgram(0); | |
1964 glEnable(GL_TEXTURE_2D); | |
1965 glShadeModel(GL_SMOOTH); // Enables Smooth Shading | |
1966 glEnable(GL_DEPTH_TEST); // Enables Depth Testing | |
1967 glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do | |
1968 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculation | |
1969 | |
1970 glEnable(GL_LIGHTING); | |
1971 glEnable(GL_LIGHT0); // Uses default lighting parameters | |
1972 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); | |
1973 glEnable(GL_NORMALIZE); | |
1974 | |
1975 float brifade = 1.0f; | |
1976 | |
1977 if (brimillis <= 1000) { | |
1978 brifade = brimillis*0.001; | |
1979 if (brifade > 1.0f) brifade = 1.0f; | |
1980 } | |
1981 GLfloat LightAmbient[]= { 0.5f*brifade, 0.5f*brifade, 0.5f*brifade, 1.0f*brifade }; | |
1982 GLfloat LightDiffuse[]= { 1.0f*brifade, 1.0f*brifade, 1.0f*brifade, 1.0f*brifade }; | |
1983 GLfloat LightPosition[]= { 0.0f, 0.0f, 15.0f*brifade, 1.0f*brifade }; | |
1984 | |
1985 glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); | |
1986 glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); | |
1987 glLightfv(GL_LIGHT1, GL_POSITION, LightPosition); | |
1988 glEnable(GL_LIGHT1); | |
1989 | |
1990 glLoadIdentity(); | |
1991 | |
1992 //nosto | |
1993 if (brimillis > 1000 && brimillis < 3000) | |
1994 { | |
1995 briyrot=(brimillis-1000)*0.047*(1.0-(cos(brimillis*0.001))); | |
1996 if (briyrot > 90.0f) briyrot = 90.0f; | |
1997 } | |
1998 | |
1999 if (brimillis > 5000) | |
2000 { | |
2001 brixrot=(brimillis-5000)*0.047*2* 1.0-(cos((brimillis-4000)*0.0001)); | |
2002 // if (brixrot > 180.0f) brixrot = 180.0f; | |
2003 } | |
2004 | |
2005 glTranslatef(0.0f, 0.0f, -50.0f+brixrot*0.2); // Move 40 Units And Into The Screen | |
2006 //glRotatef(millis*0.001,1.0,0,0); | |
2007 glRotatef(-briyrot,1.0,0.0,0.0); | |
2008 glRotatef(brixrot,0.0,0.0,1.0); | |
2009 | |
2010 recursive_render(brieflycase, brieflycase->mRootNode, 2.5); | |
2011 glDisable(GL_DEPTH_TEST); | |
2012 glDisable(GL_LIGHTING); | |
2013 glDisable(GL_NORMALIZE); | |
2014 } | |
2015 | |
2016 | |
2017 void | |
2018 on_key_press ( unsigned char key) | |
2019 { | |
2020 if (key == 1) | |
2021 { | |
2022 console_process( console, "home", 0 ); | |
2023 } | |
2024 else if (key == 4) | |
2025 { | |
2026 console_process( console, "delete", 0 ); | |
2027 } | |
2028 else if (key == 5) | |
2029 { | |
2030 console_process( console, "end", 0 ); | |
2031 } | |
2032 else if (key == 8) | |
2033 { | |
2034 console_process( console, "backspace", 0 ); | |
2035 } | |
2036 else if (key == 9) | |
2037 { | |
2038 console_process( console, "complete", 0 ); | |
2039 } | |
2040 else if (key == 11) | |
2041 { | |
2042 console_process( console, "kill", 0 ); | |
2043 } | |
2044 else if (key == 12) | |
2045 { | |
2046 console_process( console, "clear", 0 ); | |
2047 } | |
2048 else if (key == 13) | |
2049 { | |
2050 console_process( console, "enter", 0 ); | |
2051 } | |
2052 else if (key == 25) | |
2053 { | |
2054 console_process( console, "yank", 0 ); | |
2055 } | |
2056 else if (key == 27) | |
2057 { | |
2058 console_process( console, "escape", 0 ); | |
2059 } | |
2060 else if (key == 127) | |
2061 { | |
2062 console_process( console, "backspace", 0 ); | |
2063 } | |
2064 else if( key > 31) | |
2065 { | |
2066 console_process( console, "type", key ); | |
2067 } | |
2068 } | |
2069 | |
2070 /*void LoaderLogic(float dt) | |
2071 { | |
2072 printf("DEBUG: LoaderLogic(%f)\n", dt); | |
2073 }*/ | |
2074 | |
2075 int keyindex = 0; | |
2076 int nextmillis = 0; | |
2077 void ConsoleLogic(float dt) | |
2078 { | |
2079 // int kmillis = (int)(millis-15750); | |
2080 int kmillis = (int)(millis-scene_start_millis); | |
2081 | |
2082 //printf("kmillis:%d\n",kmillis); | |
2083 if (kmillis >= 0 && kmillis >= keymillis[keyindex]) | |
2084 { | |
2085 if(keyindex >= 0 && keyindex < KEYEVENTS_COUNT) | |
2086 { | |
2087 on_key_press(keyrec[keyindex]); | |
2088 } | |
2089 | |
2090 keyindex++; | |
2091 } | |
2092 } | |
2093 | |
2094 int keyindex2 = 0; | |
2095 | |
2096 void ConsoleLogic2(float dt) | |
2097 { | |
2098 int kmillis = -2000+(int)((millis-scene_start_millis)*1.3); | |
2099 | |
2100 //printf("kmillis:%d\n",kmillis); | |
2101 if (kmillis >= 0 && kmillis >= keymillis2[keyindex2]) | |
2102 { | |
2103 if(keyindex2 >= 0 && keyindex2 < KEYEVENTS_COUNT2) | |
2104 { | |
2105 on_key_press(keyrec2[keyindex2]); | |
2106 } | |
2107 | |
2108 keyindex2++; | |
2109 } | |
2110 } | |
2111 | |
2112 int kolmedeeindex = 0; | |
2113 | |
2114 const aiScene* Import3DFromFile(const std::string& pFile) | |
2115 { | |
2116 fprintf(stdout," - Import3DFromFile(\"%s\")", pFile.c_str()); | |
2117 | |
2118 //check if file exists | |
2119 std::ifstream fin(pFile.c_str()); | |
2120 if(!fin.fail()) | |
2121 { | |
2122 fin.close(); | |
2123 } | |
2124 else | |
2125 { | |
2126 printf(" could not open file %s\n", pFile.c_str()); | |
2127 exit(1); | |
2128 } | |
2129 | |
2130 const aiScene* scener = importer[kolmedeeindex].ReadFile( pFile, aiProcessPreset_TargetRealtime_Quality); | |
2131 | |
2132 // If the import failed, report it | |
2133 if( !scener) | |
2134 { | |
2135 printf(" import failed %s\n", pFile.c_str()); | |
2136 exit(1); | |
2137 } | |
2138 | |
2139 kolmedeeindex++; | |
2140 | |
2141 fprintf(stdout," success\n"); | |
2142 | |
2143 // We're done. Everything will be cleaned up by the importer destructor | |
2144 return scener; | |
2145 } | |
2146 | |
2147 int shader_index = 1; // 1 not 0 because console shader is loaded separately | |
2148 bool LoadShaders() | |
2149 { | |
2150 if(shader_index == sizeof(shaders) / sizeof(shaders[0])) return false; | |
2151 shaders[shader_index] = LoadShader(shaderss[shader_index]); | |
2152 shader_index++; | |
2153 | |
2154 return true; | |
2155 } | |
2156 int texture_index = 0; | |
2157 bool LoadTextures() | |
2158 { | |
2159 if(texture_index == sizeof(textures) / sizeof(textures[0])) return false; | |
2160 textures[texture_index] = LoadTexture(texturess[texture_index]); | |
2161 texture_index++; | |
2162 | |
2163 return true; | |
2164 } | |
2165 int assets_3dmodel_total = 1; | |
2166 bool Load3DAssets() | |
2167 { | |
2168 kapsule = Import3DFromFile("data/models/kapsule.obj"); | |
2169 LoadGLTextures(kapsule); | |
2170 | |
2171 return true; | |
2172 } | |
2173 | |
2174 bool assets_loaded = false; | |
2175 int skip_frames = 10; | |
2176 int skip_frames_count = 0; | |
2177 clock_t t_loader_begin = 0, t_loader_d; | |
2178 int assets_index = -1, assets_total = -1; | |
2179 int loader_phase = -1; | |
2180 float loading_time = 0; | |
2181 void Loader() | |
2182 { | |
2183 if(t_loader_begin == 0) { current_scene = 0; t_loader_begin = clock(); assets_total = ((sizeof(shaders) / sizeof(shaders[0])) + (sizeof(textures) / sizeof(textures[0])) + assets_3dmodel_total ); } else { loading_time = (float)((((float)t_loader_d - (float)t_loader_begin) / 1000000.0F ) * 1000); } | |
2184 if(assets_total == -1) { | |
2185 printf("ERROR: Loader(): No assets to load and/or something is just terribly wrong! Terminating...\n"); | |
2186 exit(1); | |
2187 } | |
2188 | |
2189 float phase = (float)((float)(assets_index) / (float)(assets_total)); | |
2190 const aiScene* loaderscene = bilothorn; | |
2191 | |
2192 //glClearColor (phase,phase,phase,1.0); | |
2193 glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
2194 | |
2195 float mymillis = phase*1750; | |
2196 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); // default | |
2197 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
2198 | |
2199 glUseProgram(0); | |
2200 | |
2201 glDisable(GL_TEXTURE_2D); | |
2202 glEnable(GL_BLEND); | |
2203 glBlendFunc(GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR); | |
2204 | |
2205 glShadeModel(GL_SMOOTH); // Enables Smooth Shading | |
2206 //glClearColor(1.0f-phase,1.0f-phase,1.0f-phase, 1.0f); | |
2207 glClearDepth(1.0f); // Depth Buffer Setup | |
2208 glEnable(GL_DEPTH_TEST); // Enables Depth Testing | |
2209 glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do | |
2210 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculation | |
2211 | |
2212 glDisable(GL_LIGHTING); | |
2213 glEnable(GL_LIGHT0); // Uses default lighting parameters | |
2214 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); | |
2215 glDisable(GL_NORMALIZE); | |
2216 | |
2217 float r, g, b, a = 1.0f; | |
2218 if(loader_phase < 1) { | |
2219 r = g = b = sin(loading_time*100); | |
2220 } else { | |
2221 r = g = b = a; | |
2222 } | |
2223 GLfloat LightAmbient[]= { r, g, b, a }; | |
2224 GLfloat LightDiffuse[]= { r, g, b, a }; | |
2225 GLfloat LightPosition[]= { 0.0f, 0.0f, 15.0f, 1.0f}; | |
2226 //GLfloat LightAmbient[]= { 0.0f, 1.0f-phase, 0.0f, 1.0f }; | |
2227 // GLfloat LightDiffuse[]= { 0.0f, 1.0f-phase, 0.0f, 1.0f }; | |
2228 // GLfloat LightPosition[]= { 0.0f, 0.0f, 15.0f, 1.0f }; | |
2229 | |
2230 glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); | |
2231 glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); | |
2232 glLightfv(GL_LIGHT1, GL_POSITION, LightPosition); | |
2233 glEnable(GL_LIGHT1); | |
2234 | |
2235 float zoom = -50.0f+((mymillis)*0.05*0.2)*((phase+0.5f)*(phase+0.5f)*(phase+0.5f)); | |
2236 | |
2237 if (zoom > -0.5 && startti == 0) { startti = mymillis; } | |
2238 if (zoom >= -0.5) { zoom = -0.5; jormymillis=(mymillis-startti); } | |
2239 | |
2240 | |
2241 if (jormymillis > 0) { | |
2242 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
2243 } | |
2244 | |
2245 glLoadIdentity(); | |
2246 | |
2247 glRotatef(180.0f*phase*0.974,0.0,0.0,1.0); | |
2248 glTranslatef(0.0f, 0.0f, zoom); | |
2249 /*if (jormymillis > 0) { | |
2250 glRotatef(jormymillis*0.0026,-1.0,0.0,0.0); | |
2251 }*/ | |
2252 | |
2253 skip_frames_count++; | |
2254 if(skip_frames_count == skip_frames) { | |
2255 skip_frames_count = 0; | |
2256 assets_index++; | |
2257 printf("--- MIDISYS-ENGINE: Loading asset #%i", assets_index); | |
2258 | |
2259 // begin loading animation | |
2260 | |
2261 if(loader_phase == -1) { | |
2262 loader_phase = 0; | |
2263 } else if(loader_phase == 0) { | |
2264 if(!LoadShaders()) { | |
2265 loader_phase = 1; | |
2266 } else { | |
2267 } | |
2268 } else if(loader_phase == 1) { | |
2269 if(!LoadTextures()) { | |
2270 loader_phase = 2; | |
2271 } else { | |
2272 } | |
2273 } else if(loader_phase == 2) { | |
2274 printf("..%i", assets_total); | |
2275 // load all 3d models; after that all asset loading is done | |
2276 Load3DAssets(); | |
2277 loader_phase = 3; | |
2278 } else { | |
2279 assets_loaded = true; | |
2280 } | |
2281 } else { | |
2282 // format bilotrip terminal 1.6.2.0 | |
2283 | |
2284 /*if(phase > 0.975f) { | |
2285 phase = 1.0f-phase; | |
2286 }*/ | |
2287 glClearColor ((1.0f-phase)*0.86,(1.0f-phase)*0.86,(1.0f-phase)*0.86,1.0); | |
2288 glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
2289 glFlush(); | |
2290 glutSwapBuffers(); | |
2291 } | |
2292 | |
2293 //printf("n:%i\n",(int)((float)((float)(assets_index) / (float)(assets_total)) * 3.0f)); | |
2294 /*glBegin(GL_TRIANGLES); | |
2295 glVertex3f(-25.0f,-25.0f,-50.0f); | |
2296 glVertex3f(-25.0f,25.0f,-50.0f); | |
2297 glVertex3f(25.0f,25.0f,-50.0f); | |
2298 glEnd();*/ | |
2299 //glTranslatef(0.0,floor(phase+0.25f),0.0); | |
2300 for(int n = 0; n < (int)(phase*6.9f); n++) { | |
2301 if(n<3) { | |
2302 int t = floor(n/3); | |
2303 float tf = (float)(t)*120.0f; | |
2304 if(n!=0&&n%3==0) glTranslatef(0.0,0.0,tf); | |
2305 glRotatef(120.0f,0.0,0.0,((float)(n)*phase)); | |
2306 recursive_render(loaderscene, loaderscene->mRootNode, 2.0+jormymillis*0.001); | |
2307 } | |
2308 //if (jormymillis > 0)recursive_render(loaderscene, loaderscene->mRootNode, 4.0-jormymillis*0.001); | |
2309 } | |
2310 | |
2311 | |
2312 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
2313 glDisable(GL_BLEND); | |
2314 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
2315 | |
2316 | |
2317 glUseProgram(shaders[hex]); | |
2318 float widthLoc5 = glGetUniformLocation(shaders[hex], "width"); | |
2319 float heightLoc5 = glGetUniformLocation(shaders[hex], "height"); | |
2320 float timeLoc5 = glGetUniformLocation(shaders[hex], "time"); | |
2321 float effuLoc5 = glGetUniformLocation(shaders[hex], "effu"); | |
2322 | |
2323 glUniform1f(widthLoc5, g_Width); | |
2324 glUniform1f(heightLoc5, g_Height); | |
2325 glUniform1f(timeLoc5, mymillis/100); | |
2326 glUniform1f(effuLoc5, jormymillis > 0 ? 1.0 : 0.0); | |
2327 | |
2328 glActiveTexture(GL_TEXTURE0); | |
2329 glBindTexture(GL_TEXTURE_2D, fb_tex); | |
2330 | |
2331 float location5 = glGetUniformLocation(shaders[hex], "texture0"); | |
2332 glUniform1i(location5, 0); | |
2333 | |
2334 glLoadIdentity(); | |
2335 | |
2336 glTranslatef(-1.2, -1.0, -1.0); | |
2337 //glTranslatef(0.0, 0.0, -1.0); | |
2338 | |
2339 int i=0; | |
2340 int j=0; | |
2341 glBegin(GL_QUADS); | |
2342 glVertex2f(i, j); | |
2343 glVertex2f(i + 100, j); | |
2344 glVertex2f(i + 100, j + 100); | |
2345 glVertex2f(i, j + 100); | |
2346 glEnd(); | |
2347 | |
2348 glFlush(); | |
2349 glutSwapBuffers(); | |
2350 | |
2351 glDisable(GL_DEPTH_TEST); // Enables Depth Testing | |
2352 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); // default | |
2353 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); | |
2354 glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do | |
2355 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculation | |
2356 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // default | |
2357 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); | |
2358 | |
2359 if (quitflag == 0) glutPostRedisplay(); | |
2360 } | |
2361 | |
2362 int vieterframe = 0; | |
2363 float vieterstart = 0; | |
2364 | |
2365 void LeadMaskScene() | |
2366 { | |
2367 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); // fbo | |
2368 glClear(GL_DEPTH_BUFFER_BIT); | |
2369 float mymillis = millis; | |
2370 glUseProgram(shaders[projector]); | |
2371 | |
2372 int kuvaflag = 0; | |
2373 | |
2374 if (millis >= 0 && millis < 25000) { | |
2375 kuvaflag = 0; | |
2376 } | |
2377 else if (millis >= 25000 && millis < 37000) { | |
2378 kuvaflag = 1; | |
2379 } | |
2380 else if (millis >= 37000 && millis < 48500) { | |
2381 kuvaflag = 2; | |
2382 } | |
2383 else if (millis >= 48500 && millis < 64000) { | |
2384 kuvaflag = 3; | |
2385 } | |
2386 else if (millis >= 64000 && millis < 76100) { | |
2387 kuvaflag = 4; | |
2388 } | |
2389 else if (millis >= 76100 && millis < 84000) { | |
2390 kuvaflag = 5; | |
2391 } | |
2392 else if (millis >= 84000) { | |
2393 kuvaflag = 6; | |
2394 if (vieterstart == 0) vieterstart = mymillis; | |
2395 vieterframe = (int)((mymillis-vieterstart)*0.004); | |
2396 if (vieterframe > 12) { vieterframe = 0; vieterstart = 0; } | |
2397 } | |
2398 | |
2399 glEnable(GL_BLEND); | |
2400 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); | |
2401 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA); | |
2402 | |
2403 GLint widthLoc5 = glGetUniformLocation(shaders[projector], "width"); | |
2404 GLint heightLoc5 = glGetUniformLocation(shaders[projector], "height"); | |
2405 GLint timeLoc5 = glGetUniformLocation(shaders[projector], "time"); | |
2406 GLint alphaLoc5 = glGetUniformLocation(shaders[projector], "alpha"); | |
2407 | |
2408 glUniform1f(widthLoc5, g_Width); | |
2409 glUniform1f(heightLoc5, g_Height); | |
2410 glUniform1f(timeLoc5, mymillis - (millis < 64000 ? 0 : 50000)); | |
2411 glUniform1f(alphaLoc5, mymillis*0.0001+0.2-cos(mymillis*0.0005)*0.15); | |
2412 | |
2413 glActiveTexture(GL_TEXTURE0); | |
2414 if (kuvaflag == 0) | |
2415 glBindTexture(GL_TEXTURE_2D, textures[tex_scene]); | |
2416 else if (kuvaflag == 1) | |
2417 glBindTexture(GL_TEXTURE_2D, textures[tex_dude]); | |
2418 else if (kuvaflag == 2) | |
2419 glBindTexture(GL_TEXTURE_2D, textures[tex_dude2]); | |
2420 else if (kuvaflag == 3) | |
2421 glBindTexture(GL_TEXTURE_2D, textures[tex_mask]); | |
2422 else if (kuvaflag == 4) | |
2423 glBindTexture(GL_TEXTURE_2D, textures[tex_note]); | |
2424 else if (kuvaflag == 5) | |
2425 glBindTexture(GL_TEXTURE_2D, textures[tex_exit]); | |
2426 else if (kuvaflag == 6) | |
2427 glBindTexture(GL_TEXTURE_2D, textures[tex_v0+vieterframe]); | |
2428 | |
2429 GLint location5 = glGetUniformLocation(shaders[projector], "texture0"); | |
2430 glUniform1i(location5, 0); | |
2431 | |
2432 glLoadIdentity(); | |
2433 glTranslatef(-1.2, -1.0, -1.0); | |
2434 | |
2435 glBegin(GL_QUADS); | |
2436 | |
2437 int i,j; | |
2438 | |
2439 for (i = -50; i < 50; i+=10) | |
2440 for (j = -50; j < 50; j+=10) | |
2441 { | |
2442 glVertex2f(i, j); | |
2443 glVertex2f(i + 1, j); | |
2444 glVertex2f(i + 1, j + 1); | |
2445 glVertex2f(i, j + 1); | |
2446 } | |
2447 glEnd(); | |
2448 | |
2449 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb2); // default | |
2450 | |
2451 glUseProgram(shaders[fsquad]); | |
2452 | |
2453 glEnable(GL_BLEND); | |
2454 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); | |
2455 glBlendFunc(GL_ONE_MINUS_SRC_COLOR, GL_ONE_MINUS_DST_COLOR); | |
2456 | |
2457 GLint widthLoc6 = glGetUniformLocation(shaders[fsquad], "width"); | |
2458 GLint heightLoc6 = glGetUniformLocation(shaders[fsquad], "height"); | |
2459 GLint timeLoc6 = glGetUniformLocation(shaders[fsquad], "time"); | |
2460 GLint alphaLoc6 = glGetUniformLocation(shaders[fsquad], "alpha"); | |
2461 GLint gammaLoc = glGetUniformLocation(shaders[fsquad], "gamma"); | |
2462 GLint gridLoc6 = glGetUniformLocation(shaders[fsquad], "grid"); | |
2463 GLint alphamodeLoc5 = glGetUniformLocation(shaders[fsquad], "alphamode"); | |
2464 glUniform1f(alphamodeLoc5, 0.0f); | |
2465 | |
2466 glUniform1f(gridLoc6, 0.001+cos(mymillis)*0.0005); | |
2467 | |
2468 | |
2469 glUniform1f(widthLoc6, g_Width); | |
2470 glUniform1f(heightLoc6, g_Height); | |
2471 glUniform1f(timeLoc6, mymillis/100); | |
2472 glUniform1f(alphaLoc6, 0.1+abs(cos(mymillis*0.08)*0.05)); | |
2473 glUniform1f(gammaLoc, 0.0f); | |
2474 | |
2475 glActiveTexture(GL_TEXTURE0); | |
2476 glBindTexture(GL_TEXTURE_2D, fb_tex); | |
2477 | |
2478 GLint location6 = glGetUniformLocation(shaders[fsquad], "texture0"); | |
2479 glUniform1i(location6, 0); | |
2480 | |
2481 glLoadIdentity(); | |
2482 | |
2483 glTranslatef(-1.2, -1.0, -1.0); | |
2484 | |
2485 i=0; | |
2486 j=0; | |
2487 glBegin(GL_QUADS); | |
2488 glVertex2f(i, j); | |
2489 glVertex2f(i + 100, j); | |
2490 glVertex2f(i + 100, j + 100); | |
2491 glVertex2f(i, j + 100); | |
2492 glEnd(); | |
2493 | |
2494 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
2495 | |
2496 glUseProgram(shaders[fsquad]); | |
2497 | |
2498 glDisable(GL_BLEND); | |
2499 | |
2500 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
2501 | |
2502 GLint widthLoc7 = glGetUniformLocation(shaders[fsquad], "width"); | |
2503 GLint heightLoc7 = glGetUniformLocation(shaders[fsquad], "height"); | |
2504 GLint timeLoc7 = glGetUniformLocation(shaders[fsquad], "time"); | |
2505 GLint alphaLoc7 = glGetUniformLocation(shaders[fsquad], "alpha"); | |
2506 GLint gammaLoc2 = glGetUniformLocation(shaders[fsquad], "gamma"); | |
2507 GLint gridLoc = glGetUniformLocation(shaders[fsquad], "grid"); | |
2508 GLint alphamodeLoc7 = glGetUniformLocation(shaders[fsquad], "alphamode"); | |
2509 glUniform1f(alphamodeLoc7, 0.0f); | |
2510 | |
2511 glUniform1f(widthLoc7, g_Width); | |
2512 glUniform1f(heightLoc7, g_Height); | |
2513 glUniform1f(timeLoc7, mymillis/100); | |
2514 glUniform1f(alphaLoc7, 1.0); | |
2515 glUniform1f(gammaLoc2, 4.0f); | |
2516 glUniform1f(gridLoc, 1.0f+tan(mymillis*10)*0.3); | |
2517 | |
2518 glActiveTexture(GL_TEXTURE0); | |
2519 glBindTexture(GL_TEXTURE_2D, fb_tex2); | |
2520 | |
2521 GLint location7 = glGetUniformLocation(shaders[fsquad], "texture0"); | |
2522 glUniform1i(location7, 0); | |
2523 | |
2524 glLoadIdentity(); | |
2525 | |
2526 glTranslatef(-1.2, -1.0, -1.0); | |
2527 | |
2528 i=0; | |
2529 j=0; | |
2530 glBegin(GL_QUADS); | |
2531 glVertex2f(i, j); | |
2532 glVertex2f(i + 100, j); | |
2533 glVertex2f(i + 100, j + 100); | |
2534 glVertex2f(i, j + 100); | |
2535 glEnd(); | |
2536 | |
2537 glUseProgram(shaders[projector]); | |
2538 | |
2539 glEnable(GL_BLEND); | |
2540 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD); | |
2541 glBlendFunc(GL_SRC_COLOR, GL_DST_ALPHA); | |
2542 | |
2543 widthLoc5 = glGetUniformLocation(shaders[projector], "width"); | |
2544 heightLoc5 = glGetUniformLocation(shaders[projector], "height"); | |
2545 timeLoc5 = glGetUniformLocation(shaders[projector], "time"); | |
2546 alphaLoc5 = glGetUniformLocation(shaders[projector], "alpha"); | |
2547 | |
2548 glUniform1f(widthLoc5, g_Width); | |
2549 glUniform1f(heightLoc5, g_Height); | |
2550 glUniform1f(timeLoc5, mymillis); | |
2551 glUniform1f(alphaLoc5, 1.0); | |
2552 | |
2553 glActiveTexture(GL_TEXTURE0); | |
2554 glBindTexture(GL_TEXTURE_2D, textures[tex_scene]); | |
2555 | |
2556 location5 = glGetUniformLocation(shaders[projector], "texture0"); | |
2557 glUniform1i(location5, 0); | |
2558 | |
2559 glLoadIdentity(); | |
2560 glTranslatef(-1.2, -1.0, -1.0); | |
2561 | |
2562 glBegin(GL_QUADS); | |
2563 | |
2564 | |
2565 for (i = -50; i < 50; i+=10) | |
2566 for (j = -50; j < 50; j+=10) | |
2567 { | |
2568 glVertex2f(i, j); | |
2569 glVertex2f(i + 1, j); | |
2570 glVertex2f(i + 1, j + 1); | |
2571 glVertex2f(i, j + 1); | |
2572 } | |
2573 glEnd(); | |
2574 | |
2575 | |
2576 if (millis > 37400 && millis < 37600) kapsule_render(); | |
2577 | |
2578 | |
2579 } | |
2580 | |
2581 int copbeatcounter = -1; | |
2582 int coptexid = 0; | |
2583 void CopScene() | |
2584 { | |
2585 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
2586 | |
2587 float mymillis = (millis-scene_start_millis); | |
2588 glUseProgram(shaders[copquad]); | |
2589 | |
2590 glEnable(GL_BLEND); | |
2591 | |
2592 | |
2593 float joo = cos(mymillis); | |
2594 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, joo < 0.5 ? GL_MODULATE : GL_SUBTRACT ); | |
2595 glBlendFunc(GL_SRC_COLOR, joo < 0.5 ? GL_DST_ALPHA : GL_ONE_MINUS_DST_COLOR); | |
2596 | |
2597 GLint widthLoc5 = glGetUniformLocation(shaders[copquad], "width"); | |
2598 GLint heightLoc5 = glGetUniformLocation(shaders[copquad], "height"); | |
2599 GLint timeLoc5 = glGetUniformLocation(shaders[copquad], "time"); | |
2600 GLint alphaLoc5 = glGetUniformLocation(shaders[copquad], "alpha"); | |
2601 GLint gridLoc6 = glGetUniformLocation(shaders[copquad], "grid"); | |
2602 glUniform1f(gridLoc6, tan(mymillis)); | |
2603 | |
2604 glUniform1f(widthLoc5, g_Width); | |
2605 glUniform1f(heightLoc5, g_Height); | |
2606 glUniform1f(timeLoc5, mymillis/100); | |
2607 glUniform1f(alphaLoc5, cos(mymillis*0.1)*0.01); | |
2608 | |
2609 if (scene_shader_params[2] == 36) { copbeatcounter++; } | |
2610 if (copbeatcounter > 0) { coptexid++; copbeatcounter = 0;} | |
2611 | |
2612 //int texind = (int)(mymillis*(0.001/2)); | |
2613 int texind = coptexid; | |
2614 if (texind > 30) texind = 30; | |
2615 | |
2616 glActiveTexture(GL_TEXTURE0); | |
2617 glBindTexture(GL_TEXTURE_2D, textures[tex_copkiller + texind]); | |
2618 | |
2619 glActiveTexture(GL_TEXTURE1); | |
2620 glBindTexture(GL_TEXTURE_2D, textures[texind == tex_copkiller ? tex_copkiller+17 : | |
2621 tex_copkiller + (abs(texind-1))]); | |
2622 | |
2623 GLint location5 = glGetUniformLocation(shaders[copquad], "texture0"); | |
2624 glUniform1i(location5, 0); | |
2625 | |
2626 GLint location6 = glGetUniformLocation(shaders[copquad], "texture1"); | |
2627 glUniform1i(location6, 1); | |
2628 | |
2629 glLoadIdentity(); | |
2630 | |
2631 glTranslatef(-1.2, -1.0, -1.0); | |
2632 | |
2633 int i=0; | |
2634 int j=0; | |
2635 glBegin(GL_QUADS); | |
2636 glVertex2f(i, j); | |
2637 glVertex2f(i + 100, j); | |
2638 glVertex2f(i + 100, j + 100); | |
2639 glVertex2f(i, j + 100); | |
2640 glEnd(); | |
2641 | |
2642 } | |
2643 | |
2644 static int video_started = 0; | |
2645 | |
2646 void MarssiScene() | |
2647 { | |
2648 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
2649 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); | |
2650 glDisable(GL_BLEND); | |
2651 | |
2652 if (video_started == 0) | |
2653 { | |
2654 myVideoFrame->play(); | |
2655 video_started = 1; | |
2656 } | |
2657 | |
2658 myVideoFrame->render(); | |
2659 } | |
2660 | |
2661 void LongScene() | |
2662 { | |
2663 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
2664 glDisable(GL_BLEND); | |
2665 glClearColor(0,0,0,0); | |
2666 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); | |
2667 | |
2668 glUseProgram(shaders[fsquad]); | |
2669 float mymillis = (((millis)-scene_start_millis)); | |
2670 | |
2671 GLint widthLoc5 = glGetUniformLocation(shaders[fsquad], "width"); | |
2672 GLint heightLoc5 = glGetUniformLocation(shaders[fsquad], "height"); | |
2673 GLint timeLoc5 = glGetUniformLocation(shaders[fsquad], "time"); | |
2674 GLint alphaLoc5 = glGetUniformLocation(shaders[fsquad], "alpha"); | |
2675 GLint gammaLoc = glGetUniformLocation(shaders[fsquad], "gamma"); | |
2676 GLint gridLoc6 = glGetUniformLocation(shaders[fsquad], "grid"); | |
2677 glUniform1f(gridLoc6, 0.0f); | |
2678 glUniform1f(gammaLoc, 0.0f); | |
2679 GLint alphamodeLoc5 = glGetUniformLocation(shaders[fsquad], "alphamode"); | |
2680 glUniform1f(alphamodeLoc5, 0.0f); | |
2681 | |
2682 glUniform1f(widthLoc5, g_Width); | |
2683 glUniform1f(heightLoc5, g_Height); | |
2684 glUniform1f(timeLoc5, mymillis/100); | |
2685 glUniform1f(alphaLoc5, 0.0); | |
2686 | |
2687 glActiveTexture(GL_TEXTURE0); | |
2688 glBindTexture(GL_TEXTURE_2D, textures[tex_aegis]); | |
2689 | |
2690 GLint location5 = glGetUniformLocation(shaders[fsquad], "texture0"); | |
2691 glUniform1i(location5, 0); | |
2692 | |
2693 glLoadIdentity(); | |
2694 | |
2695 glTranslatef(-1.2, -1.0, -1.0); | |
2696 | |
2697 int i=0; | |
2698 int j=0; | |
2699 glBegin(GL_QUADS); | |
2700 glVertex2f(i, j); | |
2701 glVertex2f(i + 100, j); | |
2702 glVertex2f(i + 100, j + 100); | |
2703 glVertex2f(i, j + 100); | |
2704 glEnd(); | |
2705 | |
2706 // | |
2707 if (mymillis > 2500) { | |
2708 int plussati = 0; | |
2709 if (mymillis > 2800)plussati=400; | |
2710 glEnable(GL_BLEND); | |
2711 glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); | |
2712 int lloff = (int)(((plussati+mymillis)-2500)*0.0025); | |
2713 if (lloff >= 4) lloff = 4; | |
2714 widthLoc5 = glGetUniformLocation(shaders[fsquad], "width"); | |
2715 heightLoc5 = glGetUniformLocation(shaders[fsquad], "height"); | |
2716 timeLoc5 = glGetUniformLocation(shaders[fsquad], "time"); | |
2717 alphaLoc5 = glGetUniformLocation(shaders[fsquad], "alpha"); | |
2718 float alphamodeLoc = glGetUniformLocation(shaders[fsquad], "alphamode"); | |
2719 | |
2720 glUniform1f(widthLoc5, g_Width); | |
2721 glUniform1f(heightLoc5, g_Height); | |
2722 glUniform1f(timeLoc5, mymillis/100); | |
2723 glUniform1f(alphaLoc5, 1.0); | |
2724 glUniform1f(alphamodeLoc, 1.0); | |
2725 | |
2726 glActiveTexture(GL_TEXTURE0); | |
2727 glBindTexture(GL_TEXTURE_2D, textures[tex_ll1+lloff]); | |
2728 | |
2729 GLint location5 = glGetUniformLocation(shaders[fsquad], "texture0"); | |
2730 glUniform1i(location5, 0); | |
2731 | |
2732 glLoadIdentity(); | |
2733 | |
2734 glTranslatef(-1.2, -1.0, -1.0); | |
2735 | |
2736 int i=0; | |
2737 int j=0; | |
2738 glBegin(GL_QUADS); | |
2739 glVertex2f(i, j); | |
2740 glVertex2f(i + 100, j); | |
2741 glVertex2f(i + 100, j + 100); | |
2742 glVertex2f(i, j + 100); | |
2743 glEnd(); | |
2744 | |
2745 } | |
2746 | |
2747 } | |
2748 | |
2749 int majic_texnum = 0; | |
2750 int noclearframes = 0; | |
2751 void EyeScene() | |
2752 { | |
2753 int i, j; | |
2754 | |
2755 int lisuri = 0; | |
2756 | |
2757 //printf("millis:%f\n",millis); | |
2758 if (millis > 225200) lisuri = 50000+(millis-225200)*0.5; | |
2759 if (lisuri > 150000) lisuri = 150000; | |
2760 | |
2761 float mymillis = (((millis)-scene_start_millis)*100); | |
2762 float mymillis2 = (((millis+lisuri)-scene_start_millis)*100); | |
2763 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); // fbo | |
2764 | |
2765 glClearColor((float)(scene_shader_params[1]/127)*0.7,(float)(scene_shader_params[1]/127)*0.4,(float)(scene_shader_params[1]/127)*0.8,0.9-0.005*(float)(scene_shader_params[1]/127)); | |
2766 | |
2767 if ((scene_shader_params[0] == 65 && scene_shader_param_type[0] == 0) || noclearframes > 200) | |
2768 { | |
2769 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
2770 beatmode = -beatmode; | |
2771 noclearframes = 0; | |
2772 } | |
2773 else | |
2774 { | |
2775 noclearframes++; | |
2776 } | |
2777 | |
2778 // render fbo copy to fbo | |
2779 glEnable(GL_BLEND); | |
2780 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); | |
2781 glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR); | |
2782 | |
2783 glUseProgram(shaders[eye_post]); | |
2784 | |
2785 // glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
2786 | |
2787 GLint widthLoc3 = glGetUniformLocation(shaders[eye_post], "width"); | |
2788 GLint heightLoc3 = glGetUniformLocation(shaders[eye_post], "height"); | |
2789 GLint timeLoc3 = glGetUniformLocation(shaders[eye_post], "time"); | |
2790 | |
2791 glUniform1f(widthLoc3, g_Width); | |
2792 glUniform1f(heightLoc3, g_Height); | |
2793 glUniform1f(timeLoc3, mymillis/100); | |
2794 | |
2795 glActiveTexture(GL_TEXTURE0); | |
2796 glBindTexture(GL_TEXTURE_2D, fb_tex); | |
2797 | |
2798 GLint location3 = glGetUniformLocation(shaders[eye_post], "texture0"); | |
2799 glUniform1i(location3, 0); | |
2800 | |
2801 glLoadIdentity(); | |
2802 | |
2803 glRotatef(45,0.0,0.0,1.0f); | |
2804 glTranslatef(-1.2, -1.0, 0.0+(tan(mymillis*0.00001)*0.1)*(millis-155520)*0.0001); | |
2805 | |
2806 i=0; | |
2807 j=0; | |
2808 glBegin(GL_QUADS); | |
2809 glVertex2f(i, j); | |
2810 glVertex2f(i + 100, j); | |
2811 glVertex2f(i + 100, j + 100); | |
2812 glVertex2f(i, j + 100); | |
2813 glEnd(); | |
2814 | |
2815 // render eye | |
2816 | |
2817 glEnable(GL_BLEND); | |
2818 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); | |
2819 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA); | |
2820 | |
2821 glUseProgram(shaders[eye]); | |
2822 | |
2823 GLfloat waveTime = 1+atan(mymillis*0.0001)*0.1, | |
2824 waveWidth = cos(mymillis*0.000001)*1000+atan(mymillis*0.00001)*2.0, | |
2825 waveHeight = sin(mymillis*0.0001)*100*atan(mymillis*0.00001)*2.0; | |
2826 | |
2827 GLint waveTimeLoc = glGetUniformLocation(shaders[eye], "waveTime"); | |
2828 GLint waveWidthLoc = glGetUniformLocation(shaders[eye], "waveWidth"); | |
2829 GLint waveHeightLoc = glGetUniformLocation(shaders[eye], "waveHeight"); | |
2830 | |
2831 GLint widthLoc = glGetUniformLocation(shaders[eye], "width"); | |
2832 GLint heightLoc = glGetUniformLocation(shaders[eye], "height"); | |
2833 | |
2834 GLint timeLoc = glGetUniformLocation(shaders[eye], "time"); | |
2835 | |
2836 glActiveTexture(GL_TEXTURE0); | |
2837 glBindTexture(GL_TEXTURE_2D, textures[tex_grayeye]); | |
2838 | |
2839 GLuint location; | |
2840 location = glGetUniformLocation(shaders[eye], "texture0"); | |
2841 glUniform1i(location, 0); | |
2842 | |
2843 glLoadIdentity(); | |
2844 | |
2845 glTranslatef(0.0, 0.0, -150.0+sin(mymillis*0.0000004)*120); | |
2846 glRotatef(-75.0, 1.0, 0.0, 0.0); | |
2847 glRotatef(mymillis*0.01, 0.0, 0.0, 1.0); | |
2848 | |
2849 glUniform1f(waveTimeLoc, waveTime); | |
2850 glUniform1f(waveWidthLoc, waveWidth); | |
2851 glUniform1f(waveHeightLoc, waveHeight); | |
2852 | |
2853 glUniform1f(widthLoc, g_Width); | |
2854 glUniform1f(heightLoc, g_Height); | |
2855 | |
2856 glUniform1f(timeLoc, mymillis2/100); | |
2857 | |
2858 | |
2859 int zoom = 0; | |
2860 | |
2861 for (zoom = 0; zoom < 8; zoom++) | |
2862 { | |
2863 | |
2864 glTranslatef(-0.01, -0.01, -0.1); | |
2865 glRotatef((90*zoom+mymillis*0.01)*0.1, 1.0, 0.0, 0.0); | |
2866 glRotatef((45*zoom+mymillis*0.01)*0.1, 0.0, 0.0, 1.0); | |
2867 glRotatef((25*zoom+mymillis*0.01)*0.1, 0.0, 1.0, 0.0); | |
2868 glBegin(GL_QUADS); | |
2869 | |
2870 for (i = -50; i < 50; i+=10) | |
2871 for (j = -50; j < 50; j+=10) | |
2872 { | |
2873 glVertex2f(i, j); | |
2874 glVertex2f(i + 1, j); | |
2875 glVertex2f(i + 1, j + 1); | |
2876 glVertex2f(i, j + 1); | |
2877 } | |
2878 glEnd(); | |
2879 } | |
2880 | |
2881 // eye postprocess to screen | |
2882 | |
2883 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
2884 | |
2885 glUseProgram(shaders[eye_post]); | |
2886 | |
2887 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
2888 | |
2889 glDisable(GL_BLEND); | |
2890 | |
2891 GLint widthLoc2 = glGetUniformLocation(shaders[eye_post], "width"); | |
2892 GLint heightLoc2 = glGetUniformLocation(shaders[eye_post], "height"); | |
2893 GLint timeLoc2 = glGetUniformLocation(shaders[eye_post], "time"); | |
2894 | |
2895 glUniform1f(widthLoc2, g_Width); | |
2896 glUniform1f(heightLoc2, g_Height); | |
2897 glUniform1f(timeLoc2, mymillis/100); | |
2898 | |
2899 glActiveTexture(GL_TEXTURE0); | |
2900 glBindTexture(GL_TEXTURE_2D, fb_tex); | |
2901 | |
2902 if (scene_shader_params[0] != -1 && scene_shader_param_type[0] == 0) | |
2903 { | |
2904 room_texnum = (int)(rand() % 3); | |
2905 } | |
2906 | |
2907 glActiveTexture(GL_TEXTURE1); | |
2908 glBindTexture(GL_TEXTURE_2D, textures[tex_room + room_texnum]); | |
2909 | |
2910 GLint location2 = glGetUniformLocation(shaders[eye_post], "texture0"); | |
2911 glUniform1i(location2, 0); | |
2912 | |
2913 GLint location4 = glGetUniformLocation(shaders[eye_post], "texture1"); | |
2914 glUniform1i(location4, 1); | |
2915 | |
2916 glLoadIdentity(); | |
2917 | |
2918 glTranslatef(-1.2, -1.0, -1.0); | |
2919 | |
2920 i=0; | |
2921 j=0; | |
2922 glBegin(GL_QUADS); | |
2923 glVertex2f(i, j); | |
2924 glVertex2f(i + 100, j); | |
2925 glVertex2f(i + 100, j + 100); | |
2926 glVertex2f(i, j + 100); | |
2927 glEnd(); | |
2928 | |
2929 // text overlay | |
2930 | |
2931 if (beatmode == 1) | |
2932 { | |
2933 glUseProgram(shaders[fsquad]); | |
2934 | |
2935 glEnable(GL_BLEND); | |
2936 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_SUBTRACT); | |
2937 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_DST_COLOR); | |
2938 | |
2939 GLint widthLoc5 = glGetUniformLocation(shaders[fsquad], "width"); | |
2940 GLint heightLoc5 = glGetUniformLocation(shaders[fsquad], "height"); | |
2941 GLint timeLoc5 = glGetUniformLocation(shaders[fsquad], "time"); | |
2942 GLint alphaLoc5 = glGetUniformLocation(shaders[fsquad], "alpha"); | |
2943 GLint alphamodeLoc5 = glGetUniformLocation(shaders[fsquad], "alphamode"); | |
2944 glUniform1f(alphamodeLoc5, 0.0f); | |
2945 | |
2946 glUniform1f(widthLoc5, g_Width); | |
2947 glUniform1f(heightLoc5, g_Height); | |
2948 glUniform1f(timeLoc5, mymillis/100); | |
2949 glUniform1f(alphaLoc5, cos(mymillis*0.1)*0.1); | |
2950 | |
2951 glActiveTexture(GL_TEXTURE0); | |
2952 | |
2953 majic_texnum = (int)(rand() % 4); | |
2954 | |
2955 glBindTexture(GL_TEXTURE_2D, textures[tex_majestic1+majic_texnum]); | |
2956 | |
2957 GLint location5 = glGetUniformLocation(shaders[fsquad], "texture0"); | |
2958 glUniform1i(location5, 0); | |
2959 | |
2960 glLoadIdentity(); | |
2961 | |
2962 glTranslatef(-1.2, -1.0, -1.0); | |
2963 | |
2964 i=0; | |
2965 j=0; | |
2966 glBegin(GL_QUADS); | |
2967 glVertex2f(i, j); | |
2968 glVertex2f(i + 100, j); | |
2969 glVertex2f(i + 100, j + 100); | |
2970 glVertex2f(i, j + 100); | |
2971 glEnd(); | |
2972 } | |
2973 | |
2974 } | |
2975 | |
2976 int redcounter = 1; | |
2977 | |
2978 void RedCircleScene() | |
2979 { | |
2980 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // fbo | |
2981 | |
2982 glUseProgram(shaders[redcircle]); | |
2983 float mymillis = (millis-scene_start_millis)*160; | |
2984 | |
2985 glClearColor(0,0,0,0); | |
2986 if (scene_shader_params[2] == 36) { redcounter++; } | |
2987 if (redcounter > 4) { redcounter = 0; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); } | |
2988 | |
2989 glEnable(GL_BLEND); | |
2990 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); | |
2991 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); | |
2992 | |
2993 GLint widthLoc2 = glGetUniformLocation(shaders[redcircle], "width"); | |
2994 GLint heightLoc2 = glGetUniformLocation(shaders[redcircle], "height"); | |
2995 | |
2996 glUniform1f(widthLoc2, g_Width); | |
2997 glUniform1f(heightLoc2, g_Height); | |
2998 | |
2999 glActiveTexture(GL_TEXTURE0); | |
3000 glBindTexture(GL_TEXTURE_2D, textures[tex_grayeye]); | |
3001 | |
3002 GLint location2 = glGetUniformLocation(shaders[redcircle], "texture0"); | |
3003 glUniform1i(location2, 0); | |
3004 | |
3005 glLoadIdentity(); | |
3006 | |
3007 glTranslatef(0.0, 0.0, -90.0-cos(mymillis*0.0000004)*120); | |
3008 glRotatef(-75.0, 1.0, 0.0, 0.0); | |
3009 glRotatef(mymillis*0.01, 0.0, 0.0, 1.0); | |
3010 | |
3011 glBegin(GL_QUADS); | |
3012 | |
3013 int i,j; | |
3014 | |
3015 for (i = -50; i < 50; i+=10) | |
3016 for (j = -50; j < 50; j+=10) | |
3017 { | |
3018 | |
3019 glVertex2f(i, j); | |
3020 glVertex2f(i + 1, j); | |
3021 glVertex2f(i + 1, j + 1); | |
3022 glVertex2f(i, j + 1); | |
3023 } | |
3024 glEnd(); | |
3025 | |
3026 } | |
3027 | |
3028 void VHSPost(float effuon) | |
3029 { | |
3030 if (current_scene == 6) effuon = 2.0f; | |
3031 if (current_scene == 7) effuon = 3.0f; | |
3032 float mymillis = (millis-scene_start_millis); | |
3033 | |
3034 if (current_scene == 1 || current_scene == 2) | |
3035 { | |
3036 if (millis > 105000 && millis < 112000) brieflycase_render(); | |
3037 } | |
3038 | |
3039 if (current_scene == 1 || current_scene == 3) | |
3040 { | |
3041 // console crap | |
3042 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
3043 | |
3044 glLoadIdentity(); | |
3045 | |
3046 mat4_set_identity( &projection ); | |
3047 mat4_set_identity( &model ); | |
3048 mat4_set_identity( &view ); | |
3049 | |
3050 mat4_set_orthographic( &projection, 0, g_Width, 0, g_Height, -1, 1); | |
3051 | |
3052 console_render( console ); | |
3053 } | |
3054 | |
3055 | |
3056 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // default | |
3057 glClearColor(0.0f, 0.0f, 0.0f, 0.0f); | |
3058 glClearDepth(1.0f); // Depth Buffer Setup | |
3059 | |
3060 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
3061 | |
3062 glUseProgram(shaders[vhs]); | |
3063 | |
3064 glDisable(GL_BLEND); | |
3065 float widthLoc5 = glGetUniformLocation(shaders[vhs], "width"); | |
3066 float heightLoc5 = glGetUniformLocation(shaders[vhs], "height"); | |
3067 float timeLoc5 = glGetUniformLocation(shaders[vhs], "time"); | |
3068 float effuLoc5 = glGetUniformLocation(shaders[vhs], "effu"); | |
3069 | |
3070 float beatLoc = glGetUniformLocation(shaders[vhs], "beat"); | |
3071 float noiseLoc = glGetUniformLocation(shaders[vhs], "noisetin"); | |
3072 | |
3073 if ((current_scene == 2 || current_scene == 1 || current_scene == 4) && (millis > 55000 && millis < 186000)) | |
3074 { | |
3075 if (scene_shader_params[2] == 36) { vhsbeat = 1.0f; vhsbeat_start = mymillis; } | |
3076 vhsbeat-=((mymillis-vhsbeat_start)*0.00005); | |
3077 if (vhsbeat <= (current_scene == 2 ? 0.2 : 0.1)) vhsbeat = (current_scene == 2 ? 0.2 : 0.1); | |
3078 } | |
3079 else if (current_scene == 3) { | |
3080 if (millis >= 181500 && vhsbeat_start < 181500) { | |
3081 vhsbeat_start = millis; | |
3082 //printf("START!\n"); | |
3083 } | |
3084 | |
3085 if (vhsbeat_start >= 181500) | |
3086 { | |
3087 vhsbeat = (millis-vhsbeat_start)*(0.02/30); | |
3088 //printf("vhsbeat:%f\n", vhsbeat); | |
3089 } | |
3090 } | |
3091 else if (current_scene == 6) | |
3092 { | |
3093 if (scene_shader_params[2] == 36) { vhsbeat = 1.0f; vhsbeat_start = mymillis; } | |
3094 vhsbeat-=((mymillis-vhsbeat_start)*0.0005); | |
3095 if (vhsbeat < 0.0) vhsbeat = 0.0; | |
3096 | |
3097 } | |
3098 else{ | |
3099 vhsbeat = 0.2; | |
3100 } | |
3101 | |
3102 float vhsnoise = ((float)(scene_shader_params[5]))/255.0f; | |
3103 float adder = (((float)(scene_shader_params[4]))/255.0f)-(current_scene == 2 ? 0.2 : 0.5f); | |
3104 | |
3105 if (current_scene == 4) adder = 0.0; | |
3106 | |
3107 if (current_scene == 7) vhsnoise = 1.0+cos(millis*0.001); | |
3108 | |
3109 if (!assets_loaded) vhsnoise=sin(loading_time*0.1); | |
3110 | |
3111 glUniform1f(widthLoc5, g_Width); | |
3112 glUniform1f(heightLoc5, g_Height); | |
3113 glUniform1f(timeLoc5, mymillis/100); | |
3114 glUniform1f(effuLoc5, effuon); | |
3115 glUniform1f(beatLoc, vhsbeat+adder); | |
3116 glUniform1f(noiseLoc, vhsnoise); | |
3117 | |
3118 glActiveTexture(GL_TEXTURE0); | |
3119 glBindTexture(GL_TEXTURE_2D, fake_framebuffer_tex); | |
3120 | |
3121 float location5 = glGetUniformLocation(shaders[vhs], "texture0"); | |
3122 glUniform1i(location5, 0); | |
3123 | |
3124 glLoadIdentity(); | |
3125 | |
3126 glTranslatef(-1.2, -1.0, -1.0); | |
3127 | |
3128 int i=0; | |
3129 int j=0; | |
3130 glBegin(GL_QUADS); | |
3131 glVertex2f(i, j); | |
3132 glVertex2f(i + 100, j); | |
3133 glVertex2f(i + 100, j + 100); | |
3134 glVertex2f(i, j + 100); | |
3135 glEnd(); | |
3136 | |
3137 | |
3138 } | |
3139 | |
3140 | |
3141 ///////////////////////////////////////////////////////////////// END EFFECTS | |
3142 ///////////////////////////////////////////////////////////////// END EFFECTS | |
3143 ///////////////////////////////////////////////////////////////// END EFFECTS | |
3144 ///////////////////////////////////////////////////////////////// END EFFECTS | |
3145 ///////////////////////////////////////////////////////////////// END EFFECTS | |
3146 | |
3147 // update sync from midi + mapping data | |
3148 | |
3149 void UpdateShaderParams() | |
3150 { | |
3151 int intmillis = (int)millis; | |
3152 int i; | |
3153 | |
3154 | |
3155 for (i=0; i < mapping_count; i++) | |
3156 { | |
3157 int tracknum = mapping_tracknum[i]; | |
3158 int trackidx = timeline_trackindex[tracknum]; | |
3159 if (timeline_trackindex[tracknum] >= timeline_tracklength[tracknum]) continue; | |
3160 | |
3161 MIDI_MSG currentMsg = timeline[tracknum][trackidx]; | |
3162 | |
3163 | |
3164 int dw = (int)currentMsg.dwAbsPos; | |
3165 int tarkistus = (int)(dw)*1.212; | |
3166 | |
3167 // flush midi to correct position if debugging | |
3168 if (debugmode == 1) | |
3169 { | |
3170 while (tarkistus < intmillis) | |
3171 { | |
3172 timeline_trackindex[tracknum]++; | |
3173 trackidx = timeline_trackindex[tracknum]; | |
3174 MIDI_MSG currentMsg2 = timeline[tracknum][trackidx]; | |
3175 dw = (int)currentMsg2.dwAbsPos; | |
3176 tarkistus = (int)(dw)*1.212; | |
3177 } | |
3178 printf("DEBUG: midi track %d flushed to position: %d\n", tracknum, tarkistus); | |
3179 } | |
3180 | |
3181 // reset trigs | |
3182 if (scene_shader_param_type[mapping_paramnum[i]] == 0) scene_shader_params[mapping_paramnum[i]] = -1; | |
3183 | |
3184 //if (intmillis+155520 < tarkistus*1.212) break; | |
3185 if (intmillis < tarkistus) continue; | |
3186 | |
3187 timeline_trackindex[tracknum]++; | |
3188 | |
3189 int ev = 0; | |
3190 | |
3191 if (currentMsg.bImpliedMsg) { ev = currentMsg.iImpliedMsg; } | |
3192 else { ev = currentMsg.iType; } | |
3193 | |
3194 // DebugPrintEvent(ev, currentMsg); | |
3195 | |
3196 int trigVal = -1; | |
3197 int paramVal = -1; | |
3198 | |
3199 switch(mapping_type[i]) | |
3200 { | |
3201 // trig | |
3202 case 0: | |
3203 { | |
3204 | |
3205 if (ev == msgNoteOn) | |
3206 { | |
3207 trigVal = currentMsg.MsgData.NoteOn.iNote; | |
3208 // printf("track #%d (%s), len %d, pos %d: dwAbsPos: %d (millis: %d) -> noteon: %d (shadermap num %d)\n", tracknum, timeline_trackname[tracknum], timeline_tracklength[tracknum], timeline_trackindex[tracknum], currentMsg.dwAbsPos, intmillis, trigVal, mapping_paramnum[i]); | |
3209 // printf("shader param %d trig: %d\n", mapping_paramnum[i], trigVal); | |
3210 } | |
3211 else if (ev == msgNoteOff) | |
3212 { | |
3213 trigVal = -1; | |
3214 } | |
3215 | |
3216 scene_shader_params[mapping_paramnum[i]] = trigVal; | |
3217 scene_shader_param_type[mapping_paramnum[i]] = 0; | |
3218 //if (ev == msgNoteOn) printf("sync (%s): %d: trig %d to: %f\n", timeline_trackname[tracknum], intmillis, mapping_paramnum[i], scene_shader_params[mapping_paramnum[i]]); | |
3219 break; | |
3220 } | |
3221 | |
3222 // param: | |
3223 case 1: | |
3224 { | |
3225 if (ev == msgSetParameter) | |
3226 { | |
3227 paramVal = currentMsg.MsgData.NoteParameter.iParam; | |
3228 scene_shader_params[mapping_paramnum[i]] = paramVal; | |
3229 scene_shader_param_type[mapping_paramnum[i]] = 1; | |
3230 //printf("sync (%s): %d: param %d to: %d\n", timeline_trackname[tracknum], intmillis, mapping_paramnum[i], scene_shader_params[mapping_paramnum[i]]); | |
3231 } | |
3232 | |
3233 break; | |
3234 } | |
3235 } | |
3236 } | |
3237 debugmode = 0; | |
3238 | |
3239 } | |
3240 ///////////////////////////////////////////////////////////////// MAIN LOGIC | |
3241 | |
3242 void quit() | |
3243 { | |
3244 quitflag = 1; | |
3245 printf("--- MIDISYS ENGINE: time to quit()\n"); | |
3246 if(!window) { | |
3247 glutLeaveGameMode(); | |
3248 glutLeaveMainLoop(); | |
3249 } else { | |
3250 glutDestroyWindow(window); | |
3251 glutLeaveMainLoop(); | |
3252 } | |
3253 } | |
3254 | |
3255 double min(double a, double b) | |
3256 { | |
3257 if (a<=b) return a; | |
3258 else return b; | |
3259 } | |
3260 | |
3261 GLint gFramesPerSecond = 0; | |
3262 | |
3263 void FPS(void) { | |
3264 static GLint Frames = 0; // frames averaged over 1000mS | |
3265 static GLuint Clock; // [milliSeconds] | |
3266 static GLuint PreviousClock = 0; // [milliSeconds] | |
3267 static GLuint NextClock = 0; // [milliSeconds] | |
3268 | |
3269 ++Frames; | |
3270 Clock = glutGet(GLUT_ELAPSED_TIME); //has limited resolution, so average over 1000mS | |
3271 if ( Clock < NextClock ) return; | |
3272 | |
3273 gFramesPerSecond = Frames/1; // store the averaged number of frames per second | |
3274 | |
3275 PreviousClock = Clock; | |
3276 NextClock = Clock+1000; // 1000mS=1S in the future | |
3277 Frames=0; | |
3278 } | |
3279 | |
3280 void logic() | |
3281 { | |
3282 if (assets_loaded) { | |
3283 if (music_started == -1) { | |
3284 printf("--- MIDISYS-ENGINE: total loading time: %f\n", loading_time); | |
3285 printf("--- MIDISYS-ENGINE: demo startup\n"); | |
3286 BASS_ChannelPlay(music_channel,FALSE); music_started = 1; | |
3287 if(jump_to) { BASS_ChannelSetPosition(music_channel, jump_to, BASS_POS_BYTE); } | |
3288 } | |
3289 | |
3290 QWORD bytepos = BASS_ChannelGetPosition(music_channel, BASS_POS_BYTE); | |
3291 double pos = BASS_ChannelBytes2Seconds(music_channel, bytepos); | |
3292 millis = (float)pos*1000*demo_speed_x; | |
3293 | |
3294 if (millis > 367000) quit(); | |
3295 | |
3296 demo_playlist(); | |
3297 scene_logic[current_scene](0.0f); | |
3298 } else { | |
3299 t_loader_d = clock(); | |
3300 //scene_logic[current_scene]((float)((float)(assets_index) / (float)(assets_total))); | |
3301 } | |
3302 | |
3303 // glutPostRedisplay(); | |
3304 } | |
3305 | |
3306 void timer(int value) | |
3307 { | |
3308 const int desiredFPS=60; | |
3309 glutTimerFunc(1000/desiredFPS, timer, ++value); | |
3310 | |
3311 logic(); | |
3312 | |
3313 FPS(); //only call once per frame loop to measure FPS | |
3314 if (quitflag == 0) glutPostRedisplay(); | |
3315 } | |
3316 | |
3317 | |
3318 ///////////////////////////////////////////////////////////// RENDER FUNCTION | |
3319 | |
3320 void display(void) | |
3321 { | |
3322 UpdateShaderParams(); | |
3323 scene_render[current_scene](); | |
3324 VHSPost(assets_loaded && current_scene <= 4 ? 1.0 : 0.0); | |
3325 | |
3326 glFlush(); | |
3327 glutSwapBuffers(); | |
3328 frame++; | |
3329 logic(); | |
3330 } | |
3331 | |
3332 | |
3333 // ---------------------------------------------------------------------------- | |
3334 // ---------------------------------------------------------------------------- | |
3335 | |
3336 void keyPress(unsigned char key, int x, int y) | |
3337 { | |
3338 if (key == 27) quit(); | |
3339 } | |
3340 | |
3341 void mouseMotion(int button, int state, int x, int y) | |
3342 { | |
3343 mouseX = x; | |
3344 mouseY = y; | |
3345 } | |
3346 | |
3347 void InitFBO() | |
3348 { | |
3349 glGenTextures(1, &fb_tex); | |
3350 glBindTexture(GL_TEXTURE_2D, fb_tex); | |
3351 | |
3352 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); | |
3353 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); | |
3354 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); | |
3355 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); | |
3356 | |
3357 | |
3358 printf("\tframebuffer size: %dx%d\n", g_Width, g_Height); | |
3359 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, g_Width, g_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); | |
3360 glGenFramebuffersEXT(1, &fb); | |
3361 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); | |
3362 | |
3363 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, fb_tex, 0); | |
3364 | |
3365 glGenRenderbuffersEXT(1, &depth_rb); | |
3366 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb); | |
3367 glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, g_Width, g_Height); | |
3368 | |
3369 glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb); | |
3370 | |
3371 GLenum status; | |
3372 status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); | |
3373 switch(status) | |
3374 { | |
3375 case GL_FRAMEBUFFER_COMPLETE_EXT: | |
3376 printf("\tInitFBO() status: GL_FRAMEBUFFER_COMPLETE\n"); | |
3377 break; | |
3378 default: | |
3379 printf("\tInitFBO() error: status != GL_FRAMEBUFFER_COMPLETE\n"); | |
3380 exit(1); | |
3381 break; | |
3382 } | |
3383 | |
3384 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); | |
3385 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); | |
3386 | |
3387 | |
3388 | |
3389 glGenTextures(1, &fb_tex2); | |
3390 glBindTexture(GL_TEXTURE_2D, fb_tex2); | |
3391 | |
3392 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); | |
3393 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); | |
3394 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); | |
3395 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); | |
3396 | |
3397 | |
3398 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, g_Width, g_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); | |
3399 glGenFramebuffersEXT(1, &fb2); | |
3400 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb2); | |
3401 | |
3402 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, fb_tex2, 0); | |
3403 | |
3404 glGenRenderbuffersEXT(1, &depth_rb2); | |
3405 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb2); | |
3406 glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, g_Width, g_Height); | |
3407 | |
3408 glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb2); | |
3409 | |
3410 status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); | |
3411 switch(status) | |
3412 { | |
3413 case GL_FRAMEBUFFER_COMPLETE_EXT: | |
3414 printf("\tInitFBO() status: GL_FRAMEBUFFER_COMPLETE\n"); | |
3415 break; | |
3416 default: | |
3417 printf("\tInitFBO() error: status != GL_FRAMEBUFFER_COMPLETE\n"); | |
3418 exit(1); | |
3419 break; | |
3420 } | |
3421 | |
3422 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); | |
3423 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); | |
3424 | |
3425 //---------- | |
3426 | |
3427 glGenTextures(1, &fake_framebuffer_tex); | |
3428 glBindTexture(GL_TEXTURE_2D, fake_framebuffer_tex); | |
3429 | |
3430 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); | |
3431 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); | |
3432 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); | |
3433 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); | |
3434 | |
3435 | |
3436 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, g_Width, g_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); | |
3437 glGenFramebuffersEXT(1, &fake_framebuffer); | |
3438 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); | |
3439 | |
3440 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, fake_framebuffer_tex, 0); | |
3441 | |
3442 glGenRenderbuffersEXT(1, &depth_rb3); | |
3443 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb3); | |
3444 glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, g_Width, g_Height); | |
3445 | |
3446 glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb3); | |
3447 | |
3448 glClearColor(0.0,0.0,0.0,1.0); | |
3449 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
3450 | |
3451 status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); | |
3452 switch(status) | |
3453 { | |
3454 case GL_FRAMEBUFFER_COMPLETE_EXT: | |
3455 printf("\tInitFBO() status: GL_FRAMEBUFFER_COMPLETE\n"); | |
3456 break; | |
3457 default: | |
3458 printf("\tInitFBO() error: status != GL_FRAMEBUFFER_COMPLETE\n"); | |
3459 exit(1); | |
3460 break; | |
3461 } | |
3462 | |
3463 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); | |
3464 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); | |
3465 | |
3466 | |
3467 | |
3468 } | |
3469 | |
3470 void InitGraphics(int argc, char* argv[]) | |
3471 { | |
3472 fprintf(stdout, "--- MIDISYS ENGINE: InitGraphics()\n"); | |
3473 glutInit(&argc, argv); | |
3474 | |
3475 | |
3476 if(!window) { | |
3477 glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH ); | |
3478 // 1280x720, 32bit pixel depth, 60Hz refresh rate | |
3479 glutGameModeString( "1280x720:32@60" ); | |
3480 | |
3481 // start fullscreen game mode | |
3482 glutEnterGameMode(); | |
3483 } else { | |
3484 window = glutCreateWindow("majestic twelve by bilotrip"); | |
3485 glutReshapeWindow(c_Width, c_Height); | |
3486 } | |
3487 | |
3488 glutSetCursor(GLUT_CURSOR_NONE); | |
3489 | |
3490 GLenum err = glewInit(); | |
3491 if (GLEW_OK != err) | |
3492 { | |
3493 /* Problem: glewInit failed, something is seriously wrong. */ | |
3494 fprintf(stderr, "\tInitGraphics() error: %s\n", glewGetErrorString(err)); | |
3495 exit(1); | |
3496 } | |
3497 fprintf(stdout, "\tInitGraphics() status: Using GLEW %s\n", glewGetString(GLEW_VERSION)); | |
3498 | |
3499 glEnable(GL_TEXTURE_2D); | |
3500 | |
3501 glShadeModel(GL_SMOOTH); | |
3502 | |
3503 #ifdef __APPLE__ | |
3504 int swap_interval = 1; | |
3505 CGLContextObj cgl_context = CGLGetCurrentContext(); | |
3506 CGLSetParameter(cgl_context, kCGLCPSwapInterval, &swap_interval); | |
3507 #endif | |
3508 | |
3509 glutDisplayFunc(display); | |
3510 glutReshapeFunc(reshape); | |
3511 glutIdleFunc(logic); | |
3512 glutKeyboardFunc(keyPress); | |
3513 glutMouseFunc(mouseMotion); | |
3514 glutTimerFunc(0,timer,0); | |
3515 | |
3516 fprintf(stdout, "--- MIDISYS ENGINE: InitGraphics() success\n"); | |
3517 } | |
3518 | |
3519 void StartMainLoop() | |
3520 { | |
3521 printf("--- MIDISYS ENGINE: StartMainLoop()\n"); | |
3522 glutMainLoop(); | |
3523 } | |
3524 | |
3525 int main(int argc, char* argv[]) | |
3526 { | |
3527 printf("--- MIDISYS ENGINE: bilotrip foundation MIDISYS ENGINE 4.20 - dosing, please wait\n"); | |
3528 | |
3529 // init graphics | |
3530 | |
3531 InitGraphics(argc, argv); | |
3532 | |
3533 // init console | |
3534 | |
3535 console = console_new(); | |
3536 shader = shader_load("data/shaders/v3f-t2f-c4f.vert", | |
3537 shaderss[0]); | |
3538 | |
3539 // load & init video | |
3540 | |
3541 printf("--- nu laddar vi en videofilmen, det aer jaetteroligt att fuska poe Assembly\n"); | |
3542 | |
3 | 3543 static const char *videofile = "data/video/video.ogg"; |
3544 OggPlayer ogg(videofile,AF_S16,2,44100,VF_BGRA); | |
0 | 3545 if(ogg.fail()) { |
3 | 3546 printf("could not open video file \"%s\"\n", videofile); |
0 | 3547 return -2; |
3548 } | |
3549 YUVFrame yuv_frame(ogg); | |
3550 myVideoFrame = &yuv_frame; | |
3551 | |
3552 // init MIDI sync and audio | |
3553 | |
3554 LoadMIDIEventList("data/music/midicontrols_final.mid"); | |
3555 ParseMIDITimeline("data/music/mapping.txt"); | |
3556 InitAudio("data/music/UusiArtistiNimi_-_The_March_compoVersion.mp3"); | |
3557 | |
3558 // Loader assets | |
3559 | |
3560 bilothorn = Import3DFromFile("data/models/bilotrip_logo_thorn.3ds"); | |
3561 LoadGLTextures(bilothorn); | |
3562 biloflat = Import3DFromFile("data/models/bilotrip_logo_flat.obj"); | |
3563 LoadGLTextures(biloflat); | |
3564 bilothree = Import3DFromFile("data/models/bilotrip.3ds"); | |
3565 LoadGLTextures(bilothree); | |
3566 bilotetra = Import3DFromFile("data/models/bilotrip_logo_tetra.obj"); | |
3567 LoadGLTextures(bilotetra); | |
33 | 3568 brieflycase = Import3DFromFile("data/models/brieflyCase.obj"); |
0 | 3569 LoadGLTextures(brieflycase); |
3570 | |
3571 // start mainloop | |
3572 | |
3573 StartMainLoop(); | |
3574 | |
3575 return 0; | |
3576 } |