├── README.md
├── bamdtypes.h
├── drawfunc.cpp
├── gl.h
├── main.cpp
├── makefile
├── makefile.osx
└── screens
    ├── twilight.jpg
    └── twilight_osx.jpg


/README.md:
--------------------------------------------------------------------------------
 1 | twilight
 2 | ========
 3 | 
 4 | redo of IRIX twilight backdrop in old school OpenGL
 5 | 
 6 | TODO : 
 7 | 
 8 | >~~backdrop mode 
 9 |  (First have to see if it is even possible in GLUT, if not I will have to reimplement in glx)~~
10 | 
11 | >morph mode
12 |  (evolve gradient color scheme over time)
13 | 
14 | ![MaXX Desktop](screens/twilight.jpg)
15 | ![](screens/twilight_osx.jpg)
16 | 


--------------------------------------------------------------------------------
/bamdtypes.h:
--------------------------------------------------------------------------------
 1 | ///////////////////////////////////////////////////////////////////////////////
 2 | // RTPS
 3 | // Copyright 1996-2013, Michael T. Mayers
 4 | // Provided under the MIT License (see LICENSE.txt)
 5 | ///////////////////////////////////////////////////////////////////////////////
 6 | 
 7 | #pragma once
 8 | 
 9 | ///////////////////////////////////////////////////////////////////////////
10 | //			bamdtypes.h
11 | //			COMMON BinaryArtsMeDia Types
12 | //			Michael T. Mayers
13 | //			Binary Arts, Inc
14 | ///////////////////////////////////////////////////////////////////////////
15 | 
16 | ///////////////////////////////////////////////////////////////////////////
17 | // Common Defines
18 | 
19 | #define PI	3.14159265358979323846
20 | #define PI2	6.2831853
21 | #define NEGPI2 -6.2831853
22 | #define DEG2RAD	0.017453293
23 | #define RAD2DEG	57.29678
24 | 
25 | #ifndef	NULL
26 | #define NULL	0
27 | #endif
28 | 
29 | #define ZERO	0
30 | 
31 | #define NO	0
32 | #define YES	1
33 | #define FALSE	0
34 | #define TRUE	1
35 | 
36 | #define BAD	1
37 | #define GOOD	0
38 | #define PASS	0
39 | #define FAIL	1
40 | #define ERR	1
41 | #define NOERR	0
42 | 
43 | ///////////////////////////////////////////////////////////////////////////
44 | // Common Types
45 | 
46 | #ifdef IRIX
47 | typedef unsigned long long int	    U64;
48 | typedef signed long long int	    S64;
49 | #endif
50 | #ifdef WIN32
51 | typedef unsigned __int64			U64;
52 | typedef signed __int64				S64;		
53 | #endif
54 | 
55 | typedef char			    		UBOOL;
56 | 
57 | typedef unsigned long int	    	U32;
58 | typedef signed long int		    	S32;
59 | typedef unsigned short int	    	U16;
60 | typedef signed short int	    	S16;
61 | typedef unsigned char		    	U8;
62 | typedef signed char		    		S8;
63 | typedef float			    		F32;
64 | typedef double			    		F64;
65 | typedef float			    		FLOAT;
66 | typedef char *			    		STRING;
67 | typedef void *			    		ADDRESS;
68 | 
69 | ///////////////////////////////////////////////////////////////////////////
70 | ///////////////////////////////////////////////////////////////////////////
71 | // metric conversion constants
72 | 
73 | #include "metric.h"
74 | 
75 | ///////////////////////////////////////////////////////////////////////////////
76 | 


