Add MainFrm::GetCSProj() getter method
[survex.git] / src / gla-gl.cc
blob12811ca16f0299fa3b1034df25e6cfa71533d20f
1 //
2 // gla-gl.cc
3 //
4 // OpenGL implementation for the GLA abstraction layer.
5 //
6 // Copyright (C) 2002-2003,2005 Mark R. Shinwell
7 // Copyright (C) 2003,2004,2005,2006,2007,2010,2011,2012,2013,2014,2015,2017,2018 Olly Betts
8 //
9 // This program is free software; you can redistribute it and/or modify
10 // it under the terms of the GNU General Public License as published by
11 // the Free Software Foundation; either version 2 of the License, or
12 // (at your option) any later version.
14 // This program is distributed in the hope that it will be useful,
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 // GNU General Public License for more details.
19 // You should have received a copy of the GNU General Public License
20 // along with this program; if not, write to the Free Software
21 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
28 #include <wx/confbase.h>
29 #include <wx/image.h>
31 #include <algorithm>
33 #include "aven.h"
34 #include "gla.h"
35 #include "message.h"
36 #include "useful.h"
38 #ifdef HAVE_GL_GL_H
39 # include <GL/gl.h>
40 #elif defined HAVE_OPENGL_GL_H
41 # include <OpenGL/gl.h>
42 #endif
44 #ifdef HAVE_GL_GLEXT_H
45 # include <GL/glext.h>
46 #elif defined HAVE_OPENGL_GLEXT_H
47 # include <OpenGL/glext.h>
48 #endif
50 #ifndef GL_POINT_SIZE_MAX
51 #define GL_POINT_SIZE_MAX 0x8127
52 #endif
53 #ifndef GL_POINT_SPRITE
54 #define GL_POINT_SPRITE 0x8861
55 #endif
56 #ifndef GL_COORD_REPLACE
57 #define GL_COORD_REPLACE 0x8862
58 #endif
59 // GL_POINT_SIZE_RANGE is deprecated in OpenGL 1.2 and later, and replaced by
60 // GL_SMOOTH_POINT_SIZE_RANGE.
61 #ifndef GL_SMOOTH_POINT_SIZE_RANGE
62 #define GL_SMOOTH_POINT_SIZE_RANGE GL_POINT_SIZE_RANGE
63 #endif
64 // GL_POINT_SIZE_GRANULARITY is deprecated in OpenGL 1.2 and later, and
65 // replaced by GL_SMOOTH_POINT_SIZE_GRANULARITY.
66 #ifndef GL_SMOOTH_POINT_SIZE_GRANULARITY
67 #define GL_SMOOTH_POINT_SIZE_GRANULARITY GL_POINT_SIZE_GRANULARITY
68 #endif
69 // GL_ALIASED_POINT_SIZE_RANGE was added in OpenGL 1.2.
70 #ifndef GL_ALIASED_POINT_SIZE_RANGE
71 #define GL_ALIASED_POINT_SIZE_RANGE 0x846D
72 #endif
74 using namespace std;
76 const int BLOB_DIAMETER = 5;
78 #define BLOB_TEXTURE \
79 o, o, o, o, o, o, o, o,\
80 o, o, o, o, o, o, o, o,\
81 o, o, I, I, I, o, o, o,\
82 o, I, I, I, I, I, o, o,\
83 o, I, I, I, I, I, o, o,\
84 o, I, I, I, I, I, o, o,\
85 o, o, I, I, I, o, o, o,\
86 o, o, o, o, o, o, o, o
88 #define CROSS_TEXTURE \
89 o, o, o, o, o, o, o, o,\
90 I, o, o, o, o, o, I, o,\
91 o, I, o, o, o, I, o, o,\
92 o, o, I, o, I, o, o, o,\
93 o, o, o, I, o, o, o, o,\
94 o, o, I, o, I, o, o, o,\
95 o, I, o, o, o, I, o, o,\
96 I, o, o, o, o, o, I, o
98 static bool opengl_initialised = false;
100 string GetGLSystemDescription()
102 // If OpenGL isn't initialised we may get a SEGV from glGetString.
103 if (!opengl_initialised)
104 return "No OpenGL information available yet - try opening a file.";
105 const char *p = (const char*)glGetString(GL_VERSION);
106 if (!p)
107 return "Couldn't read OpenGL version!";
109 string info;
110 info += "OpenGL ";
111 info += p;
112 info += '\n';
113 info += (const char*)glGetString(GL_VENDOR);
114 info += '\n';
115 info += (const char*)glGetString(GL_RENDERER);
116 #if defined __WXGTK__ || defined __WXX11__ || defined __WXMOTIF__
117 info += string_format("\nGLX %0.1f\n", wxGLCanvas::GetGLXVersion() * 0.1);
118 #else
119 info += '\n';
120 #endif
122 GLint red, green, blue;
123 glGetIntegerv(GL_RED_BITS, &red);
124 glGetIntegerv(GL_GREEN_BITS, &green);
125 glGetIntegerv(GL_BLUE_BITS, &blue);
126 GLint max_texture_size;
127 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
128 GLint max_viewport[2];
129 glGetIntegerv(GL_MAX_VIEWPORT_DIMS, max_viewport);
130 GLdouble point_size_range[2];
131 glGetDoublev(GL_SMOOTH_POINT_SIZE_RANGE, point_size_range);
132 GLdouble point_size_granularity;
133 glGetDoublev(GL_SMOOTH_POINT_SIZE_GRANULARITY, &point_size_granularity);
134 info += string_format("R%dG%dB%d\n"
135 "Max Texture size: %dx%d\n"
136 "Max Viewport size: %dx%d\n"
137 "Smooth Point Size %.3f-%.3f (granularity %.3f)",
138 (int)red, (int)green, (int)blue,
139 (int)max_texture_size, (int)max_texture_size,
140 (int)max_viewport[0], (int)max_viewport[1],
141 point_size_range[0], point_size_range[1],
142 point_size_granularity);
143 glGetDoublev(GL_ALIASED_POINT_SIZE_RANGE, point_size_range);
144 if (glGetError() != GL_INVALID_ENUM) {
145 info += string_format("\nAliased point size %.3f-%.3f",
146 point_size_range[0], point_size_range[1]);
149 info += "\nDouble buffered: ";
150 if (double_buffered)
151 info += "true";
152 else
153 info += "false";
155 const GLubyte* gl_extensions = glGetString(GL_EXTENSIONS);
156 if (*gl_extensions) {
157 info += '\n';
158 info += (const char*)gl_extensions;
160 return info;
163 static bool
164 glpoint_sprite_works()
166 // Point sprites provide an easy, fast way for us to draw crosses by
167 // texture mapping GL points.
169 // If we have OpenGL >= 2.0 then we definitely have GL_POINT_SPRITE.
170 // Otherwise see if we have the GL_ARB_point_sprite or GL_NV_point_sprite
171 // extensions.
173 // The symbolic constants GL_POINT_SPRITE, GL_POINT_SPRITE_ARB, and
174 // GL_POINT_SPRITE_NV all give the same number so it doesn't matter
175 // which we use.
176 static bool glpoint_sprite = false;
177 static bool checked = false;
178 if (!checked) {
179 float maxSize = 0.0f;
180 glGetFloatv(GL_POINT_SIZE_MAX, &maxSize);
181 if (maxSize >= 8) {
182 glpoint_sprite = (atoi((const char *)glGetString(GL_VERSION)) >= 2);
183 if (!glpoint_sprite) {
184 const char * p = (const char *)glGetString(GL_EXTENSIONS);
185 while (true) {
186 size_t l = 0;
187 if (memcmp(p, "GL_ARB_point_sprite", 19) == 0) {
188 l = 19;
189 } else if (memcmp(p, "GL_NV_point_sprite", 18) == 0) {
190 l = 18;
192 if (l) {
193 p += l;
194 if (*p == '\0' || *p == ' ') {
195 glpoint_sprite = true;
196 break;
199 p = strchr(p + 1, ' ');
200 if (!p) break;
201 ++p;
205 checked = true;
207 return glpoint_sprite;
210 static void
211 log_gl_error(const wxChar * str, GLenum error_code)
213 const char * e = reinterpret_cast<const char *>(gluErrorString(error_code));
214 wxLogError(str, wxString(e, wxConvUTF8).c_str());
217 // Important: CHECK_GL_ERROR must not be called within a glBegin()/glEnd() pair
218 // (thus it must not be called from BeginLines(), etc., or within a
219 // BeginLines()/EndLines() block etc.)
220 #define CHECK_GL_ERROR(M, F) do { \
221 if (!opengl_initialised) { \
222 wxLogError(wxT(__FILE__ ":" STRING(__LINE__) ": OpenGL not initialised before (call " F " in method " M ")")); \
224 GLenum error_code_ = glGetError(); \
225 if (error_code_ != GL_NO_ERROR) { \
226 log_gl_error(wxT(__FILE__ ":" STRING(__LINE__) ": OpenGL error: %s " \
227 "(call " F " in method " M ")"), error_code_); \
229 } while (0)
232 // GLAPen
235 GLAPen::GLAPen()
237 components[0] = components[1] = components[2] = 0.0;
240 void GLAPen::SetColour(double red, double green, double blue)
242 components[0] = red;
243 components[1] = green;
244 components[2] = blue;
247 double GLAPen::GetRed() const
249 return components[0];
252 double GLAPen::GetGreen() const
254 return components[1];
257 double GLAPen::GetBlue() const
259 return components[2];
262 void GLAPen::Interpolate(const GLAPen& pen, double how_far)
264 components[0] += how_far * (pen.GetRed() - components[0]);
265 components[1] += how_far * (pen.GetGreen() - components[1]);
266 components[2] += how_far * (pen.GetBlue() - components[2]);
269 struct ColourTriple {
270 // RGB triple: values are from 0-255 inclusive for each component.
271 unsigned char r, g, b;
274 // These must be in the same order as the entries in COLOURS[] below.
275 const ColourTriple COLOURS[] = {
276 { 0, 0, 0 }, // black
277 { 100, 100, 100 }, // grey
278 { 180, 180, 180 }, // light grey
279 { 140, 140, 140 }, // light grey 2
280 { 90, 90, 90 }, // dark grey
281 { 255, 255, 255 }, // white
282 { 0, 100, 255}, // turquoise
283 { 0, 255, 40 }, // green
284 { 150, 205, 224 }, // indicator 1
285 { 114, 149, 160 }, // indicator 2
286 { 255, 255, 0 }, // yellow
287 { 255, 0, 0 }, // red
288 { 40, 40, 255 }, // blue
291 bool GLAList::need_to_generate() {
292 // Bail out if the list is already cached, or can't usefully be cached.
293 if (flags & (GLACanvas::CACHED|GLACanvas::NEVER_CACHE))
294 return false;
296 // Create a new OpenGL list to hold this sequence of drawing
297 // operations.
298 if (gl_list == 0) {
299 gl_list = glGenLists(1);
300 CHECK_GL_ERROR("GLAList::need_to_generate", "glGenLists");
301 #ifdef GLA_DEBUG
302 printf("glGenLists(1) returned %u\n", (unsigned)gl_list);
303 #endif
304 if (gl_list == 0) {
305 // If we can't create a list for any reason, fall back to just
306 // drawing directly, and flag the list as NEVER_CACHE as there's
307 // unlikely to be much point calling glGenLists() again.
308 flags = GLACanvas::NEVER_CACHE;
309 return false;
312 // We should have 256 lists for font drawing and a dozen or so for 2D
313 // and 3D lists. So something is amiss if we've generated 1000 lists,
314 // probably a infinite loop in the lazy list mechanism.
315 assert(gl_list < 1000);
317 // https://www.opengl.org/resources/faq/technical/displaylist.htm advises:
319 // "Stay away from GL_COMPILE_AND_EXECUTE mode. Instead, create the
320 // list using GL_COMPILE mode, then execute it with glCallList()."
321 glNewList(gl_list, GL_COMPILE);
322 CHECK_GL_ERROR("GLAList::need_to_generate", "glNewList");
323 return true;
326 void GLAList::finalise(unsigned int list_flags)
328 glEndList();
329 CHECK_GL_ERROR("GLAList::finalise", "glEndList");
330 if (list_flags & GLACanvas::NEVER_CACHE) {
331 glDeleteLists(gl_list, 1);
332 CHECK_GL_ERROR("GLAList::finalise", "glDeleteLists");
333 gl_list = 0;
334 flags = GLACanvas::NEVER_CACHE;
335 } else {
336 flags = list_flags | GLACanvas::CACHED;
340 bool GLAList::DrawList() const {
341 if ((flags & GLACanvas::CACHED) == 0)
342 return false;
343 glCallList(gl_list);
344 CHECK_GL_ERROR("GLAList::DrawList", "glCallList");
345 return true;
349 // GLACanvas
352 BEGIN_EVENT_TABLE(GLACanvas, wxGLCanvas)
353 EVT_SIZE(GLACanvas::OnSize)
354 END_EVENT_TABLE()
356 static const int wx_gl_window_attribs[] = {
357 WX_GL_DOUBLEBUFFER,
358 WX_GL_RGBA,
359 WX_GL_DEPTH_SIZE, 16,
363 // Pass wxWANTS_CHARS so that the window gets cursor keys on MS Windows.
364 GLACanvas::GLACanvas(wxWindow* parent, int id)
365 : wxGLCanvas(parent, id, wx_gl_window_attribs, wxDefaultPosition,
366 wxDefaultSize, wxWANTS_CHARS),
367 ctx(this), m_Translation(), blob_method(UNKNOWN), cross_method(UNKNOWN),
368 x_size(0), y_size(0)
370 // Constructor.
372 m_Quadric = NULL;
373 m_Pan = 0.0;
374 m_Tilt = 0.0;
375 m_Scale = 0.0;
376 m_VolumeDiameter = 1.0;
377 m_SmoothShading = false;
378 m_Texture = 0;
379 m_Textured = false;
380 m_Perspective = false;
381 m_Fog = false;
382 m_AntiAlias = false;
383 list_flags = 0;
384 alpha = 1.0;
387 GLACanvas::~GLACanvas()
389 // Destructor.
391 if (m_Quadric) {
392 gluDeleteQuadric(m_Quadric);
393 CHECK_GL_ERROR("~GLACanvas", "gluDeleteQuadric");
397 void GLACanvas::FirstShow()
399 // Update our record of the client area size and centre.
400 GetClientSize(&x_size, &y_size);
401 if (x_size < 1) x_size = 1;
402 if (y_size < 1) y_size = 1;
404 ctx.SetCurrent(*this);
405 opengl_initialised = true;
407 // Set the background colour of the canvas to black.
408 glClearColor(0.0, 0.0, 0.0, 1.0);
409 CHECK_GL_ERROR("FirstShow", "glClearColor");
411 // Set viewport.
412 glViewport(0, 0, x_size, y_size);
413 CHECK_GL_ERROR("FirstShow", "glViewport");
415 save_hints = false;
417 vendor = wxString((const char *)glGetString(GL_VENDOR), wxConvUTF8);
418 renderer = wxString((const char *)glGetString(GL_RENDERER), wxConvUTF8);
420 wxConfigBase * cfg = wxConfigBase::Get();
421 wxString s;
422 if (cfg->Read(wxT("opengl_survex"), &s, wxString()) && s == wxT(VERSION) &&
423 cfg->Read(wxT("opengl_vendor"), &s, wxString()) && s == vendor &&
424 cfg->Read(wxT("opengl_renderer"), &s, wxString()) && s == renderer) {
425 // The survex version, vendor and renderer are the same as those
426 // we cached hints for, so use those hints.
427 int v;
428 if (cfg->Read(wxT("blob_method"), &v, 0) &&
429 (v == SPRITE || v == POINT || v == LINES)) {
430 // How to draw blobs.
431 blob_method = v;
433 if (cfg->Read(wxT("cross_method"), &v, 0) &&
434 (v == SPRITE || v == LINES)) {
435 // How to draw crosses.
436 cross_method = v;
441 if (m_Quadric) return;
442 // One time initialisation follows.
444 m_Quadric = gluNewQuadric();
445 CHECK_GL_ERROR("FirstShow", "gluNewQuadric");
446 if (!m_Quadric) {
447 abort(); // FIXME need to cope somehow
450 glShadeModel(GL_FLAT);
451 CHECK_GL_ERROR("FirstShow", "glShadeModel");
452 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // So text works.
453 CHECK_GL_ERROR("FirstShow", "glPolygonMode");
454 //glAlphaFunc(GL_GREATER, 0.5f);
455 //CHECK_GL_ERROR("FirstShow", "glAlphaFunc");
457 // We want glReadPixels() to read from the front buffer (which is the
458 // default for single-buffered displays).
459 if (double_buffered) {
460 glReadBuffer(GL_FRONT);
461 CHECK_GL_ERROR("FirstShow", "glReadBuffer");
464 // Grey fog effect.
465 GLfloat fogcolour[4] = { 0.5, 0.5, 0.5, 1.0 };
466 glFogfv(GL_FOG_COLOR, fogcolour);
467 CHECK_GL_ERROR("FirstShow", "glFogfv");
469 // Linear fogging.
470 glFogi(GL_FOG_MODE, GL_LINEAR);
471 CHECK_GL_ERROR("FirstShow", "glFogi");
473 // Optimise for speed (compute fog per vertex).
474 glHint(GL_FOG_HINT, GL_FASTEST);
475 CHECK_GL_ERROR("FirstShow", "glHint");
477 // No padding on pixel packing and unpacking (default is to pad each
478 // line to a multiple of 4 bytes).
479 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // For setting texture maps.
480 CHECK_GL_ERROR("FirstShow", "glPixelStorei GL_UNPACK_ALIGNMENT");
481 glPixelStorei(GL_PACK_ALIGNMENT, 1); // For screengrabs and movies.
482 CHECK_GL_ERROR("FirstShow", "glPixelStorei GL_PACK_ALIGNMENT");
484 // Load font
485 wxString path = wmsg_cfgpth();
486 path += wxCONFIG_PATH_SEPARATOR;
487 path += wxT("unifont.pixelfont");
488 if (!m_Font.load(path)) {
489 // FIXME: do something better.
490 // We have this message available: Error in format of font file “%s”
491 fprintf(stderr, "Failed to parse compiled-in font data\n");
492 exit(1);
495 if (blob_method == UNKNOWN) {
496 // Check if we can use GL_POINTS to plot blobs at stations.
497 GLdouble point_size_range[2];
498 glGetDoublev(GL_SMOOTH_POINT_SIZE_RANGE, point_size_range);
499 CHECK_GL_ERROR("FirstShow", "glGetDoublev GL_SMOOTH_POINT_SIZE_RANGE");
500 if (point_size_range[0] <= BLOB_DIAMETER &&
501 point_size_range[1] >= BLOB_DIAMETER) {
502 blob_method = POINT;
503 } else {
504 blob_method = glpoint_sprite_works() ? SPRITE : LINES;
506 save_hints = true;
509 if (blob_method == POINT) {
510 glPointSize(BLOB_DIAMETER);
511 CHECK_GL_ERROR("FirstShow", "glPointSize");
514 if (cross_method == UNKNOWN) {
515 cross_method = glpoint_sprite_works() ? SPRITE : LINES;
516 save_hints = true;
519 if (cross_method == SPRITE) {
520 glGenTextures(1, &m_CrossTexture);
521 CHECK_GL_ERROR("FirstShow", "glGenTextures");
522 glBindTexture(GL_TEXTURE_2D, m_CrossTexture);
523 CHECK_GL_ERROR("FirstShow", "glBindTexture");
524 // Cross image for drawing crosses using texture mapped point sprites.
525 const unsigned char crossteximage[128] = {
526 #define o 0,0
527 #define I 255,255
528 CROSS_TEXTURE
529 #undef o
530 #undef I
532 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
533 CHECK_GL_ERROR("FirstShow", "glPixelStorei");
534 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
535 CHECK_GL_ERROR("FirstShow", "glTexEnvi");
536 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
537 CHECK_GL_ERROR("FirstShow", "glTexParameteri GL_TEXTURE_WRAP_S");
538 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
539 CHECK_GL_ERROR("FirstShow", "glTexParameteri GL_TEXTURE_WRAP_T");
540 glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 8, 8, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, (GLvoid *)crossteximage);
541 CHECK_GL_ERROR("FirstShow", "glTexImage2D");
542 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
543 CHECK_GL_ERROR("FirstShow", "glTexParameteri GL_TEXTURE_MAG_FILTER");
544 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
545 CHECK_GL_ERROR("FirstShow", "glTexParameteri GL_TEXTURE_MIN_FILTER");
548 if (blob_method == SPRITE) {
549 glGenTextures(1, &m_BlobTexture);
550 CHECK_GL_ERROR("FirstShow", "glGenTextures");
551 glBindTexture(GL_TEXTURE_2D, m_BlobTexture);
552 CHECK_GL_ERROR("FirstShow", "glBindTexture");
553 // Image for drawing blobs using texture mapped point sprites.
554 const unsigned char blobteximage[128] = {
555 #define o 0,0
556 #define I 255,255
557 BLOB_TEXTURE
558 #undef o
559 #undef I
561 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
562 CHECK_GL_ERROR("FirstShow", "glPixelStorei");
563 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
564 CHECK_GL_ERROR("FirstShow", "glTexEnvi");
565 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
566 CHECK_GL_ERROR("FirstShow", "glTexParameteri GL_TEXTURE_WRAP_S");
567 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
568 CHECK_GL_ERROR("FirstShow", "glTexParameteri GL_TEXTURE_WRAP_T");
569 glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 8, 8, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, (GLvoid *)blobteximage);
570 CHECK_GL_ERROR("FirstShow", "glTexImage2D");
571 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
572 CHECK_GL_ERROR("FirstShow", "glTexParameteri GL_TEXTURE_MAG_FILTER");
573 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
574 CHECK_GL_ERROR("FirstShow", "glTexParameteri GL_TEXTURE_MIN_FILTER");
578 void GLACanvas::Clear()
580 // Clear the canvas.
582 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
583 CHECK_GL_ERROR("Clear", "glClear");
586 void GLACanvas::SetScale(Double scale)
588 if (scale != m_Scale) {
589 vector<GLAList>::iterator i;
590 for (i = drawing_lists.begin(); i != drawing_lists.end(); ++i) {
591 i->invalidate_if(INVALIDATE_ON_SCALE);
594 m_Scale = scale;
598 void GLACanvas::OnSize(wxSizeEvent & event)
600 wxSize size = event.GetSize();
602 unsigned int mask = 0;
603 if (size.GetWidth() != x_size) mask |= INVALIDATE_ON_X_RESIZE;
604 if (size.GetHeight() != y_size) mask |= INVALIDATE_ON_Y_RESIZE;
605 if (mask) {
606 vector<GLAList>::iterator i;
607 for (i = drawing_lists.begin(); i != drawing_lists.end(); ++i) {
608 i->invalidate_if(mask);
611 // The width and height go to zero when the panel is dragged right
612 // across so we clamp them to be at least 1 to avoid problems.
613 x_size = size.GetWidth();
614 y_size = size.GetHeight();
615 if (x_size < 1) x_size = 1;
616 if (y_size < 1) y_size = 1;
619 event.Skip();
621 if (!opengl_initialised) return;
623 // Set viewport.
624 glViewport(0, 0, x_size, y_size);
625 CHECK_GL_ERROR("OnSize", "glViewport");
628 void GLACanvas::AddTranslationScreenCoordinates(int dx, int dy)
630 // Translate the data by a given amount, specified in screen coordinates.
632 // Find out how far the translation takes us in data coordinates.
633 SetDataTransform();
635 double x0, y0, z0;
636 double x, y, z;
637 gluUnProject(0.0, 0.0, 0.0, modelview_matrix, projection_matrix, viewport,
638 &x0, &y0, &z0);
639 CHECK_GL_ERROR("AddTranslationScreenCoordinates", "gluUnProject");
640 gluUnProject(dx, -dy, 0.0, modelview_matrix, projection_matrix, viewport,
641 &x, &y, &z);
642 CHECK_GL_ERROR("AddTranslationScreenCoordinates", "gluUnProject (2)");
644 // Apply the translation.
645 AddTranslation(Vector3(x - x0, y - y0, z - z0));
648 void GLACanvas::SetVolumeDiameter(glaCoord diameter)
650 // Set the size of the data drawing volume by giving the diameter of the
651 // smallest sphere containing it.
653 m_VolumeDiameter = max(glaCoord(1.0), diameter);
656 void GLACanvas::StartDrawing()
658 // Prepare for a redraw operation.
660 ctx.SetCurrent(*this);
661 glDepthMask(GL_TRUE);
663 if (!save_hints) return;
665 // We want to check on the second redraw.
666 static int draw_count = 2;
667 if (--draw_count != 0) return;
669 if (cross_method != LINES) {
670 SetColour(col_WHITE);
671 Clear();
672 SetDataTransform();
673 BeginCrosses();
674 DrawCross(-m_Translation.GetX(), -m_Translation.GetY(), -m_Translation.GetZ());
675 EndCrosses();
676 static const unsigned char expected_cross[64 * 3] = {
677 #define o 0,0,0
678 #define I 255,255,255
679 CROSS_TEXTURE
680 #undef o
681 #undef I
683 if (!CheckVisualFidelity(expected_cross)) {
684 cross_method = LINES;
685 save_hints = true;
689 if (blob_method != LINES) {
690 SetColour(col_WHITE);
691 Clear();
692 SetDataTransform();
693 BeginBlobs();
694 DrawBlob(-m_Translation.GetX(), -m_Translation.GetY(), -m_Translation.GetZ());
695 EndBlobs();
696 static const unsigned char expected_blob[64 * 3] = {
697 #define o 0,0,0
698 #define I 255,255,255
699 BLOB_TEXTURE
700 #undef o
701 #undef I
703 if (!CheckVisualFidelity(expected_blob)) {
704 blob_method = LINES;
705 save_hints = true;
709 wxConfigBase * cfg = wxConfigBase::Get();
710 cfg->Write(wxT("opengl_survex"), wxT(VERSION));
711 cfg->Write(wxT("opengl_vendor"), vendor);
712 cfg->Write(wxT("opengl_renderer"), renderer);
713 cfg->Write(wxT("blob_method"), blob_method);
714 cfg->Write(wxT("cross_method"), cross_method);
715 cfg->Flush();
716 save_hints = false;
719 void GLACanvas::EnableSmoothPolygons(bool filled)
721 // Prepare for drawing smoothly-shaded polygons.
722 // Only use this when required (in particular lines in lists may not be
723 // coloured correctly when this is enabled).
725 glPushAttrib(GL_ENABLE_BIT|GL_LIGHTING_BIT|GL_POLYGON_BIT);
726 if (filled) {
727 glShadeModel(GL_SMOOTH);
728 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
729 } else {
730 glDisable(GL_LINE_SMOOTH);
731 glDisable(GL_TEXTURE_2D);
732 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
734 CHECK_GL_ERROR("EnableSmoothPolygons", "glPolygonMode");
736 if (filled && m_SmoothShading) {
737 static const GLfloat mat_specular[] = { 0.2, 0.2, 0.2, 1.0 };
738 static const GLfloat light_position[] = { -1.0, -1.0, -1.0, 0.0 };
739 static const GLfloat light_ambient[] = { 0.3, 0.3, 0.3, 1.0 };
740 static const GLfloat light_diffuse[] = { 0.7, 0.7, 0.7, 1.0 };
741 glEnable(GL_COLOR_MATERIAL);
742 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
743 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 10.0);
744 glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
745 glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
746 glLightfv(GL_LIGHT0, GL_POSITION, light_position);
747 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
748 glEnable(GL_LIGHTING);
749 glEnable(GL_LIGHT0);
753 void GLACanvas::DisableSmoothPolygons()
755 glPopAttrib();
758 void GLACanvas::PlaceNormal(const Vector3 &v)
760 // Add a normal (for polygons etc.)
762 glNormal3d(v.GetX(), v.GetY(), v.GetZ());
765 void GLACanvas::SetDataTransform()
767 // Set projection.
768 glMatrixMode(GL_PROJECTION);
769 CHECK_GL_ERROR("SetDataTransform", "glMatrixMode");
770 glLoadIdentity();
771 CHECK_GL_ERROR("SetDataTransform", "glLoadIdentity");
773 double aspect = double(y_size) / double(x_size);
775 Double near_plane = 1.0;
776 if (m_Perspective) {
777 Double lr = near_plane * tan(rad(25.0));
778 Double far_plane = m_VolumeDiameter * 5 + near_plane; // FIXME: work out properly
779 Double tb = lr * aspect;
780 glFrustum(-lr, lr, -tb, tb, near_plane, far_plane);
781 CHECK_GL_ERROR("SetViewportAndProjection", "glFrustum");
782 } else {
783 near_plane = 0.0;
784 assert(m_Scale != 0.0);
785 Double lr = m_VolumeDiameter / m_Scale * 0.5;
786 Double far_plane = m_VolumeDiameter + near_plane;
787 Double tb = lr;
788 if (aspect >= 1.0) {
789 tb *= aspect;
790 } else {
791 lr /= aspect;
793 glOrtho(-lr, lr, -tb, tb, near_plane, far_plane);
794 CHECK_GL_ERROR("SetViewportAndProjection", "glOrtho");
797 // Set the modelview transform for drawing data.
798 glMatrixMode(GL_MODELVIEW);
799 CHECK_GL_ERROR("SetDataTransform", "glMatrixMode");
800 glLoadIdentity();
801 CHECK_GL_ERROR("SetDataTransform", "glLoadIdentity");
802 if (m_Perspective) {
803 glTranslated(0.0, 0.0, -near_plane);
804 } else {
805 glTranslated(0.0, 0.0, -0.5 * m_VolumeDiameter);
807 CHECK_GL_ERROR("SetDataTransform", "glTranslated");
808 // Get axes the correct way around (z upwards, y into screen)
809 glRotated(-90.0, 1.0, 0.0, 0.0);
810 CHECK_GL_ERROR("SetDataTransform", "glRotated");
811 glRotated(-m_Tilt, 1.0, 0.0, 0.0);
812 CHECK_GL_ERROR("SetDataTransform", "glRotated");
813 glRotated(m_Pan, 0.0, 0.0, 1.0);
814 CHECK_GL_ERROR("SetDataTransform", "CopyToOpenGL");
815 if (m_Perspective) {
816 glTranslated(m_Translation.GetX(),
817 m_Translation.GetY(),
818 m_Translation.GetZ());
819 CHECK_GL_ERROR("SetDataTransform", "glTranslated");
822 // Save projection matrix.
823 glGetDoublev(GL_PROJECTION_MATRIX, projection_matrix);
824 CHECK_GL_ERROR("SetDataTransform", "glGetDoublev");
826 // Save viewport coordinates.
827 glGetIntegerv(GL_VIEWPORT, viewport);
828 CHECK_GL_ERROR("SetDataTransform", "glGetIntegerv");
830 // Save modelview matrix.
831 glGetDoublev(GL_MODELVIEW_MATRIX, modelview_matrix);
832 CHECK_GL_ERROR("SetDataTransform", "glGetDoublev");
834 if (!m_Perspective) {
835 // Adjust the translation so we don't change the Z position of the model
836 double X, Y, Z;
837 gluProject(m_Translation.GetX(),
838 m_Translation.GetY(),
839 m_Translation.GetZ(),
840 modelview_matrix, projection_matrix, viewport,
841 &X, &Y, &Z);
842 double Tx, Ty, Tz;
843 gluUnProject(X, Y, 0.5, modelview_matrix, projection_matrix, viewport,
844 &Tx, &Ty, &Tz);
845 glTranslated(Tx, Ty, Tz);
846 CHECK_GL_ERROR("SetDataTransform", "glTranslated");
847 glGetDoublev(GL_MODELVIEW_MATRIX, modelview_matrix);
850 glEnable(GL_DEPTH_TEST);
851 CHECK_GL_ERROR("SetDataTransform", "glEnable GL_DEPTH_TEST");
853 if (m_Textured) {
854 glBindTexture(GL_TEXTURE_2D, m_Texture);
855 glEnable(GL_TEXTURE_2D);
856 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
857 CHECK_GL_ERROR("ToggleTextured", "glTexParameteri GL_TEXTURE_WRAP_S");
858 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
859 CHECK_GL_ERROR("ToggleTextured", "glTexParameteri GL_TEXTURE_WRAP_T");
860 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
861 CHECK_GL_ERROR("ToggleTextured", "glTexParameteri GL_TEXTURE_MAG_FILTER");
862 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
863 GL_LINEAR_MIPMAP_LINEAR);
864 CHECK_GL_ERROR("ToggleTextured", "glTexParameteri GL_TEXTURE_MIN_FILTER");
865 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
866 } else {
867 glDisable(GL_TEXTURE_2D);
869 if (m_Fog) {
870 glFogf(GL_FOG_START, near_plane);
871 glFogf(GL_FOG_END, near_plane + m_VolumeDiameter);
872 glEnable(GL_FOG);
873 } else {
874 glDisable(GL_FOG);
877 glEnable(GL_BLEND);
878 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
879 if (m_AntiAlias) {
880 glEnable(GL_LINE_SMOOTH);
881 } else {
882 glDisable(GL_LINE_SMOOTH);
886 void GLACanvas::SetIndicatorTransform()
888 list_flags |= NEVER_CACHE;
890 // Set the modelview transform and projection for drawing indicators.
892 glDisable(GL_DEPTH_TEST);
893 CHECK_GL_ERROR("SetIndicatorTransform", "glDisable GL_DEPTH_TEST");
894 glDisable(GL_FOG);
895 CHECK_GL_ERROR("SetIndicatorTransform", "glDisable GL_FOG");
897 // Just a simple 2D projection.
898 glMatrixMode(GL_PROJECTION);
899 CHECK_GL_ERROR("SetIndicatorTransform", "glMatrixMode");
900 glLoadIdentity();
901 CHECK_GL_ERROR("SetIndicatorTransform", "glLoadIdentity (2)");
902 gluOrtho2D(0, x_size, 0, y_size);
903 CHECK_GL_ERROR("SetIndicatorTransform", "gluOrtho2D");
905 // No modelview transform.
906 glMatrixMode(GL_MODELVIEW);
907 CHECK_GL_ERROR("SetIndicatorTransform", "glMatrixMode");
908 glLoadIdentity();
909 CHECK_GL_ERROR("SetIndicatorTransform", "glLoadIdentity");
911 glDisable(GL_TEXTURE_2D);
912 CHECK_GL_ERROR("SetIndicatorTransform", "glDisable GL_TEXTURE_2D");
913 glDisable(GL_BLEND);
914 CHECK_GL_ERROR("SetIndicatorTransform", "glDisable GL_BLEND");
915 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
916 CHECK_GL_ERROR("SetIndicatorTransform", "glTexParameteri GL_TEXTURE_WRAP_S");
917 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
918 CHECK_GL_ERROR("SetIndicatorTransform", "glTexParameteri GL_TEXTURE_WRAP_T");
919 glAlphaFunc(GL_GREATER, 0.5f);
920 CHECK_GL_ERROR("SetIndicatorTransform", "glAlphaFunc");
921 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
922 CHECK_GL_ERROR("SetIndicatorTransform", "glTexParameteri GL_TEXTURE_MAG_FILTER");
923 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
924 CHECK_GL_ERROR("SetIndicatorTransform", "glTexParameteri GL_TEXTURE_MIN_FILTER");
925 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
926 CHECK_GL_ERROR("SetIndicatorTransform", "glHint");
929 void GLACanvas::FinishDrawing()
931 // Complete a redraw operation.
933 if (double_buffered) {
934 SwapBuffers();
935 } else {
936 glFlush();
937 CHECK_GL_ERROR("FinishDrawing", "glFlush");
941 void GLACanvas::DrawList(unsigned int l)
943 // FIXME: uncomment to disable use of lists for debugging:
944 // GenerateList(l); return;
945 if (l >= drawing_lists.size()) drawing_lists.resize(l + 1);
947 // We generate the OpenGL lists lazily to minimise delays on startup.
948 // So check if we need to generate the OpenGL list now.
949 if (drawing_lists[l].need_to_generate()) {
950 // Clear list_flags so that we can note what conditions to invalidate
951 // the cached OpenGL list on.
952 list_flags = 0;
954 #ifdef GLA_DEBUG
955 printf("generating list #%u... ", l);
956 m_Vertices = 0;
957 #endif
958 GenerateList(l);
959 #ifdef GLA_DEBUG
960 printf("done (%d vertices)\n", m_Vertices);
961 #endif
962 drawing_lists[l].finalise(list_flags);
965 if (!drawing_lists[l].DrawList()) {
966 // That list isn't cached (which means it probably can't usefully be
967 // cached).
968 GenerateList(l);
972 void GLACanvas::DrawListZPrepass(unsigned int l)
974 glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
975 DrawList(l);
976 glDepthMask(GL_FALSE);
977 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
978 glDepthFunc(GL_EQUAL);
979 DrawList(l);
980 glDepthMask(GL_TRUE);
981 glDepthFunc(GL_LESS);
984 void GLACanvas::DrawList2D(unsigned int l, glaCoord x, glaCoord y, Double rotation)
986 glMatrixMode(GL_PROJECTION);
987 CHECK_GL_ERROR("DrawList2D", "glMatrixMode");
988 glPushMatrix();
989 CHECK_GL_ERROR("DrawList2D", "glPushMatrix");
990 glTranslated(x, y, 0);
991 CHECK_GL_ERROR("DrawList2D", "glTranslated");
992 if (rotation != 0.0) {
993 glRotated(rotation, 0, 0, -1);
994 CHECK_GL_ERROR("DrawList2D", "glRotated");
996 DrawList(l);
997 glMatrixMode(GL_PROJECTION);
998 CHECK_GL_ERROR("DrawList2D", "glMatrixMode 2");
999 glPopMatrix();
1000 CHECK_GL_ERROR("DrawList2D", "glPopMatrix");
1003 void GLACanvas::SetColour(const GLAPen& pen, double rgb_scale)
1005 // Set the colour for subsequent operations.
1006 glColor4f(pen.GetRed() * rgb_scale, pen.GetGreen() * rgb_scale,
1007 pen.GetBlue() * rgb_scale, alpha);
1010 void GLACanvas::SetColour(const GLAPen& pen)
1012 // Set the colour for subsequent operations.
1013 glColor4d(pen.components[0], pen.components[1], pen.components[2], alpha);
1016 void GLACanvas::SetColour(gla_colour colour, double rgb_scale)
1018 // Set the colour for subsequent operations.
1019 rgb_scale /= 255.0;
1020 glColor4f(COLOURS[colour].r * rgb_scale,
1021 COLOURS[colour].g * rgb_scale,
1022 COLOURS[colour].b * rgb_scale,
1023 alpha);
1026 void GLACanvas::SetColour(gla_colour colour)
1028 // Set the colour for subsequent operations.
1029 if (alpha == 1.0) {
1030 glColor3ubv(&COLOURS[colour].r);
1031 } else {
1032 glColor4ub(COLOURS[colour].r,
1033 COLOURS[colour].g,
1034 COLOURS[colour].b,
1035 (unsigned char)(255 * alpha));
1039 void GLACanvas::DrawText(glaCoord x, glaCoord y, glaCoord z, const wxString& str)
1041 // Draw a text string on the current buffer in the current font.
1042 glRasterPos3d(x, y, z);
1043 CHECK_GL_ERROR("DrawText", "glRasterPos3d");
1044 m_Font.write_string(str.data(), str.size());
1047 void GLACanvas::DrawIndicatorText(int x, int y, const wxString& str)
1049 glRasterPos2d(x, y);
1050 CHECK_GL_ERROR("DrawIndicatorText", "glRasterPos2d");
1051 m_Font.write_string(str.data(), str.size());
1054 void GLACanvas::GetTextExtent(const wxString& str, int * x_ext, int * y_ext) const
1056 m_Font.get_text_extent(str.data(), str.size(), x_ext, y_ext);
1059 void GLACanvas::BeginQuadrilaterals()
1061 // Commence drawing of quadrilaterals.
1063 glBegin(GL_QUADS);
1066 void GLACanvas::EndQuadrilaterals()
1068 // Finish drawing of quadrilaterals.
1070 glEnd();
1071 CHECK_GL_ERROR("EndQuadrilaterals", "glEnd GL_QUADS");
1074 void GLACanvas::BeginLines()
1076 // Commence drawing of a set of lines.
1078 glBegin(GL_LINES);
1081 void GLACanvas::EndLines()
1083 // Finish drawing of a set of lines.
1085 glEnd();
1086 CHECK_GL_ERROR("EndLines", "glEnd GL_LINES");
1089 void GLACanvas::BeginTriangles()
1091 // Commence drawing of a set of triangles.
1093 glBegin(GL_TRIANGLES);
1096 void GLACanvas::EndTriangles()
1098 // Finish drawing of a set of triangles.
1100 glEnd();
1101 CHECK_GL_ERROR("EndTriangles", "glEnd GL_TRIANGLES");
1104 void GLACanvas::BeginTriangleStrip()
1106 // Commence drawing of a triangle strip.
1108 glBegin(GL_TRIANGLE_STRIP);
1111 void GLACanvas::EndTriangleStrip()
1113 // Finish drawing of a triangle strip.
1115 glEnd();
1116 CHECK_GL_ERROR("EndTriangleStrip", "glEnd GL_TRIANGLE_STRIP");
1119 void GLACanvas::BeginPolyline()
1121 // Commence drawing of a polyline.
1123 glBegin(GL_LINE_STRIP);
1126 void GLACanvas::EndPolyline()
1128 // Finish drawing of a polyline.
1130 glEnd();
1131 CHECK_GL_ERROR("EndPolyline", "glEnd GL_LINE_STRIP");
1134 void GLACanvas::BeginPolygon()
1136 // Commence drawing of a polygon.
1138 glBegin(GL_POLYGON);
1141 void GLACanvas::EndPolygon()
1143 // Finish drawing of a polygon.
1145 glEnd();
1146 CHECK_GL_ERROR("EndPolygon", "glEnd GL_POLYGON");
1149 void GLACanvas::PlaceVertex(glaCoord x, glaCoord y, glaCoord z)
1151 // Place a vertex for the current object being drawn.
1153 #ifdef GLA_DEBUG
1154 m_Vertices++;
1155 #endif
1156 glVertex3d(x, y, z);
1159 void GLACanvas::PlaceVertex(glaCoord x, glaCoord y, glaCoord z,
1160 glaTexCoord tex_x, glaTexCoord tex_y)
1162 // Place a vertex for the current object being drawn.
1164 #ifdef GLA_DEBUG
1165 m_Vertices++;
1166 #endif
1167 glTexCoord2f(tex_x, tex_y);
1168 glVertex3d(x, y, z);
1171 void GLACanvas::PlaceIndicatorVertex(glaCoord x, glaCoord y)
1173 // Place a vertex for the current indicator object being drawn.
1175 PlaceVertex(x, y, 0.0);
1178 void GLACanvas::BeginBlobs()
1180 // Commence drawing of a set of blobs.
1181 if (blob_method == SPRITE) {
1182 glPushAttrib(GL_ENABLE_BIT|GL_POINT_BIT);
1183 CHECK_GL_ERROR("BeginBlobs", "glPushAttrib");
1184 glBindTexture(GL_TEXTURE_2D, m_BlobTexture);
1185 CHECK_GL_ERROR("BeginBlobs", "glBindTexture");
1186 glEnable(GL_ALPHA_TEST);
1187 CHECK_GL_ERROR("BeginBlobs", "glEnable GL_ALPHA_TEST");
1188 glPointSize(8);
1189 CHECK_GL_ERROR("BeginBlobs", "glPointSize");
1190 glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
1191 CHECK_GL_ERROR("BeginBlobs", "glTexEnvi GL_POINT_SPRITE");
1192 glEnable(GL_TEXTURE_2D);
1193 CHECK_GL_ERROR("BeginBlobs", "glEnable GL_TEXTURE_2D");
1194 glEnable(GL_POINT_SPRITE);
1195 CHECK_GL_ERROR("BeginBlobs", "glEnable GL_POINT_SPRITE");
1196 glBegin(GL_POINTS);
1197 } else if (blob_method == POINT) {
1198 glPushAttrib(GL_ENABLE_BIT);
1199 CHECK_GL_ERROR("BeginBlobs", "glPushAttrib");
1200 glEnable(GL_ALPHA_TEST);
1201 CHECK_GL_ERROR("BeginBlobs", "glEnable GL_ALPHA_TEST");
1202 glEnable(GL_POINT_SMOOTH);
1203 CHECK_GL_ERROR("BeginBlobs", "glEnable GL_POINT_SMOOTH");
1204 glBegin(GL_POINTS);
1205 } else {
1206 glPushAttrib(GL_TRANSFORM_BIT|GL_VIEWPORT_BIT|GL_ENABLE_BIT);
1207 CHECK_GL_ERROR("BeginBlobs", "glPushAttrib");
1208 SetIndicatorTransform();
1209 glEnable(GL_DEPTH_TEST);
1210 CHECK_GL_ERROR("BeginBlobs", "glEnable GL_DEPTH_TEST");
1211 glBegin(GL_LINES);
1215 void GLACanvas::EndBlobs()
1217 // Finish drawing of a set of blobs.
1218 glEnd();
1219 if (blob_method != LINES) {
1220 CHECK_GL_ERROR("EndBlobs", "glEnd GL_POINTS");
1221 } else {
1222 CHECK_GL_ERROR("EndBlobs", "glEnd GL_LINES");
1224 glPopAttrib();
1225 CHECK_GL_ERROR("EndBlobs", "glPopAttrib");
1228 void GLACanvas::DrawBlob(glaCoord x, glaCoord y, glaCoord z)
1230 if (blob_method != LINES) {
1231 // Draw a marker.
1232 PlaceVertex(x, y, z);
1233 } else {
1234 double X, Y, Z;
1235 if (!Transform(Vector3(x, y, z), &X, &Y, &Z)) {
1236 printf("bad transform\n");
1237 return;
1239 // Stuff behind us (in perspective view) will get clipped,
1240 // but we can save effort with a cheap check here.
1241 if (Z <= 0) return;
1243 X -= BLOB_DIAMETER * 0.5;
1244 Y -= BLOB_DIAMETER * 0.5;
1246 PlaceVertex(X, Y + 1, Z);
1247 PlaceVertex(X, Y + (BLOB_DIAMETER - 1), Z);
1249 for (int i = 1; i < (BLOB_DIAMETER - 1); ++i) {
1250 PlaceVertex(X + i, Y, Z);
1251 PlaceVertex(X + i, Y + BLOB_DIAMETER, Z);
1254 PlaceVertex(X + (BLOB_DIAMETER - 1), Y + 1, Z);
1255 PlaceVertex(X + (BLOB_DIAMETER - 1), Y + (BLOB_DIAMETER - 1), Z);
1257 #ifdef GLA_DEBUG
1258 m_Vertices++;
1259 #endif
1262 void GLACanvas::DrawBlob(glaCoord x, glaCoord y)
1264 if (blob_method != LINES) {
1265 // Draw a marker.
1266 PlaceVertex(x, y, 0);
1267 } else {
1268 x -= BLOB_DIAMETER * 0.5;
1269 y -= BLOB_DIAMETER * 0.5;
1271 PlaceVertex(x, y + 1, 0);
1272 PlaceVertex(x, y + (BLOB_DIAMETER - 1), 0);
1274 for (int i = 1; i < (BLOB_DIAMETER - 1); ++i) {
1275 PlaceVertex(x + i, y, 0);
1276 PlaceVertex(x + i, y + BLOB_DIAMETER, 0);
1279 PlaceVertex(x + (BLOB_DIAMETER - 1), y + 1, 0);
1280 PlaceVertex(x + (BLOB_DIAMETER - 1), y + (BLOB_DIAMETER - 1), 0);
1282 #ifdef GLA_DEBUG
1283 m_Vertices++;
1284 #endif
1287 void GLACanvas::BeginCrosses()
1289 // Plot crosses.
1290 if (cross_method == SPRITE) {
1291 glPushAttrib(GL_ENABLE_BIT|GL_POINT_BIT);
1292 CHECK_GL_ERROR("BeginCrosses", "glPushAttrib");
1293 glBindTexture(GL_TEXTURE_2D, m_CrossTexture);
1294 CHECK_GL_ERROR("BeginCrosses", "glBindTexture");
1295 glEnable(GL_ALPHA_TEST);
1296 CHECK_GL_ERROR("BeginCrosses", "glEnable GL_ALPHA_TEST");
1297 glPointSize(8);
1298 CHECK_GL_ERROR("BeginCrosses", "glPointSize");
1299 glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
1300 CHECK_GL_ERROR("BeginCrosses", "glTexEnvi GL_POINT_SPRITE");
1301 glEnable(GL_TEXTURE_2D);
1302 CHECK_GL_ERROR("BeginCrosses", "glEnable GL_TEXTURE_2D");
1303 glEnable(GL_POINT_SPRITE);
1304 CHECK_GL_ERROR("BeginCrosses", "glEnable GL_POINT_SPRITE");
1305 glBegin(GL_POINTS);
1306 } else {
1307 // To get the crosses to appear at a constant size and orientation on
1308 // screen, we plot them in the Indicator transform coordinates (which
1309 // unfortunately means they can't be usefully put in an opengl display
1310 // list).
1311 glPushAttrib(GL_TRANSFORM_BIT|GL_VIEWPORT_BIT|GL_ENABLE_BIT);
1312 CHECK_GL_ERROR("BeginCrosses", "glPushAttrib 2");
1313 SetIndicatorTransform();
1314 // Align line drawing to pixel centres to get pixel-perfect rendering
1315 // (graphics card and driver bugs aside).
1316 glTranslated(-0.5, -0.5, 0);
1317 CHECK_GL_ERROR("BeginCrosses", "glTranslated");
1318 glEnable(GL_DEPTH_TEST);
1319 CHECK_GL_ERROR("BeginCrosses", "glEnable GL_DEPTH_TEST");
1320 glBegin(GL_LINES);
1324 void GLACanvas::EndCrosses()
1326 glEnd();
1327 if (cross_method == SPRITE) {
1328 CHECK_GL_ERROR("EndCrosses", "glEnd GL_POINTS");
1329 } else {
1330 CHECK_GL_ERROR("EndCrosses", "glEnd GL_LINES");
1332 glPopAttrib();
1333 CHECK_GL_ERROR("EndCrosses", "glPopAttrib");
1336 void GLACanvas::DrawCross(glaCoord x, glaCoord y, glaCoord z)
1338 if (cross_method == SPRITE) {
1339 // Draw a marker.
1340 PlaceVertex(x, y, z);
1341 } else {
1342 double X, Y, Z;
1343 if (!Transform(Vector3(x, y, z), &X, &Y, &Z)) {
1344 printf("bad transform\n");
1345 return;
1347 // Stuff behind us (in perspective view) will get clipped,
1348 // but we can save effort with a cheap check here.
1349 if (Z <= 0) return;
1351 // Round to integers before adding on the offsets for the
1352 // cross arms to avoid uneven crosses.
1353 X = rint(X);
1354 Y = rint(Y);
1355 // Need to extend lines by an extra pixel (which shouldn't get drawn by
1356 // the diamond-exit rule).
1357 PlaceVertex(X - 3, Y - 3, Z);
1358 PlaceVertex(X + 4, Y + 4, Z);
1359 PlaceVertex(X - 3, Y + 3, Z);
1360 PlaceVertex(X + 4, Y - 4, Z);
1362 #ifdef GLA_DEBUG
1363 m_Vertices++;
1364 #endif
1367 void GLACanvas::DrawRing(glaCoord x, glaCoord y)
1369 // Draw an unfilled circle
1370 const Double radius = 4;
1371 assert(m_Quadric);
1372 glMatrixMode(GL_MODELVIEW);
1373 CHECK_GL_ERROR("DrawRing", "glMatrixMode");
1374 glPushMatrix();
1375 CHECK_GL_ERROR("DrawRing", "glPushMatrix");
1376 glTranslated(x, y, 0.0);
1377 CHECK_GL_ERROR("DrawRing", "glTranslated");
1378 gluDisk(m_Quadric, radius - 1.0, radius, 12, 1);
1379 CHECK_GL_ERROR("DrawRing", "gluDisk");
1380 glPopMatrix();
1381 CHECK_GL_ERROR("DrawRing", "glPopMatrix");
1384 void GLACanvas::DrawRectangle(gla_colour fill, gla_colour edge,
1385 glaCoord x0, glaCoord y0, glaCoord w, glaCoord h)
1387 // Draw a filled rectangle with an edge in the indicator plane.
1388 // (x0, y0) specify the bottom-left corner of the rectangle and (w, h) the
1389 // size.
1391 SetColour(fill);
1392 BeginQuadrilaterals();
1393 PlaceIndicatorVertex(x0, y0);
1394 PlaceIndicatorVertex(x0 + w, y0);
1395 PlaceIndicatorVertex(x0 + w, y0 + h);
1396 PlaceIndicatorVertex(x0, y0 + h);
1397 EndQuadrilaterals();
1399 if (edge != fill) {
1400 SetColour(edge);
1401 BeginPolyline();
1402 PlaceIndicatorVertex(x0, y0);
1403 PlaceIndicatorVertex(x0 + w, y0);
1404 PlaceIndicatorVertex(x0 + w, y0 + h);
1405 PlaceIndicatorVertex(x0, y0 + h);
1406 PlaceIndicatorVertex(x0, y0);
1407 EndLines();
1411 void
1412 GLACanvas::DrawShadedRectangle(const GLAPen & fill_bot, const GLAPen & fill_top,
1413 glaCoord x0, glaCoord y0,
1414 glaCoord w, glaCoord h)
1416 // Draw a graduated filled rectangle in the indicator plane.
1417 // (x0, y0) specify the bottom-left corner of the rectangle and (w, h) the
1418 // size.
1420 glShadeModel(GL_SMOOTH);
1421 CHECK_GL_ERROR("DrawShadedRectangle", "glShadeModel GL_SMOOTH");
1422 BeginQuadrilaterals();
1423 SetColour(fill_bot);
1424 PlaceIndicatorVertex(x0, y0);
1425 PlaceIndicatorVertex(x0 + w, y0);
1426 SetColour(fill_top);
1427 PlaceIndicatorVertex(x0 + w, y0 + h);
1428 PlaceIndicatorVertex(x0, y0 + h);
1429 EndQuadrilaterals();
1430 glShadeModel(GL_FLAT);
1431 CHECK_GL_ERROR("DrawShadedRectangle", "glShadeModel GL_FLAT");
1434 void GLACanvas::DrawCircle(gla_colour edge, gla_colour fill,
1435 glaCoord cx, glaCoord cy, glaCoord radius)
1437 // Draw a filled circle with an edge.
1438 SetColour(fill);
1439 glMatrixMode(GL_MODELVIEW);
1440 CHECK_GL_ERROR("DrawCircle", "glMatrixMode");
1441 glPushMatrix();
1442 CHECK_GL_ERROR("DrawCircle", "glPushMatrix");
1443 glTranslated(cx, cy, 0.0);
1444 CHECK_GL_ERROR("DrawCircle", "glTranslated");
1445 assert(m_Quadric);
1446 gluDisk(m_Quadric, 0.0, radius, 36, 1);
1447 CHECK_GL_ERROR("DrawCircle", "gluDisk");
1448 SetColour(edge);
1449 gluDisk(m_Quadric, radius - 1.0, radius, 36, 1);
1450 CHECK_GL_ERROR("DrawCircle", "gluDisk (2)");
1451 glPopMatrix();
1452 CHECK_GL_ERROR("DrawCircle", "glPopMatrix");
1455 void GLACanvas::DrawSemicircle(gla_colour edge, gla_colour fill,
1456 glaCoord cx, glaCoord cy,
1457 glaCoord radius, glaCoord start)
1459 // Draw a filled semicircle with an edge.
1460 // The semicircle extends from "start" deg to "start"+180 deg (increasing
1461 // clockwise, 0 deg upwards).
1462 SetColour(fill);
1463 glMatrixMode(GL_MODELVIEW);
1464 CHECK_GL_ERROR("DrawSemicircle", "glMatrixMode");
1465 glPushMatrix();
1466 CHECK_GL_ERROR("DrawSemicircle", "glPushMatrix");
1467 glTranslated(cx, cy, 0.0);
1468 CHECK_GL_ERROR("DrawSemicircle", "glTranslated");
1469 assert(m_Quadric);
1470 gluPartialDisk(m_Quadric, 0.0, radius, 36, 1, start, 180.0);
1471 CHECK_GL_ERROR("DrawSemicircle", "gluPartialDisk");
1472 SetColour(edge);
1473 gluPartialDisk(m_Quadric, radius - 1.0, radius, 36, 1, start, 180.0);
1474 CHECK_GL_ERROR("DrawSemicircle", "gluPartialDisk (2)");
1475 glPopMatrix();
1476 CHECK_GL_ERROR("DrawSemicircle", "glPopMatrix");
1479 void
1480 GLACanvas::DrawTriangle(gla_colour edge, gla_colour fill,
1481 const Vector3 &p0, const Vector3 &p1, const Vector3 &p2)
1483 // Draw a filled triangle with an edge.
1485 SetColour(fill);
1486 BeginTriangles();
1487 PlaceIndicatorVertex(p0.GetX(), p0.GetY());
1488 PlaceIndicatorVertex(p1.GetX(), p1.GetY());
1489 PlaceIndicatorVertex(p2.GetX(), p2.GetY());
1490 EndTriangles();
1492 SetColour(edge);
1493 glBegin(GL_LINE_STRIP);
1494 PlaceIndicatorVertex(p0.GetX(), p0.GetY());
1495 PlaceIndicatorVertex(p1.GetX(), p1.GetY());
1496 PlaceIndicatorVertex(p2.GetX(), p2.GetY());
1497 glEnd();
1498 CHECK_GL_ERROR("DrawTriangle", "glEnd GL_LINE_STRIP");
1501 void GLACanvas::EnableDashedLines()
1503 // Enable dashed lines, and start drawing in them.
1505 glLineStipple(1, 0x3333);
1506 CHECK_GL_ERROR("EnableDashedLines", "glLineStipple");
1507 glEnable(GL_LINE_STIPPLE);
1508 CHECK_GL_ERROR("EnableDashedLines", "glEnable GL_LINE_STIPPLE");
1511 void GLACanvas::DisableDashedLines()
1513 glDisable(GL_LINE_STIPPLE);
1514 CHECK_GL_ERROR("DisableDashedLines", "glDisable GL_LINE_STIPPLE");
1517 bool GLACanvas::Transform(const Vector3 & v,
1518 double* x_out, double* y_out, double* z_out) const
1520 // Convert from data coordinates to screen coordinates.
1522 // Perform the projection.
1523 return gluProject(v.GetX(), v.GetY(), v.GetZ(),
1524 modelview_matrix, projection_matrix, viewport,
1525 x_out, y_out, z_out);
1528 void GLACanvas::ReverseTransform(Double x, Double y,
1529 double* x_out, double* y_out, double* z_out) const
1531 // Convert from screen coordinates to data coordinates.
1533 // Perform the projection.
1534 gluUnProject(x, y, 0.0, modelview_matrix, projection_matrix, viewport,
1535 x_out, y_out, z_out);
1536 CHECK_GL_ERROR("ReverseTransform", "gluUnProject");
1539 Double GLACanvas::SurveyUnitsAcrossViewport() const
1541 // Measure the current viewport in survey units, taking into account the
1542 // current display scale.
1544 assert(m_Scale != 0.0);
1545 list_flags |= INVALIDATE_ON_SCALE;
1546 Double result = m_VolumeDiameter / m_Scale;
1547 if (y_size < x_size) {
1548 result = result * x_size / y_size;
1550 return result;
1553 void GLACanvas::ToggleSmoothShading()
1555 m_SmoothShading = !m_SmoothShading;
1558 void GLACanvas::ToggleTextured()
1560 m_Textured = !m_Textured;
1561 if (m_Textured && m_Texture == 0) {
1562 glGenTextures(1, &m_Texture);
1563 CHECK_GL_ERROR("ToggleTextured", "glGenTextures");
1565 glBindTexture(GL_TEXTURE_2D, m_Texture);
1566 CHECK_GL_ERROR("ToggleTextured", "glBindTexture");
1568 ::wxInitAllImageHandlers();
1570 wxImage img;
1571 wxString texture(wmsg_cfgpth());
1572 texture += wxCONFIG_PATH_SEPARATOR;
1573 texture += wxT("images");
1574 texture += wxCONFIG_PATH_SEPARATOR;
1575 texture += wxT("texture.png");
1576 if (!img.LoadFile(texture, wxBITMAP_TYPE_PNG)) {
1577 // FIXME
1578 fprintf(stderr, "Couldn't load image.\n");
1579 exit(1);
1582 // Generate mipmaps.
1583 gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, // was GL_LUMINANCE
1584 img.GetWidth(), img.GetHeight(),
1585 GL_RGB, GL_UNSIGNED_BYTE, img.GetData());
1586 CHECK_GL_ERROR("ToggleTextured", "gluBuild2DMipmaps");
1588 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1589 CHECK_GL_ERROR("ToggleTextured", "glTexEnvi");
1593 bool GLACanvas::SaveScreenshot(const wxString & fnm, wxBitmapType type) const
1595 const int width = x_size;
1596 const int height = y_size;
1597 unsigned char *pixels = (unsigned char *)malloc(3 * width * (height + 1));
1598 if (!pixels) return false;
1599 glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)pixels);
1600 CHECK_GL_ERROR("SaveScreenshot", "glReadPixels");
1601 unsigned char * tmp_row = pixels + 3 * width * height;
1602 // We need to flip the image vertically - this approach should be more
1603 // efficient than using wxImage::Mirror(false) as that creates a new
1604 // wxImage object.
1605 for (int y = height / 2 - 1; y >= 0; --y) {
1606 unsigned char * upper = pixels + 3 * width * y;
1607 unsigned char * lower = pixels + 3 * width * (height - y - 1);
1608 memcpy(tmp_row, upper, 3 * width);
1609 memcpy(upper, lower, 3 * width);
1610 memcpy(lower, tmp_row, 3 * width);
1612 // NB wxImage constructor calls free(pixels) for us.
1613 wxImage grab(width, height, pixels);
1614 return grab.SaveFile(fnm, type);
1617 bool GLACanvas::CheckVisualFidelity(const unsigned char * target) const
1619 unsigned char pixels[3 * 8 * 8];
1620 if (double_buffered) {
1621 glReadBuffer(GL_BACK);
1622 CHECK_GL_ERROR("FirstShow", "glReadBuffer");
1624 glReadPixels(x_size / 2 - 4, y_size / 2 - 5, 8, 8,
1625 GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)pixels);
1626 CHECK_GL_ERROR("CheckVisualFidelity", "glReadPixels");
1627 if (double_buffered) {
1628 glReadBuffer(GL_FRONT);
1629 CHECK_GL_ERROR("FirstShow", "glReadBuffer");
1631 #if 0
1632 // Show what got drawn and what was expected for debugging.
1633 for (int y = 0; y < 8; ++y) {
1634 for (int x = 0; x < 8; ++x) {
1635 int o = (y * 8 + x) * 3;
1636 printf("%c", pixels[o] ? 'X' : '.');
1638 printf(" ");
1639 for (int x = 0; x < 8; ++x) {
1640 int o = (y * 8 + x) * 3;
1641 printf("%c", target[o] ? 'X' : '.');
1643 printf("\n");
1645 #endif
1646 return (memcmp(pixels, target, sizeof(pixels)) == 0);
1649 void GLACanvas::ReadPixels(int width, int height, unsigned char * buf) const
1651 CHECK_GL_ERROR("ReadPixels", "glReadPixels");
1652 glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)buf);
1655 void GLACanvas::PolygonOffset(bool on) const
1657 if (on) {
1658 glPolygonOffset(1.0, 1.0);
1659 glEnable(GL_POLYGON_OFFSET_FILL);
1660 } else {
1661 glDisable(GL_POLYGON_OFFSET_FILL);