← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/rss-glx/gutsy

« back to all changes in this revision

Viewing changes to reallyslick/cpp_src/helios.cpp

  • Committer: Bazaar Package Importer
  • Author(s): LaMont Jones
  • Date: 2005-11-30 18:21:27 UTC
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20051130182127-5iww7elbiyzej1lk
Tags: upstream-0.8.0
Import upstream version 0.8.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
reallyslick/cpp_src/helios.cpp
20
20
 
21
21
#include <math.h>
22
22
#include <stdio.h>
23
 
#include <time.h>
24
23
#include <GL/gl.h>
25
24
#include <GL/glu.h>
26
25
#include <GL/glx.h>
27
 
#include <sys/time.h>
28
26
 
29
27
#include "driver.h"
30
 
#include "impCubeVolume.h"
31
 
#include "impCrawlPoint.h"
32
 
#include "impSphere.h"
 
28
#include "Implicit/impCubeVolume.h"
 
29
#include "Implicit/impCrawlPoint.h"
 
30
#include "Implicit/impSphere.h"
33
31
#include "loadTexture.h"
34
32
#include "rgbhsl.h"
35
33
#include "rsDefines.h"
36
34
#include "rsRand.h"
37
 
#include "rsMatrix.h"
38
 
#include "rsQuat.h"
39
 
#include "rsVec.h"
 
35
#include "rsMath/rsMatrix.h"
 
36
#include "rsMath/rsQuat.h"
 
37
#include "rsMath/rsVec.h"
40
38
 
41
39
char *hack_name = (char *)"helios";
42
40
 
74
72
int dSurface;
75
73
int dWireframe;
76
74
int dBlur;
77
 
int dPriority;
78
75
 
79
76
impCubeVolume *volume;
80
77
impSurface *surface;
108
105
 
109
106
emitter::emitter ()
110
107
{
111
 
        pos = rsVec (myRandf (1000.0f) - 500.0f, myRandf (1000.0f) - 500.0f, myRandf (1000.0f) - 500.0f);
 
108
        pos = rsVec (rsRandf (1000.0f) - 500.0f, rsRandf (1000.0f) - 500.0f, rsRandf (1000.0f) - 500.0f);
112
109
}
113
110
 
114
111
class attracter:public particle {
132
129
 
133
130
attracter::attracter ()
134
131
{
135
 
        pos = rsVec (myRandf (1000.0f) - 500.0f, myRandf (1000.0f) - 500.0f, myRandf (1000.0f) - 500.0f);
 
132
        pos = rsVec (rsRandf (1000.0f) - 500.0f, rsRandf (1000.0f) - 500.0f, rsRandf (1000.0f) - 500.0f);
136
133
}
137
134
 
138
135
class ion:public particle {
153
150
 
154
151
        pos = rsVec (0.0f, 0.0f, 0.0f);
155
152
        rgb = rsVec (0.0f, 0.0f, 0.0f);
156
 
