Moved wxGLCanvas to more normal positions

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@6326 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

samples/opengl/penguin/Makefile

@@ -0,0 +1,37 @@
+#
+# File:		Makefile
+# Author:	Robert Roebling
+# Created:	1999
+# Updated:	
+# Copyright:	(c) 1998 Robert Roebling
+#
+# Makefile for OpenGL demo (GTK version)
+#
+# This makefile requires wxWindows/GTK to be 
+# installed (possibly using "make install")
+# on your system.
+#
+
+CPP = gcc
+CC = gcc
+WXCONFIG=../../../wx-config
+WXINCLUDE=-I../../../include
+WXLIB=-L../../../lib
+
+Penguin: penguin.o trackball.o lw.o # glcanvas.o
+	$(CPP) -o Penguin penguin.o trackball.o lw.o `$(WXCONFIG) --libs` $(WXLIB) -lMesaGL -lMesaGLU
+
+penguin.o: penguin.cpp
+	$(CPP) `$(WXCONFIG) --cflags` -I../../gtk $(WXINCLUDE) -c penguin.cpp
+
+lw.o: lw.cpp
+	$(CPP) `$(WXCONFIG) --cflags` -I../../gtk $(WXINCLUDE) -c lw.cpp
+
+trackball.o: trackball.c
+	$(CC) `$(WXCONFIG) --cflags` -I../../gtk $(WXINCLUDE) -c trackball.c
+
+glcanvas.o: ../../gtk/glcanvas.cpp
+	$(CPP) `$(WXCONFIG) --cflags` `gtk-config --cflags` -g -I../../gtk $(WXINCLUDE) -c ../../gtk/glcanvas.cpp
+
+clean: 
+	rm -f *.o Penguin

samples/opengl/penguin/lw.cpp

