forked from rtv/Stage
-
Notifications
You must be signed in to change notification settings - Fork 3
/
glutgraphics.cc
377 lines (305 loc) · 9.39 KB
/
glutgraphics.cc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
/*
* Player - One Hell of a Robot Server
* glutgraphics.cc: GLUT-based graphics3d + 2d driver
* Copyright (C) 2007
* Brian Gerkey, Richard Vaughan
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
/*
* A simple example of how to write a driver that will be built as a
* shared object.
*/
// ONLY if you need something that was #define'd as a result of configure
// (e.g., HAVE_CFMAKERAW), then #include <config.h>, like so:
/*
#if HAVE_CONFIG_H
#include <config.h>
#endif
*/
#include <unistd.h>
#include <string.h>
#include <libplayercore/playercore.h>
#include <GLUT/glut.h>
#include <stdio.h>
#include <math.h>
GLfloat light0_ambient[] =
{0.2, 0.2, 0.2, 1.0};
GLfloat light0_diffuse[] =
{0.0, 0.0, 0.0, 1.0};
GLfloat light1_diffuse[] =
{1.0, 0.0, 0.0, 1.0};
GLfloat light1_position[] =
{1.0, 1.0, 1.0, 0.0};
GLfloat light2_diffuse[] =
{0.0, 1.0, 0.0, 1.0};
GLfloat light2_position[] =
{-1.0, -1.0, 1.0, 0.0};
float s = 0.0;
GLfloat angle1 = 0.0, angle2 = 0.0;
void
output(GLfloat x, GLfloat y, char *text)
{
char *p;
glPushMatrix();
glTranslatef(x, y, 0);
for (p = text; *p; p++)
glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
glPopMatrix();
}
void
display(void)
{
static GLfloat amb[] =
{0.4, 0.4, 0.4, 0.0};
static GLfloat dif[] =
{1.0, 1.0, 1.0, 0.0};
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_LIGHT1);
glDisable(GL_LIGHT2);
amb[3] = dif[3] = cos(s) / 2.0 + 0.5;
glMaterialfv(GL_FRONT, GL_AMBIENT, amb);
glMaterialfv(GL_FRONT, GL_DIFFUSE, dif);
glPushMatrix();
glTranslatef(-0.3, -0.3, 0.0);
glRotatef(angle1, 1.0, 5.0, 0.0);
glCallList(1); /* render ico display list */
glPopMatrix();
glClear(GL_DEPTH_BUFFER_BIT);
glEnable(GL_LIGHT2);
glDisable(GL_LIGHT1);
amb[3] = dif[3] = 0.5 - cos(s * .95) / 2.0;
glMaterialfv(GL_FRONT, GL_AMBIENT, amb);
glMaterialfv(GL_FRONT, GL_DIFFUSE, dif);
glPushMatrix();
glTranslatef(0.3, 0.3, 0.0);
glRotatef(angle2, 1.0, 0.0, 5.0);
glCallList(1); /* render ico display list */
glPopMatrix();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, 1500, 0, 1500);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
/* Rotate text slightly to help show jaggies. */
glRotatef(4, 0.0, 0.0, 1.0);
output(200, 225, "This is antialiased.");
glDisable(GL_LINE_SMOOTH);
glDisable(GL_BLEND);
output(160, 100, "This text is not.");
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glPopAttrib();
glMatrixMode(GL_MODELVIEW);
glutSwapBuffers();
}
void
idle(void)
{
angle1 = (GLfloat) fmod(angle1 + 0.8, 360.0);
angle2 = (GLfloat) fmod(angle2 + 1.1, 360.0);
s += 0.05;
//usleep( 100000 );
static int g=1;
printf( "cycle %d\n", g++ );
glutPostRedisplay();
}
void
redraw( int val )
{
angle1 = (GLfloat) fmod(angle1 + 0.8, 360.0);
angle2 = (GLfloat) fmod(angle2 + 1.1, 360.0);
s += 0.05;
//usleep( 100000 );
static int g=1;
printf( "cycle %d\n", g++ );
glutPostRedisplay();
glutTimerFunc( 100, redraw, 0 );
}
void
visible(int vis)
{
if (vis == GLUT_VISIBLE)
//glutTimerFunc( 100, redraw, 0 );
glutIdleFunc( idle );
else
glutIdleFunc(NULL);
}
////////////////////////////////////////////////////////////////////////////////
// The class for the driver
class ExampleDriver : public Driver
{
public:
// Constructor; need that
ExampleDriver(ConfigFile* cf, int section);
// Must implement the following methods.
virtual int Setup();
virtual int Shutdown();
// This method will be invoked on each incoming message
virtual int ProcessMessage(MessageQueue* resp_queue,
player_msghdr * hdr,
void * data);
private:
// Main function for device thread.
virtual void Main();
virtual void Update();
int foop;
};
// A factory creation function, declared outside of the class so that it
// can be invoked without any object context (alternatively, you can
// declare it static in the class). In this function, we create and return
// (as a generic Driver*) a pointer to a new instance of this driver.
Driver*
ExampleDriver_Init(ConfigFile* cf, int section)
{
puts( "my init" );
// Create and return a new instance of this driver
return((Driver*)(new ExampleDriver(cf, section)));
}
// A driver registration function, again declared outside of the class so
// that it can be invoked without object context. In this function, we add
// the driver into the given driver table, indicating which interface the
// driver can support and how to create a driver instance.
void ExampleDriver_Register(DriverTable* table)
{
table->AddDriver("glutgraphics", ExampleDriver_Init);
}
////////////////////////////////////////////////////////////////////////////////
// Constructor. Retrieve options from the configuration file and do any
// pre-Setup() setup.
ExampleDriver::ExampleDriver(ConfigFile* cf, int section)
: Driver(cf, section, false, PLAYER_MSGQUEUE_DEFAULT_MAXLEN,
PLAYER_GRAPHICS3D_CODE)
{
// Read an option from the configuration file
//this->foop = cf->ReadInt(section, "foo", 0);
return;
}
static int argc = 1;
static char *argv = "fake";
////////////////////////////////////////////////////////////////////////////////
// Set up the device. Return 0 if things go well, and -1 otherwise.
int ExampleDriver::Setup()
{
puts("Example driver initialising");
// Here you do whatever is necessary to setup the device, like open and
// configure a serial port.
//printf("Was foo option given in config file? %d\n", this->foop);
glutInit( &argc, &argv );
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("blender");
glutDisplayFunc(display);
glutVisibilityFunc(visible);
glNewList(1, GL_COMPILE); /* create ico display list */
glutSolidIcosahedron();
glEndList();
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse);
glLightfv(GL_LIGHT1, GL_POSITION, light1_position);
glLightfv(GL_LIGHT2, GL_DIFFUSE, light2_diffuse);
glLightfv(GL_LIGHT2, GL_POSITION, light2_position);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_LINE_SMOOTH);
glLineWidth(2.0);
glMatrixMode(GL_PROJECTION);
gluPerspective( /* field of view in degree */ 40.0,
/* aspect ratio */ 1.0,
/* Z near */ 1.0, /* Z far */ 10.0);
glMatrixMode(GL_MODELVIEW);
gluLookAt(0.0, 0.0, 5.0, /* eye is at (0,0,5) */
0.0, 0.0, 0.0, /* center is at (0,0,0) */
0.0, 1.0, 0.); /* up is in positive Y direction */
glTranslatef(0.0, 0.6, -1.0);
puts("Example driver ready");
// Start the device thread; spawns a new thread and executes
// ExampleDriver::Main(), which contains the main loop for the driver.
//StartThread();
return(0);
}
////////////////////////////////////////////////////////////////////////////////
// Shutdown the device
int ExampleDriver::Shutdown()
{
puts("Shutting example driver down");
// Stop and join the driver thread
StopThread();
// Here you would shut the device down by, for example, closing a
// serial port.
puts("Example driver has been shutdown");
return(0);
}
int ExampleDriver::ProcessMessage(MessageQueue* resp_queue,
player_msghdr * hdr,
void * data)
{
// Process messages here. Send a response if necessary, using Publish().
// If you handle the message successfully, return 0. Otherwise,
// return -1, and a NACK will be sent for you, if a response is required.
// call this from the driver's private thread - on a timer?
// receive messages and do drawing
return(0);
}
void ExampleDriver::Update()
{
ProcessMessages();
glutCheckLoop();
return;
}
////////////////////////////////////////////////////////////////////////////////
// Main function for device thread
void ExampleDriver::Main()
{
printf( "entering main loop" );
//glutMainLoop();
//return 0; /* ANSI C requires main to return int. */
// The main loop; interact with the device here
for(;;)
{}
//{
// test if we are supposed to cancel
//pthread_testcancel();
// Process incoming messages. ExampleDriver::ProcessMessage() is
// called on each message.
//ProcessMessages();
// Interact with the device, and push out the resulting data, using
// Driver::Publish()
// Sleep (you might, for example, block on a read() instead)
//usleep(100000);
}
////////////////////////////////////////////////////////////////////////////////
// Extra stuff for building a shared object.
/* need the extern to avoid C++ name-mangling */
extern "C" {
int player_driver_init(DriverTable* table)
{
puts("Example driver initializing");
ExampleDriver_Register(table);
puts("Example driver done");
return(0);
}
}