        temp = myRandf (2.0f) + 0.4f;
 
153
        temp = rsRandf (2.0f) + 0.4f;
157
154
        size = float (dSize) * temp;
158
155
        speed = float (dSpeed) * 12.0f / temp;
159
156
}
161
158
void
162
159
  ion::start ()
163
160
{
164
 
        int i = myRandi (dEmitters);
 
161
        int i = rsRandi (dEmitters);
165
162
        float offset = elapsedTime * speed;
166
163
 
167
164
        pos = elist[i].pos;
168
165
 
169
 
        switch (myRandi (14)) {
 
166
        switch (rsRandi (14)) {
170
167
        case 0:
171
168
                pos[0] += offset;
172
169
                break;
293
290
        switch (whichTarget) {
294
291
        case 0:         // random
295
292
                for (i = 0; i < dEmitters; i++)
296
 
                        elist[i].settargetpos (rsVec (rsVec (myRandf (1000.0f) - 500.0f, myRandf (1000.0f) - 500.0f, myRandf (1000.0f) - 500.0f)));
 
293
                        elist[i].settargetpos (rsVec (rsVec (rsRandf (1000.0f) - 500.0f, rsRandf (1000.0f) - 500.0f, rsRandf (1000.0f) - 500.0f)));
297
294
                for (i = 0; i < dAttracters; i++)
298
 
                        alist[i].settargetpos (rsVec (rsVec (myRandf (1000.0f) - 500.0f, myRandf (1000.0f) - 500.0f, myRandf (1000.0f) - 500.0f)));
 
295
                        alist[i].settargetpos (rsVec (rsVec (rsRandf (1000.0f) - 500.0f, rsRandf (1000.0f) - 500.0f, rsRandf (1000.0f) - 500.0f)));
299
296
                break;
300
297
        case 1:
301
298
                {               // line (all emitters on one side, all attracters on the other)
377
374
                }
378
375
        case 5:         // random distribution across a plane
379
376
                for (i = 0; i < dEmitters; i++)
380
 
                        elist[i].settargetpos (rsVec (rsVec (myRandf (1000.0f) - 500.0f, 0.0f, myRandf (1000.0f) - 500.0f)));
 
377
                        elist[i].settargetpos (rsVec (rsVec (rsRandf (1000.0f) - 500.0f, 0.0f, rsRandf (1000.0f) - 500.0f)));
381
378
                for (i = 0; i < dAttracters; i++)
382
 
                        alist[i].settargetpos (rsVec (rsVec (myRandf (1000.0f) - 500.0f, 0.0f, myRandf (1000.0f) - 500.0f)));
 
379
                        alist[i].settargetpos (rsVec (rsVec (rsRandf (1000.0f) - 500.0f, 0.0f, rsRandf (1000.0f) - 500.0f)));
383
380
                break;
384
381
        case 6:
385
382
                {               // random distribution across 2 planes
386
383
                        float height = -525.0f + float (dEmitters * 25);
387
384
 
388
385
                        for (i = 0; i < dEmitters; i++)
389
 
                                elist[i].settargetpos (rsVec (rsVec (myRandf (1000.0f) - 500.0f, height, myRandf (1000.0f) - 500.0f)));
 
386
                                elist[i].settargetpos (rsVec (rsVec (rsRandf (1000.0f) - 500.0f, height, rsRandf (1000.0f) - 500.0f)));
390
387
 
391
388
                        height = 525.0f - float (dAttracters * 25);
392
389
 
393
390
                        for (i = 0; i < dAttracters; i++)
394
 
                                alist[i].settargetpos (rsVec (rsVec (myRandf (1000.0f) - 500.0f, height, myRandf (1000.0f) - 500.0f)));
 
391
                                alist[i].settargetpos (rsVec (rsVec (rsRandf (1000.0f) - 500.0f, height, rsRandf (1000.0f) - 500.0f)));
395
392
 
396
393
                        break;
397
394
                }
484
481
        return (value);
485
482
}
486
483
 
487
 
void hack_draw (xstuff_t * XStuff)
 
484
void hack_draw (xstuff_t * XStuff, double currentTime, float frameTime)
488
485
{
489
486
        int i;
490
487
        static int ionsReleased = 0;
495
492
#endif
496
493
 
497
494
        Window window = XStuff->window;
498
 
        static int thisTime, lastTime;
499
 
        struct timeval now;
500
 
 
501
 
        /*
502
 
         * update time 
503
 
         */
504
 
        gettimeofday (&now, NULL);
505
 
        thisTime = (now.tv_sec & 65535) * 1000 + now.tv_usec / 1000;
506
 
 
507
 
        if (lastTime == -1)
508
 
                lastTime = thisTime;
509
 
 
510
 
        if (thisTime >= lastTime)
511
 
                elapsedTime = (thisTime - lastTime) * 0.001f;
512
 
        lastTime = thisTime;
 
495
 
 
496
        elapsedTime = frameTime;
513
497
 
514
498
#ifdef BENCHMARK
515
499
        if (a++ == 1000)
532
516
 
533
517
        if (preCameraInterp >= PI) {
534
518
                oldCameraDistance = targetCameraDistance;
535
 
                targetCameraDistance = -myRandf (1300.0f) - 200.0f;
 
519
                targetCameraDistance = -rsRandf (1300.0f) - 200.0f;
536
520
                preCameraInterp = 0.0f;
537
521
        }
538
522
 
 
523
        glMatrixMode (GL_MODELVIEW);
539
524
        glLoadIdentity ();
540
525
        glTranslatef (0.0, 0.0, cameraDistance);
541
526
 
553
538
                radialVel += radialVelDiff;
554
539
        } else {
555
540
                radialVel = targetRadialVel;
556
 
                if (myRandi (2)) {
557
 
                        targetRadialVel = rsVec (myRandf (1.0f), myRandf (1.0f), myRandf (1.0f));
 
541
                if (rsRandi (2)) {
 
542
                        targetRadialVel = rsVec (rsRandf (1.0f), rsRandf (1.0f), rsRandf (1.0f));
558
543
                        targetRadialVel.normalize ();
559
 
                        targetRadialVel *= float (dCameraspeed) * myRandf (0.002f);
 
544
                        targetRadialVel *= float (dCameraspeed) * rsRandf (0.002f);
560
545
                } else
561
546
                        targetRadialVel = rsVec (0.0f, 0.0f, 0.0f);
562
547
        }
576
561
        rotMat.get (billboardMat);
577
562
 
578
563
        // Calculate new color
579
 
        static rsVec oldHsl, newHsl = rsVec (myRandf (1.0f), 1.0f, 1.0f), targetHsl;
 
564
        static rsVec oldHsl, newHsl = rsVec (rsRandf (1.0f), 1.0f, 1.0f), targetHsl;
580
565
        static float colorInterp = 1.0f, colorChange;
581
566
 
582
567
        colorInterp += elapsedTime * colorChange;
583
568
        if (colorInterp >= 1.0f) {
584
 
                if (!myRandi (3) && dIons >= 100)       // change color suddenly
585
 
                        newHsl = rsVec (myRandf (1.0f), 1.0f - (myRandf (1.0f) * myRandf (1.0f)), 1.0f);
 
569
                if (!rsRandi (3) && dIons >= 100)       // change color suddenly
 
570
                        newHsl = rsVec (rsRandf (1.0f), 1.0f - (rsRandf (1.0f) * rsRandf (1.0f)), 1.0f);
586
571
                oldHsl = newHsl;
587
 
                targetHsl = rsVec (myRandf (1.0f), 1.0f - (myRandf (1.0f) * myRandf (1.0f)), 1.0f);
 
572
                targetHsl = rsVec (rsRandf (1.0f), 1.0f - (rsRandf (1.0f) * rsRandf (1.0f)), 1.0f);
588
573
                colorInterp = 0.0f;
589
574
                // amount by which to change colorInterp each second
590
 
                colorChange = myRandf (0.005f * float (dSpeed)) + (0.002f * float (dSpeed));
 
575
                colorChange = rsRandf (0.005f * float (dSpeed)) + (0.002f * float (dSpeed));
591
576
        } else {
592
577
                float diff = targetHsl[0] - oldHsl[0];
593
578
 
630
615
                static int newTarget = 0, lastTarget;
631
616
 
632
617
                lastTarget = newTarget;
633
 
                newTarget = myRandi (10);
 
618
                newTarget = rsRandi (10);
634
619
                if (newTarget == lastTarget)
635
620
                        newTarget++;
636
621
                setTargets (newTarget);
638
623
                interp = 0.0f;
639
624
                wait = 10.0f;   // pause after forming each new pattern
640
625
                interpconst = 0.001f;
641
 
                if (!myRandi (4))       // interpolate really fast sometimes
 
626
                if (!rsRandi (4))       // interpolate really fast sometimes
642
627
                        interpconst = 0.1f;
643
628
        }
644
629
        // Update particles
659
644
                        spheres[i].setPosition (elist[i].pos[0], elist[i].pos[1], elist[i].pos[2]);
660
645
                for (i = 0; i < dAttracters; i++)
661
646
                        spheres[dEmitters + i].setPosition (alist[i].pos[0], alist[i].pos[1], alist[i].pos[2]);
662
 
                std::list < impCrawlPoint > crawlpointlist;
663
 
                float center[3];
664
 
 
665
 
                for (i = 0; i < dEmitters + dAttracters; i++) {
666
 
                        spheres[i].center (center);
667
 
                        crawlpointlist.push_back (impCrawlPoint (center));
668
 
                }
 
647
 
 
648
                impCrawlPointVector cpv;
 
649
                for(i=0; i<dEmitters+dAttracters; i++)
 
650
                        spheres[i].addCrawlPoint(cpv);
 
651
 
669
652
                surface->reset ();
 
653
 
670
654
                static float valuetrig = 0.0f;
671
 
 
672
655
                valuetrig += elapsedTime;
673
 
                volume->surfacevalue = 0.45f + 0.05f * cos (valuetrig);
674
 
                volume->make_surface (crawlpointlist);
 
656
 
 
657
                volume->setSurfaceValue(0.45f + 0.05f * cosf(valuetrig));
 
658
                volume->makeSurface(cpv);
675
659
        }
676
660
        // Draw
677
661
        // clear the screen
678
662
        if (dBlur) {            // partially
679
 
                glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
680
 
                glColor4f (0.0f, 0.0f, 0.0f, 0.5f - (float (sqrt (sqrt (double (dBlur)))) * 0.15495f));
681
 
 
 
663
                glMatrixMode (GL_PROJECTION);
682
664
                glPushMatrix ();
683
 
                glLoadIdentity ();
684
 
                glBegin (GL_TRIANGLE_STRIP);
685
 
                glVertex3f (-5.0f, -4.0f, -3.0f);
686
 
                glVertex3f (5.0f, -4.0f, -3.0f);
687
 
                glVertex3f (-5.0f, 4.0f, -3.0f);
688
 
                glVertex3f (5.0f, 4.0f, -3.0f);
689
 
                glEnd ();
690
 
                glPopMatrix ();
 
665
                        glLoadIdentity();
 
666
                        glOrtho(0.0, 1.0, 0.0, 1.0, 1.0, -1.0);
 
667
                        glMatrixMode(GL_MODELVIEW);
 
668
                        glPushMatrix();
 
669
                                glLoadIdentity();
 
670
                                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
671
                                glColor4f(0.0f, 0.0f, 0.0f, 0.5f - (float(sqrtf(sqrtf(float(dBlur)))) * 0.15495f));
 
672
                                glBegin(GL_TRIANGLE_STRIP);
 
673
                                        glVertex3f(0.0f, 0.0f, 0.0f);
 
674
                                        glVertex3f(1.0f, 0.0f, 0.0f);
 
675
                                        glVertex3f(0.0f, 1.0f, 0.0f);
 
676
                                        glVertex3f(1.0f, 1.0f, 0.0f);
 
677
                        glEnd();
 
678
                glPopMatrix();
 
679
                glMatrixMode(GL_PROJECTION);
 
680
                glPopMatrix();
691
681
        } else                  // completely
692
682
                glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
693
683
 
694
684
        // Draw ions
 
685
        glMatrixMode(GL_MODELVIEW);
695
686
        glBlendFunc (GL_ONE, GL_ONE);
696
687
        glBindTexture (GL_TEXTURE_2D, 1);
697
688
        for (i = 0; i < ionsReleased; i++)
796
787
        glMatrixMode (GL_PROJECTION);
797
788
        glLoadIdentity ();
798
789
        gluPerspective (60.0, float (XStuff->windowWidth) / float (XStuff->windowHeight), 0.1, 10000.0f);
799
 
 
800
 
        glMatrixMode (GL_MODELVIEW);
801
 
 
802
 
        glDisable (GL_DEPTH_TEST);
803
 
        glEnable (GL_BLEND);
804
 
        glLightModeli (GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
805
790
}
806
791
 
807
792
void hack_init (xstuff_t * XStuff)
813
798
        // Window initialization
814
799
        hack_reshape (XStuff);
815
800
 
 
801
        glDisable (GL_DEPTH_TEST);
 
802
        glEnable (GL_BLEND);
 
803
        glLightModeli (GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
 
804
 
816
805
        // Clear the buffers and test for type of buffer swapping
817
 
        // glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
818
806
        glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
819
807
        glXSwapBuffers (XStuff->display, XStuff->window);       // wglSwapLayerBuffers(hdc, WGL_SWAP_MAIN_PLANE);
820
808
        glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
893
881
                volume = new impCubeVolume;
894
882
                volume->init (50, 50, 50, 35.0f);
895
883
                volume->function = surfaceFunction;
896
 
                surface = new impSurface;
897
 
                surface->init (6000);
898
 
                volume->surface = surface;
 
884
                surface = volume->getSurface();
 
885
 
899
886
                spheres = new impSphere[dEmitters + dAttracters];
900
 
                float sphereScaleFactor = 1.0f / float (sqrt (double (2 * dEmitters + dAttracters)));
901
887
 
 
888
                float sphereScaleFactor = 1.0f / sqrtf (double (2 * dEmitters + dAttracters));
902
889
                for (i = 0; i < dEmitters; i++)
903
 
                        spheres[i].setScale (400.0f * sphereScaleFactor);
 
890
                        spheres[i].setThickness (400.0f * sphereScaleFactor);
904
891
                for (i = 0; i < dAttracters; i++)
905
 
                        spheres[i + dEmitters].setScale (200.0f * sphereScaleFactor);
 
892
                        spheres[i + dEmitters].setThickness (200.0f * sphereScaleFactor);
906
893
        }
907
894
}
908
895