@@ -0,0 +1,427 @@
+/*
+ * Copyright (C) 1998 Janne L<>f <jlof@mail.student.oulu.fi>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifdef __WXMSW__
+#include <windows.h>
+#endif
+
+#include "lw.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+#define wxInt32 int
+#define wxUint32 unsigned int
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#define MK_ID(a,b,c,d) ((((wxUint32)(a))<<24)| \
+			(((wxUint32)(b))<<16)| \
+			(((wxUint32)(c))<< 8)| \
+			(((wxUint32)(d))    ))
+
+#define ID_FORM MK_ID('F','O','R','M')
+#define ID_LWOB MK_ID('L','W','O','B')
+#define ID_PNTS MK_ID('P','N','T','S')
+#define ID_SRFS MK_ID('S','R','F','S')
+#define ID_SURF MK_ID('S','U','R','F')
+#define ID_POLS MK_ID('P','O','L','S')
+#define ID_COLR MK_ID('C','O','L','R')
+
+static wxInt32 read_char(FILE *f)
+{
+  int c = fgetc(f);
+  return c;
+}
+
+static wxInt32 read_short(FILE *f)
+{
+  return (read_char(f)<<8) | read_char(f);
+}
+
+static wxInt32 read_long(FILE *f)
+{
+  return (read_char(f)<<24) | (read_char(f)<<16) | (read_char(f)<<8) | read_char(f);
+}
+
+static GLfloat read_float(FILE *f)
+{
+  wxInt32 x = read_long(f);
+  return *(GLfloat*)&x;
+}
+
+static int read_string(FILE *f, char *s)
+{
+  int c;
+  int cnt = 0;
+  do {
+    c = read_char(f);
+    if (cnt < LW_MAX_NAME_LEN)
+      s[cnt] = c;
+    else
+      s[LW_MAX_NAME_LEN-1] = 0;
+    cnt++;
+  } while (c != 0);
+  /* if length of string (including \0) is odd skip another byte */
+  if (cnt%2) {
+    read_char(f);
+    cnt++;
+  }
+  return cnt;
+}
+
+static void read_srfs(FILE *f, int nbytes, lwObject *lwo)
+{
+  int guess_cnt = lwo->material_cnt;
+
+  while (nbytes > 0) {
+    lwMaterial *material;
+
+    /* allocate more memory for materials if needed */
+    if (guess_cnt <= lwo->material_cnt) {
+      guess_cnt += guess_cnt/2 + 4;
+      lwo->material = (lwMaterial*) realloc(lwo->material, sizeof(lwMaterial)*guess_cnt);
+    }
+    material = lwo->material + lwo->material_cnt++;
+
+    /* read name */
+    nbytes -= read_string(f,material->name);
+
+    /* defaults */
+    material->r = 0.7;
+    material->g = 0.7;
+    material->b = 0.7;
+  }
+  lwo->material = (lwMaterial*) realloc(lwo->material, sizeof(lwMaterial)*lwo->material_cnt);
+}
+
+
+static void read_surf(FILE *f, int nbytes, lwObject *lwo)
+{
+  int i;
+  char name[LW_MAX_NAME_LEN];
+  lwMaterial *material = NULL;
+
+  /* read surface name */
+  nbytes -= read_string(f,name);
+
+  /* find material */
+  for (i=0; i< lwo->material_cnt; i++) {
+    if (strcmp(lwo->material[i].name,name) == 0) {
+      material = &lwo->material[i];
+      break;
+    }
+  }
+
+  /* read values */
+  while (nbytes > 0) {
+    int id = read_long(f);
+    int len = read_short(f);
+    nbytes -= 6 + len + (len%2);
+
+    switch (id) {
+    case ID_COLR:
+      material->r = read_char(f) / 255.0;
+      material->g = read_char(f) / 255.0;
+      material->b = read_char(f) / 255.0;
+      read_char(f); /* dummy */
+      break;
+    default:
+      fseek(f, len+(len%2), SEEK_CUR);
+    }
+  }
+}
+
+
+static void read_pols(FILE *f, int nbytes, lwObject *lwo)
+{
+  int guess_cnt = lwo->face_cnt;
+  
+  while (nbytes > 0) {
+    lwFace *face;
+    int i;
+
+    /* allocate more memory for polygons if necessary */
+    if (guess_cnt <= lwo->face_cnt) {
+      guess_cnt += guess_cnt + 4;
+      lwo->face = (lwFace*) realloc((void*) lwo->face, sizeof(lwFace)*guess_cnt);
+    }
+    face = lwo->face + lwo->face_cnt++;
+
+    /* number of points in this face */
+    face->index_cnt = read_short(f);
+    nbytes -= 2;
+
+    /* allocate space for points */
+    face->index = (int*) calloc(sizeof(int)*face->index_cnt,1);
+    
+    /* read points in */
+    for (i=0; i<face->index_cnt; i++) {
+      face->index[i] = read_short(f);
+      nbytes -= 2;
+    }
+    
+    /* read surface material */
+    face->material = read_short(f);
+    nbytes -= 2;
+    
+    /* skip over detail  polygons */
+    if (face->material < 0) {
+      int det_cnt;
+      face->material = -face->material;
+      det_cnt = read_short(f);
+      nbytes -= 2;
+      while (det_cnt-- > 0) {
+	int cnt = read_short(f);
+	fseek(f, cnt*2+2, SEEK_CUR);
+	nbytes -= cnt*2+2;
+      }
+    }
+    face->material -= 1;
+  }
+  /* readjust to true size */
+  lwo->face = (lwFace*) realloc(lwo->face, sizeof(lwFace)*lwo->face_cnt);
+}
+
+
+
+static void read_pnts(FILE *f, int nbytes, lwObject *lwo)
+{
+  int i;
+  lwo->vertex_cnt = nbytes / 12;
+  lwo->vertex = (float*) calloc(sizeof(GLfloat)*lwo->vertex_cnt*3, 1);
+  for (i=0; i<lwo->vertex_cnt; i++) {
+    lwo->vertex[i*3+0] = read_float(f);
+    lwo->vertex[i*3+1] = read_float(f);
+    lwo->vertex[i*3+2] = read_float(f);
+  }
+}
+
+
+
+
+
+
+int lw_is_lwobject(const char *lw_file)
+{
+  FILE *f = fopen(lw_file, "rb");
+  if (f) {
+    wxInt32 form = read_long(f);
+    wxInt32 nlen = read_long(f);
+    wxInt32 lwob = read_long(f);
+    fclose(f);
+    if (form == ID_FORM && nlen != 0 && lwob == ID_LWOB)
+      return TRUE;
+  }
+  return FALSE;
+}
+
+
+lwObject *lw_object_read(const char *lw_file)
+{
+  FILE *f = NULL;
+  lwObject *lw_object = NULL;
+
+  wxInt32 form_bytes = 0;
+  wxInt32 read_bytes = 0;
+
+  /* open file */
+  f = fopen(lw_file, "rb");
+  if (f == NULL) {
+    return NULL;
+  }
+
+  /* check for headers */
+  if (read_long(f) != ID_FORM) {
+    fclose(f);
+    return NULL;
+  }
+  form_bytes = read_long(f);
+  read_bytes += 4;
+
+  if (read_long(f) != ID_LWOB) {
+    fclose(f);
+    return NULL;
+  }
+
+  /* create new lwObject */
+  lw_object = (lwObject*) calloc(sizeof(lwObject),1);
+
+  /* read chunks */
+  while (read_bytes < form_bytes) {
+    wxInt32  id     = read_long(f);
+    wxInt32  nbytes = read_long(f);
+    read_bytes += 8 + nbytes + (nbytes%2);
+
+    switch (id) {
+    case ID_PNTS:
+      read_pnts(f, nbytes, lw_object);
+      break;
+    case ID_POLS:
+      read_pols(f, nbytes, lw_object);
+      break;
+    case ID_SRFS:
+      read_srfs(f, nbytes, lw_object);
+      break;
+    case ID_SURF:
+      read_surf(f, nbytes, lw_object);
+      break;
+    default:
+      fseek(f, nbytes + (nbytes%2), SEEK_CUR);
+    }
+  }
+
+  fclose(f);
+  return lw_object;
+}
+
+
+
+void lw_object_free(lwObject *lw_object)
+{
+  if (lw_object->face) {
+    int i;
+    for (i=0; i<lw_object->face_cnt; i++)
+      free(lw_object->face[i].index);
+    free(lw_object->face);
+  }
+  free(lw_object->material);
+  free(lw_object->vertex);
+  free(lw_object);
+}
+
+
+
+
+
+#define PX(i) (lw_object->vertex[face->index[i]*3+0])
+#define PY(i) (lw_object->vertex[face->index[i]*3+1])
+#define PZ(i) (lw_object->vertex[face->index[i]*3+2])
+void lw_object_show(const lwObject *lw_object)
+{
+  int i,j;
+  int prev_index_cnt = -1;
+  int prev_material  = -1;
+  GLfloat prev_nx = 0;
+  GLfloat prev_ny = 0;
+  GLfloat prev_nz = 0;
+
+  for (i=0; i<lw_object->face_cnt; i++) {
+    GLfloat ax,ay,az,bx,by,bz,nx,ny,nz,r;
+    const lwFace *face = lw_object->face+i;
+
+    /* ignore faces with less than 3 points */
+    if (face->index_cnt < 3)
+      continue;
+
+    /* calculate normal */
+    ax = PX(1) - PX(0);
+    ay = PY(1) - PY(0);
+    az = PZ(1) - PZ(0);
+
+    bx = PX(face->index_cnt-1) - PX(0);
+    by = PY(face->index_cnt-1) - PY(0);
+    bz = PZ(face->index_cnt-1) - PZ(0);
+
+    nx = ay * bz - az * by;
+    ny = az * bx - ax * bz;
+    nz = ax * by - ay * bx;
+
+    r = sqrt(nx*nx + ny*ny + nz*nz);
+    if (r < 0.000001) /* avoid division by zero */
+      continue;
+    nx /= r;
+    ny /= r;
+    nz /= r;
+
+    /* glBegin/glEnd */
+    if (prev_index_cnt != face->index_cnt || prev_index_cnt > 4) {
+      if (prev_index_cnt > 0) glEnd();
+      prev_index_cnt = face->index_cnt;
+      switch (face->index_cnt) {
+      case 3:
+	glBegin(GL_TRIANGLES);
+	break;
+      case 4:
+	glBegin(GL_QUADS);
+	break;
+      default:
+	glBegin(GL_POLYGON);
+      }
+    }
+
+    /* update material if necessary */
+    if (prev_material != face->material) {
+      prev_material = face->material;
+      glColor3f(lw_object->material[face->material].r,
+		lw_object->material[face->material].g,
+		lw_object->material[face->material].b);
+    }
+
+    /* update normal if necessary */
+    if (nx != prev_nx || ny != prev_ny || nz != prev_nz) {
+      prev_nx = nx;
+      prev_ny = ny;
+      prev_nz = nz;
+      glNormal3f(nx,ny,nz);
+    }
+
+    /* draw polygon/triangle/quad */
+    for (j=0; j<face->index_cnt; j++)
+      glVertex3f(PX(j),PY(j),PZ(j));
+
+  }
+
+  /* if glBegin was called call glEnd */
+  if (prev_index_cnt > 0)
+    glEnd();
+}
+
+
+GLfloat lw_object_radius(const lwObject *lwo)
+{
+  int i;
+  double max_radius = 0.0;
+
+  for (i=0; i<lwo->vertex_cnt; i++) {
+    GLfloat *v = &lwo->vertex[i*3];
+    double r = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
+    if (r > max_radius)
+      max_radius = r;
+  }
+  return sqrt(max_radius);
+}
+
+void lw_object_scale(lwObject *lwo, GLfloat scale)
+{
+  int i;
+
+  for (i=0; i<lwo->vertex_cnt; i++) {
+    lwo->vertex[i*3+0] *= scale;
+    lwo->vertex[i*3+1] *= scale;
+    lwo->vertex[i*3+2] *= scale;
+  }
+}
+
+