--------------------------------------------------------------------------------
/drawfunc.cpp:
--------------------------------------------------------------------------------
  1 | ///////////////////////////////////////////////////////////////////////////////
  2 | // TWILIGHT (Port of old IRIX twilight backdrop from Iris GL to old school OpenGL)
  3 | ///////////////////////////////////////////////////////////////////////////////
  4 | 
  5 | #define NDEBUG
  6 | 		
  7 | #include <math.h>
  8 | #include <vector>
  9 | #include <assert.h>
 10 | #include <stdio.h>
 11 | 
 12 | #include "gl.h"
 13 | 
 14 | struct color4{ float r, g, b, a; };
 15 | 
 16 | // prototypes
 17 | void draw_background(float x, float y);
 18 | color4 star_color(float y, float max_y);
 19 | 
 20 | // point in y where color transition occurs
 21 | #define TRANSITION 0.3f
 22 | #define NUM_SMALL_STARS 2500
 23 | #define NUM_BIG_STARS 200
 24 | 
 25 | static float orange[3] = {1.0f,0.3f,0};
 26 | static float blueish[3] = {0.0f,0.5f,0.7f};
 27 | static float black[3] = {0.0f,0.0f,0.0f};
 28 | 
 29 | extern GLsizei	gw, gh;
 30 | 
 31 | 
 32 | ////////////////////////////////////////////////////////////////////////////////////
 33 | // draw particles
 34 | ////////////////////////////////////////////////////////////////////////////////////
 35 | 
 36 | void drawfunc( void )
 37 | {	
 38 | 	glClearColor( 0.1, 0.0, 0.0, 1.0 );
 39 | 	glClearDepth( 0.0f );
 40 | 	glViewport( 0, 0, gw, gh );
 41 | 	glClear( GL_COLOR_BUFFER_BIT );
 42 | 	assert(glGetError()==0);
 43 | 	
 44 | 	//////////////////////
 45 | 
 46 | 	glDisable( GL_BLEND );
 47 | 	glDisable( GL_LIGHTING );
 48 | 	glDisable( GL_DEPTH_TEST );
 49 | 	glDisable( GL_STENCIL_TEST );
 50 | 	glDisable( GL_SCISSOR_TEST );
 51 | 	glDisable( GL_ALPHA_TEST );
 52 | 	glDisable( GL_TEXTURE_2D );
 53 | 	glDisable( GL_CULL_FACE );
 54 | 	assert(glGetError()==0);
 55 | 	glDisable( GL_FOG );
 56 | 	assert(glGetError()==0);
 57 | 
 58 | 	glColorMask(true,true,true,true);
 59 | 	glShadeModel( GL_SMOOTH );
 60 | 	//////////////////////
 61 | 	assert(glGetError()==0);
 62 | 
 63 | 	srand48(0);
 64 | 	draw_background((float)gw, (float)gh);
 65 | 
 66 | 	assert(glGetError()==0);
 67 | 	//////////////////////
 68 | 	glFlush();
 69 | 	//glutSwapBuffers();
 70 | 	
 71 | }
 72 | 
 73 | void draw_background(float x, float y)
 74 | {
 75 | 	glMatrixMode( GL_PROJECTION );
 76 | 	glLoadIdentity();	
 77 | 	gluOrtho2D(-.5, (float)gw-.5, -.5, (float)gh-.5);
 78 | 
 79 | 	glMatrixMode( GL_MODELVIEW );
 80 | 	glLoadIdentity();	
 81 | 
 82 | 	//////////////////////
 83 | 
 84 |     int i,j;
 85 | 	float v1[2],v2[2],v3[2],v4[2];
 86 | 
 87 | 	v1[0] = v4[0] = 0.0;
 88 | 	v2[0] = v3[0] = x;
 89 | 	
 90 | 	v1[1] = v2[1] = 0.0;
 91 | 	v3[1] = v4[1] = y*TRANSITION;
 92 | 
 93 | 	glColor4f(1.0f,1.0f,1.0f,1.0f);
 94 | 
 95 | 	glBegin(GL_LINES);
 96 | 		glVertex3f(0.0f,0.0f,0.0f);
 97 | 		//glVertex3f(1.0f,0.0f,0.0f);
 98 | 		glVertex3f(gw,gh,0.0f);
 99 | 		//glVertex3f(0.0f,1.0f,0.0f);
100 | 	glEnd();
101 | 	//printf( "yo\n" );
102 | 
103 | 	glBegin(GL_QUADS);
104 | 		glColor3f(orange[0],orange[1],orange[2]);
105 | 		glVertex2fv(v1);
106 | 		glVertex2fv(v2);
107 | 		glColor3f(blueish[0],blueish[1],blueish[2]);
108 | 		glVertex2fv(v3);
109 | 		glVertex2fv(v4);
110 | 	glEnd();
111 | 
112 | 	v1[1] = v2[1] = y;
113 | 	glBegin(GL_QUADS);
114 | 		glColor3f(blueish[0],blueish[1],blueish[2]);
115 | 		glVertex2fv(v4);
116 | 		glVertex2fv(v3);
117 | 		glColor3f(black[0],black[1],black[2]);
118 | 		glVertex2fv(v2);
119 | 		glVertex2fv(v1);
120 | 	glEnd();
121 | 
122 | 	srand48(0); 
123 | 
124 | 	glEnable( GL_BLEND );
125 | 	glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
126 | 	glBegin(GL_POINTS);
127 | 	{
128 | 		for (int i = 0; i < NUM_SMALL_STARS; i++)
129 | 		{	
130 | 			float frx = drand48();				
131 | 			float fry = drand48();				
132 | 			float fx = x*frx;
133 | 			float fy = y*fry;
134 | 
135 | 			auto c = star_color(fy, y);
136 | 			glColor4f(c.r,c.g,c.b,logf(fry*3.0f));
137 | 							
138 | 				glVertex2f(fx,fy);
139 | 	    }
140 | 	}
141 | 	glEnd();
142 | 
143 | 
144 | 	glEnable( GL_POINT_SMOOTH );
145 | 	for( float fsize=1.0f; fsize<=2.0f; fsize += (drand48()*0.2f) )
146 | 	{
147 | 		glPointSize(fsize);
148 | 		glBegin(GL_POINTS);
149 | 		{
150 | 			int inump = drand48()*25.0f;
151 | 			for (int i = 0; i < inump; i++)
152 | 			{	
153 | 				float frx = drand48();				
154 | 				float fry = drand48();				
155 | 				float fx = x*frx;
156 | 				float fy = y*fry;
157 | 
158 | 				auto c = star_color(fy, y);
159 | 				glColor4f(c.r,c.g,c.b,fry);							
160 | 				glVertex2f(fx,fy);
161 | 		    }
162 | 		}
163 | 		glEnd();
164 | 	}
165 | }
166 | 
167 | 
168 | color4 star_color(float y, float max_y)
169 | {
170 |     int r,g,b;
171 | 	float a;
172 | 	float ratio;
173 | 	color4 rval;
174 | 
175 | 	if (y > max_y/2)
176 | 	{
177 | 		rval.r=1.0f;
178 | 		rval.g=1.0f;
179 | 		rval.b=1.0f;
180 | 		rval.a=0.5f;
181 | 		return rval;
182 | 	}
183 | 
184 | 
185 |     if (y < TRANSITION*max_y)
186 | 	{
187 | 		ratio = y / (max_y * TRANSITION);
188 | 		
189 | 		r = orange[0]*(1.0 - ratio) + blueish[0]*ratio;
190 | 		g = orange[1]*(1.0 - ratio) + blueish[1]*ratio;
191 | 		b = orange[2]*(1.0 - ratio) + blueish[2]*ratio;
192 | 		a = 0.5f;
193 |     }
194 | 	else
195 | 	{
196 | 		ratio = (y - max_y*TRANSITION)/(max_y - max_y*TRANSITION);
197 | 		
198 | 		r = blueish[0]*(1.0 - ratio) + black[0]*ratio;
199 | 		g = blueish[1]*(1.0 - ratio) + black[1]*ratio;
200 | 		b = blueish[2]*(1.0 - ratio) + black[2]*ratio;
201 | 		a = 0.5f;
202 |     }
203 | 
204 | 	/* r,g and b are now the sky color at y, now blend with white */
205 | 
206 | 	a = (y/(max_y/2.0));
207 | 
208 | 	rval.r = r*(1.0-a) + a;
209 | 	rval.g = g*(1.0-a) + a;
210 | 	rval.b = b*(1.0-a) + a;
211 | 	rval.a = a;
212 | 	return rval;
213 | }
214 | 


