comparison trunk/src/Modules/Output/Graphics/Devices/GraphicsOutputDevicewxGLCanvas.cc @ 397:7a573750b186

- First add of a lot of graphics code from the old version. Not working yet, not even compiling yet.

+// Copyright 2006, Willem van Engen
+//
+// AIM-C: A C++ implementation of the Auditory Image Model
+// http://www.acousticscale.org/AIMC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/*!
+ * \file
+ * \brief Output device for output to a wxWidgets OpenGL canvas
+ *
+ * \author Willem van Engen <[e-mail]>
+ * \date created 2006/09/21
+ * \version \$Id: $
+ */
+
+#include "Support/Common.h"
+
+/*! \class GraphicsOutputDevicewxGLCanvas
+ *
+ *  Graphics output takes a large part of the application's performance at the
+ *  moment when it is inline with the Process() loop. Much is gained by
+ *  putting it in a separate thread, which can be done using ShotTargetThreaded.
+ *
+ *  OpenGL-related documents:
+ *   - http://www.opengl.org/
+ *   - http://www.sgi.com/products/software/opengl/
+ *   - http://developer.apple.com/graphicsimaging/opengl/
+ *   - http://developer.nvidia.com/page/documentation.html
+ *   - Vertex arrays
+ *     - http://www.opengl.org/registry/specs/EXT/vertex_array.txt
+ *     - http://www.awprofessional.com/articles/article.asp?p=461848&seqNum=2&rl=1
+ *     - http://jdobry.webpark.cz/opengl/opengl_maximum_performance.html
+ *   - Fonts and OpenGL
+ *     - http://gltt.sourceforge.net/
+ */
+
+// And finally our own
+#include "Support/util.h"
+#include "Output/GraphicsOutputDevice.h"
+#include "Output/GraphicsOutputDevicewxGLCanvas.h"
+
+BEGIN_EVENT_TABLE(GraphicsOutputDevicewxGLCanvas, wxGLCanvas)
+    EVT_SIZE(GraphicsOutputDevicewxGLCanvas::OnSize)
+    EVT_PAINT(GraphicsOutputDevicewxGLCanvas::OnPaint)
+    EVT_ERASE_BACKGROUND(GraphicsOutputDevicewxGLCanvas::OnEraseBackground)
+END_EVENT_TABLE()
+
+// wxGLCanvas attributes
+int GraphicsOutputDevicewxGLCanvas::GLAttrlist[] = {
+  WX_GL_RGBA, 1,
+  WX_GL_DOUBLEBUFFER, 1,
+  WX_GL_MIN_RED, 5,
+  WX_GL_MIN_GREEN, 5,
+  WX_GL_MIN_BLUE, 5,
+  WX_GL_MIN_ALPHA, 3,
+  WX_GL_DEPTH_SIZE, 16,
+  0
+};
+
+// OpenGL get procaddress function pointer, differs across platforms
+typedef void (*(*glGetProcAddressPtr_t)(const char*))();
+
+GraphicsOutputDevicewxGLCanvas::GraphicsOutputDevicewxGLCanvas(Parameters *pParam,
+	                                                             wxWindow *parent,
+                                                               wxWindowID id,
+                                                               const wxPoint& pos,
+                                                               const wxSize& size,
+                                                               long style,
+                                                               const wxString& name)
+	: wxGLCanvas(parent, (wxGLCanvas*) NULL, id, pos, size,
+               style|wxFULL_REPAINT_ON_RESIZE, name, GLAttrlist),
+	  GraphicsOutputDevice(pParam) {
+	m_init = false;
+	m_gllist = 0;
+	m_pWorkerContext = NULL;
+	m_bAntialiasing = true;
+	m_pFont = NULL;
+	m_sFontFile = NULL;
+	m_iFontsize = -1;
+#if !defined(_MACOSX)
+	s_bWorkerNeedsInit = false;
+#endif
+
+#ifdef WITH_GL_VERTEX_ARRAYS
+	m_iVertexType = 0xffff; // no gBegin() has happened yet
+	m_bStaticColor = false;
+	m_pVertices = NULL;
+	m_iVerticesMax = 0;
+	// Enable vertex arrays if possible
+#ifdef _MACOSX
+	m_glLockArraysEXT = ::glLockArraysEXT;
+	m_glUnlockArraysEXT = ::glUnlockArraysEXT;
+	m_bVertexArrayLock = true;
+#else
+	m_bVertexArrayLock = false;
+	// OpenGL command needed to fetch entry point, do it in InitGL()
+#endif /* _MACOSX */
+#endif /* WITH_GL_VERTEX_ARRAYS */
+}
+
+GraphicsOutputDevicewxGLCanvas::~GraphicsOutputDevicewxGLCanvas() {
+	// Cleanup OpenGL display list
+	if (m_init) {
+		glDeleteLists(m_gllist, 1);
+	}
+	DELETE_IF_NONNULL(m_pWorkerContext);
+	DELETE_IF_NONNULL(m_pFont);
+#ifdef WITH_GL_VERTEX_ARRAYS
+	DELETE_ARRAY_IF_NONNULL(m_pVertices);
+#endif
+}
+
+void GraphicsOutputDevicewxGLCanvas::Start() {
+	// This seems to be needed to prevent a crash on windows, but why????
+	SetCurrent();
+	return GraphicsOutputDevice::Start();
+}
+
+bool GraphicsOutputDevicewxGLCanvas::Initialize(unsigned int iVerticesMax) {
+	AIM_ASSERT(m_pParam);
+	// Give a chance to update anti-aliasing settings
+	if (m_bAntialiasing != m_pParam->GetBool("output.antialias")) {
+	  m_bAntialiasing = m_pParam->GetBool("output.antialias");
+		if (SetCurrent()) {
+		  InitGL();
+#if !defined(_MACOSX)
+			{
+				wxMutexLocker lock(s_mutexOpenGL);
+				s_bWorkerNeedsInit = true;
+			}
+#endif
+		}
+	}
+
+#ifdef WITH_GL_VERTEX_ARRAYS
+	// Re-allocate vertices
+	if (iVerticesMax > m_iVerticesMax) {
+		DELETE_IF_NONNULL(m_pVertices);
+		m_iVerticesMax = iVerticesMax;
+		// If color is static, we need not store the color
+		if (m_bStaticColor)
+			m_pVertices = new GLfloat[(iVerticesMax+1)*3];
+		else
+			m_pVertices = new GLfloat[(iVerticesMax+1)*6];
+	}
+#endif
+
+  // Change font if requested
+	const char *sFontFile = m_pParam->GetString("output.gl.fontfile");
+	unsigned int iFontsize = m_pParam->GetUInt("output.fontsize");
+	if (!m_sFontFile
+      || !strcmp(m_sFontFile,sFontFile)==0
+      || m_iFontsize!=(int)iFontsize) {
+		wxMutexLocker lock(s_mutexOpenGL);
+		DELETE_IF_NONNULL(m_pFont);
+		wxString sWorkingFontFilename = wxString::FromAscii(sFontFile);
+		if (!wxFileExists(sWorkingFontFilename)) {
+	    sWorkingFontFilename = wxString::FromAscii(aimDataDir());
+		  sWorkingFontFilename += _T("/");
+		  sWorkingFontFilename += wxString::FromAscii(sFontFile);
+		}
+		//if (!wxFileExists(sWorkingFontFilename))
+		//sWorkingFontFilename.replace("Font:").append(sFontFile);
+		m_pFont = static_cast<FTFont*>(new FTGLBitmapFont(sWorkingFontFilename.fn_str()));
+		if (!m_pFont || m_pFont->Error()) {
+			aimERROR(_T("Couldn't load font '%s'"), sFontFile);
+			DELETE_IF_NONNULL(m_pFont);
+		} else {
+			// Display lists don't mix with our own usage :(
+			// May not be needed for a Bitmap font
+			//m_pFont->UseDisplayList(false);
+			if ( !m_pFont->FaceSize(iFontsize) ) {
+				AIM_ERROR(_T("Couldn't select font size %u on font '%s'"), iFontsize, sFontFile);
+				DELETE_IF_NONNULL(m_pFont);
+			}
+		}
+		m_sFontFile = sFontFile;
+		m_iFontsize = iFontsize;
+	}
+	return true;
+}
+bool GraphicsOutputDevicewxGLCanvas::Initialize() {
+	return Initialize(0);
+}
+
+void GraphicsOutputDevicewxGLCanvas::Render() {
+	wxPaintDC dc(this);
+	// We want to initialize first from main thread.
+	if (!m_init) {
+	  if (!SetCurrent()) return;
+	  InitGL();
+	}
+	// Render saved list only if not animating (redrawn anyway in that case)
+	if (!m_bRunning) {
+		if (!SetCurrent()) {
+      return;
+    }
+		glClear(GL_COLOR_BUFFER_BIT/*|GL_DEPTH_BUFFER_BIT*/);
+		glCallList(m_gllist);
+		SwapBuffers();
+	}
+}
+
+void GraphicsOutputDevicewxGLCanvas::OnPaint(wxPaintEvent& WXUNUSED(event)) {
+  Render();
+}
+
+void GraphicsOutputDevicewxGLCanvas::OnSize(wxSizeEvent& event) {
+  // this is also necessary to update the context on some platforms
+  wxGLCanvas::OnSize(event);
+
+  // set GL viewport
+	// (not called by wxGLCanvas::OnSize on all platforms...)
+  if (SetCurrent()) {
+		DoResize();
+		// It is only sensible to update the other thread when it's running
+		// Don't acquire the mutex when s_bWorkerNeedsInit already to avoid deadlock
+		if (/*m_bRunning &&*/ !s_bWorkerNeedsInit) {
+			wxMutexLocker lock(s_mutexOpenGL);
+			s_bWorkerNeedsInit = true;
+		}
+	}
+}
+
+void GraphicsOutputDevicewxGLCanvas::OnEraseBackground(wxEraseEvent& WXUNUSED(event)) {
+}
+
+bool GraphicsOutputDevicewxGLCanvas::SetCurrent() {
+  bool bRet=true;
+
+#ifndef __WXMOTIF__
+	bRet = (GetContext()!=NULL);
+	if (bRet)
+#endif
+	{
+		wxGLCanvas::SetCurrent();
+	}
+	return bRet;
+}
+
+void GraphicsOutputDevicewxGLCanvas::DoResize() {
+  int w, h;
+	GetClientSize(&w, &h);
+	glViewport(0, 0, (GLint)w, (GLint)h);
+}
+
+void GraphicsOutputDevicewxGLCanvas::InitGL() {
+  /* No SetCurrent() here, because this can be called from different GL contexts.
+	 * Convenient for multi-threaded operation. */
+  //aimERROR(_T("InitGL Called"));
+#if defined(WITH_GL_VERTEX_ARRAYS) && !defined(_MACOSX)
+	if (!m_init) {
+	  /* This needs to be done here, because OpenGL commands may need SetCurrent()
+		 * and an already shown window. */
+		char *extensions = (char *)glGetString(GL_EXTENSIONS);
+		if (!extensions) {
+			AIM_INFO(_T("Could not query OpenGL extensions, vertex arrays disabled"));
+    }	else if (strstr(extensions, "GL_EXT_compiled_vertex_array")) {
+			m_glLockArraysEXT = (LOCAL_PFNGLLOCKARRAYSEXTPROC)GL_GET_PROC_ADDRESS("glLockArraysEXT");
+			m_glUnlockArraysEXT = (LOCAL_PFNGLUNLOCKARRAYSEXTPROC)GL_GET_PROC_ADDRESS("glUnlockArraysEXT");
+			if(!m_glLockArraysEXT || !m_glUnlockArraysEXT)
+				AIM_ERROR(_T("OpenGL error on GL_EXT_compiled_vertex_array"));
+			else
+				m_bVertexArrayLock = true;
+		}
+	}
+#endif
+	DoResize();
+	glClearColor(0, 0, 0, 1);
+	glMatrixMode( GL_PROJECTION );
+	glLoadIdentity( );
+
+	glEnable(GL_VERTEX_ARRAY);
+
+	// Window limits in OpenGL co-ordiantes
+	//! \todo Make this configurable, or change and document fixed values
+	glOrtho(0.0, 1.0, 0.0, 1.0, 0.0, 1.0);
+	glTranslatef(0.0, 0.0, 0.0);
+
+	if (m_bAntialiasing) {
+		glEnable(GL_LINE_SMOOTH);
+		glEnable(GL_BLEND);
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+		//glBlendFunc(GL_ONE, GL_ONE);
+		glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
+	} else {
+		glDisable(GL_LINE_SMOOTH);
+		glDisable(GL_BLEND);
+	}
+	glLineWidth(1.0);
+
+	// Get a free display list only the first time
+	if (!m_init) {
+#if !defined(_MACOSX)
+		// Windows and Linux need a separate worker context
+		aimASSERT(wxIsMainThread());
+#if wxCHECK_VERSION(2,8,0)
+		m_pWorkerContext = new wxGLContext(this, m_glContext);
+#else
+		m_pWorkerContext = new wxGLContext(true,
+                                       this,
+                                       wxNullPalette,
+                                       m_glContext);
+#endif
+		aimASSERT(m_pWorkerContext);
+		s_bWorkerNeedsInit = true;
+#endif
+		m_gllist = glGenLists(1);
+		aimASSERT(m_gllist);
+		// Empty window at start
+		glNewList(m_gllist, GL_COMPILE_AND_EXECUTE);
+		glEndList();
+		m_init = true;
+	}
+}
+
+// Call before any other render* functions
+void GraphicsOutputDevicewxGLCanvas::gGrab() {
+	AimwxGuiLocker __lock__;
+#if !defined(_MACOSX)
+	// Detect if we're the main thread or not.
+	if (!wxIsMainThread()) {
+		// We're called by a worker thread, make sure there's a right context
+		AIM_ASSERT(m_pWorkerContext);
+#if wxCHECK_VERSION(2,8,0)
+		m_pWorkerContext->SetCurrent(*this);
+#else
+		m_pWorkerContext->SetCurrent();
+#endif
+		// Update OpenGL settings if needed
+		wxMutexLocker lock(s_mutexOpenGL);
+		if (s_bWorkerNeedsInit) {
+			InitGL();
+			s_bWorkerNeedsInit = false;
+		}
+	} else
+#endif
+	{
+		// Either called by main thread, or we need no special worker glContext
+		if (!SetCurrent()) {
+		  return;
+		}
+		// Init OpenGL once, but after SetCurrent
+		if (!m_init) {
+			InitGL();
+		}
+	}
+	glClear(GL_COLOR_BUFFER_BIT);
+
+	// Start and store in a display list for redrawing
+	glNewList(m_gllist, GL_COMPILE);
+}
+
+void GraphicsOutputDevicewxGLCanvas::gBeginLineStrip() {
+#ifdef WITH_GL_VERTEX_ARRAYS
+	aimASSERT(m_iVertexType == 0xffff); // Previous gBegin*() must be gEnd()ed
+	// New lines vertex array
+	m_iVertexCount = 0;
+	m_iVertexType = GL_LINE_STRIP;
+#else
+	AimwxGuiLocker __lock__;
+	glBegin(GL_LINE_STRIP);
+#endif
+}
+
+void GraphicsOutputDevicewxGLCanvas::gBeginQuadStrip() {
+#ifdef WITH_GL_VERTEX_ARRAYS
+	aimASSERT(m_iVertexType == 0xffff); // Previous gBegin*() must be gEnd()ed
+	// New quads vertex array
+	m_iVertexCount = 0;
+	m_iVertexType = GL_QUAD_STRIP;
+#else
+	AimwxGuiLocker __lock__;
+	glBegin(GL_QUAD_STRIP);
+#endif
+}
+
+void GraphicsOutputDevicewxGLCanvas::gVertex3f(float x, float y, float z) {
+#ifdef WITH_GL_VERTEX_ARRAYS
+	aimASSERT(m_iVertexType != 0xffff); // Must be inside gBegin*()
+	if (m_iVertexCount>=m_iVerticesMax) {
+		static bool errShown=false;
+		if (!errShown) {
+			aimERROR(_T("Error: max vertex count reached: %d"), m_iVertexCount);
+			errShown=true;
+		}
+		return;
+	}
+	if (m_bStaticColor) {
+		m_pVertices[m_iVertexCount*3+0] = x;
+		m_pVertices[m_iVertexCount*3+1] = y;
+		m_pVertices[m_iVertexCount*3+2] = z;
+	} else {
+		m_pVertices[m_iVertexCount*6+0] = m_fCurColorR;
+		m_pVertices[m_iVertexCount*6+1] = m_fCurColorG;
+		m_pVertices[m_iVertexCount*6+2] = m_fCurColorB;
+		m_pVertices[m_iVertexCount*6+3] = x;
+		m_pVertices[m_iVertexCount*6+4] = y;
+		m_pVertices[m_iVertexCount*6+5] = z;
+	}
+	m_iVertexCount++;
+#else
+	AimwxGuiLocker __lock__;
+	glVertex3f(x,y,z);
+#endif
+}
+
+void GraphicsOutputDevicewxGLCanvas::gColor3f(float r, float g, float b) {
+#ifdef WITH_GL_VERTEX_ARRAYS
+	if (m_iVertexType==0xffff || m_bStaticColor) {
+		// If not inside vertex array run, use the ordinary command
+		glColor3f(r, g, b);
+	}
+	if (!m_bStaticColor) {
+		// Set current color for vertex array usage
+		m_fCurColorR = r;
+		m_fCurColorG = g;
+		m_fCurColorB = b;
+	}
+#else
+	AimwxGuiLocker __lock__;
+    glColor3f(r, g, b);
+#endif
+}
+
+void GraphicsOutputDevicewxGLCanvas::gEnd() {
+#ifdef WITH_GL_VERTEX_ARRAYS
+	aimASSERT(m_iVertexType != 0xffff); // Must be inside gBegin*()
+	AimwxGuiLocker __lock__;
+
+	// Draw the vertex array
+	glEnableClientState(GL_VERTEX_ARRAY);
+
+	// Draw vertices
+	if (m_bStaticColor)
+		glVertexPointer(3, GL_FLOAT, 0, m_pVertices);
+	else
+		glInterleavedArrays(GL_C3F_V3F, 0, m_pVertices);
+	if (m_bVertexArrayLock) m_glLockArraysEXT(0, m_iVertexCount);
+	glDrawArrays(m_iVertexType, 0, m_iVertexCount);
+	if (m_bVertexArrayLock) m_glUnlockArraysEXT();
+
+	glDisableClientState(GL_VERTEX_ARRAY);
+
+	// Remember we're outside a gBegin()..gEnd() loop
+	m_iVertexType = 0xffff;
+#else
+	AimwxGuiLocker __lock__;
+	glEnd();
+#endif
+}
+
+void GraphicsOutputDevicewxGLCanvas::gText3f(float x,
+                                             float y,
+                                             float z,
+                                             const char *sStr,
+                                             bool bRotated) {
+#ifdef WITH_GL_VERTEX_ARRAYS
+	aimASSERT(m_iVertexType == 0xffff); // Must be outside gBegin*()
+#endif
+
+	if (!m_pFont)
+	  return;
+
+	//! \todo make rotation work
+	if (bRotated)
+		return;
+
+	{
+		AimwxGuiLocker __lock__;
+		/*
+		if (bRotated) {
+			glPushMatrix();
+			glTranslatef(x,y,z);
+			glRotatef(90.0f, 0, 0, 1.0f);
+			glRasterPos3f(0,0,0);
+			m_pFont->Render(sStr);
+			glPopMatrix();
+		} else {
+		*/
+		glRasterPos3f(x, y, z);
+		m_pFont->Render(sStr);
+	}
+}
+
+void GraphicsOutputDevicewxGLCanvas::gRelease() {
+#ifdef WITH_GL_VERTEX_ARRAYS
+	aimASSERT(m_iVertexType == 0xffff); // Must be gEnd()ed
+#endif
+	AimwxGuiLocker __lock__;
+	glEndList();
+	glCallList(m_gllist);
+	//glFlush();
+ 	SwapBuffers(); // Doesn't matter in what context
+}