samples/opengl/penguin/lw.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 1998 Janne L<>f <jlof@mail.student.oulu.fi>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifndef LW_H
+#define LW_H
+
+#include <GL/gl.h>
+
+#define LW_MAX_POINTS   200
+#define LW_MAX_NAME_LEN 500
+
+typedef struct {
+  char name[LW_MAX_NAME_LEN];
+  GLfloat r,g,b;
+} lwMaterial;
+
+typedef struct {
+  int material;         /* material of this face */
+  int index_cnt;        /* number of vertices */
+  int *index;           /* index to vertex */
+  float *texcoord;      /* u,v texture coordinates */
+} lwFace;
+
+typedef struct {
+  int face_cnt;
+  lwFace *face;
+
+  int material_cnt;
+  lwMaterial *material;
+
+  int vertex_cnt;
+  GLfloat *vertex;
+
+} lwObject;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int       lw_is_lwobject(const char     *lw_file);
+lwObject *lw_object_read(const char     *lw_file);
+void      lw_object_free(      lwObject *lw_object);
+void      lw_object_show(const lwObject *lw_object);
+
+GLfloat   lw_object_radius(const lwObject *lw_object);
+void      lw_object_scale (lwObject *lw_object, GLfloat scale);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LW_H */
+

samples/opengl/penguin/makefile.b32

