← Back to branch summary

~ubuntu-branches/ubuntu/wily/zaz/wily

« back to all changes in this revision

Viewing changes to .pc/jumpy_keyboard.patch/src/scene.cpp

  • Committer: Package Import Robot
  • Author(s): Miriam Ruiz, Miriam Ruiz, Paul Wise, Evgeni Golov
  • Date: 2013-09-13 21:08:20 UTC
  • Revision ID: package-import@ubuntu.com-20130913210820-w3ls7jg852s2sqcp
Tags: 1.0.0~dfsg1-2
http://bugs.debian.org/649021
http://bugs.debian.org/649017
https://launchpad.net/bugs/656468
[ Miriam Ruiz ]
* Fixed man page
* Added patch by Steve Cotton to fix jumpu keyboard. Closes: #649021
* Changed my email to miriam@debian.org
* Upgraded Standards-Version from 3.9.2 to 3.9.4
* Upgraded compat level to 9
* Fortified build

[ Paul Wise ]
* Add patches by Steve Cotton to fix crashes (Closes: #649017; LP: #656468)
* dbg/data packages don't have ELF files and therefore don't need shlibs
* Wrap and sort various files for more readable diffs
* Drop dh-buildinfo since it isn't useful these days
* Drop quilt build-dep, not needed with dpkg-source v3
* Link to the versioned filenames for the GPL
* Document gettext.h copyright and license
* Clean up patches and add DEP-3 headers
* Use slightly shorter homepage
* Add a watch file

[ Evgeni Golov ]
* Correct Vcs-* URLs to point to anonscm.debian.org

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/jumpy_keyboard.patch/src/scene.cpp
 
1
/*
 
2
 * Zaz
 
3
 * Copyright (C) Remigiusz Dybka 2009 <remigiusz.dybka@gmail.com>
 
4
 *
 
5
 Zaz is free software: you can redistribute it and/or modify it
 
6
 under the terms of the GNU General Public License as published by the
 
7
 Free Software Foundation, either version 3 of the License, or
 
8
 (at your option) any later version.
 
9
 
 
10
 Zaz is distributed in the hope that it will be useful, but
 
11
 WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
13
 See the GNU General Public License for more details.
 
14
 
 
15
 You should have received a copy of the GNU General Public License along
 
16
 with this program.  If not, see <http://www.gnu.org/licenses/>.
 
17
 */
 
18
 
 
19
#include "scene.h"
 
20
#include "mixer.h"
 
21
 
 
22
#include <ctime>
 
23
#include <cstdlib>
 
24
#include <sstream>
 
25
 
 
26
#include <GL/gl.h>
 
27
 
 
28
namespace Scenes
 
29
{
 
30
Mixer *mixer = NULL;
 
31
 
 
32
Scene::Scene(SDL_Surface *surf, uint fps)
 
33
{
 
34
    surface = surf;
 
35
    desiredFPS = fps;
 
36
    quit = resync = false;
 
37
    logicInputFrame = 0;
 
38
    renderframedecimator = 1;
 
39
    show_fps = settings.getb("showFps", false);
 
40
    restartFromFrame = 0;
 
41
    screenshotRequested = false;
 
42
 
 
43
    vwidth = 100 * (640.0/480.0);
 
44
    vleft = (100 - vwidth) / 2;
 
45
    vheight = 100.0;
 
46
}
 
47
 
 
48
void Scene::RestartTimers()
 
49
{
 
50
    tickStart = SDL_GetTicks() - ((restartFromFrame * 1000) / desiredFPS);
 
51
    logicFrame = restartFromFrame;
 
52
 
 
53
    logicInterval = 1000.0 / desiredFPS;
 
54
}
 
55
 
 
56
void Scene::Run()
 
57
{
 
58
    mode = RUN;
 
59
    mixerMode = Realtime;
 
60
    Go();
 
61
}
 
62
 
 
63
void Scene::Record(ostream &outstr, uint fromFrame)
 
64
{
 
65
    mode = RECORD;
 
66
    mixerMode = Realtime;
 
67
    out_stream = &outstr;
 
68
    restartFromFrame = fromFrame;
 
69
    Go();
 
70
}
 
71
 
 
72
void Scene::Play(istream &instr)
 
73
{
 
74
    mode = PLAY;
 
75
    mixerMode = Realtime;
 
76
    in_stream = &instr;
 
77
    Go();
 
78
}
 
79
 
 
80
void Scene::Export(string philename, istream &instr, uint skipframes)
 
81
{
 
82
    string phn;
 
83
#ifdef WIN32
 
84
    phn = Settings::W32_CreateFile(philename);
 
85
#else
 
86
    phn = philename;
 
87
#endif
 
88
    ogvexp = new OgvExport(phn, surface->w, surface->h, desiredFPS / skipframes);
 
89
 
 
90
    mode = RENDER;
 
91
    renderframedecimator = skipframes;
 
92
    mixerMode = Nonrealtime;
 
93
    in_stream = &instr;
 
94
    Mixer *oldmixer = mixer;
 
95
    mixer = NULL;
 
96
    Go();
 
97
    mixer = oldmixer;
 
98
    delete (ogvexp);
 
99
}
 
100
 
 
101
void Scene::Go()
 
102
{
 
103
    bool ownMixer = false;
 
104
 
 
105
    if (mixer == NULL)
 
106
    {
 
107
        mixer = new Mixer(mixerMode);
 
108
        ownMixer = true;
 
109
    }
 
110
 
 
111
    void *pixels;
 
112
    uint exportedFrame = 0;
 
113
    void *pcmbuffer;
 
114
 
 
115
    int pcmbuffersize = (44100 * 2 * 2) / (desiredFPS / renderframedecimator);
 
116
 
 
117
    if (mode == RENDER)
 
118
    {
 
119
        pixels = malloc(3 * surface->w * surface->h);
 
120
        pcmbuffer = malloc(pcmbuffersize);
 
121
    }
 
122
 
 
123
    GLSetup();
 
124
    RestartTimers();
 
125
    uint last_sec = tickStart / 1000;
 
126
    uint lfpsc = 0;
 
127
    uint rfpsc = 0;
 
128
 
 
129
    mixer->Play();
 
130
 
 
131
    while (!quit)
 
132
    {
 
133
        int currTick = SDL_GetTicks() - tickStart;
 
134
        if (currTick < 0)
 
135
        {
 
136
 
 
137
            currTick = 0;
 
138
        }
 
139
 
 
140
        uint currFrame = (currTick / 1000) * desiredFPS;
 
141
        uint now_sec = currTick / 1000;
 
142
 
 
143
        currFrame += (uint)(double(currTick % 1000) / 1000.0 * desiredFPS);
 
144
 
 
145
        if (mode == RENDER)
 
146
            currFrame = logicFrame+1;
 
147
 
 
148
        // are we ahead of time ?
 
149
        if (!resync)
 
150
            if (logicFrame >= currFrame)
 
151
            {
 
152
                SDL_Delay((Uint32)double(((logicFrame + 1) * logicInterval) - currTick));
 
153
                continue;
 
154
            }
 
155
 
 
156
        while (!resync && (logicFrame < currFrame))
 
157
        {
 
158
            if ((mode == RUN) || (mode == RECORD))
 
159
            {
 
160
                events = CreateFrameEvents();
 
161
 
 
162
                if (mode == RECORD)
 
163
                {
 
164
                    SaveFrameEvents();
 
165
                }
 
166
            }
 
167
 
 
168
            if ((mode == PLAY) || (mode == RENDER))
 
169
            {
 
170
                events = LoadFrameEvents();
 
171
                /*if (!events.empty)
 
172
                    SDL_WarpMouse(events.mouseX, events.mouseY);
 
173
                 */
 
174
            }
 
175
 
 
176
            Logic(logicFrame);
 
177
            ++logicInputFrame;
 
178
            ++logicFrame;
 
179
            lfpsc++;
 
180
        }
 
181
 
 
182
        if (mode != RENDER)
 
183
        {
 
184
            Render(logicFrame);
 
185
 
 
186
            if (screenshotRequested)
 
187
            {
 
188
                SaveScreenshot(screenshotFilename);
 
189
                screenshotRequested = false;
 
190
            }
 
191
 
 
192
            if (show_fps)
 
193
            {
 
194
                stringstream fpsmsg;
 
195
                fpsmsg << "fps: " << renderFPS;
 
196
                glLoadIdentity( );
 
197
                double vleft = (100 - 100 * (640.0/480.0)) / 2;
 
198
 
 
199
                glTranslated(vleft, 98, 50);
 
200
                glScaled(0.1, 0.1, 0.1);
 
201
 
 
202
                glColor3f(1.0f, 1.0f, 1.0f);
 
203
                glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 
204
                if ((renderFPS < 200) && (renderFPS > 0))
 
205
                    font->Render(fpsmsg.str().c_str());
 
206
            }
 
207
 
 
208
            SDL_GL_SwapBuffers();
 
209
            rfpsc++;
 
210
        }
 
211
 
 
212
        if (resync)
 
213
        {
 
214
            resync = false;
 
215
            GLSetup();
 
216
            RestartTimers();
 
217
            continue;
 
218
        }
 
219
 
 
220
        if (mode == PLAY)
 
221
        {
 
222
            events = CreateFrameEvents();
 
223
            if (events.keyDown.size() > 0)
 
224
                for (vector<SDLKey>::iterator i = events.keyDown.begin(); i != events.keyDown.end(); ++i)
 
225
                {
 
226
                    if (*i == SDLK_ESCAPE)
 
227
                        quit = true;
 
228
                }
 
229
        }
 
230
 
 
231
        if (mode == RENDER)
 
232
        {
 
233
            events = CreateFrameEvents();
 
234
 
 
235
            if (events.keyDown.size() > 0)
 
236
                for (vector<SDLKey>::iterator i = events.keyDown.begin(); i != events.keyDown.end(); ++i)
 
237
                {
 
238
                    if (*i == SDLK_ESCAPE)
 
239
                        quit = true;
 
240
                }
 
241
 
 
242
            if (logicFrame%renderframedecimator == 0)
 
243
            {
 
244
                Render(logicFrame);
 
245
 
 
246
                glFlush();
 
247
                glPixelStorei(GL_PACK_ALIGNMENT, 1);
 
248
                glReadPixels(0, 0, surface->w, surface->h,
 
249
                             GL_RGB, GL_UNSIGNED_BYTE, pixels);
 
250
                mixer->Fill((Uint8 *)pcmbuffer, pcmbuffersize);
 
251
 
 
252
                ogvexp->FeedFrame(pixels, pcmbuffer);
 
253
 
 
254
                exportedFrame++;
 
255
 
 
256
                // add progress before showing the buffer
 
257
                char msg[256];
 
258
                sprintf(msg, "%s", _("Exporting video [press ESC to cancel]"));
 
259
                glLoadIdentity( );
 
260
                FTBBox b = font->BBox(msg);
 
261
                double tw = b.Upper().X() / 7;
 
262
 
 
263
                glTranslated((100 - tw) / 2, 40, 50);
 
264
                glScaled(1.0/7.0, 1.0/7.0, 1.0/7.0);
 
265
 
 
266
                glColor3f(1.0f, 1.0f, 1.0f);
 
267
                glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 
268
                font->Render(msg);
 
269
                SDL_GL_SwapBuffers();
 
270
                rfpsc++;
 
271
            }
 
272
        }
 
273
 
 
274
        if (now_sec != last_sec)
 
275
        {
 
276
            last_sec = now_sec;
 
277
            renderFPS = rfpsc;
 
278
            logicFPS = lfpsc;
 
279
            lfpsc = rfpsc = 0;
 
280
        }
 
281
    }
 
282
 
 
283
    if (mode == RENDER)
 
284
    {
 
285
        free(pixels);
 
286
        free(pcmbuffer);
 
287
    }
 
288
 
 
289
    if (ownMixer)
 
290
    {
 
291
        delete mixer;
 
292
        mixer = 0;
 
293
    }
 
294
}
 
295
 
 
296
void Scene::Branch(Scene *scn)
 
297
{
 
298
    // no branching while recording/playing/rendering
 
299
    if (mode != RUN)
 
300
        return;
 
301
 
 
302
    //cout << "Leaving on frame :" << logicInputFrame << endl;
 
303
    scn->logicInputFrame = logicInputFrame + 1;
 
304
    scn->GLSetup();
 
305
    scn->Run();
 
306
    logicInputFrame = scn->logicInputFrame;
 
307
    resync = true;
 
308
}
 
309
 
 
310
FrameEvents Scene::CreateFrameEvents()
 
311
{
 
312
    SDL_Event event;
 
313
    FrameEvents ev;
 
314
 
 
315
    bool mmotion = false;
 
316
    int mmx = 0;
 
317
    int mmy = 0;
 
318
    int rmx = 0;
 
319
    int rmy = 0;
 
320
 
 
321
 
 
322
    while (SDL_PollEvent(&event))
 
323
    {
 
324
        switch (event.type)
 
325
        {
 
326
        case SDL_KEYDOWN:
 
327
            ev.keyDown.push_back(event.key.keysym.sym);
 
328
            ev.empty = false;
 
329
            ev.unicode.push_back(event.key.keysym.unicode);
 
330
            break;
 
331
        case SDL_KEYUP:
 
332
            ev.keyUp.push_back(event.key.keysym.sym);
 
333
            ev.empty = false;
 
334
            break;
 
335
        case SDL_MOUSEBUTTONDOWN:
 
336
            if (event.button.button == SDL_BUTTON_LEFT)
 
337
                ev.buttDown[0] = true;
 
338
            if (event.button.button == SDL_BUTTON_RIGHT)
 
339
                ev.buttDown[1] = true;
 
340
            if (event.button.button == SDL_BUTTON_MIDDLE)
 
341
                ev.buttDown[2] = true;
 
342
 
 
343
            ev.empty = false;
 
344
            break;
 
345
 
 
346
        case SDL_MOUSEBUTTONUP:
 
347
            if (event.button.button == SDL_BUTTON_LEFT)
 
348
                ev.buttUp[0] = true;
 
349
            if (event.button.button == SDL_BUTTON_RIGHT)
 
350
                ev.buttUp[1] = true;
 
351
            if (event.button.button == SDL_BUTTON_MIDDLE)
 
352
                ev.buttUp[2] = true;
 
353
 
 
354
            ev.empty = false;
 
355
            break;
 
356
 
 
357
        case SDL_MOUSEMOTION:
 
358
            mmx = event.motion.x;
 
359
            mmy = event.motion.y;
 
360
            rmx = event.motion.xrel;
 
361
            rmy = event.motion.yrel;
 
362
 
 
363
            mmotion = true;
 
364
            break;
 
365
        }
 
366
    }
 
367
 
 
368
    if (mmotion)
 
369
    {
 
370
        if (logicInputFrame == 0)
 
371
            rmx = rmy = 0;
 
372
 
 
373
        ev.relmouseX = rmx;
 
374
        ev.relmouseY = rmy;
 
375
 
 
376
        ev.mouseX = (double)mmx / (double)surface->w;
 
377
        ev.mouseY = (double)mmy / (double)surface->h;
 
378
 
 
379
        // convert to int and back exactly as recording/playback would have done
 
380
        ev.mouseX = (double)((int)(ev.mouseX * MOUSE_RESOLUTION)) / MOUSE_RESOLUTION;
 
381
        ev.mouseY = (double)((int)(ev.mouseY * MOUSE_RESOLUTION)) / MOUSE_RESOLUTION;
 
382
 
 
383
        RecalculateMousePos(mmx, mmy);
 
384
        ev.empty = false;
 
385
    }
 
386
 
 
387
    return ev;
 
388
}
 
389
 
 
390
void Scene::RecalculateMousePos(int mmx, int mmy)
 
391
{
 
392
    if ((mmx == mmy) && (mmx == -1))
 
393
    {
 
394
        SDL_GetMouseState(&mmx, &mmy);
 
395
    }
 
396
 
 
397
    double mouseX = (double)mmx / (double)surface->w;
 
398
    double mouseY = (double)mmy / (double)surface->h;
 
399
 
 
400
    // convert to int and back exactly as recording/playback would have done
 
401
    mouseX = (double)((int)(mouseX * MOUSE_RESOLUTION)) / MOUSE_RESOLUTION;
 
402
    mouseY = (double)((int)(mouseY * MOUSE_RESOLUTION)) / MOUSE_RESOLUTION;
 
403
 
 
404
    mx = (vwidth * mouseX) + vleft;
 
405
    my = vheight - (vheight * mouseY);
 
406
}
 
407
 
 
408
 
 
409
FrameEvents Scene::LoadFrameEvents()
 
410
{
 
411
    FrameEvents ev;
 
412
 
 
413
    if (nextEventLine.empty())
 
414
        *in_stream >> nextEventLine;
 
415
 
 
416
    uint rec_frame = atoi(nextEventLine.c_str());
 
417
 
 
418
    if (rec_frame == logicInputFrame)
 
419
    {
 
420
        //cout << nextEventLine << endl;
 
421
 
 
422
        // split line in fields
 
423
        vector<string> fields;
 
424
        string::size_type startpos = 0;
 
425
        string::size_type endpos = string::npos;
 
426
 
 
427
        while ((endpos = nextEventLine.find_first_of(':', startpos)) != string::npos)
 
428
        {
 
429
            fields.push_back(nextEventLine.substr(startpos, (endpos - startpos)));
 
430
            startpos = endpos + 1;
 
431
        }
 
432
 
 
433
        fields.push_back(nextEventLine.substr(startpos));
 
434
 
 
435
        // interpret fields
 
436
        ev.empty = false;
 
437
 
 
438
        // keydown
 
439
        startpos = 0;
 
440
        endpos = string::npos;
 
441
        while ((endpos = fields[1].find_first_of(',', startpos)) != string::npos)
 
442
        {
 
443
            ev.keyDown.push_back((SDLKey)atoi(fields[1].substr(startpos, (endpos - startpos)).c_str()));
 
444
            startpos = endpos + 1;
 
445
        }
 
446
 
 
447
        if (fields[1].size() - startpos)
 
448
            ev.keyDown.push_back((SDLKey)atoi(fields[1].substr(startpos).c_str()));
 
449
 
 
450
        // keyup
 
451
        startpos = 0;
 
452
        endpos = string::npos;
 
453
        while ((endpos = fields[2].find_first_of(',', startpos)) != string::npos)
 
454
        {
 
455
            ev.keyUp.push_back((SDLKey)atoi(fields[2].substr(startpos, (endpos - startpos)).c_str()));
 
456
            startpos = endpos + 1;
 
457
        }
 
458
 
 
459
        if (fields[2].size() - startpos)
 
460
            ev.keyUp.push_back((SDLKey)atoi(fields[2].substr(startpos).c_str()));
 
461
 
 
462
        ev.mouseX = atoi(fields[3].c_str());
 
463
        ev.mouseY = atoi(fields[4].c_str());
 
464
 
 
465
        ev.mouseX = (double)ev.mouseX / (double) MOUSE_RESOLUTION;
 
466
        ev.mouseY = (double)ev.mouseY / (double) MOUSE_RESOLUTION;
 
467
        ev.relmouseX = atoi(fields[5].c_str());
 
468
        ev.relmouseY = atoi(fields[6].c_str());
 
469
 
 
470
 
 
471
        ev.buttDown[0] = fields[7][0] == '1';
 
472
        ev.buttDown[1] = fields[7][1] == '1';
 
473
        ev.buttDown[2] = fields[7][2] == '1';
 
474
 
 
475
        ev.buttUp[0] = fields[8][0] == '1';
 
476
        ev.buttUp[1] = fields[8][1] == '1';
 
477
        ev.buttUp[2] = fields[8][2] == '1';
 
478
 
 
479
        *in_stream >> nextEventLine;
 
480
    }
 
481
 
 
482
    return ev;
 
483
}
 
484
 
 
485
void Scene::SaveFrameEvents()
 
486
{
 
487
    if (!events.empty)
 
488
    {
 
489
        bool escape_hit = false;
 
490
        for (vector<SDLKey>::iterator i = events.keyDown.begin(); i != events.keyDown.end(); ++i)
 
491
        {
 
492
            if (*i == SDLK_ESCAPE)
 
493
                escape_hit = true;
 
494
        }
 
495
 
 
496
        if (escape_hit) // don't save the event
 
497
            return;
 
498
 
 
499
        *out_stream << logicInputFrame;
 
500
        // keydown
 
501
        *out_stream << ":";
 
502
        for (vector<SDLKey>::iterator i = events.keyDown.begin(); i != events.keyDown.end(); ++i)
 
503
        {
 
504
            if (i != events.keyDown.begin())
 
505
                *out_stream << ",";
 
506
 
 
507
            *out_stream << *i;
 
508
        }
 
509
 
 
510
        // keyup
 
511
        *out_stream << ":";
 
512
        for (vector<SDLKey>::iterator i = events.keyUp.begin(); i != events.keyUp.end(); ++i)
 
513
        {
 
514
            if (i != events.keyUp.begin())
 
515
                *out_stream << ",";
 
516
 
 
517
            *out_stream << *i;
 
518
        }
 
519
 
 
520
        // mouse position
 
521
        *out_stream << ":" << (int)(events.mouseX * MOUSE_RESOLUTION) << ":" << (int)(events.mouseY * MOUSE_RESOLUTION);
 
522
        *out_stream << ":" << events.relmouseX << ":" << events.relmouseY;
 
523
        // buttons
 
524
        *out_stream << ":" << events.buttDown[0] << events.buttDown[1] << events.buttDown[2];
 
525
        *out_stream << ":" << events.buttUp[0] << events.buttUp[1] << events.buttUp[2];
 
526
 
 
527
        *out_stream << endl;
 
528
    }
 
529
}
 
530
 
 
531
void Scene::SaveScreenshot(string philename)
 
532
{
 
533
    unsigned char *pixels;
 
534
 
 
535
    pixels = (unsigned char *)malloc(3 * surface->w * surface->h);
 
536
    glPixelStorei(GL_PACK_ALIGNMENT, 1);
 
537
    glReadPixels(0, 0, surface->w, surface->h,
 
538
                 GL_RGB, GL_UNSIGNED_BYTE, pixels);
 
539
 
 
540
 
 
541
    Uint32 rmask, gmask, bmask;//, amask;
 
542
 
 
543
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
 
544
    rmask = 0xff000000;
 
545
    gmask = 0x00ff0000;
 
546
    bmask = 0x0000ff00;
 
547
    //amask = 0x000000ff;
 
548
#else
 
549
    rmask = 0x000000ff;
 
550
    gmask = 0x0000ff00;
 
551
    bmask = 0x00ff0000;
 
552
    //amask = 0xff000000;
 
553
#endif
 
554
 
 
555
    SDL_Surface *temp = SDL_CreateRGBSurface(SDL_SWSURFACE, surface->w, surface->h, 24, rmask, gmask, bmask, 0);
 
556
 
 
557
    for (int i=0; i<surface->h; i++)
 
558
        memcpy(((char *) temp->pixels) + temp->pitch * i,
 
559
               pixels + 3*surface->w * (surface->h-i-1),
 
560
               surface->w*3);
 
561
    free(pixels);
 
562
#ifdef WIN32
 
563
    SDL_SaveBMP(temp, Settings::W32_CreateFile(philename).c_str());
 
564
#else
 
565
    SDL_SaveBMP(temp, philename.c_str());
 
566
#endif
 
567
    SDL_FreeSurface(temp);
 
568
}
 
569
 
 
570
void Scene::Screenshot(string philename)
 
571
{
 
572
    screenshotFilename = philename;
 
573
    screenshotRequested = true;
 
574
}
 
575
}