Mercurial > hg > forks > bilotrip-mj12
annotate src/main.c @ 44:f0073a47c31d
Fix various warnings.
| author | Matti Hamalainen <ccr@tnsp.org> |
|---|---|
| date | Tue, 06 Aug 2013 00:04:37 +0300 |
| parents | 5770a4c85961 |
| children | d85542c96791 |
| 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}}; | |
| 42 | 188 //vec4 black = {{0,0,0,1}}; |
| 189 //vec4 none = {{0,0,1,0}}; | |
| 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 | |
| 41 | 986 void demo_playlist() |
| 0 | 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 { | |
| 41 | 1326 strncpy(timeline_trackname[track_index], (char *) msg.MsgData.MetaEvent.Data.Text.pData, 8); |
| 1327 timeline_trackname[track_index][8] = 0; | |
| 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 { | |
| 44 | 1407 int y; |
| 1408 size_t i, stride = w * comp; | |
| 0 | 1409 uint8 *out = data; |
| 1410 | |
| 1411 for (y = 0; y < (h>>1); ++y) { | |
| 1412 stbi_uc *p1 = out + y * stride; | |
| 1413 stbi_uc *p2 = out + (h-1-y) * stride; | |
| 1414 for (i = 0; i < stride; ++i) { | |
| 1415 stbi_uc t = p1[i]; | |
| 1416 p1[i] = p2[i]; | |
| 1417 p2[i] = t; | |
| 1418 } | |
| 1419 } | |
| 1420 } | |
| 1421 | |
| 1422 int scale_image_RGB_to_NTSC_safe(int width, int height, int channels,stbi_uc* data) { | |
| 1423 const float scale_lo = 16.0f - 0.499f; | |
| 1424 const float scale_hi = 235.0f + 0.499f; | |
| 1425 int i, j; | |
| 1426 int nc = channels; | |
| 1427 | |
| 1428 unsigned char* orig = data; | |
| 1429 | |
| 1430 unsigned char scale_LUT[256]; | |
| 1431 /* error check */ | |
| 1432 if( (width < 1) || (height < 1) || | |
| 1433 (channels < 1) || (orig == NULL) ) | |
| 1434 { | |
| 1435 /* nothing to do */ | |
| 1436 return 0; | |
| 1437 } | |
| 1438 /* set up the scaling Look Up Table */ | |
| 1439 for( i = 0; i < 256; ++i ) | |
| 1440 { | |
| 1441 scale_LUT[i] = (unsigned char)((scale_hi - scale_lo) * i / 255.0f + scale_lo); | |
| 1442 } | |
| 1443 /* for channels = 2 or 4, ignore the alpha component */ | |
| 1444 nc -= 1 - (channels & 1); | |
| 1445 /* OK, go through the image and scale any non-alpha components */ | |
| 1446 for( i = 0; i < width*height*channels; i += channels ) | |
| 1447 { | |
| 1448 for( j = 0; j < nc; ++j ) | |
| 1449 { | |
| 1450 orig[i+j] = scale_LUT[orig[i+j]]; | |
| 1451 } | |
| 1452 } | |
| 1453 return 1; | |
| 1454 } | |
| 1455 | |
| 1456 | |
| 1457 GLuint LoadTexture(const char* pFilename, int invert) | |
| 1458 { | |
| 44 | 1459 if(!load_textures) return 0; |
| 0 | 1460 |
| 1461 if (strcmp(pFilename,"") == 0) return 99999; | |
| 1462 printf(" - LoadTexture(\"%s\")", pFilename); | |
| 1463 GLuint tex_2d; | |
| 1464 unsigned char *data; | |
| 1465 int x, y, comp; | |
| 1466 | |
| 1467 FILE *file = fopen(pFilename, "rb"); | |
| 1468 if (!file) | |
| 1469 return 0; | |
| 1470 | |
| 1471 data = stbi_load_from_file(file, &x, &y, &comp, 0); | |
| 1472 fclose(file); | |
| 1473 //gluBuild2DMipmaps( GL_TEXTURE_2D, 4, x, y, GL_RGBA, GL_UNSIGNED_BYTE, data ); | |
| 1474 | |
| 1475 glGenTextures( 1, &tex_2d ); | |
| 1476 glBindTexture( GL_TEXTURE_2D, tex_2d ); | |
| 1477 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); | |
| 1478 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP ); | |
| 1479 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP ); | |
| 1480 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); | |
| 1481 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); | |
| 1482 | |
| 1483 | |
| 1484 if (invert == 1) | |
| 1485 { | |
| 1486 stbi_flip_y(x, y, comp, data); | |
| 1487 } | |
| 1488 else | |
| 1489 { | |
| 1490 } | |
| 1491 | |
| 1492 scale_image_RGB_to_NTSC_safe(x,y,comp,data); | |
| 1493 | |
| 1494 if( comp == 3 ) { | |
| 1495 glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, x, y, 0, GL_RGB, GL_UNSIGNED_BYTE, data ); | |
| 1496 } else if( comp == 4 ) { | |
| 1497 glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, x, y, 0, GL_RGBA, GL_UNSIGNED_BYTE, data ); | |
| 1498 } | |
| 1499 | |
| 1500 | |
| 1501 if(0 == tex_2d) | |
| 1502 { | |
| 1503 printf(" error loading texture from file \"%s\"\n", pFilename); | |
| 1504 exit(1); | |
| 1505 } | |
| 1506 | |
| 1507 printf(" success\n"); | |
| 1508 | |
| 1509 return tex_2d; | |
| 1510 } | |
| 1511 | |
| 1512 GLuint LoadTexture(const char* pFilename) | |
| 1513 { | |
| 1514 return LoadTexture(pFilename, 1); | |
| 1515 } | |
| 1516 | |
| 1517 int LoadGLTextures(const aiScene* scene) { | |
| 1518 | |
| 1519 if (scene->HasTextures()) | |
| 1520 { | |
| 1521 printf("ERROR: support for meshes with embedded textures is not implemented\n"); | |
| 1522 exit(1); | |
| 1523 } | |
| 1524 | |
| 1525 /* scan scene's materials for textures */ | |
| 1526 for (unsigned int m=0; m<scene->mNumMaterials; m++) | |
| 1527 { | |
| 1528 int texIndex = 0; | |
| 1529 aiReturn texFound = AI_SUCCESS; | |
| 1530 aiString path; // filename | |
| 1531 | |
| 1532 while (texFound == AI_SUCCESS) | |
| 1533 { | |
| 1534 texFound = scene->mMaterials[m]->GetTexture(aiTextureType_DIFFUSE, texIndex, &path); | |
| 44 | 1535 textureIdMap[path.data] = LoadTexture(path.data, 0); |
| 0 | 1536 texIndex++; |
| 1537 } | |
| 1538 } | |
| 44 | 1539 |
| 0 | 1540 return true; |
| 1541 } | |
| 1542 | |
| 1543 GLuint LoadShader(const char* pFilename) | |
| 1544 { | |
| 1545 fprintf(stdout," - LoadShader(\"%s\")", pFilename); | |
| 1546 | |
| 1547 #ifdef SUPERVERBOSE | |
| 1548 printf("\n"); | |
| 1549 #endif | |
| 1550 | |
| 1551 char vsName[256] = ""; | |
| 1552 strcpy(vsName, pFilename); | |
| 1553 strcat(vsName, ".vs"); | |
| 1554 | |
| 1555 char fsName[256] = ""; | |
| 1556 strcpy(fsName, pFilename); | |
| 1557 strcat(fsName, ".fs"); | |
| 1558 | |
| 1559 #ifdef SUPERVERBOSE | |
| 1560 fprintf(stdout,"\tLoadShader(\"%s\") vertex shader source file: \"%s\"\n", pFilename, vsName); | |
| 1561 #endif | |
| 1562 | |
| 1563 GLchar *vsSource = File2String(vsName); | |
| 1564 | |
| 1565 #ifdef SUPERVERBOSE | |
| 1566 fprintf(stdout,"\tLoadShader(\"%s\") vertex shader source:\n----------------------------------------------------\n%s\n----------------------------------------------------\n", pFilename, vsSource); | |
| 1567 #endif | |
| 1568 | |
| 1569 #ifdef SUPERVERBOSE | |
| 1570 fprintf(stdout,"\tLoadShader(\"%s\") fragment shader source file: \"%s\"\n", pFilename, fsName); | |
| 1571 #endif | |
| 1572 | |
| 1573 GLchar *fsSource = File2String(fsName); | |
| 1574 | |
| 1575 #ifdef SUPERVERBOSE | |
| 1576 fprintf(stdout,"\tLoadShader(\"%s\") fragment shader source:\n----------------------------------------------------\n%s\n----------------------------------------------------\n", pFilename, fsSource); | |
| 1577 #endif | |
| 1578 | |
| 1579 GLuint vs, fs, sp; | |
| 1580 | |
| 1581 #ifdef SUPERVERBOSE | |
| 1582 printf("\tLoadShader(): vs glCreateShader\n"); | |
| 1583 #endif | |
| 1584 vs = glCreateShader(GL_VERTEX_SHADER); | |
| 1585 PrintShaderLog(vs); | |
| 1586 #ifdef SUPERVERBOSE | |
| 1587 printf("\tLoadShader(): vs glShaderSource\n"); | |
| 1588 #endif | |
| 1589 glShaderSource(vs, 1, (const GLchar**)&vsSource, NULL); | |
| 1590 PrintShaderLog(vs); | |
| 1591 #ifdef SUPERVERBOSE | |
| 1592 printf("\tLoadShader(): vs glCompileShader\n"); | |
| 1593 #endif | |
| 1594 glCompileShader(vs); | |
| 1595 PrintShaderLog(vs); | |
| 1596 #ifdef SUPERVERBOSE | |
| 1597 printf("\tLoadShader(): vs compiled\n"); | |
| 1598 #endif | |
| 1599 | |
| 1600 #ifdef SUPERVERBOSE | |
| 1601 printf("\tLoadShader(): fs glCreateShader\n"); | |
| 1602 #endif | |
| 1603 fs = glCreateShader(GL_FRAGMENT_SHADER); | |
| 1604 PrintShaderLog(fs); | |
| 1605 #ifdef SUPERVERBOSE | |
| 1606 printf("\tLoadShader(): fs glShaderSource\n"); | |
| 1607 #endif | |
| 1608 glShaderSource(fs, 1, (const GLchar**)&fsSource, NULL); | |
| 1609 PrintShaderLog(fs); | |
| 1610 #ifdef SUPERVERBOSE | |
| 1611 printf("\tLoadShader(): fs glCompileShader\n"); | |
| 1612 #endif | |
| 1613 glCompileShader(fs); | |
| 1614 PrintShaderLog(fs); | |
| 1615 #ifdef SUPERVERBOSE | |
| 1616 printf("\tLoadShader(): fs compiled\n"); | |
| 1617 #endif | |
| 1618 | |
| 1619 free(vsSource); | |
| 1620 free(fsSource); | |
| 1621 | |
| 1622 #ifdef SUPERVERBOSE | |
| 1623 printf("\tLoadShader(): glCreateProgram\n"); | |
| 1624 #endif | |
| 1625 sp = glCreateProgram(); | |
| 1626 PrintShaderLog(sp); | |
| 1627 #ifdef SUPERVERBOSE | |
| 1628 printf("\tLoadShader(): glAttachShader vs\n"); | |
| 1629 #endif | |
| 1630 glAttachShader(sp, vs); | |
| 1631 PrintShaderLog(sp); | |
| 1632 #ifdef SUPERVERBOSE | |
| 1633 printf("\tLoadShader(): glAttachShader fs\n"); | |
| 1634 #endif | |
| 1635 glAttachShader(sp, fs); | |
| 1636 PrintShaderLog(sp); | |
| 1637 #ifdef SUPERVERBOSE | |
| 1638 printf("\tLoadShader(): glLinkProgram\n"); | |
| 1639 #endif | |
| 1640 glLinkProgram(sp); | |
| 1641 PrintShaderLog(sp); | |
| 1642 | |
| 1643 #ifdef SUPERVERBOSE | |
| 1644 fprintf(stdout,"--- MIDISYS ENGINE: LoadShader(\"%s\") success\n", pFilename); | |
| 1645 #else | |
| 1646 printf(" success\n"); | |
| 1647 #endif | |
| 1648 | |
| 1649 return sp; | |
| 1650 } | |
| 1651 | |
| 1652 ///////////////////////////////////////////////////////////////// EFFECTS | |
| 1653 ///////////////////////////////////////////////////////////////// EFFECTS | |
| 1654 ///////////////////////////////////////////////////////////////// EFFECTS | |
| 1655 ///////////////////////////////////////////////////////////////// EFFECTS | |
| 1656 ///////////////////////////////////////////////////////////////// EFFECTS | |
| 1657 | |
| 1658 | |
| 1659 // Can't send color down as a pointer to aiColor4D because AI colors are ABGR. | |
| 1660 void Color4f(const aiColor4D *color) | |
| 1661 { | |
| 1662 glColor4f(color->r, color->g, color->b, color->a); | |
| 1663 } | |
| 1664 | |
| 1665 void set_float4(float f[4], float a, float b, float c, float d) | |
| 1666 { | |
| 1667 f[0] = a; | |
| 1668 f[1] = b; | |
| 1669 f[2] = c; | |
| 1670 f[3] = d; | |
| 1671 } | |
| 1672 | |
| 1673 void color4_to_float4(const aiColor4D *c, float f[4]) | |
| 1674 { | |
| 1675 f[0] = c->r; | |
| 1676 f[1] = c->g; | |
| 1677 f[2] = c->b; | |
| 1678 f[3] = c->a; | |
| 1679 } | |
| 1680 | |
| 1681 void apply_material(const aiMaterial *mtl) | |
| 1682 { | |
| 1683 float c[4]; | |
| 1684 | |
| 1685 GLenum fill_mode; | |
| 1686 int ret1, ret2; | |
| 1687 aiColor4D diffuse; | |
| 1688 aiColor4D specular; | |
| 1689 aiColor4D ambient; | |
| 1690 aiColor4D emission; | |
| 1691 float shininess, strength; | |
| 1692 int two_sided; | |
| 1693 int wireframe; | |
| 1694 unsigned int max; // changed: to unsigned | |
| 1695 | |
| 1696 int texIndex = 0; | |
| 1697 aiString texPath; //contains filename of texture | |
| 1698 | |
| 1699 if(AI_SUCCESS == mtl->GetTexture(aiTextureType_DIFFUSE, texIndex, &texPath)) | |
| 1700 { | |
| 1701 //bind texture | |
| 44 | 1702 GLuint texId = (GLuint) textureIdMap.at(texPath.data); |
| 0 | 1703 if (texId != 99999) glBindTexture(GL_TEXTURE_2D, texId); |
| 1704 } | |
| 1705 | |
| 1706 set_float4(c, 0.8f, 0.8f, 0.8f, 1.0f); | |
| 1707 if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_DIFFUSE, &diffuse)) | |
| 1708 color4_to_float4(&diffuse, c); | |
| 1709 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, c); | |
| 1710 | |
| 1711 set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f); | |
| 1712 if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_SPECULAR, &specular)) | |
| 1713 color4_to_float4(&specular, c); | |
| 1714 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c); | |
| 1715 | |
| 1716 set_float4(c, 0.2f, 0.2f, 0.2f, 1.0f); | |
| 1717 if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_AMBIENT, &ambient)) | |
| 1718 color4_to_float4(&ambient, c); | |
| 1719 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, c); | |
| 1720 | |
| 1721 set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f); | |
| 1722 if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_EMISSIVE, &emission)) | |
| 1723 color4_to_float4(&emission, c); | |
| 1724 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, c); | |
| 1725 | |
| 1726 max = 1; | |
| 1727 ret1 = aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS, &shininess, &max); | |
| 1728 max = 1; | |
| 1729 ret2 = aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS_STRENGTH, &strength, &max); | |
| 1730 if((ret1 == AI_SUCCESS) && (ret2 == AI_SUCCESS)) | |
| 1731 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess * strength); | |
| 1732 else { | |
| 1733 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0f); | |
| 1734 set_float4(c, 0.0f, 0.0f, 0.0f, 0.0f); | |
| 1735 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c); | |
| 1736 } | |
| 1737 | |
| 1738 max = 1; | |
| 1739 if(AI_SUCCESS == aiGetMaterialIntegerArray(mtl, AI_MATKEY_ENABLE_WIREFRAME, &wireframe, &max)) | |
| 1740 fill_mode = wireframe ? GL_LINE : GL_FILL; | |
| 1741 else | |
| 1742 fill_mode = GL_FILL; | |
| 1743 glPolygonMode(GL_FRONT_AND_BACK, fill_mode); | |
| 1744 | |
| 1745 max = 1; | |
| 1746 if((AI_SUCCESS == aiGetMaterialIntegerArray(mtl, AI_MATKEY_TWOSIDED, &two_sided, &max)) && two_sided) | |
| 1747 glEnable(GL_CULL_FACE); | |
| 1748 else | |
| 1749 glDisable(GL_CULL_FACE); | |
| 1750 } | |
| 1751 | |
| 1752 | |
| 1753 void recursive_render (const struct aiScene *sc, const struct aiNode* nd, float scale) | |
| 1754 { | |
| 1755 | |
| 1756 unsigned int i; | |
| 1757 unsigned int n=0, t; | |
| 1758 aiMatrix4x4 m = nd->mTransformation; | |
| 1759 | |
| 1760 aiMatrix4x4 m2; | |
| 1761 aiMatrix4x4::Scaling(aiVector3D(scale, scale, scale), m2); | |
| 1762 m = m * m2; | |
| 1763 | |
| 1764 // update transform | |
| 1765 m.Transpose(); | |
| 1766 glPushMatrix(); | |
| 1767 glMultMatrixf((float*)&m); | |
| 1768 | |
| 1769 // draw all meshes assigned to this node | |
| 1770 for (; n < nd->mNumMeshes; ++n) | |
| 1771 { | |
| 1772 const struct aiMesh* mesh = sc->mMeshes[nd->mMeshes[n]]; | |
| 1773 | |
| 1774 apply_material(sc->mMaterials[mesh->mMaterialIndex]); | |
| 1775 | |
| 1776 | |
| 1777 if(mesh->mNormals == NULL) | |
| 1778 { | |
| 1779 glDisable(GL_LIGHTING); | |
| 1780 } | |
| 1781 else | |
| 1782 { | |
| 1783 glEnable(GL_LIGHTING); | |
| 1784 } | |
| 1785 | |
| 1786 if(mesh->mColors[0] != NULL) | |
| 1787 { | |
| 1788 glEnable(GL_COLOR_MATERIAL); | |
| 1789 } | |
| 1790 else | |
| 1791 { | |
| 1792 glDisable(GL_COLOR_MATERIAL); | |
| 1793 } | |
| 1794 | |
| 1795 | |
| 1796 | |
| 1797 for (t = 0; t < mesh->mNumFaces; ++t) { | |
| 1798 const struct aiFace* face = &mesh->mFaces[t]; | |
| 1799 GLenum face_mode; | |
| 1800 | |
| 1801 switch(face->mNumIndices) | |
| 1802 { | |
| 1803 case 1: face_mode = GL_POINTS; break; | |
| 1804 case 2: face_mode = GL_LINES; break; | |
| 1805 case 3: face_mode = GL_TRIANGLES; break; | |
| 1806 default: face_mode = GL_POLYGON; break; | |
| 1807 } | |
| 1808 | |
| 1809 glBegin(face_mode); | |
| 1810 | |
| 1811 for(i = 0; i < face->mNumIndices; i++) // go through all vertices in face | |
| 1812 { | |
| 1813 int vertexIndex = face->mIndices[i]; // get group index for current index | |
| 1814 if(mesh->mColors[0] != NULL) | |
| 1815 Color4f(&mesh->mColors[0][vertexIndex]); | |
| 1816 if(mesh->mNormals != NULL) | |
| 1817 | |
| 1818 if(mesh->HasTextureCoords(0)) //HasTextureCoords(texture_coordinates_set) | |
| 1819 { | |
| 1820 glTexCoord2f(mesh->mTextureCoords[0][vertexIndex].x, 1 - mesh->mTextureCoords[0][vertexIndex].y); //mTextureCoords[channel][vertex] | |
| 1821 } | |
| 1822 | |
| 1823 glNormal3fv(&mesh->mNormals[vertexIndex].x); | |
| 1824 glVertex3fv(&mesh->mVertices[vertexIndex].x); | |
| 1825 } | |
| 1826 | |
| 1827 glEnd(); | |
| 1828 | |
| 1829 } | |
| 1830 | |
| 1831 } | |
| 1832 | |
| 1833 | |
| 1834 // draw all children | |
| 1835 for (n = 0; n < nd->mNumChildren; ++n) | |
| 1836 { | |
| 1837 recursive_render(sc, nd->mChildren[n], scale); | |
| 1838 } | |
| 1839 | |
| 1840 glPopMatrix(); | |
| 1841 } | |
| 1842 float jormymillis = 0.0; | |
| 1843 float startti = 0; | |
| 1844 float startti2 = 0; | |
| 1845 float pantime = 0; | |
| 1846 void BiloThreeScene() | |
| 1847 { | |
| 1848 float mymillis = (millis-scene_start_millis); | |
| 1849 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
| 1850 glUseProgram(0); | |
| 1851 | |
| 1852 float colmy = mymillis*0.0001; | |
| 1853 if (colmy > 0.5) colmy = 0.5; | |
| 1854 | |
| 1855 if (millis > 302800) colmy-=((millis-302800)*0.00001); | |
| 1856 | |
| 1857 glClearColor(colmy, 0.0f, 0.0f, 0.0f); | |
| 1858 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
| 1859 | |
| 1860 glDisable(GL_TEXTURE_2D); | |
| 1861 glEnable(GL_BLEND); | |
| 1862 glBlendFunc(GL_SRC_COLOR, GL_ONE_MINUS_DST_COLOR); | |
| 1863 | |
| 1864 glShadeModel(GL_SMOOTH); // Enables Smooth Shading | |
| 1865 glEnable(GL_DEPTH_TEST); // Enables Depth Testing | |
| 1866 glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do | |
| 1867 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculation | |
| 1868 | |
| 1869 glDisable(GL_LIGHTING); | |
| 1870 glEnable(GL_LIGHT0); // Uses default lighting parameters | |
| 1871 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); | |
| 1872 glEnable(GL_NORMALIZE); | |
| 1873 | |
| 1874 float zoom = -300.0f+(((mymillis-jormymillis)*atan(mymillis*0.005))*0.05); | |
| 1875 | |
| 1876 if (zoom > -0.5 && startti == 0) { startti = mymillis; } | |
| 1877 if (zoom >= -0.5) { zoom = -0.5; jormymillis+=290;} | |
| 1878 | |
| 1879 glLoadIdentity(); | |
| 1880 | |
| 1881 if (jormymillis > 300*60 && startti2 == 0) | |
| 1882 { | |
| 1883 startti2 = mymillis; | |
| 1884 } | |
| 1885 | |
| 1886 if (jormymillis > 300*60) | |
| 1887 { | |
| 1888 pantime = mymillis-startti2; | |
| 1889 } | |
| 1890 | |
| 1891 glTranslatef(0.0f, startti2 > 0 ? -7.5f-pantime*0.0008 : -7.5f, zoom+pantime*0.001*atan(pantime*0.005)); | |
| 1892 if (jormymillis > 0) { | |
| 1893 glRotatef(jormymillis*0.0026,-1.0,0.0,0.0); | |
| 1894 } | |
| 1895 | |
| 1896 float zoomfactor = 2.0+jormymillis*0.0001; | |
| 1897 if (zoomfactor > 4.0) zoomfactor = 4.0; | |
| 1898 | |
| 1899 if (startti > 0) recursive_render(bilothree, bilothree->mRootNode, zoomfactor-0.5); | |
| 1900 recursive_render(bilothree, bilothree->mRootNode, zoomfactor); | |
| 1901 recursive_render(bilothree, bilothree->mRootNode, 6.0-zoomfactor); | |
| 1902 | |
| 1903 } | |
| 1904 | |
| 1905 | |
| 1906 | |
| 1907 | |
| 1908 void KolmeDeeLogic(float dt) | |
| 1909 { | |
| 1910 kujalla_angle += dt*0.01; | |
| 1911 } | |
| 1912 | |
| 1913 void kapsule_render() | |
| 1914 { | |
| 1915 | |
| 1916 glEnable(GL_BLEND); | |
| 1917 glUseProgram(0); | |
| 1918 glEnable(GL_TEXTURE_2D); | |
| 1919 glShadeModel(GL_SMOOTH); // Enables Smooth Shading | |
| 1920 glEnable(GL_DEPTH_TEST); // Enables Depth Testing | |
| 1921 glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do | |
| 1922 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculation | |
| 1923 | |
| 1924 glEnable(GL_LIGHTING); | |
| 1925 glEnable(GL_LIGHT0); // Uses default lighting parameters | |
| 1926 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); | |
| 1927 glEnable(GL_NORMALIZE); | |
| 1928 | |
| 1929 GLfloat LightAmbient[]= { 0.5f, 0.5f, 0.5f, 1.0f }; | |
| 1930 GLfloat LightDiffuse[]= { 1.0f, 1.0f, 1.0f, 1.0f }; | |
| 1931 GLfloat LightPosition[]= { 0.0f, 0.0f, 15.0f, 1.0f }; | |
| 1932 | |
| 1933 glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); | |
| 1934 glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); | |
| 1935 glLightfv(GL_LIGHT1, GL_POSITION, LightPosition); | |
| 1936 glEnable(GL_LIGHT1); | |
| 1937 | |
| 1938 glLoadIdentity(); | |
| 1939 | |
| 1940 glTranslatef(0.0f, 0.0f, -50.0f+cos(millis*0.05)*25); // Move 40 Units And Into The Screen | |
| 1941 glRotatef(millis*0.01,1.0,0,0); | |
| 1942 glRotatef(millis*0.008,0.0,0.0,1.0); | |
| 1943 glRotatef(millis*0.006,0.0,1.0,0.0); | |
| 1944 | |
| 1945 recursive_render(kapsule, kapsule->mRootNode, 2.5); | |
| 1946 glDisable(GL_DEPTH_TEST); | |
| 1947 glDisable(GL_LIGHTING); | |
| 1948 glDisable(GL_NORMALIZE); | |
| 1949 } | |
| 1950 | |
| 1951 float brimillis = 0.0; | |
| 1952 float bristart = 0.0; | |
| 1953 float brixrot = 0.0; | |
| 1954 float briyrot = 0.0; | |
| 1955 | |
| 1956 void brieflycase_render() | |
| 1957 { | |
| 1958 if (bristart == 0) {bristart = millis;} | |
| 1959 brimillis = millis-bristart; | |
| 1960 | |
| 1961 glEnable(GL_BLEND); | |
| 1962 glUseProgram(0); | |
| 1963 glEnable(GL_TEXTURE_2D); | |
| 1964 glShadeModel(GL_SMOOTH); // Enables Smooth Shading | |
| 1965 glEnable(GL_DEPTH_TEST); // Enables Depth Testing | |
| 1966 glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do | |
| 1967 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculation | |
| 1968 | |
| 1969 glEnable(GL_LIGHTING); | |
| 1970 glEnable(GL_LIGHT0); // Uses default lighting parameters | |
| 1971 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); | |
| 1972 glEnable(GL_NORMALIZE); | |
| 1973 | |
| 1974 float brifade = 1.0f; | |
| 1975 | |
| 1976 if (brimillis <= 1000) { | |
| 1977 brifade = brimillis*0.001; | |
| 1978 if (brifade > 1.0f) brifade = 1.0f; | |
| 1979 } | |
| 1980 GLfloat LightAmbient[]= { 0.5f*brifade, 0.5f*brifade, 0.5f*brifade, 1.0f*brifade }; | |
| 1981 GLfloat LightDiffuse[]= { 1.0f*brifade, 1.0f*brifade, 1.0f*brifade, 1.0f*brifade }; | |
| 1982 GLfloat LightPosition[]= { 0.0f, 0.0f, 15.0f*brifade, 1.0f*brifade }; | |
| 1983 | |
| 1984 glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); | |
| 1985 glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); | |
| 1986 glLightfv(GL_LIGHT1, GL_POSITION, LightPosition); | |
| 1987 glEnable(GL_LIGHT1); | |
| 1988 | |
| 1989 glLoadIdentity(); | |
| 1990 | |
| 1991 //nosto | |
| 1992 if (brimillis > 1000 && brimillis < 3000) | |
| 1993 { | |
| 1994 briyrot=(brimillis-1000)*0.047*(1.0-(cos(brimillis*0.001))); | |
| 1995 if (briyrot > 90.0f) briyrot = 90.0f; | |
| 1996 } | |
| 1997 | |
| 1998 if (brimillis > 5000) | |
| 1999 { | |
| 2000 brixrot=(brimillis-5000)*0.047*2* 1.0-(cos((brimillis-4000)*0.0001)); | |
| 2001 // if (brixrot > 180.0f) brixrot = 180.0f; | |
| 2002 } | |
| 2003 | |
| 2004 glTranslatef(0.0f, 0.0f, -50.0f+brixrot*0.2); // Move 40 Units And Into The Screen | |
| 2005 //glRotatef(millis*0.001,1.0,0,0); | |
| 2006 glRotatef(-briyrot,1.0,0.0,0.0); | |
| 2007 glRotatef(brixrot,0.0,0.0,1.0); | |
| 2008 | |
| 2009 recursive_render(brieflycase, brieflycase->mRootNode, 2.5); | |
| 2010 glDisable(GL_DEPTH_TEST); | |
| 2011 glDisable(GL_LIGHTING); | |
| 2012 glDisable(GL_NORMALIZE); | |
| 2013 } | |
| 2014 | |
| 2015 | |
| 2016 void | |
| 2017 on_key_press ( unsigned char key) | |
| 2018 { | |
| 2019 if (key == 1) | |
| 2020 { | |
| 2021 console_process( console, "home", 0 ); | |
| 2022 } | |
| 2023 else if (key == 4) | |
| 2024 { | |
| 2025 console_process( console, "delete", 0 ); | |
| 2026 } | |
| 2027 else if (key == 5) | |
| 2028 { | |
| 2029 console_process( console, "end", 0 ); | |
| 2030 } | |
| 2031 else if (key == 8) | |
| 2032 { | |
| 2033 console_process( console, "backspace", 0 ); | |
| 2034 } | |
| 2035 else if (key == 9) | |
| 2036 { | |
| 2037 console_process( console, "complete", 0 ); | |
| 2038 } | |
| 2039 else if (key == 11) | |
| 2040 { | |
| 2041 console_process( console, "kill", 0 ); | |
| 2042 } | |
| 2043 else if (key == 12) | |
| 2044 { | |
| 2045 console_process( console, "clear", 0 ); | |
| 2046 } | |
| 2047 else if (key == 13) | |
| 2048 { | |
| 2049 console_process( console, "enter", 0 ); | |
| 2050 } | |
| 2051 else if (key == 25) | |
| 2052 { | |
| 2053 console_process( console, "yank", 0 ); | |
| 2054 } | |
| 2055 else if (key == 27) | |
| 2056 { | |
| 2057 console_process( console, "escape", 0 ); | |
| 2058 } | |
| 2059 else if (key == 127) | |
| 2060 { | |
| 2061 console_process( console, "backspace", 0 ); | |
| 2062 } | |
| 2063 else if( key > 31) | |
| 2064 { | |
| 2065 console_process( console, "type", key ); | |
| 2066 } | |
| 2067 } | |
| 2068 | |
| 2069 /*void LoaderLogic(float dt) | |
| 2070 { | |
| 2071 printf("DEBUG: LoaderLogic(%f)\n", dt); | |
| 2072 }*/ | |
| 2073 | |
| 2074 int keyindex = 0; | |
| 2075 int nextmillis = 0; | |
| 2076 void ConsoleLogic(float dt) | |
| 2077 { | |
| 2078 // int kmillis = (int)(millis-15750); | |
| 2079 int kmillis = (int)(millis-scene_start_millis); | |
| 2080 | |
| 2081 //printf("kmillis:%d\n",kmillis); | |
| 2082 if (kmillis >= 0 && kmillis >= keymillis[keyindex]) | |
| 2083 { | |
| 2084 if(keyindex >= 0 && keyindex < KEYEVENTS_COUNT) | |
| 2085 { | |
| 2086 on_key_press(keyrec[keyindex]); | |
| 2087 } | |
| 2088 | |
| 2089 keyindex++; | |
| 2090 } | |
| 2091 } | |
| 2092 | |
| 2093 int keyindex2 = 0; | |
| 2094 | |
| 2095 void ConsoleLogic2(float dt) | |
| 2096 { | |
| 2097 int kmillis = -2000+(int)((millis-scene_start_millis)*1.3); | |
| 2098 | |
| 2099 //printf("kmillis:%d\n",kmillis); | |
| 2100 if (kmillis >= 0 && kmillis >= keymillis2[keyindex2]) | |
| 2101 { | |
| 2102 if(keyindex2 >= 0 && keyindex2 < KEYEVENTS_COUNT2) | |
| 2103 { | |
| 2104 on_key_press(keyrec2[keyindex2]); | |
| 2105 } | |
| 2106 | |
| 2107 keyindex2++; | |
| 2108 } | |
| 2109 } | |
| 2110 | |
| 2111 int kolmedeeindex = 0; | |
| 2112 | |
| 2113 const aiScene* Import3DFromFile(const std::string& pFile) | |
| 2114 { | |
| 2115 fprintf(stdout," - Import3DFromFile(\"%s\")", pFile.c_str()); | |
| 2116 | |
| 2117 //check if file exists | |
| 2118 std::ifstream fin(pFile.c_str()); | |
| 2119 if(!fin.fail()) | |
| 2120 { | |
| 2121 fin.close(); | |
| 2122 } | |
| 2123 else | |
| 2124 { | |
| 2125 printf(" could not open file %s\n", pFile.c_str()); | |
| 2126 exit(1); | |
| 2127 } | |
| 2128 | |
| 2129 const aiScene* scener = importer[kolmedeeindex].ReadFile( pFile, aiProcessPreset_TargetRealtime_Quality); | |
| 2130 | |
| 2131 // If the import failed, report it | |
| 2132 if( !scener) | |
| 2133 { | |
| 2134 printf(" import failed %s\n", pFile.c_str()); | |
| 2135 exit(1); | |
| 2136 } | |
| 2137 | |
| 2138 kolmedeeindex++; | |
| 2139 | |
| 2140 fprintf(stdout," success\n"); | |
| 2141 | |
| 2142 // We're done. Everything will be cleaned up by the importer destructor | |
| 2143 return scener; | |
| 2144 } | |
| 2145 | |
| 2146 int shader_index = 1; // 1 not 0 because console shader is loaded separately | |
| 2147 bool LoadShaders() | |
| 2148 { | |
| 2149 if(shader_index == sizeof(shaders) / sizeof(shaders[0])) return false; | |
| 2150 shaders[shader_index] = LoadShader(shaderss[shader_index]); | |
| 2151 shader_index++; | |
| 2152 | |
| 2153 return true; | |
| 2154 } | |
| 2155 int texture_index = 0; | |
| 2156 bool LoadTextures() | |
| 2157 { | |
| 2158 if(texture_index == sizeof(textures) / sizeof(textures[0])) return false; | |
| 2159 textures[texture_index] = LoadTexture(texturess[texture_index]); | |
| 2160 texture_index++; | |
| 2161 | |
| 2162 return true; | |
| 2163 } | |
| 2164 int assets_3dmodel_total = 1; | |
| 2165 bool Load3DAssets() | |
| 2166 { | |
| 2167 kapsule = Import3DFromFile("data/models/kapsule.obj"); | |
| 2168 LoadGLTextures(kapsule); | |
| 2169 | |
| 2170 return true; | |
| 2171 } | |
| 2172 | |
| 2173 bool assets_loaded = false; | |
| 2174 int skip_frames = 10; | |
| 2175 int skip_frames_count = 0; | |
| 2176 clock_t t_loader_begin = 0, t_loader_d; | |
| 2177 int assets_index = -1, assets_total = -1; | |
| 2178 int loader_phase = -1; | |
| 2179 float loading_time = 0; | |
| 2180 void Loader() | |
| 2181 { | |
| 2182 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); } | |
| 2183 if(assets_total == -1) { | |
| 2184 printf("ERROR: Loader(): No assets to load and/or something is just terribly wrong! Terminating...\n"); | |
| 2185 exit(1); | |
| 2186 } | |
| 2187 | |
| 2188 float phase = (float)((float)(assets_index) / (float)(assets_total)); | |
| 2189 const aiScene* loaderscene = bilothorn; | |
| 2190 | |
| 2191 //glClearColor (phase,phase,phase,1.0); | |
| 2192 glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
| 2193 | |
| 2194 float mymillis = phase*1750; | |
| 2195 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); // default | |
| 2196 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
| 2197 | |
| 2198 glUseProgram(0); | |
| 2199 | |
| 2200 glDisable(GL_TEXTURE_2D); | |
| 2201 glEnable(GL_BLEND); | |
| 2202 glBlendFunc(GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR); | |
| 2203 | |
| 2204 glShadeModel(GL_SMOOTH); // Enables Smooth Shading | |
| 2205 //glClearColor(1.0f-phase,1.0f-phase,1.0f-phase, 1.0f); | |
| 2206 glClearDepth(1.0f); // Depth Buffer Setup | |
| 2207 glEnable(GL_DEPTH_TEST); // Enables Depth Testing | |
| 2208 glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do | |
| 2209 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculation | |
| 2210 | |
| 2211 glDisable(GL_LIGHTING); | |
| 2212 glEnable(GL_LIGHT0); // Uses default lighting parameters | |
| 2213 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); | |
| 2214 glDisable(GL_NORMALIZE); | |
| 2215 | |
| 2216 float r, g, b, a = 1.0f; | |
| 2217 if(loader_phase < 1) { | |
| 2218 r = g = b = sin(loading_time*100); | |
| 2219 } else { | |
| 2220 r = g = b = a; | |
| 2221 } | |
| 2222 GLfloat LightAmbient[]= { r, g, b, a }; | |
| 2223 GLfloat LightDiffuse[]= { r, g, b, a }; | |
| 2224 GLfloat LightPosition[]= { 0.0f, 0.0f, 15.0f, 1.0f}; | |
| 2225 //GLfloat LightAmbient[]= { 0.0f, 1.0f-phase, 0.0f, 1.0f }; | |
| 2226 // GLfloat LightDiffuse[]= { 0.0f, 1.0f-phase, 0.0f, 1.0f }; | |
| 2227 // GLfloat LightPosition[]= { 0.0f, 0.0f, 15.0f, 1.0f }; | |
| 2228 | |
| 2229 glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); | |
| 2230 glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); | |
| 2231 glLightfv(GL_LIGHT1, GL_POSITION, LightPosition); | |
| 2232 glEnable(GL_LIGHT1); | |
| 2233 | |
| 2234 float zoom = -50.0f+((mymillis)*0.05*0.2)*((phase+0.5f)*(phase+0.5f)*(phase+0.5f)); | |
| 2235 | |
| 2236 if (zoom > -0.5 && startti == 0) { startti = mymillis; } | |
| 2237 if (zoom >= -0.5) { zoom = -0.5; jormymillis=(mymillis-startti); } | |
| 2238 | |
| 2239 | |
| 2240 if (jormymillis > 0) { | |
| 2241 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
| 2242 } | |
| 2243 | |
| 2244 glLoadIdentity(); | |
| 2245 | |
| 2246 glRotatef(180.0f*phase*0.974,0.0,0.0,1.0); | |
| 2247 glTranslatef(0.0f, 0.0f, zoom); | |
| 2248 /*if (jormymillis > 0) { | |
| 2249 glRotatef(jormymillis*0.0026,-1.0,0.0,0.0); | |
| 2250 }*/ | |
| 2251 | |
| 2252 skip_frames_count++; | |
| 2253 if(skip_frames_count == skip_frames) { | |
| 2254 skip_frames_count = 0; | |
| 2255 assets_index++; | |
| 2256 printf("--- MIDISYS-ENGINE: Loading asset #%i", assets_index); | |
| 2257 | |
| 2258 // begin loading animation | |
| 2259 | |
| 2260 if(loader_phase == -1) { | |
| 2261 loader_phase = 0; | |
| 2262 } else if(loader_phase == 0) { | |
| 2263 if(!LoadShaders()) { | |
| 2264 loader_phase = 1; | |
| 2265 } else { | |
| 2266 } | |
| 2267 } else if(loader_phase == 1) { | |
| 2268 if(!LoadTextures()) { | |
| 2269 loader_phase = 2; | |
| 2270 } else { | |
| 2271 } | |
| 2272 } else if(loader_phase == 2) { | |
| 2273 printf("..%i", assets_total); | |
| 2274 // load all 3d models; after that all asset loading is done | |
| 2275 Load3DAssets(); | |
| 2276 loader_phase = 3; | |
| 2277 } else { | |
| 2278 assets_loaded = true; | |
| 2279 } | |
| 2280 } else { | |
| 2281 // format bilotrip terminal 1.6.2.0 | |
| 2282 | |
| 2283 /*if(phase > 0.975f) { | |
| 2284 phase = 1.0f-phase; | |
| 2285 }*/ | |
| 2286 glClearColor ((1.0f-phase)*0.86,(1.0f-phase)*0.86,(1.0f-phase)*0.86,1.0); | |
| 2287 glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
| 2288 glFlush(); | |
| 2289 glutSwapBuffers(); | |
| 2290 } | |
| 2291 | |
| 2292 //printf("n:%i\n",(int)((float)((float)(assets_index) / (float)(assets_total)) * 3.0f)); | |
| 2293 /*glBegin(GL_TRIANGLES); | |
| 2294 glVertex3f(-25.0f,-25.0f,-50.0f); | |
| 2295 glVertex3f(-25.0f,25.0f,-50.0f); | |
| 2296 glVertex3f(25.0f,25.0f,-50.0f); | |
| 2297 glEnd();*/ | |
| 2298 //glTranslatef(0.0,floor(phase+0.25f),0.0); | |
| 2299 for(int n = 0; n < (int)(phase*6.9f); n++) { | |
| 2300 if(n<3) { | |
| 2301 int t = floor(n/3); | |
| 2302 float tf = (float)(t)*120.0f; | |
| 2303 if(n!=0&&n%3==0) glTranslatef(0.0,0.0,tf); | |
| 2304 glRotatef(120.0f,0.0,0.0,((float)(n)*phase)); | |
| 2305 recursive_render(loaderscene, loaderscene->mRootNode, 2.0+jormymillis*0.001); | |
| 2306 } | |
| 2307 //if (jormymillis > 0)recursive_render(loaderscene, loaderscene->mRootNode, 4.0-jormymillis*0.001); | |
| 2308 } | |
| 2309 | |
| 2310 | |
| 2311 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
| 2312 glDisable(GL_BLEND); | |
| 2313 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
| 2314 | |
| 2315 | |
| 2316 glUseProgram(shaders[hex]); | |
| 2317 float widthLoc5 = glGetUniformLocation(shaders[hex], "width"); | |
| 2318 float heightLoc5 = glGetUniformLocation(shaders[hex], "height"); | |
| 2319 float timeLoc5 = glGetUniformLocation(shaders[hex], "time"); | |
| 2320 float effuLoc5 = glGetUniformLocation(shaders[hex], "effu"); | |
| 2321 | |
| 2322 glUniform1f(widthLoc5, g_Width); | |
| 2323 glUniform1f(heightLoc5, g_Height); | |
| 2324 glUniform1f(timeLoc5, mymillis/100); | |
| 2325 glUniform1f(effuLoc5, jormymillis > 0 ? 1.0 : 0.0); | |
| 2326 | |
| 2327 glActiveTexture(GL_TEXTURE0); | |
| 2328 glBindTexture(GL_TEXTURE_2D, fb_tex); | |
| 2329 | |
| 2330 float location5 = glGetUniformLocation(shaders[hex], "texture0"); | |
| 2331 glUniform1i(location5, 0); | |
| 2332 | |
| 2333 glLoadIdentity(); | |
| 2334 | |
| 2335 glTranslatef(-1.2, -1.0, -1.0); | |
| 2336 //glTranslatef(0.0, 0.0, -1.0); | |
| 2337 | |
| 2338 int i=0; | |
| 2339 int j=0; | |
| 2340 glBegin(GL_QUADS); | |
| 2341 glVertex2f(i, j); | |
| 2342 glVertex2f(i + 100, j); | |
| 2343 glVertex2f(i + 100, j + 100); | |
| 2344 glVertex2f(i, j + 100); | |
| 2345 glEnd(); | |
| 2346 | |
| 2347 glFlush(); | |
| 2348 glutSwapBuffers(); | |
| 2349 | |
| 2350 glDisable(GL_DEPTH_TEST); // Enables Depth Testing | |
| 2351 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); // default | |
| 2352 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); | |
| 2353 glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do | |
| 2354 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculation | |
| 2355 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // default | |
| 2356 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); | |
| 2357 | |
| 2358 if (quitflag == 0) glutPostRedisplay(); | |
| 2359 } | |
| 2360 | |
| 2361 int vieterframe = 0; | |
| 2362 float vieterstart = 0; | |
| 2363 | |
| 2364 void LeadMaskScene() | |
| 2365 { | |
| 2366 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); // fbo | |
| 2367 glClear(GL_DEPTH_BUFFER_BIT); | |
| 2368 float mymillis = millis; | |
| 2369 glUseProgram(shaders[projector]); | |
| 2370 | |
| 2371 int kuvaflag = 0; | |
| 2372 | |
| 2373 if (millis >= 0 && millis < 25000) { | |
| 2374 kuvaflag = 0; | |
| 2375 } | |
| 2376 else if (millis >= 25000 && millis < 37000) { | |
| 2377 kuvaflag = 1; | |
| 2378 } | |
| 2379 else if (millis >= 37000 && millis < 48500) { | |
| 2380 kuvaflag = 2; | |
| 2381 } | |
| 2382 else if (millis >= 48500 && millis < 64000) { | |
| 2383 kuvaflag = 3; | |
| 2384 } | |
| 2385 else if (millis >= 64000 && millis < 76100) { | |
| 2386 kuvaflag = 4; | |
| 2387 } | |
| 2388 else if (millis >= 76100 && millis < 84000) { | |
| 2389 kuvaflag = 5; | |
| 2390 } | |
| 2391 else if (millis >= 84000) { | |
| 2392 kuvaflag = 6; | |
| 2393 if (vieterstart == 0) vieterstart = mymillis; | |
| 2394 vieterframe = (int)((mymillis-vieterstart)*0.004); | |
| 2395 if (vieterframe > 12) { vieterframe = 0; vieterstart = 0; } | |
| 2396 } | |
| 2397 | |
| 2398 glEnable(GL_BLEND); | |
| 2399 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); | |
| 2400 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA); | |
| 2401 | |
| 2402 GLint widthLoc5 = glGetUniformLocation(shaders[projector], "width"); | |
| 2403 GLint heightLoc5 = glGetUniformLocation(shaders[projector], "height"); | |
| 2404 GLint timeLoc5 = glGetUniformLocation(shaders[projector], "time"); | |
| 2405 GLint alphaLoc5 = glGetUniformLocation(shaders[projector], "alpha"); | |
| 2406 | |
| 2407 glUniform1f(widthLoc5, g_Width); | |
| 2408 glUniform1f(heightLoc5, g_Height); | |
| 2409 glUniform1f(timeLoc5, mymillis - (millis < 64000 ? 0 : 50000)); | |
| 2410 glUniform1f(alphaLoc5, mymillis*0.0001+0.2-cos(mymillis*0.0005)*0.15); | |
| 2411 | |
| 2412 glActiveTexture(GL_TEXTURE0); | |
| 2413 if (kuvaflag == 0) | |
| 2414 glBindTexture(GL_TEXTURE_2D, textures[tex_scene]); | |
| 2415 else if (kuvaflag == 1) | |
| 2416 glBindTexture(GL_TEXTURE_2D, textures[tex_dude]); | |
| 2417 else if (kuvaflag == 2) | |
| 2418 glBindTexture(GL_TEXTURE_2D, textures[tex_dude2]); | |
| 2419 else if (kuvaflag == 3) | |
| 2420 glBindTexture(GL_TEXTURE_2D, textures[tex_mask]); | |
| 2421 else if (kuvaflag == 4) | |
| 2422 glBindTexture(GL_TEXTURE_2D, textures[tex_note]); | |
| 2423 else if (kuvaflag == 5) | |
| 2424 glBindTexture(GL_TEXTURE_2D, textures[tex_exit]); | |
| 2425 else if (kuvaflag == 6) | |
| 2426 glBindTexture(GL_TEXTURE_2D, textures[tex_v0+vieterframe]); | |
| 2427 | |
| 2428 GLint location5 = glGetUniformLocation(shaders[projector], "texture0"); | |
| 2429 glUniform1i(location5, 0); | |
| 2430 | |
| 2431 glLoadIdentity(); | |
| 2432 glTranslatef(-1.2, -1.0, -1.0); | |
| 2433 | |
| 2434 glBegin(GL_QUADS); | |
| 2435 | |
| 2436 int i,j; | |
| 2437 | |
| 2438 for (i = -50; i < 50; i+=10) | |
| 2439 for (j = -50; j < 50; j+=10) | |
| 2440 { | |
| 2441 glVertex2f(i, j); | |
| 2442 glVertex2f(i + 1, j); | |
| 2443 glVertex2f(i + 1, j + 1); | |
| 2444 glVertex2f(i, j + 1); | |
| 2445 } | |
| 2446 glEnd(); | |
| 2447 | |
| 2448 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb2); // default | |
| 2449 | |
| 2450 glUseProgram(shaders[fsquad]); | |
| 2451 | |
| 2452 glEnable(GL_BLEND); | |
| 2453 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); | |
| 2454 glBlendFunc(GL_ONE_MINUS_SRC_COLOR, GL_ONE_MINUS_DST_COLOR); | |
| 2455 | |
| 2456 GLint widthLoc6 = glGetUniformLocation(shaders[fsquad], "width"); | |
| 2457 GLint heightLoc6 = glGetUniformLocation(shaders[fsquad], "height"); | |
| 2458 GLint timeLoc6 = glGetUniformLocation(shaders[fsquad], "time"); | |
| 2459 GLint alphaLoc6 = glGetUniformLocation(shaders[fsquad], "alpha"); | |
| 2460 GLint gammaLoc = glGetUniformLocation(shaders[fsquad], "gamma"); | |
| 2461 GLint gridLoc6 = glGetUniformLocation(shaders[fsquad], "grid"); | |
| 2462 GLint alphamodeLoc5 = glGetUniformLocation(shaders[fsquad], "alphamode"); | |
| 2463 glUniform1f(alphamodeLoc5, 0.0f); | |
| 2464 | |
| 2465 glUniform1f(gridLoc6, 0.001+cos(mymillis)*0.0005); | |
| 2466 | |
| 2467 | |
| 2468 glUniform1f(widthLoc6, g_Width); | |
| 2469 glUniform1f(heightLoc6, g_Height); | |
| 2470 glUniform1f(timeLoc6, mymillis/100); | |
| 2471 glUniform1f(alphaLoc6, 0.1+abs(cos(mymillis*0.08)*0.05)); | |
| 2472 glUniform1f(gammaLoc, 0.0f); | |
| 2473 | |
| 2474 glActiveTexture(GL_TEXTURE0); | |
| 2475 glBindTexture(GL_TEXTURE_2D, fb_tex); | |
| 2476 | |
| 2477 GLint location6 = glGetUniformLocation(shaders[fsquad], "texture0"); | |
| 2478 glUniform1i(location6, 0); | |
| 2479 | |
| 2480 glLoadIdentity(); | |
| 2481 | |
| 2482 glTranslatef(-1.2, -1.0, -1.0); | |
| 2483 | |
| 2484 i=0; | |
| 2485 j=0; | |
| 2486 glBegin(GL_QUADS); | |
| 2487 glVertex2f(i, j); | |
| 2488 glVertex2f(i + 100, j); | |
| 2489 glVertex2f(i + 100, j + 100); | |
| 2490 glVertex2f(i, j + 100); | |
| 2491 glEnd(); | |
| 2492 | |
| 2493 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
| 2494 | |
| 2495 glUseProgram(shaders[fsquad]); | |
| 2496 | |
| 2497 glDisable(GL_BLEND); | |
| 2498 | |
| 2499 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
| 2500 | |
| 2501 GLint widthLoc7 = glGetUniformLocation(shaders[fsquad], "width"); | |
| 2502 GLint heightLoc7 = glGetUniformLocation(shaders[fsquad], "height"); | |
| 2503 GLint timeLoc7 = glGetUniformLocation(shaders[fsquad], "time"); | |
| 2504 GLint alphaLoc7 = glGetUniformLocation(shaders[fsquad], "alpha"); | |
| 2505 GLint gammaLoc2 = glGetUniformLocation(shaders[fsquad], "gamma"); | |
| 2506 GLint gridLoc = glGetUniformLocation(shaders[fsquad], "grid"); | |
| 2507 GLint alphamodeLoc7 = glGetUniformLocation(shaders[fsquad], "alphamode"); | |
| 2508 glUniform1f(alphamodeLoc7, 0.0f); | |
| 2509 | |
| 2510 glUniform1f(widthLoc7, g_Width); | |
| 2511 glUniform1f(heightLoc7, g_Height); | |
| 2512 glUniform1f(timeLoc7, mymillis/100); | |
| 2513 glUniform1f(alphaLoc7, 1.0); | |
| 2514 glUniform1f(gammaLoc2, 4.0f); | |
| 2515 glUniform1f(gridLoc, 1.0f+tan(mymillis*10)*0.3); | |
| 2516 | |
| 2517 glActiveTexture(GL_TEXTURE0); | |
| 2518 glBindTexture(GL_TEXTURE_2D, fb_tex2); | |
| 2519 | |
| 2520 GLint location7 = glGetUniformLocation(shaders[fsquad], "texture0"); | |
| 2521 glUniform1i(location7, 0); | |
| 2522 | |
| 2523 glLoadIdentity(); | |
| 2524 | |
| 2525 glTranslatef(-1.2, -1.0, -1.0); | |
| 2526 | |
| 2527 i=0; | |
| 2528 j=0; | |
| 2529 glBegin(GL_QUADS); | |
| 2530 glVertex2f(i, j); | |
| 2531 glVertex2f(i + 100, j); | |
| 2532 glVertex2f(i + 100, j + 100); | |
| 2533 glVertex2f(i, j + 100); | |
| 2534 glEnd(); | |
| 2535 | |
| 2536 glUseProgram(shaders[projector]); | |
| 2537 | |
| 2538 glEnable(GL_BLEND); | |
| 2539 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD); | |
| 2540 glBlendFunc(GL_SRC_COLOR, GL_DST_ALPHA); | |
| 2541 | |
| 2542 widthLoc5 = glGetUniformLocation(shaders[projector], "width"); | |
| 2543 heightLoc5 = glGetUniformLocation(shaders[projector], "height"); | |
| 2544 timeLoc5 = glGetUniformLocation(shaders[projector], "time"); | |
| 2545 alphaLoc5 = glGetUniformLocation(shaders[projector], "alpha"); | |
| 2546 | |
| 2547 glUniform1f(widthLoc5, g_Width); | |
| 2548 glUniform1f(heightLoc5, g_Height); | |
| 2549 glUniform1f(timeLoc5, mymillis); | |
| 2550 glUniform1f(alphaLoc5, 1.0); | |
| 2551 | |
| 2552 glActiveTexture(GL_TEXTURE0); | |
| 2553 glBindTexture(GL_TEXTURE_2D, textures[tex_scene]); | |
| 2554 | |
| 2555 location5 = glGetUniformLocation(shaders[projector], "texture0"); | |
| 2556 glUniform1i(location5, 0); | |
| 2557 | |
| 2558 glLoadIdentity(); | |
| 2559 glTranslatef(-1.2, -1.0, -1.0); | |
| 2560 | |
| 2561 glBegin(GL_QUADS); | |
| 2562 | |
| 2563 | |
| 2564 for (i = -50; i < 50; i+=10) | |
| 2565 for (j = -50; j < 50; j+=10) | |
| 2566 { | |
| 2567 glVertex2f(i, j); | |
| 2568 glVertex2f(i + 1, j); | |
| 2569 glVertex2f(i + 1, j + 1); | |
| 2570 glVertex2f(i, j + 1); | |
| 2571 } | |
| 2572 glEnd(); | |
| 2573 | |
| 2574 | |
| 2575 if (millis > 37400 && millis < 37600) kapsule_render(); | |
| 2576 | |
| 2577 | |
| 2578 } | |
| 2579 | |
| 2580 int copbeatcounter = -1; | |
| 2581 int coptexid = 0; | |
| 2582 void CopScene() | |
| 2583 { | |
| 2584 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
| 2585 | |
| 2586 float mymillis = (millis-scene_start_millis); | |
| 2587 glUseProgram(shaders[copquad]); | |
| 2588 | |
| 2589 glEnable(GL_BLEND); | |
| 2590 | |
| 2591 | |
| 2592 float joo = cos(mymillis); | |
| 2593 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, joo < 0.5 ? GL_MODULATE : GL_SUBTRACT ); | |
| 2594 glBlendFunc(GL_SRC_COLOR, joo < 0.5 ? GL_DST_ALPHA : GL_ONE_MINUS_DST_COLOR); | |
| 2595 | |
| 2596 GLint widthLoc5 = glGetUniformLocation(shaders[copquad], "width"); | |
| 2597 GLint heightLoc5 = glGetUniformLocation(shaders[copquad], "height"); | |
| 2598 GLint timeLoc5 = glGetUniformLocation(shaders[copquad], "time"); | |
| 2599 GLint alphaLoc5 = glGetUniformLocation(shaders[copquad], "alpha"); | |
| 2600 GLint gridLoc6 = glGetUniformLocation(shaders[copquad], "grid"); | |
| 2601 glUniform1f(gridLoc6, tan(mymillis)); | |
| 2602 | |
| 2603 glUniform1f(widthLoc5, g_Width); | |
| 2604 glUniform1f(heightLoc5, g_Height); | |
| 2605 glUniform1f(timeLoc5, mymillis/100); | |
| 2606 glUniform1f(alphaLoc5, cos(mymillis*0.1)*0.01); | |
| 2607 | |
| 2608 if (scene_shader_params[2] == 36) { copbeatcounter++; } | |
| 2609 if (copbeatcounter > 0) { coptexid++; copbeatcounter = 0;} | |
| 2610 | |
| 2611 //int texind = (int)(mymillis*(0.001/2)); | |
| 2612 int texind = coptexid; | |
| 2613 if (texind > 30) texind = 30; | |
| 2614 | |
| 2615 glActiveTexture(GL_TEXTURE0); | |
| 2616 glBindTexture(GL_TEXTURE_2D, textures[tex_copkiller + texind]); | |
| 2617 | |
| 2618 glActiveTexture(GL_TEXTURE1); | |
| 2619 glBindTexture(GL_TEXTURE_2D, textures[texind == tex_copkiller ? tex_copkiller+17 : | |
| 2620 tex_copkiller + (abs(texind-1))]); | |
| 2621 | |
| 2622 GLint location5 = glGetUniformLocation(shaders[copquad], "texture0"); | |
| 2623 glUniform1i(location5, 0); | |
| 2624 | |
| 2625 GLint location6 = glGetUniformLocation(shaders[copquad], "texture1"); | |
| 2626 glUniform1i(location6, 1); | |
| 2627 | |
| 2628 glLoadIdentity(); | |
| 2629 | |
| 2630 glTranslatef(-1.2, -1.0, -1.0); | |
| 2631 | |
| 2632 int i=0; | |
| 2633 int j=0; | |
| 2634 glBegin(GL_QUADS); | |
| 2635 glVertex2f(i, j); | |
| 2636 glVertex2f(i + 100, j); | |
| 2637 glVertex2f(i + 100, j + 100); | |
| 2638 glVertex2f(i, j + 100); | |
| 2639 glEnd(); | |
| 2640 | |
| 2641 } | |
| 2642 | |
| 2643 static int video_started = 0; | |
| 2644 | |
| 2645 void MarssiScene() | |
| 2646 { | |
| 2647 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
| 2648 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); | |
| 2649 glDisable(GL_BLEND); | |
| 2650 | |
| 2651 if (video_started == 0) | |
| 2652 { | |
| 2653 myVideoFrame->play(); | |
| 2654 video_started = 1; | |
| 2655 } | |
| 2656 | |
| 2657 myVideoFrame->render(); | |
| 2658 } | |
| 2659 | |
| 2660 void LongScene() | |
| 2661 { | |
| 2662 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
| 2663 glDisable(GL_BLEND); | |
| 2664 glClearColor(0,0,0,0); | |
| 2665 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); | |
| 2666 | |
| 2667 glUseProgram(shaders[fsquad]); | |
| 2668 float mymillis = (((millis)-scene_start_millis)); | |
| 2669 | |
| 2670 GLint widthLoc5 = glGetUniformLocation(shaders[fsquad], "width"); | |
| 2671 GLint heightLoc5 = glGetUniformLocation(shaders[fsquad], "height"); | |
| 2672 GLint timeLoc5 = glGetUniformLocation(shaders[fsquad], "time"); | |
| 2673 GLint alphaLoc5 = glGetUniformLocation(shaders[fsquad], "alpha"); | |
| 2674 GLint gammaLoc = glGetUniformLocation(shaders[fsquad], "gamma"); | |
| 2675 GLint gridLoc6 = glGetUniformLocation(shaders[fsquad], "grid"); | |
| 2676 glUniform1f(gridLoc6, 0.0f); | |
| 2677 glUniform1f(gammaLoc, 0.0f); | |
| 2678 GLint alphamodeLoc5 = glGetUniformLocation(shaders[fsquad], "alphamode"); | |
| 2679 glUniform1f(alphamodeLoc5, 0.0f); | |
| 2680 | |
| 2681 glUniform1f(widthLoc5, g_Width); | |
| 2682 glUniform1f(heightLoc5, g_Height); | |
| 2683 glUniform1f(timeLoc5, mymillis/100); | |
| 2684 glUniform1f(alphaLoc5, 0.0); | |
| 2685 | |
| 2686 glActiveTexture(GL_TEXTURE0); | |
| 2687 glBindTexture(GL_TEXTURE_2D, textures[tex_aegis]); | |
| 2688 | |
| 2689 GLint location5 = glGetUniformLocation(shaders[fsquad], "texture0"); | |
| 2690 glUniform1i(location5, 0); | |
| 2691 | |
| 2692 glLoadIdentity(); | |
| 2693 | |
| 2694 glTranslatef(-1.2, -1.0, -1.0); | |
| 2695 | |
| 2696 int i=0; | |
| 2697 int j=0; | |
| 2698 glBegin(GL_QUADS); | |
| 2699 glVertex2f(i, j); | |
| 2700 glVertex2f(i + 100, j); | |
| 2701 glVertex2f(i + 100, j + 100); | |
| 2702 glVertex2f(i, j + 100); | |
| 2703 glEnd(); | |
| 2704 | |
| 2705 // | |
| 2706 if (mymillis > 2500) { | |
| 2707 int plussati = 0; | |
| 2708 if (mymillis > 2800)plussati=400; | |
| 2709 glEnable(GL_BLEND); | |
| 2710 glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); | |
| 2711 int lloff = (int)(((plussati+mymillis)-2500)*0.0025); | |
| 2712 if (lloff >= 4) lloff = 4; | |
| 2713 widthLoc5 = glGetUniformLocation(shaders[fsquad], "width"); | |
| 2714 heightLoc5 = glGetUniformLocation(shaders[fsquad], "height"); | |
| 2715 timeLoc5 = glGetUniformLocation(shaders[fsquad], "time"); | |
| 2716 alphaLoc5 = glGetUniformLocation(shaders[fsquad], "alpha"); | |
| 2717 float alphamodeLoc = glGetUniformLocation(shaders[fsquad], "alphamode"); | |
| 2718 | |
| 2719 glUniform1f(widthLoc5, g_Width); | |
| 2720 glUniform1f(heightLoc5, g_Height); | |
| 2721 glUniform1f(timeLoc5, mymillis/100); | |
| 2722 glUniform1f(alphaLoc5, 1.0); | |
| 2723 glUniform1f(alphamodeLoc, 1.0); | |
| 2724 | |
| 2725 glActiveTexture(GL_TEXTURE0); | |
| 2726 glBindTexture(GL_TEXTURE_2D, textures[tex_ll1+lloff]); | |
| 2727 | |
| 2728 GLint location5 = glGetUniformLocation(shaders[fsquad], "texture0"); | |
| 2729 glUniform1i(location5, 0); | |
| 2730 | |
| 2731 glLoadIdentity(); | |
| 2732 | |
| 2733 glTranslatef(-1.2, -1.0, -1.0); | |
| 2734 | |
| 2735 int i=0; | |
| 2736 int j=0; | |
| 2737 glBegin(GL_QUADS); | |
| 2738 glVertex2f(i, j); | |
| 2739 glVertex2f(i + 100, j); | |
| 2740 glVertex2f(i + 100, j + 100); | |
| 2741 glVertex2f(i, j + 100); | |
| 2742 glEnd(); | |
| 2743 | |
| 2744 } | |
| 2745 | |
| 2746 } | |
| 2747 | |
| 2748 int majic_texnum = 0; | |
| 2749 int noclearframes = 0; | |
| 2750 void EyeScene() | |
| 2751 { | |
| 2752 int i, j; | |
| 2753 | |
| 2754 int lisuri = 0; | |
| 2755 | |
| 2756 //printf("millis:%f\n",millis); | |
| 2757 if (millis > 225200) lisuri = 50000+(millis-225200)*0.5; | |
| 2758 if (lisuri > 150000) lisuri = 150000; | |
| 2759 | |
| 2760 float mymillis = (((millis)-scene_start_millis)*100); | |
| 2761 float mymillis2 = (((millis+lisuri)-scene_start_millis)*100); | |
| 2762 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); // fbo | |
| 2763 | |
| 2764 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)); | |
| 2765 | |
| 2766 if ((scene_shader_params[0] == 65 && scene_shader_param_type[0] == 0) || noclearframes > 200) | |
| 2767 { | |
| 2768 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
| 2769 beatmode = -beatmode; | |
| 2770 noclearframes = 0; | |
| 2771 } | |
| 2772 else | |
| 2773 { | |
| 2774 noclearframes++; | |
| 2775 } | |
| 2776 | |
| 2777 // render fbo copy to fbo | |
| 2778 glEnable(GL_BLEND); | |
| 2779 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); | |
| 2780 glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR); | |
| 2781 | |
| 2782 glUseProgram(shaders[eye_post]); | |
| 2783 | |
| 2784 // glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
| 2785 | |
| 2786 GLint widthLoc3 = glGetUniformLocation(shaders[eye_post], "width"); | |
| 2787 GLint heightLoc3 = glGetUniformLocation(shaders[eye_post], "height"); | |
| 2788 GLint timeLoc3 = glGetUniformLocation(shaders[eye_post], "time"); | |
| 2789 | |
| 2790 glUniform1f(widthLoc3, g_Width); | |
| 2791 glUniform1f(heightLoc3, g_Height); | |
| 2792 glUniform1f(timeLoc3, mymillis/100); | |
| 2793 | |
| 2794 glActiveTexture(GL_TEXTURE0); | |
| 2795 glBindTexture(GL_TEXTURE_2D, fb_tex); | |
| 2796 | |
| 2797 GLint location3 = glGetUniformLocation(shaders[eye_post], "texture0"); | |
| 2798 glUniform1i(location3, 0); | |
| 2799 | |
| 2800 glLoadIdentity(); | |
| 2801 | |
| 2802 glRotatef(45,0.0,0.0,1.0f); | |
| 2803 glTranslatef(-1.2, -1.0, 0.0+(tan(mymillis*0.00001)*0.1)*(millis-155520)*0.0001); | |
| 2804 | |
| 2805 i=0; | |
| 2806 j=0; | |
| 2807 glBegin(GL_QUADS); | |
| 2808 glVertex2f(i, j); | |
| 2809 glVertex2f(i + 100, j); | |
| 2810 glVertex2f(i + 100, j + 100); | |
| 2811 glVertex2f(i, j + 100); | |
| 2812 glEnd(); | |
| 2813 | |
| 2814 // render eye | |
| 2815 | |
| 2816 glEnable(GL_BLEND); | |
| 2817 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); | |
| 2818 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA); | |
| 2819 | |
| 2820 glUseProgram(shaders[eye]); | |
| 2821 | |
| 2822 GLfloat waveTime = 1+atan(mymillis*0.0001)*0.1, | |
| 2823 waveWidth = cos(mymillis*0.000001)*1000+atan(mymillis*0.00001)*2.0, | |
| 2824 waveHeight = sin(mymillis*0.0001)*100*atan(mymillis*0.00001)*2.0; | |
| 2825 | |
| 2826 GLint waveTimeLoc = glGetUniformLocation(shaders[eye], "waveTime"); | |
| 2827 GLint waveWidthLoc = glGetUniformLocation(shaders[eye], "waveWidth"); | |
| 2828 GLint waveHeightLoc = glGetUniformLocation(shaders[eye], "waveHeight"); | |
| 2829 | |
| 2830 GLint widthLoc = glGetUniformLocation(shaders[eye], "width"); | |
| 2831 GLint heightLoc = glGetUniformLocation(shaders[eye], "height"); | |
| 2832 | |
| 2833 GLint timeLoc = glGetUniformLocation(shaders[eye], "time"); | |
| 2834 | |
| 2835 glActiveTexture(GL_TEXTURE0); | |
| 2836 glBindTexture(GL_TEXTURE_2D, textures[tex_grayeye]); | |
| 2837 | |
| 2838 GLuint location; | |
| 2839 location = glGetUniformLocation(shaders[eye], "texture0"); | |
| 2840 glUniform1i(location, 0); | |
| 2841 | |
| 2842 glLoadIdentity(); | |
| 2843 | |
| 2844 glTranslatef(0.0, 0.0, -150.0+sin(mymillis*0.0000004)*120); | |
| 2845 glRotatef(-75.0, 1.0, 0.0, 0.0); | |
| 2846 glRotatef(mymillis*0.01, 0.0, 0.0, 1.0); | |
| 2847 | |
| 2848 glUniform1f(waveTimeLoc, waveTime); | |
| 2849 glUniform1f(waveWidthLoc, waveWidth); | |
| 2850 glUniform1f(waveHeightLoc, waveHeight); | |
| 2851 | |
| 2852 glUniform1f(widthLoc, g_Width); | |
| 2853 glUniform1f(heightLoc, g_Height); | |
| 2854 | |
| 2855 glUniform1f(timeLoc, mymillis2/100); | |
| 2856 | |
| 2857 | |
| 2858 int zoom = 0; | |
| 2859 | |
| 2860 for (zoom = 0; zoom < 8; zoom++) | |
| 2861 { | |
| 2862 | |
| 2863 glTranslatef(-0.01, -0.01, -0.1); | |
| 2864 glRotatef((90*zoom+mymillis*0.01)*0.1, 1.0, 0.0, 0.0); | |
| 2865 glRotatef((45*zoom+mymillis*0.01)*0.1, 0.0, 0.0, 1.0); | |
| 2866 glRotatef((25*zoom+mymillis*0.01)*0.1, 0.0, 1.0, 0.0); | |
| 2867 glBegin(GL_QUADS); | |
| 2868 | |
| 2869 for (i = -50; i < 50; i+=10) | |
| 2870 for (j = -50; j < 50; j+=10) | |
| 2871 { | |
| 2872 glVertex2f(i, j); | |
| 2873 glVertex2f(i + 1, j); | |
| 2874 glVertex2f(i + 1, j + 1); | |
| 2875 glVertex2f(i, j + 1); | |
| 2876 } | |
| 2877 glEnd(); | |
| 2878 } | |
| 2879 | |
| 2880 // eye postprocess to screen | |
| 2881 | |
| 2882 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
| 2883 | |
| 2884 glUseProgram(shaders[eye_post]); | |
| 2885 | |
| 2886 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
| 2887 | |
| 2888 glDisable(GL_BLEND); | |
| 2889 | |
| 2890 GLint widthLoc2 = glGetUniformLocation(shaders[eye_post], "width"); | |
| 2891 GLint heightLoc2 = glGetUniformLocation(shaders[eye_post], "height"); | |
| 2892 GLint timeLoc2 = glGetUniformLocation(shaders[eye_post], "time"); | |
| 2893 | |
| 2894 glUniform1f(widthLoc2, g_Width); | |
| 2895 glUniform1f(heightLoc2, g_Height); | |
| 2896 glUniform1f(timeLoc2, mymillis/100); | |
| 2897 | |
| 2898 glActiveTexture(GL_TEXTURE0); | |
| 2899 glBindTexture(GL_TEXTURE_2D, fb_tex); | |
| 2900 | |
| 2901 if (scene_shader_params[0] != -1 && scene_shader_param_type[0] == 0) | |
| 2902 { | |
| 2903 room_texnum = (int)(rand() % 3); | |
| 2904 } | |
| 2905 | |
| 2906 glActiveTexture(GL_TEXTURE1); | |
| 2907 glBindTexture(GL_TEXTURE_2D, textures[tex_room + room_texnum]); | |
| 2908 | |
| 2909 GLint location2 = glGetUniformLocation(shaders[eye_post], "texture0"); | |
| 2910 glUniform1i(location2, 0); | |
| 2911 | |
| 2912 GLint location4 = glGetUniformLocation(shaders[eye_post], "texture1"); | |
| 2913 glUniform1i(location4, 1); | |
| 2914 | |
| 2915 glLoadIdentity(); | |
| 2916 | |
| 2917 glTranslatef(-1.2, -1.0, -1.0); | |
| 2918 | |
| 2919 i=0; | |
| 2920 j=0; | |
| 2921 glBegin(GL_QUADS); | |
| 2922 glVertex2f(i, j); | |
| 2923 glVertex2f(i + 100, j); | |
| 2924 glVertex2f(i + 100, j + 100); | |
| 2925 glVertex2f(i, j + 100); | |
| 2926 glEnd(); | |
| 2927 | |
| 2928 // text overlay | |
| 2929 | |
| 2930 if (beatmode == 1) | |
| 2931 { | |
| 2932 glUseProgram(shaders[fsquad]); | |
| 2933 | |
| 2934 glEnable(GL_BLEND); | |
| 2935 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_SUBTRACT); | |
| 2936 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_DST_COLOR); | |
| 2937 | |
| 2938 GLint widthLoc5 = glGetUniformLocation(shaders[fsquad], "width"); | |
| 2939 GLint heightLoc5 = glGetUniformLocation(shaders[fsquad], "height"); | |
| 2940 GLint timeLoc5 = glGetUniformLocation(shaders[fsquad], "time"); | |
| 2941 GLint alphaLoc5 = glGetUniformLocation(shaders[fsquad], "alpha"); | |
| 2942 GLint alphamodeLoc5 = glGetUniformLocation(shaders[fsquad], "alphamode"); | |
| 2943 glUniform1f(alphamodeLoc5, 0.0f); | |
| 2944 | |
| 2945 glUniform1f(widthLoc5, g_Width); | |
| 2946 glUniform1f(heightLoc5, g_Height); | |
| 2947 glUniform1f(timeLoc5, mymillis/100); | |
| 2948 glUniform1f(alphaLoc5, cos(mymillis*0.1)*0.1); | |
| 2949 | |
| 2950 glActiveTexture(GL_TEXTURE0); | |
| 2951 | |
| 2952 majic_texnum = (int)(rand() % 4); | |
| 2953 | |
| 2954 glBindTexture(GL_TEXTURE_2D, textures[tex_majestic1+majic_texnum]); | |
| 2955 | |
| 2956 GLint location5 = glGetUniformLocation(shaders[fsquad], "texture0"); | |
| 2957 glUniform1i(location5, 0); | |
| 2958 | |
| 2959 glLoadIdentity(); | |
| 2960 | |
| 2961 glTranslatef(-1.2, -1.0, -1.0); | |
| 2962 | |
| 2963 i=0; | |
| 2964 j=0; | |
| 2965 glBegin(GL_QUADS); | |
| 2966 glVertex2f(i, j); | |
| 2967 glVertex2f(i + 100, j); | |
| 2968 glVertex2f(i + 100, j + 100); | |
| 2969 glVertex2f(i, j + 100); | |
| 2970 glEnd(); | |
| 2971 } | |
| 2972 | |
| 2973 } | |
| 2974 | |
| 2975 int redcounter = 1; | |
| 2976 | |
| 2977 void RedCircleScene() | |
| 2978 { | |
| 2979 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // fbo | |
| 2980 | |
| 2981 glUseProgram(shaders[redcircle]); | |
| 2982 float mymillis = (millis-scene_start_millis)*160; | |
| 2983 | |
| 2984 glClearColor(0,0,0,0); | |
| 2985 if (scene_shader_params[2] == 36) { redcounter++; } | |
| 2986 if (redcounter > 4) { redcounter = 0; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); } | |
| 2987 | |
| 2988 glEnable(GL_BLEND); | |
| 2989 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); | |
| 2990 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); | |
| 2991 | |
| 2992 GLint widthLoc2 = glGetUniformLocation(shaders[redcircle], "width"); | |
| 2993 GLint heightLoc2 = glGetUniformLocation(shaders[redcircle], "height"); | |
| 2994 | |
| 2995 glUniform1f(widthLoc2, g_Width); | |
| 2996 glUniform1f(heightLoc2, g_Height); | |
| 2997 | |
| 2998 glActiveTexture(GL_TEXTURE0); | |
| 2999 glBindTexture(GL_TEXTURE_2D, textures[tex_grayeye]); | |
| 3000 | |
| 3001 GLint location2 = glGetUniformLocation(shaders[redcircle], "texture0"); | |
| 3002 glUniform1i(location2, 0); | |
| 3003 | |
| 3004 glLoadIdentity(); | |
| 3005 | |
| 3006 glTranslatef(0.0, 0.0, -90.0-cos(mymillis*0.0000004)*120); | |
| 3007 glRotatef(-75.0, 1.0, 0.0, 0.0); | |
| 3008 glRotatef(mymillis*0.01, 0.0, 0.0, 1.0); | |
| 3009 | |
| 3010 glBegin(GL_QUADS); | |
| 3011 | |
| 3012 int i,j; | |
| 3013 | |
| 3014 for (i = -50; i < 50; i+=10) | |
| 3015 for (j = -50; j < 50; j+=10) | |
| 3016 { | |
| 3017 | |
| 3018 glVertex2f(i, j); | |
| 3019 glVertex2f(i + 1, j); | |
| 3020 glVertex2f(i + 1, j + 1); | |
| 3021 glVertex2f(i, j + 1); | |
| 3022 } | |
| 3023 glEnd(); | |
| 3024 | |
| 3025 } | |
| 3026 | |
| 3027 void VHSPost(float effuon) | |
| 3028 { | |
| 3029 if (current_scene == 6) effuon = 2.0f; | |
| 3030 if (current_scene == 7) effuon = 3.0f; | |
| 3031 float mymillis = (millis-scene_start_millis); | |
| 3032 | |
| 3033 if (current_scene == 1 || current_scene == 2) | |
| 3034 { | |
| 3035 if (millis > 105000 && millis < 112000) brieflycase_render(); | |
| 3036 } | |
| 3037 | |
| 3038 if (current_scene == 1 || current_scene == 3) | |
| 3039 { | |
| 3040 // console crap | |
| 3041 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); // default | |
| 3042 | |
| 3043 glLoadIdentity(); | |
| 3044 | |
| 3045 mat4_set_identity( &projection ); | |
| 3046 mat4_set_identity( &model ); | |
| 3047 mat4_set_identity( &view ); | |
| 3048 | |
| 3049 mat4_set_orthographic( &projection, 0, g_Width, 0, g_Height, -1, 1); | |
| 3050 | |
| 3051 console_render( console ); | |
| 3052 } | |
| 3053 | |
| 3054 | |
| 3055 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // default | |
| 3056 glClearColor(0.0f, 0.0f, 0.0f, 0.0f); | |
| 3057 glClearDepth(1.0f); // Depth Buffer Setup | |
| 3058 | |
| 3059 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
| 3060 | |
| 3061 glUseProgram(shaders[vhs]); | |
| 3062 | |
| 3063 glDisable(GL_BLEND); | |
| 3064 float widthLoc5 = glGetUniformLocation(shaders[vhs], "width"); | |
| 3065 float heightLoc5 = glGetUniformLocation(shaders[vhs], "height"); | |
| 3066 float timeLoc5 = glGetUniformLocation(shaders[vhs], "time"); | |
| 3067 float effuLoc5 = glGetUniformLocation(shaders[vhs], "effu"); | |
| 3068 | |
| 3069 float beatLoc = glGetUniformLocation(shaders[vhs], "beat"); | |
| 3070 float noiseLoc = glGetUniformLocation(shaders[vhs], "noisetin"); | |
| 3071 | |
| 3072 if ((current_scene == 2 || current_scene == 1 || current_scene == 4) && (millis > 55000 && millis < 186000)) | |
| 3073 { | |
| 3074 if (scene_shader_params[2] == 36) { vhsbeat = 1.0f; vhsbeat_start = mymillis; } | |
| 3075 vhsbeat-=((mymillis-vhsbeat_start)*0.00005); | |
| 3076 if (vhsbeat <= (current_scene == 2 ? 0.2 : 0.1)) vhsbeat = (current_scene == 2 ? 0.2 : 0.1); | |
| 3077 } | |
| 3078 else if (current_scene == 3) { | |
| 3079 if (millis >= 181500 && vhsbeat_start < 181500) { | |
| 3080 vhsbeat_start = millis; | |
| 3081 //printf("START!\n"); | |
| 3082 } | |
| 3083 | |
| 3084 if (vhsbeat_start >= 181500) | |
| 3085 { | |
| 3086 vhsbeat = (millis-vhsbeat_start)*(0.02/30); | |
| 3087 //printf("vhsbeat:%f\n", vhsbeat); | |
| 3088 } | |
| 3089 } | |
| 3090 else if (current_scene == 6) | |
| 3091 { | |
| 3092 if (scene_shader_params[2] == 36) { vhsbeat = 1.0f; vhsbeat_start = mymillis; } | |
| 3093 vhsbeat-=((mymillis-vhsbeat_start)*0.0005); | |
| 3094 if (vhsbeat < 0.0) vhsbeat = 0.0; | |
| 3095 | |
| 3096 } | |
| 3097 else{ | |
| 3098 vhsbeat = 0.2; | |
| 3099 } | |
| 3100 | |
| 3101 float vhsnoise = ((float)(scene_shader_params[5]))/255.0f; | |
| 3102 float adder = (((float)(scene_shader_params[4]))/255.0f)-(current_scene == 2 ? 0.2 : 0.5f); | |
| 3103 | |
| 3104 if (current_scene == 4) adder = 0.0; | |
| 3105 | |
| 3106 if (current_scene == 7) vhsnoise = 1.0+cos(millis*0.001); | |
| 3107 | |
| 3108 if (!assets_loaded) vhsnoise=sin(loading_time*0.1); | |
| 3109 | |
| 3110 glUniform1f(widthLoc5, g_Width); | |
| 3111 glUniform1f(heightLoc5, g_Height); | |
| 3112 glUniform1f(timeLoc5, mymillis/100); | |
| 3113 glUniform1f(effuLoc5, effuon); | |
| 3114 glUniform1f(beatLoc, vhsbeat+adder); | |
| 3115 glUniform1f(noiseLoc, vhsnoise); | |
| 3116 | |
| 3117 glActiveTexture(GL_TEXTURE0); | |
| 3118 glBindTexture(GL_TEXTURE_2D, fake_framebuffer_tex); | |
| 3119 | |
| 3120 float location5 = glGetUniformLocation(shaders[vhs], "texture0"); | |
| 3121 glUniform1i(location5, 0); | |
| 3122 | |
| 3123 glLoadIdentity(); | |
| 3124 | |
| 3125 glTranslatef(-1.2, -1.0, -1.0); | |
| 3126 | |
| 3127 int i=0; | |
| 3128 int j=0; | |
| 3129 glBegin(GL_QUADS); | |
| 3130 glVertex2f(i, j); | |
| 3131 glVertex2f(i + 100, j); | |
| 3132 glVertex2f(i + 100, j + 100); | |
| 3133 glVertex2f(i, j + 100); | |
| 3134 glEnd(); | |
| 3135 | |
| 3136 | |
| 3137 } | |
| 3138 | |
| 3139 | |
| 3140 ///////////////////////////////////////////////////////////////// END EFFECTS | |
| 3141 ///////////////////////////////////////////////////////////////// END EFFECTS | |
| 3142 ///////////////////////////////////////////////////////////////// END EFFECTS | |
| 3143 ///////////////////////////////////////////////////////////////// END EFFECTS | |
| 3144 ///////////////////////////////////////////////////////////////// END EFFECTS | |
| 3145 | |
| 3146 // update sync from midi + mapping data | |
| 3147 | |
| 3148 void UpdateShaderParams() | |
| 3149 { | |
| 3150 int intmillis = (int)millis; | |
| 3151 int i; | |
| 3152 | |
| 3153 | |
| 3154 for (i=0; i < mapping_count; i++) | |
| 3155 { | |
| 3156 int tracknum = mapping_tracknum[i]; | |
| 3157 int trackidx = timeline_trackindex[tracknum]; | |
| 3158 if (timeline_trackindex[tracknum] >= timeline_tracklength[tracknum]) continue; | |
| 3159 | |
| 3160 MIDI_MSG currentMsg = timeline[tracknum][trackidx]; | |
| 3161 | |
| 3162 | |
| 3163 int dw = (int)currentMsg.dwAbsPos; | |
| 3164 int tarkistus = (int)(dw)*1.212; | |
| 3165 | |
| 3166 // flush midi to correct position if debugging | |
| 3167 if (debugmode == 1) | |
| 3168 { | |
| 3169 while (tarkistus < intmillis) | |
| 3170 { | |
| 3171 timeline_trackindex[tracknum]++; | |
| 3172 trackidx = timeline_trackindex[tracknum]; | |
| 3173 MIDI_MSG currentMsg2 = timeline[tracknum][trackidx]; | |
| 3174 dw = (int)currentMsg2.dwAbsPos; | |
| 3175 tarkistus = (int)(dw)*1.212; | |
| 3176 } | |
| 3177 printf("DEBUG: midi track %d flushed to position: %d\n", tracknum, tarkistus); | |
| 3178 } | |
| 3179 | |
| 3180 // reset trigs | |
| 3181 if (scene_shader_param_type[mapping_paramnum[i]] == 0) scene_shader_params[mapping_paramnum[i]] = -1; | |
| 3182 | |
| 3183 //if (intmillis+155520 < tarkistus*1.212) break; | |
| 3184 if (intmillis < tarkistus) continue; | |
| 3185 | |
| 3186 timeline_trackindex[tracknum]++; | |
| 3187 | |
| 3188 int ev = 0; | |
| 3189 | |
| 3190 if (currentMsg.bImpliedMsg) { ev = currentMsg.iImpliedMsg; } | |
| 3191 else { ev = currentMsg.iType; } | |
| 3192 | |
| 3193 // DebugPrintEvent(ev, currentMsg); | |
| 3194 | |
| 3195 int trigVal = -1; | |
| 3196 int paramVal = -1; | |
| 3197 | |
| 3198 switch(mapping_type[i]) | |
| 3199 { | |
| 3200 // trig | |
| 3201 case 0: | |
| 3202 { | |
| 3203 | |
| 3204 if (ev == msgNoteOn) | |
| 3205 { | |
| 3206 trigVal = currentMsg.MsgData.NoteOn.iNote; | |
| 3207 // 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]); | |
| 3208 // printf("shader param %d trig: %d\n", mapping_paramnum[i], trigVal); | |
| 3209 } | |
| 3210 else if (ev == msgNoteOff) | |
| 3211 { | |
| 3212 trigVal = -1; | |
| 3213 } | |
| 3214 | |
| 3215 scene_shader_params[mapping_paramnum[i]] = trigVal; | |
| 3216 scene_shader_param_type[mapping_paramnum[i]] = 0; | |
| 3217 //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]]); | |
| 3218 break; | |
| 3219 } | |
| 3220 | |
| 3221 // param: | |
| 3222 case 1: | |
| 3223 { | |
| 3224 if (ev == msgSetParameter) | |
| 3225 { | |
| 3226 paramVal = currentMsg.MsgData.NoteParameter.iParam; | |
| 3227 scene_shader_params[mapping_paramnum[i]] = paramVal; | |
| 3228 scene_shader_param_type[mapping_paramnum[i]] = 1; | |
| 3229 //printf("sync (%s): %d: param %d to: %d\n", timeline_trackname[tracknum], intmillis, mapping_paramnum[i], scene_shader_params[mapping_paramnum[i]]); | |
| 3230 } | |
| 3231 | |
| 3232 break; | |
| 3233 } | |
| 3234 } | |
| 3235 } | |
| 3236 debugmode = 0; | |
| 3237 | |
| 3238 } | |
| 3239 ///////////////////////////////////////////////////////////////// MAIN LOGIC | |
| 3240 | |
| 3241 void quit() | |
| 3242 { | |
| 3243 quitflag = 1; | |
| 3244 printf("--- MIDISYS ENGINE: time to quit()\n"); | |
| 3245 if(!window) { | |
| 3246 glutLeaveGameMode(); | |
| 3247 glutLeaveMainLoop(); | |
| 3248 } else { | |
| 3249 glutDestroyWindow(window); | |
| 3250 glutLeaveMainLoop(); | |
| 3251 } | |
| 3252 } | |
| 3253 | |
| 3254 double min(double a, double b) | |
| 3255 { | |
| 3256 if (a<=b) return a; | |
| 3257 else return b; | |
| 3258 } | |
| 3259 | |
| 3260 GLint gFramesPerSecond = 0; | |
| 3261 | |
| 3262 void FPS(void) { | |
| 3263 static GLint Frames = 0; // frames averaged over 1000mS | |
| 3264 static GLuint Clock; // [milliSeconds] | |
| 42 | 3265 //static GLuint PreviousClock = 0; // [milliSeconds] |
| 0 | 3266 static GLuint NextClock = 0; // [milliSeconds] |
| 3267 | |
| 3268 ++Frames; | |
| 3269 Clock = glutGet(GLUT_ELAPSED_TIME); //has limited resolution, so average over 1000mS | |
| 3270 if ( Clock < NextClock ) return; | |
| 3271 | |
| 3272 gFramesPerSecond = Frames/1; // store the averaged number of frames per second | |
| 3273 | |
| 42 | 3274 //PreviousClock = Clock; |
| 0 | 3275 NextClock = Clock+1000; // 1000mS=1S in the future |
| 3276 Frames=0; | |
| 3277 } | |
| 3278 | |
| 3279 void logic() | |
| 3280 { | |
| 3281 if (assets_loaded) { | |
| 3282 if (music_started == -1) { | |
| 3283 printf("--- MIDISYS-ENGINE: total loading time: %f\n", loading_time); | |
| 3284 printf("--- MIDISYS-ENGINE: demo startup\n"); | |
| 3285 BASS_ChannelPlay(music_channel,FALSE); music_started = 1; | |
| 3286 if(jump_to) { BASS_ChannelSetPosition(music_channel, jump_to, BASS_POS_BYTE); } | |
| 3287 } | |
| 3288 | |
| 3289 QWORD bytepos = BASS_ChannelGetPosition(music_channel, BASS_POS_BYTE); | |
| 3290 double pos = BASS_ChannelBytes2Seconds(music_channel, bytepos); | |
| 3291 millis = (float)pos*1000*demo_speed_x; | |
| 3292 | |
| 3293 if (millis > 367000) quit(); | |
| 3294 | |
| 3295 demo_playlist(); | |
| 3296 scene_logic[current_scene](0.0f); | |
| 3297 } else { | |
| 3298 t_loader_d = clock(); | |
| 3299 //scene_logic[current_scene]((float)((float)(assets_index) / (float)(assets_total))); | |
| 3300 } | |
| 3301 | |
| 3302 // glutPostRedisplay(); | |
| 3303 } | |
| 3304 | |
| 3305 void timer(int value) | |
| 3306 { | |
| 3307 const int desiredFPS=60; | |
| 3308 glutTimerFunc(1000/desiredFPS, timer, ++value); | |
| 3309 | |
| 3310 logic(); | |
| 3311 | |
| 3312 FPS(); //only call once per frame loop to measure FPS | |
| 3313 if (quitflag == 0) glutPostRedisplay(); | |
| 3314 } | |
| 3315 | |
| 3316 | |
| 3317 ///////////////////////////////////////////////////////////// RENDER FUNCTION | |
| 3318 | |
| 3319 void display(void) | |
| 3320 { | |
| 3321 UpdateShaderParams(); | |
| 3322 scene_render[current_scene](); | |
| 3323 VHSPost(assets_loaded && current_scene <= 4 ? 1.0 : 0.0); | |
| 3324 | |
| 3325 glFlush(); | |
| 3326 glutSwapBuffers(); | |
| 3327 frame++; | |
| 3328 logic(); | |
| 3329 } | |
| 3330 | |
| 3331 | |
| 3332 // ---------------------------------------------------------------------------- | |
| 3333 // ---------------------------------------------------------------------------- | |
| 3334 | |
| 3335 void keyPress(unsigned char key, int x, int y) | |
| 3336 { | |
| 3337 if (key == 27) quit(); | |
| 3338 } | |
| 3339 | |
| 3340 void mouseMotion(int button, int state, int x, int y) | |
| 3341 { | |
| 3342 mouseX = x; | |
| 3343 mouseY = y; | |
| 3344 } | |
| 3345 | |
| 3346 void InitFBO() | |
| 3347 { | |
| 3348 glGenTextures(1, &fb_tex); | |
| 3349 glBindTexture(GL_TEXTURE_2D, fb_tex); | |
| 3350 | |
| 3351 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); | |
| 3352 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); | |
| 3353 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); | |
| 3354 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); | |
| 3355 | |
| 3356 | |
| 3357 printf("\tframebuffer size: %dx%d\n", g_Width, g_Height); | |
| 3358 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, g_Width, g_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); | |
| 3359 glGenFramebuffersEXT(1, &fb); | |
| 3360 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); | |
| 3361 | |
| 3362 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, fb_tex, 0); | |
| 3363 | |
| 3364 glGenRenderbuffersEXT(1, &depth_rb); | |
| 3365 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb); | |
| 3366 glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, g_Width, g_Height); | |
| 3367 | |
| 3368 glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb); | |
| 3369 | |
| 3370 GLenum status; | |
| 3371 status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); | |
| 3372 switch(status) | |
| 3373 { | |
| 3374 case GL_FRAMEBUFFER_COMPLETE_EXT: | |
| 3375 printf("\tInitFBO() status: GL_FRAMEBUFFER_COMPLETE\n"); | |
| 3376 break; | |
| 3377 default: | |
| 3378 printf("\tInitFBO() error: status != GL_FRAMEBUFFER_COMPLETE\n"); | |
| 3379 exit(1); | |
| 3380 break; | |
| 3381 } | |
| 3382 | |
| 3383 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); | |
| 3384 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); | |
| 3385 | |
| 3386 | |
| 3387 | |
| 3388 glGenTextures(1, &fb_tex2); | |
| 3389 glBindTexture(GL_TEXTURE_2D, fb_tex2); | |
| 3390 | |
| 3391 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); | |
| 3392 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); | |
| 3393 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); | |
| 3394 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); | |
| 3395 | |
| 3396 | |
| 3397 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, g_Width, g_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); | |
| 3398 glGenFramebuffersEXT(1, &fb2); | |
| 3399 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb2); | |
| 3400 | |
| 3401 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, fb_tex2, 0); | |
| 3402 | |
| 3403 glGenRenderbuffersEXT(1, &depth_rb2); | |
| 3404 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb2); | |
| 3405 glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, g_Width, g_Height); | |
| 3406 | |
| 3407 glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb2); | |
| 3408 | |
| 3409 status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); | |
| 3410 switch(status) | |
| 3411 { | |
| 3412 case GL_FRAMEBUFFER_COMPLETE_EXT: | |
| 3413 printf("\tInitFBO() status: GL_FRAMEBUFFER_COMPLETE\n"); | |
| 3414 break; | |
| 3415 default: | |
| 3416 printf("\tInitFBO() error: status != GL_FRAMEBUFFER_COMPLETE\n"); | |
| 3417 exit(1); | |
| 3418 break; | |
| 3419 } | |
| 3420 | |
| 3421 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); | |
| 3422 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); | |
| 3423 | |
| 3424 //---------- | |
| 3425 | |
| 3426 glGenTextures(1, &fake_framebuffer_tex); | |
| 3427 glBindTexture(GL_TEXTURE_2D, fake_framebuffer_tex); | |
| 3428 | |
| 3429 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); | |
| 3430 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); | |
| 3431 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); | |
| 3432 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); | |
| 3433 | |
| 3434 | |
| 3435 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, g_Width, g_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); | |
| 3436 glGenFramebuffersEXT(1, &fake_framebuffer); | |
| 3437 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fake_framebuffer); | |
| 3438 | |
| 3439 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, fake_framebuffer_tex, 0); | |
| 3440 | |
| 3441 glGenRenderbuffersEXT(1, &depth_rb3); | |
| 3442 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb3); | |
| 3443 glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, g_Width, g_Height); | |
| 3444 | |
| 3445 glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb3); | |
| 3446 | |
| 3447 glClearColor(0.0,0.0,0.0,1.0); | |
| 3448 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); | |
| 3449 | |
| 3450 status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); | |
| 3451 switch(status) | |
| 3452 { | |
| 3453 case GL_FRAMEBUFFER_COMPLETE_EXT: | |
| 3454 printf("\tInitFBO() status: GL_FRAMEBUFFER_COMPLETE\n"); | |
| 3455 break; | |
| 3456 default: | |
| 3457 printf("\tInitFBO() error: status != GL_FRAMEBUFFER_COMPLETE\n"); | |
| 3458 exit(1); | |
| 3459 break; | |
| 3460 } | |
| 3461 | |
| 3462 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); | |
| 3463 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); | |
| 3464 | |
| 3465 | |
| 3466 | |
| 3467 } | |
| 3468 | |
| 3469 void InitGraphics(int argc, char* argv[]) | |
| 3470 { | |
| 3471 fprintf(stdout, "--- MIDISYS ENGINE: InitGraphics()\n"); | |
| 3472 glutInit(&argc, argv); | |
| 3473 | |
| 3474 | |
| 3475 if(!window) { | |
| 3476 glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH ); | |
| 3477 // 1280x720, 32bit pixel depth, 60Hz refresh rate | |
| 3478 glutGameModeString( "1280x720:32@60" ); | |
| 3479 | |
| 3480 // start fullscreen game mode | |
| 3481 glutEnterGameMode(); | |
| 3482 } else { | |
| 3483 window = glutCreateWindow("majestic twelve by bilotrip"); | |
| 3484 glutReshapeWindow(c_Width, c_Height); | |
| 3485 } | |
| 3486 | |
| 3487 glutSetCursor(GLUT_CURSOR_NONE); | |
| 3488 | |
| 3489 GLenum err = glewInit(); | |
| 3490 if (GLEW_OK != err) | |
| 3491 { | |
| 3492 /* Problem: glewInit failed, something is seriously wrong. */ | |
| 3493 fprintf(stderr, "\tInitGraphics() error: %s\n", glewGetErrorString(err)); | |
| 3494 exit(1); | |
| 3495 } | |
| 3496 fprintf(stdout, "\tInitGraphics() status: Using GLEW %s\n", glewGetString(GLEW_VERSION)); | |
| 3497 | |
| 3498 glEnable(GL_TEXTURE_2D); | |
| 3499 | |
| 3500 glShadeModel(GL_SMOOTH); | |
| 3501 | |
| 3502 #ifdef __APPLE__ | |
| 3503 int swap_interval = 1; | |
| 3504 CGLContextObj cgl_context = CGLGetCurrentContext(); | |
| 3505 CGLSetParameter(cgl_context, kCGLCPSwapInterval, &swap_interval); | |
| 3506 #endif | |
| 3507 | |
| 3508 glutDisplayFunc(display); | |
| 3509 glutReshapeFunc(reshape); | |
| 3510 glutIdleFunc(logic); | |
| 3511 glutKeyboardFunc(keyPress); | |
| 3512 glutMouseFunc(mouseMotion); | |
| 3513 glutTimerFunc(0,timer,0); | |
| 3514 | |
| 3515 fprintf(stdout, "--- MIDISYS ENGINE: InitGraphics() success\n"); | |
| 3516 } | |
| 3517 | |
| 3518 void StartMainLoop() | |
| 3519 { | |
| 3520 printf("--- MIDISYS ENGINE: StartMainLoop()\n"); | |
| 3521 glutMainLoop(); | |
| 3522 } | |
| 3523 | |
| 3524 int main(int argc, char* argv[]) | |
| 3525 { | |
| 3526 printf("--- MIDISYS ENGINE: bilotrip foundation MIDISYS ENGINE 4.20 - dosing, please wait\n"); | |
| 3527 | |
| 3528 // init graphics | |
| 3529 | |
| 3530 InitGraphics(argc, argv); | |
| 3531 | |
| 3532 // init console | |
| 3533 | |
| 3534 console = console_new(); | |
| 3535 shader = shader_load("data/shaders/v3f-t2f-c4f.vert", | |
| 3536 shaderss[0]); | |
| 3537 | |
| 3538 // load & init video | |
| 3539 | |
| 3540 printf("--- nu laddar vi en videofilmen, det aer jaetteroligt att fuska poe Assembly\n"); | |
| 3541 | |
| 3 | 3542 static const char *videofile = "data/video/video.ogg"; |
| 3543 OggPlayer ogg(videofile,AF_S16,2,44100,VF_BGRA); | |
| 0 | 3544 if(ogg.fail()) { |
| 3 | 3545 printf("could not open video file \"%s\"\n", videofile); |
| 0 | 3546 return -2; |
| 3547 } | |
| 3548 YUVFrame yuv_frame(ogg); | |
| 3549 myVideoFrame = &yuv_frame; | |
| 3550 | |
| 3551 // init MIDI sync and audio | |
| 3552 | |
| 3553 LoadMIDIEventList("data/music/midicontrols_final.mid"); | |
| 3554 ParseMIDITimeline("data/music/mapping.txt"); | |
| 3555 InitAudio("data/music/UusiArtistiNimi_-_The_March_compoVersion.mp3"); | |
| 3556 | |
| 3557 // Loader assets | |
| 3558 | |
| 3559 bilothorn = Import3DFromFile("data/models/bilotrip_logo_thorn.3ds"); | |
| 3560 LoadGLTextures(bilothorn); | |
| 3561 biloflat = Import3DFromFile("data/models/bilotrip_logo_flat.obj"); | |
| 3562 LoadGLTextures(biloflat); | |
| 3563 bilothree = Import3DFromFile("data/models/bilotrip.3ds"); | |
| 3564 LoadGLTextures(bilothree); | |
| 3565 bilotetra = Import3DFromFile("data/models/bilotrip_logo_tetra.obj"); | |
| 3566 LoadGLTextures(bilotetra); | |
| 33 | 3567 brieflycase = Import3DFromFile("data/models/brieflyCase.obj"); |
| 0 | 3568 LoadGLTextures(brieflycase); |
| 3569 | |
| 3570 // start mainloop | |
| 3571 | |
| 3572 StartMainLoop(); | |
| 3573 | |
| 3574 return 0; | |
| 3575 } |