@@ -0,0 +1,18 @@
+#
+# File:		makefile.b32
+# Author:	Julian Smart
+# Created:	1999
+# Updated:	
+# Copyright:
+#
+# Makefile : Builds sample for 32-bit BC++
+
+WXDIR = $(WXWIN)
+
+TARGET=penguin
+#EXTRALIBS=$(WXDIR)\lib\glcanvas.lib
+#EXTRACPPFLAGS=-I$(WXDIR)\utils\glcanvas\win
+OBJECTS = $(TARGET).obj lw.obj trackball.obj
+
+!include $(WXDIR)\src\makeprog.b32
+

samples/opengl/penguin/makefile.bcc

@@ -0,0 +1,21 @@
+#
+# File:		makefile.bcc
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+#
+# Builds a BC++ 16-bit sample
+
+!if "$(WXWIN)" == ""
+!error You must define the WXWIN variable in autoexec.bat, e.g. WXWIN=c:\wx
+!endif
+
+WXDIR = $(WXWIN)
+
+TARGET=penguin
+#EXTRALIBS=$(WXDIR)\lib\glcanvas.lib
+#EXTRACPPFLAGS=-I$(WXDIR)\utils\glcanvas\win
+OBJECTS = $(TARGET).obj
+
+!include $(WXDIR)\src\makeprog.bcc
+