--------------------------------------------------------------------------------
/gl.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #if defined(OSX)
 4 | #include <OpenGL/gl.h>
 5 | #include <OpenGL/glu.h>
 6 | #include <GLUT/glut.h>
 7 | #else // Other IX
 8 | #include <GL/gl.h>
 9 | #include <GL/glu.h>
10 | #include <GL/glut.h>
11 | #endif
12 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
  1 | ///////////////////////////////////////////////////////////////////////////////
  2 | // RTPS
  3 | // Copyright 1996-2013, Michael T. Mayers
  4 | // Provided under the MIT License (see LICENSE.txt)
  5 | ///////////////////////////////////////////////////////////////////////////////
  6 | 
  7 | #include <vector>
  8 | #include <math.h>
  9 | #include <stdlib.h>
 10 | #include <unistd.h>
 11 | 
 12 | #include "gl.h"
 13 | 
 14 | using namespace std;
 15 | 
 16 | ///////////////////////////////////////////////////////////////////////////
 17 | ///////////////////////////////////////////////////////////////////////////
 18 | 
 19 | void iterate( void );
 20 | void windowreshape( GLsizei w, GLsizei h );
 21 | void menuhandler( int value );
 22 | void mousehandler( int button, int state, int x, int y );
 23 | void keyboardhandler( unsigned char key, int x, int y );
 24 | void motionhandler(int x, int y);
 25 | void drawfunc( void );
 26 | 
 27 | 
 28 | GLsizei	gw, gh;
 29 | 
 30 | int mainwinid;
 31 | 
 32 | #if !defined(OSX)
 33 | #include <GL/glx.h>
 34 | #include <stdio.h>
 35 | #else
 36 | #import <Cocoa/Cocoa.h>
 37 | 
 38 | @interface MyOpenGLView : NSOpenGLView
 39 | @end
 40 | @implementation MyOpenGLView
 41 | -(void) drawRect: (NSRect) bounds
 42 | {
 43 |     drawfunc();
 44 | }
 45 | @end
 46 | #endif
 47 | 
 48 | ///////////////////////////////////////////////////////////////////////////
 49 | 
 50 | int main( int argc, char * argv[] )
 51 | {   	
 52 | #if 0
 53 |     glutInitWindowPosition( 0, 0 );
 54 |     glutInitWindowSize( 640, 480 );	
 55 |     glutInit(&argc, argv);
 56 |     glutInitDisplayMode(GLUT_RGBA /*| GLUT_DOUBLE*/ );
 57 |     mainwinid = glutCreateWindow("Twilight 2013, courtesy of TweakoZ");
 58 |    
 59 |     glutDisplayFunc(drawfunc);
 60 |     glutReshapeFunc(windowreshape);
 61 |     glutIdleFunc( iterate );
 62 |    
 63 |     glutCreateMenu(menuhandler);
 64 |     glutAddMenuEntry("FullScreen", 1);
 65 |     glutAddMenuEntry("Windowed", 2);
 66 |     glutAddMenuEntry("ResetPosition", 3);
 67 |     glutAddMenuEntry("Quit", 4);
 68 | 
 69 |     glutAttachMenu(GLUT_RIGHT_BUTTON);
 70 |     
 71 |     glutMouseFunc( mousehandler );
 72 |     glutKeyboardFunc( keyboardhandler );
 73 |     glutMotionFunc( motionhandler );
 74 |    
 75 |     glutMainLoop(); //glutMainLoopEvent();
 76 | #elif !defined(OSX)
 77 |     Display *dpy = XOpenDisplay(getenv("DISPLAY"));
 78 | 
 79 |     Window win;
 80 |     if (argc == 2) {
 81 |       win = strtoul(argv[1], NULL, 0);
 82 |     } else {
 83 |       printf("Drawing to root window. If you don't see background, provide ID of window to which we should draw as command line argument.\n");
 84 |       win = DefaultRootWindow(dpy);
 85 |     }
 86 |     GLint att[] = {GLX_RGBA, None};
 87 |     XVisualInfo *vi = glXChooseVisual(dpy, 0, att);
 88 |     XWindowAttributes gwa;
 89 |     XSetWindowAttributes swa;
 90 |     XEvent xev;
 91 | 
 92 |     swa.event_mask = ExposureMask;
 93 |     XChangeWindowAttributes(dpy, win, CWEventMask, &swa);
 94 | 
 95 |     glXMakeCurrent(dpy, win, glXCreateContext(dpy, vi, NULL, GL_TRUE));
 96 | 
 97 |     while(1) {
 98 |         XNextEvent(dpy, &xev);
 99 | 
100 |         if (xev.type == Expose) {
101 |             XGetWindowAttributes(dpy, win, &gwa);
102 |             gw = gwa.width;
103 |             gh = gwa.height;
104 |             drawfunc();
105 |         }
106 |     }
107 | #else
108 |     NSApplication *app = [NSApplication sharedApplication];
109 |     float factor = [NSScreen mainScreen].backingScaleFactor;
110 |     NSRect mainDisplayRect = [[NSScreen mainScreen] frame];
111 |     NSWindow *fullScreenWindow = [[NSWindow alloc] initWithContentRect: mainDisplayRect styleMask:NSBorderlessWindowMask backing:NSBackingStoreBuffered defer:YES];
112 | 
113 |     gw = mainDisplayRect.size.width * factor;
114 |     gh = mainDisplayRect.size.height * factor;
115 | 
116 |     [fullScreenWindow setLevel:kCGDesktopWindowLevel];
117 |     [fullScreenWindow setContentView:[[MyOpenGLView alloc] init]];
118 |     [fullScreenWindow makeKeyAndOrderFront:nil];
119 | 
120 |     [app run];
121 | #endif
122 | 
123 | }
124 | 
125 | ///////////////////////////////////////////////////////////////////////////
126 | ///////////////////////////////////////////////////////////////////////////
127 | 
128 | void iterate( void )
129 | {	
130 | 	drawfunc();
131 | 	usleep(500000);
132 | }
133 | 
134 | ///////////////////////////////////////////////////////////////
135 | ///////////////////////////////////////////////////////////////
136 | 
137 | void windowreshape( GLsizei w,  GLsizei h )
138 | 
139 | {
140 | 	gw = w;
141 | 	gh = h;
142 | 	
143 | 	glViewport( 0, 0, gw, gh );
144 | 	
145 | 	glMatrixMode( GL_PROJECTION );
146 | 	glLoadIdentity();
147 | 	
148 | //	gluPerspective( 40.0f, ((F32)gw/(F32)gh), 0.1f, 100.0f );
149 | //	gluLookAt( eyex, eyey, eyez, 
150 | //		   cenx, ceny, cenz,
151 | //		   0.0f, 1.0f, 0.0f );
152 | //	
153 | //	glTranslatef( 0.0f, 0.0f, 0.0f );
154 | }
155 | 
156 | ///////////////////////////////////////////////////////////////
157 | ///////////////////////////////////////////////////////////////
158 | 
159 | void menuhandler( int value )
160 | 
161 | {   
162 |     switch (value)
163 | 
164 |     {	case 1:	// Go Full Screen
165 | 	
166 | 		{   glutFullScreen();
167 | 	    	break;
168 | 		}
169 | 	
170 | 		case 2:	// Go Windowed
171 | 	
172 | 		{	glutSetWindow( mainwinid );
173 | 			glutReshapeWindow( 640, 480 );
174 | 			glutPositionWindow( 0, 0 );
175 | 			break;
176 | 		}
177 |     
178 | 		case 4:	// Quit
179 | 		
180 | 		{   exit(0);
181 | 		    break;
182 | 		}
183 |     
184 | 		default:
185 | 		    break;
186 |     }
187 | }
188 | 
189 | ///////////////////////////////////////////////////////////////
190 | ///////////////////////////////////////////////////////////////
191 | 
192 | void mousehandler(int button, int state, int x, int y)
193 | 
194 | {   /*if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
195 | 
196 |     {	movingxz = 1;
197 | 		movingy = 0;
198 | 		beginx = x;
199 | 		beginy = y;		//if(glutGetModifiers() & GLUT_ACTIVE_SHIFT)
200 |     }
201 | 
202 | //int glutGetModifiers(void)  
203 | 
204 |     if (button == GLUT_LEFT_BUTTON && state == GLUT_UP)
205 |   
206 |     {	movingxz = 0;
207 |     }
208 |     
209 |     if ( (button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) || ((button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)&&glutGetModifiers()==GLUT_ACTIVE_SHIFT) )
210 | 
211 |     {	movingy = 1;
212 | 		movingxz = 0;
213 | 		beginx = x;
214 | 		beginy = y;
215 |     }
216 |   
217 |     if (button == GLUT_MIDDLE_BUTTON && state == GLUT_UP)
218 |   
219 |     {	movingy = 0;
220 |     }*/
221 | }
222 | 
223 | ///////////////////////////////////////////////////////////////
224 | 
225 | void motionhandler(int x, int y)
226 | 
227 | {   /*extern int movingxz;
228 |     extern int movingy;
229 |     extern int beginx;
230 |     extern int beginy;
231 |     extern F32 eyex;
232 |     extern F32 eyey;
233 |     extern F32 eyez;
234 |     extern F32 h, p, zoom;
235 |     extern U32 gmassn;
236 |     
237 |     int deltax;
238 |     int deltay;
239 |             
240 |     deltax = beginx - x;
241 |     deltay = beginy - y;
242 |       
243 |     if( movingxz == 1 )
244 |     
245 |     {	h += (F32) (deltax/4800.0f);
246 | 		p += (F32) (deltay/4800.0f);
247 |     }
248 | 
249 | 	else if( movingy == 1 )
250 |     
251 |     {	zoom += (F32) (deltay/2400.0f);
252 |     }
253 |     
254 |     eyex = zoom * sinf( h * PI2 * DEG2RAD );
255 |     eyey = zoom * sinf( p * PI2 * DEG2RAD );
256 |     eyez = zoom * cosf( h * PI2 * DEG2RAD );*/
257 |     
258 | }
259 | 
260 | ///////////////////////////////////////////////////////////////
261 | 
262 | void keyboardhandler( unsigned char key, int x, int y )
263 | 
264 | {	/*static F32 saveval;
265 | 	int dx, dy;
266 | 	
267 | 	
268 | 	
269 | 	dx = x;
270 | 	dy = y;
271 | 		
272 | 	switch( key )
273 | 	{	
274 | 		case ' ':
275 | 			re_init();
276 | 			break;
277 | 		case '/':
278 | 			gvmass[gmassn] /= 10.0f;
279 | 			break;
280 | 		case '*':
281 | 			gvmass[gmassn] *= 10.0f;
282 | 			break;
283 | 		case ']':
284 | 			gpointsize *= 1.25f;
285 | 			break;
286 | 		case '[':
287 | 			gpointsize /= 1.25f;
288 | 			break;
289 | 		case '}':
290 | 			NPAR *= 2;
291 | 			re_init();
292 | 			break;
293 | 		case '{':
294 | 			NPAR /= 2;
295 | 			re_init();
296 | 			break;
297 | 		case '-':
298 | 			gvmass[gmassn] /= 1.1f;
299 | 			break;
300 | 		case '+':
301 | 			gvmass[gmassn] *= 1.1f;
302 | 			break;
303 | 		case 's':
304 | 			saveval = gvmass[gmassn];
305 | 			break;
306 | 		case 'l':
307 | 			gvmass[gmassn] = saveval;
308 | 			break;
309 | 		case '0':
310 | 			gvmass[gmassn] = 1.0f;
311 | 			break;
312 | 		case 'a':
313 | 			attreptoggle[gmassn] = 1.0f;
314 | 			break;
315 | 		case 'r':
316 | 			attreptoggle[gmassn] = -1.0f;
317 | 			break;
318 | 		case 'd':
319 | 			attached[gmassn] = false;
320 | 			break;
321 | 		case 'D':
322 | 			for( U32 di=0; di<4; di++ )	// detach others
323 | 			{	if( di != gmassn ) attached[di] = false;
324 | 			}
325 | 			attached[gmassn] = true;			
326 | 			break;
327 | 		case '1':
328 | 			gmassn = 0;
329 | 			break;
330 | 		case '2':
331 | 			gmassn = 1;
332 | 			break;
333 | 		case '3':
334 | 			gmassn = 2;
335 | 			break;
336 | 		case '4':
337 | 			gmassn = 3;
338 | 			break;
339 | 		case 'i':
340 | 			if( showtext==FALSE ) showtext=TRUE;
341 | 			else( showtext = FALSE );
342 | 			break;		
343 | 		case 'h':
344 | 			if( showhelp==FALSE ) showhelp = TRUE;
345 | 			else showhelp = FALSE;
346 | 			break;
347 | 		case '.':		
348 | 			if( showparticles==FALSE ) showparticles = TRUE;
349 | 			else showparticles = FALSE;
350 | 			break;
351 | 		case '>':
352 | 			if( dots==FALSE ) dots = TRUE;
353 | 			else dots = FALSE;
354 | 			break;
355 | 		case 'g':
356 | 			if( nmgrav==FALSE ) nmgrav = TRUE;
357 | 			else nmgrav = FALSE;
358 | 			break;
359 | 	}
360 | 	
361 | 	updatetexts();	*/
362 | 
363 | }
364 | 
365 | ///////////////////////////////////////////////////////////////
366 | 