samples/opengl/penguin/makefile.g95

@@ -0,0 +1,18 @@
+#
+# File:         makefile.g95
+# Author:       Julian Smart
+# Created:      1999
+# Updated:
+# Copyright:    (c) Julian Smart, 1999
+#
+# Makefile for wxWindows sample (Cygwin/Mingw32).
+
+WXDIR = ../../..
+
+TARGET=penguin
+#EXTRACPPFLAGS=-I../../win
+EXTRALIBS=-lopengl32 -lglu32
+OBJECTS = $(TARGET).o lw.o trackball.o
+
+include $(WXDIR)/src/makeprog.g95
+

samples/opengl/penguin/makefile.unx

@@ -0,0 +1,21 @@
+#
+# File:		makefile.unx
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+# Copyright:	(c) 1998 Julian Smart
+#
+# Makefile for penguin example (UNIX).
+
+PROGRAM=penguin
+
+OPENGLHOME=/home/jacs/mesa/Mesa-2.3
+
+EXTRACPPFLAGS=-I$(OPENGLHOME)/include # -I../../motif
+EXTRALDFLAGS=-L$(OPENGLHOME)/lib
+EXTRALDLIBS=-lMesaGL -lMesaGLU
+
+OBJECTS=$(PROGRAM).o trackball.o lw.o
+
+include ../../../src/makeprog.env
+

samples/opengl/penguin/makefile.vc

@@ -0,0 +1,30 @@
+#
+# File:		makefile.vc
+# Author:	Julian Smart
+# Created:	1999
+# Updated:	
+# Copyright:	(c) Julian Smart
+#
+# Makefile : Builds sample (VC++, WIN32)
+# Use FINAL=1 argument to nmake to build final version with no debug info.
+
+# Set WXDIR for your system
+WXDIR = $(WXWIN)
+
+!if "$(FINAL)" == "1"
+!else
+LIBEXT=_d
+!endif
+
+PROGRAM=penguin
+OBJECTS = $(PROGRAM).obj trackball.obj lw.obj
+#EXTRAINC=-I..\..\win
+EXTRALIBS=glu32.lib opengl32.lib
+
+!include $(WXDIR)\src\makeprog.vc
+
+lw.obj:      lw.cpp lw.h
+        $(cc) @<<
+$(CPPFLAGS2) /c $*.$(SRCSUFF)
+<<
+

samples/opengl/penguin/makefile.wat

@@ -0,0 +1,17 @@
+#
+# Makefile for WATCOM
+#
+# Created by Julian Smart, January 1999
+# 
+#
+
+WXDIR = $(%WXWIN)
+
+PROGRAM = penguin
+OBJECTS = $(PROGRAM).obj
+#EXTRALIBS=$(WXDIR)\lib\glcanvas.lib
+#EXTRACPPFLAGS=-I$(WXDIR)\utils\glcanvas\win
+
+!include $(WXDIR)\src\makeprog.wat
+
+

samples/opengl/penguin/penguin.cpp

@@ -0,0 +1,236 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        penguin.cpp
+// Purpose:     wxGLCanvas demo program
+// Author:      Robert Roebling
+// Modified by:
+// Created:     04/01/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Robert Roebling
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#pragma interface
+#endif
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+#include "wx/wx.h"
+#endif
+
+#include "penguin.h"
+#include <GL/glu.h>
+
+#define VIEW_ASPECT 1.3
+
+/* `Main program' equivalent, creating windows and returning main app frame */
+bool MyApp::OnInit(void)
+{
+
+  /* Create the main frame window */
+  MyFrame *frame = new MyFrame(NULL, "wxWindows OpenGL Demo", wxPoint(50, 50), wxSize(400, 300));
+
+  /* Make a menubar */
+  wxMenu *fileMenu = new wxMenu;
+
+  fileMenu->Append(wxID_EXIT, "E&xit");
+  wxMenuBar *menuBar = new wxMenuBar;
+  menuBar->Append(fileMenu, "&File");
+  frame->SetMenuBar(menuBar);
+
+  frame->m_canvas = new TestGLCanvas(frame, -1, wxPoint(0, 0), wxSize(200, 200));
+
+  /* Load file wiht mesh data */
+  frame->m_canvas->LoadLWO( "penguin.lwo" );
+
+  /* Show the frame */
+  frame->Show(TRUE);
+  
+  return TRUE;
+}
+
+IMPLEMENT_APP(MyApp)
+
+BEGIN_EVENT_TABLE(MyFrame, wxFrame)
+    EVT_MENU(wxID_EXIT, MyFrame::OnExit)
+END_EVENT_TABLE()
+
+/* My frame constructor */
+MyFrame::MyFrame(wxFrame *frame, const wxString& title, const wxPoint& pos,
+    const wxSize& size, long style):
+  wxFrame(frame, -1, title, pos, size, style)
+{
+    m_canvas = NULL;
+}
+
+/* Intercept menu commands */
+void MyFrame::OnExit(wxCommandEvent& event)
+{
+    Destroy();
+}
+
+BEGIN_EVENT_TABLE(TestGLCanvas, wxGLCanvas)
+    EVT_SIZE(TestGLCanvas::OnSize)
+    EVT_PAINT(TestGLCanvas::OnPaint)
+    EVT_ERASE_BACKGROUND(TestGLCanvas::OnEraseBackground)
+    EVT_MOUSE_EVENTS(TestGLCanvas::OnMouse)
+END_EVENT_TABLE()
+
+TestGLCanvas::TestGLCanvas(wxWindow *parent, wxWindowID id,
+    const wxPoint& pos, const wxSize& size, long style, const wxString& name):
+  wxGLCanvas(parent, id, pos, size, style, name)
+{
+   block = FALSE;
+}
+
+TestGLCanvas::~TestGLCanvas(void)
+{
+    /* destroy mesh */
+    lw_object_free(info.lwobject);
+}
+
+void TestGLCanvas::OnPaint( wxPaintEvent& event )
+{
+    /* must always be here */
+    wxPaintDC dc(this);
+
+#ifndef __WXMOTIF__
+    if (!GetContext()) return;
+#endif
+
+    SetCurrent();
+    
+    /* initialize OpenGL */
+    if (info.do_init == TRUE) 
+    {
+        InitGL();
+        info.do_init = FALSE;
+    }
+  
+    /* view */
+    glMatrixMode( GL_PROJECTION );
+    glLoadIdentity();
+    gluPerspective( info.zoom, VIEW_ASPECT, 1, 100 );
+    glMatrixMode( GL_MODELVIEW );
+
+    /* clear */
+    glClearColor( .3, .4, .6, 1 );
+    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+    /* transformations */
+    GLfloat m[4][4];
+    glLoadIdentity();
+    glTranslatef( 0, 0, -30 );
+    build_rotmatrix( m,info.quat );
+    glMultMatrixf( &m[0][0] );
+
+    /* draw object */
+    lw_object_show( info.lwobject );
+    
+    /* flush */
+    glFlush();
+
+    /* swap */
+    SwapBuffers();
+}
+
+void TestGLCanvas::OnSize(wxSizeEvent& event)
+{
+    int width, height;
+    GetClientSize(& width, & height);
+    
+#ifndef __WXMOTIF__
+    if (GetContext())
+#endif
+    {
+        SetCurrent();
+        glViewport(0, 0, width, height);
+    }
+}
+
+void TestGLCanvas::OnEraseBackground(wxEraseEvent& event)
+{
+    /* Do nothing, to avoid flashing on MSW */
+}
+
+void TestGLCanvas::LoadLWO(const wxString &filename)
+{
+    /* test if lightwave object */
+    if (!lw_is_lwobject(filename)) return;
+  
+    /* read lightwave object */
+    lwObject *lwobject = lw_object_read(filename);
+    
+    /* scale */
+    lw_object_scale(lwobject, 10.0 / lw_object_radius(lwobject));
+    
+    /* set up mesh info */
+    info.do_init = TRUE;
+    info.lwobject = lwobject;
+    info.beginx = 0;
+    info.beginy = 0;
+    info.zoom   = 45;
+    trackball( info.quat, 0.0, 0.0, 0.0, 0.0 );
+}
+
+void TestGLCanvas::OnMouse( wxMouseEvent& event )
+{
+    wxSize sz(GetClientSize());
+    if (event.Dragging())
+    {
+        /* drag in progress, simulate trackball */
+        float spin_quat[4];
+        trackball(spin_quat,
+	      (2.0*info.beginx -       sz.x) / sz.x,
+	      (     sz.y - 2.0*info.beginy) / sz.y,
+	      (     2.0*event.GetX() - sz.x) / sz.x,
+	      (    sz.y - 2.0*event.GetY()) / sz.y);
+	      
+        add_quats( spin_quat, info.quat, info.quat );
+	
+        /* orientation has changed, redraw mesh */
+  	Refresh(FALSE);
+    }
+    
+    info.beginx = event.GetX();
+    info.beginy = event.GetY();
+}
+
+void TestGLCanvas::InitGL(void)
+{
+    GLfloat light0_pos[4]   = { -50.0, 50.0, 0.0, 0.0 };
+    GLfloat light0_color[4] = { .6, .6, .6, 1.0 }; /* white light */
+    GLfloat light1_pos[4]   = {  50.0, 50.0, 0.0, 0.0 };
+    GLfloat light1_color[4] = { .4, .4, 1, 1.0 };  /* cold blue light */
+
+    /* remove back faces */
+    glDisable(GL_CULL_FACE);
+    glEnable(GL_DEPTH_TEST);
+  
+    /* speedups */
+    glEnable(GL_DITHER);
+    glShadeModel(GL_SMOOTH);
+    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
+    glHint(GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
+
+    /* light */
+    glLightfv(GL_LIGHT0, GL_POSITION, light0_pos);
+    glLightfv(GL_LIGHT0, GL_DIFFUSE,  light0_color);  
+    glLightfv(GL_LIGHT1, GL_POSITION, light1_pos);
+    glLightfv(GL_LIGHT1, GL_DIFFUSE,  light1_color);
+    glEnable(GL_LIGHT0);
+    glEnable(GL_LIGHT1);
+    glEnable(GL_LIGHTING);
+    
+    glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
+    glEnable(GL_COLOR_MATERIAL);  
+}
+
+

samples/opengl/penguin/penguin.h

@@ -0,0 +1,84 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        penguin.h
+// Purpose:     wxGLCanvas demo program
+// Author:      Robert Roebling
+// Modified by:
+// Created:     04/01/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Robert Roebling
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_PENGUIN_H_
+#define _WX_PENGUIN_H_
+
+
+#include "wx/defs.h"
+#include "wx/app.h"
+#include "wx/menu.h"
+#include "wx/dcclient.h"
+
+#include "wx/glcanvas.h"
+
+extern "C" {
+#include "lw.h"
+#include "trackball.h"
+}
+
+/* information needed to display lightwave mesh */
+typedef struct 
+{
+//  gint do_init;         /* true if initgl not yet called */
+  int do_init;
+  lwObject *lwobject;   /* lightwave object mesh */
+  float beginx,beginy;  /* position of mouse */
+  float quat[4];        /* orientation of object */
+  float zoom;           /* field of view in degrees */
+} mesh_info;
+
+
+/* Define a new application type */
+class MyApp: public wxApp
+{
+public:
+    bool OnInit(void);
+};
+
+/* Define a new frame type */
+class TestGLCanvas;
+class MyFrame: public wxFrame
+{
+public:
+    MyFrame(wxFrame *frame, const wxString& title, const wxPoint& pos, const wxSize& size,
+        long style = wxDEFAULT_FRAME_STYLE);
+
+    void OnExit(wxCommandEvent& event);
+public:
+    TestGLCanvas*    m_canvas;
+
+DECLARE_EVENT_TABLE()
+};
+
+
+class TestGLCanvas: public wxGLCanvas
+{
+ public:
+   TestGLCanvas(wxWindow *parent, const wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition,
+      const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "TestGLCanvas");
+   ~TestGLCanvas(void);
+
+   void OnPaint(wxPaintEvent& event);
+   void OnSize(wxSizeEvent& event);
+   void OnEraseBackground(wxEraseEvent& event);
+   void LoadLWO( const wxString &filename);
+   void OnMouse( wxMouseEvent& event );
+   void InitGL(void);
+   
+   mesh_info  info;
+   bool       block;
+
+DECLARE_EVENT_TABLE()
+};
+
+#endif
+

samples/opengl/penguin/penguin.rc

@@ -0,0 +1,3 @@
+/* mondrian ICON "mondrian.ico" */
+#include "wx/msw/wx.rc"
+

samples/opengl/penguin/trackball.h

@@ -0,0 +1,78 @@
+/*
+ * (c) Copyright 1993, 1994, Silicon Graphics, Inc.
+ * ALL RIGHTS RESERVED
+ * Permission to use, copy, modify, and distribute this software for
+ * any purpose and without fee is hereby granted, provided that the above
+ * copyright notice appear in all copies and that both the copyright notice
+ * and this permission notice appear in supporting documentation, and that
+ * the name of Silicon Graphics, Inc. not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.
+ *
+ * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
+ * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
+ * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
+ * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
+ * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
+ * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
+ * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
+ * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
+ * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
+ * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * US Government Users Restricted Rights
+ * Use, duplication, or disclosure by the Government is subject to
+ * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
+ * (c)(1)(ii) of the Rights in Technical Data and Computer Software
+ * clause at DFARS 252.227-7013 and/or in similar or successor
+ * clauses in the FAR or the DOD or NASA FAR Supplement.
+ * Unpublished-- rights reserved under the copyright laws of the
+ * United States.  Contractor/manufacturer is Silicon Graphics,
+ * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
+ *
+ * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
+ */
+/*
+ * trackball.h
+ * A virtual trackball implementation
+ * Written by Gavin Bell for Silicon Graphics, November 1988.
+ */
+
+/*
+ * Pass the x and y coordinates of the last and current positions of
+ * the mouse, scaled so they are from (-1.0 ... 1.0).
+ *
+ * The resulting rotation is returned as a quaternion rotation in the
+ * first paramater.
+ */
+void
+trackball(float q[4], float p1x, float p1y, float p2x, float p2y);
+
+/*
+ * Given two quaternions, add them together to get a third quaternion.
+ * Adding quaternions to get a compound rotation is analagous to adding
+ * translations to get a compound translation.  When incrementally
+ * adding rotations, the first argument here should be the new
+ * rotation, the second and third the total rotation (which will be
+ * over-written with the resulting new total rotation).
+ */
+void
+add_quats(float *q1, float *q2, float *dest);
+
+/*
+ * A useful function, builds a rotation matrix in Matrix based on
+ * given quaternion.
+ */
+void
+build_rotmatrix(float m[4][4], float q[4]);
+
+/*
+ * This function computes a quaternion based on an axis (defined by
+ * the given vector) and an angle about which to rotate.  The angle is
+ * expressed in radians.  The result is put into the third argument.
+ */
+void
+axis_to_quat(float a[3], float phi, float q[4]);
+