--------------------------------------------------------------------------------
/makefile:
--------------------------------------------------------------------------------
 1 | 
 2 | cc		= gcc
 3 | CC		= g++
 4 | 
 5 | LIBS = -lglut -lGLU -lGL -lX11 -lm -lrt
 6 | 
 7 | #///////////////////////////////////////////////////////////////////////////////
 8 | 
 9 | CFLAGS = --std=c++0x -g -I.
10 | 
11 | #///////////////////////////////////////////////////////////////////////////////
12 | # RULES
13 | 
14 | .SUFFIXES:	.cpp .o .obj
15 | 
16 | .cpp.o:
17 | 	$(CC) $(CFLAGS) -O3 -c $< -o $@ 
18 | 
19 | #///////////////////////////////////////////////////////////////////////////////
20 | 
21 | OBJS = drawfunc.o 
22 | 
23 | all:	$(OBJS)
24 | 	$(CC) main.cpp -o twilight $(CFLAGS) $(OBJS) $(LIBS)
25 | 
26 | #///////////////////////////////////////////////////////////////////////////////
27 | 
28 | clean:
29 | 	rm -f *.o
30 | 	rm -f ork/*.o 
31 | 	rm twilight
32 | 
33 | #///////////////////////////////////////////////////////////////////////////////
34 | 


--------------------------------------------------------------------------------
/makefile.osx:
--------------------------------------------------------------------------------
 1 | 
 2 | cc		= clang 
 3 | CC		= clang++
 4 | 
 5 | LIBS = -lm -framework OpenGL -framework GLUT -framework Cocoa
 6 | 
 7 | #///////////////////////////////////////////////////////////////////////////////
 8 | 
 9 | CFLAGS = --std=c++0x -g -I. -DOSX
10 | 
11 | #///////////////////////////////////////////////////////////////////////////////
12 | # RULES
13 | 
14 | .SUFFIXES:	.cpp .o .obj
15 | 
16 | .cpp.o:
17 | 	$(CC) -x objective-c++ $(CFLAGS) -O3 -c $< -o $@ 
18 | 
19 | #///////////////////////////////////////////////////////////////////////////////
20 | 
21 | OBJS = main.o drawfunc.o 
22 | 
23 | all:	$(OBJS)
24 | 	$(CC) -o twilight $(CFLAGS) $(OBJS) $(LIBS)
25 | 
26 | #///////////////////////////////////////////////////////////////////////////////
27 | 
28 | clean:
29 | 	rm -f *.o
30 | 	rm -f ork/*.o 
31 | 	rm twilight
32 | 
33 | #///////////////////////////////////////////////////////////////////////////////
34 | 


--------------------------------------------------------------------------------
/screens/twilight.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tweakoz/twilight/38e8d71aede6e266fb2d5ed9fd9aff4be09cc9f0/screens/twilight.jpg


--------------------------------------------------------------------------------
/screens/twilight_osx.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tweakoz/twilight/38e8d71aede6e266fb2d5ed9fd9aff4be09cc9f0/screens/twilight_osx.jpg


--------------------------------------------------------------------------------