[wxWidgets.git] / utils / glcanvas / win / glcanvas.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        glcanvas.cpp
// Purpose:     wxGLCanvas, for using OpenGL with wxWindows under MS Windows
// Author:      Julian Smart
// Modified by:
// Created:     04/01/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "glcanvas.h"
#endif

#include "wx/wxprec.h"

#if defined(__BORLANDC__)
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include <wx/frame.h>
#endif

#include "GL/gl.h"

#include "glcanvas.h"

/*
 * GLContext implementation
 */

wxGLContext::wxGLContext(bool isRGB, wxWindow *win, const wxPalette& palette)
{
  m_window = win;

  m_hDC = (WXHDC) ::GetDC((HWND) win->GetHWND());

  SetupPixelFormat();
  SetupPalette(palette);

  m_glContext = wglCreateContext((HDC) m_hDC);
  wglMakeCurrent((HDC) m_hDC, m_glContext);
}

wxGLContext::~wxGLContext()
{
  if (m_glContext)
  {
    wglMakeCurrent(NULL, NULL);
	wglDeleteContext(m_glContext);
  }

  ::ReleaseDC((HWND) m_window->GetHWND(), (HDC) m_hDC);
}

void wxGLContext::SwapBuffers()
{
  if (m_glContext)
  {
    wglMakeCurrent((HDC) m_hDC, m_glContext);
    ::SwapBuffers((HDC) m_hDC);    //blits the backbuffer into DC
  }
}

void wxGLContext::SetCurrent()
{
  if (m_glContext)
  {
    wglMakeCurrent((HDC) m_hDC, m_glContext);
  }

/*
	setupPixelFormat(hDC);
	setupPalette(hDC);
*/
}

void wxGLContext::SetColour(const char *colour)
{
  float r = 0.0;
  float g = 0.0;
  float b = 0.0;
  wxColour *col = wxTheColourDatabase->FindColour(colour);
  if (col)
  {
    r = (float)(col->Red()/256.0);
    g = (float)(col->Green()/256.0);
    b = (float)(col->Blue()/256.0);
    glColor3f( r, g, b);
  }
}

void wxGLContext::SetupPixelFormat() // (HDC hDC)
{
    PIXELFORMATDESCRIPTOR pfd = {
	sizeof(PIXELFORMATDESCRIPTOR),	/* size */
	1,				/* version */
	PFD_SUPPORT_OPENGL |
	PFD_DRAW_TO_WINDOW |
	PFD_DOUBLEBUFFER,		/* support double-buffering */
	PFD_TYPE_RGBA,			/* color type */
	16,				/* prefered color depth */
	0, 0, 0, 0, 0, 0,		/* color bits (ignored) */
	0,				/* no alpha buffer */
	0,				/* alpha bits (ignored) */
	0,				/* no accumulation buffer */
	0, 0, 0, 0,			/* accum bits (ignored) */
	16,				/* depth buffer */
	0,				/* no stencil buffer */
	0,				/* no auxiliary buffers */
	PFD_MAIN_PLANE,			/* main layer */
	0,				/* reserved */
	0, 0, 0,			/* no layer, visible, damage masks */
    };
    int pixelFormat;

    pixelFormat = ChoosePixelFormat((HDC) m_hDC, &pfd);
    if (pixelFormat == 0) {
	MessageBox(WindowFromDC((HDC) m_hDC), "ChoosePixelFormat failed.", "Error",
		MB_ICONERROR | MB_OK);
	exit(1);
    }

    if (SetPixelFormat((HDC) m_hDC, pixelFormat, &pfd) != TRUE) {
	MessageBox(WindowFromDC((HDC) m_hDC), "SetPixelFormat failed.", "Error",
		MB_ICONERROR | MB_OK);
	exit(1);
    }
}

void wxGLContext::SetupPalette(const wxPalette& palette)
{
    int pixelFormat = GetPixelFormat((HDC) m_hDC);
    PIXELFORMATDESCRIPTOR pfd;

    DescribePixelFormat((HDC) m_hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

    if (pfd.dwFlags & PFD_NEED_PALETTE)
    {
    }
    else
    {
	  return;
    }

    m_palette = palette;

    if ( !m_palette.Ok() )
    {
        m_palette = CreateDefaultPalette();
    }

    if (m_palette.Ok())
    {
        SelectPalette((HDC) m_hDC, (HPALETTE) m_palette.GetHPALETTE(), FALSE);
        RealizePalette((HDC) m_hDC);
    }
}

wxPalette wxGLContext::CreateDefaultPalette()
{
    PIXELFORMATDESCRIPTOR pfd;
    int paletteSize;
    int pixelFormat = GetPixelFormat((HDC) m_hDC);

    DescribePixelFormat((HDC) m_hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

	paletteSize = 1 << pfd.cColorBits;

    LOGPALETTE* pPal =
     (LOGPALETTE*) malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
    pPal->palVersion = 0x300;
    pPal->palNumEntries = paletteSize;

    /* build a simple RGB color palette */
    {
	int redMask = (1 << pfd.cRedBits) - 1;
	int greenMask = (1 << pfd.cGreenBits) - 1;
	int blueMask = (1 << pfd.cBlueBits) - 1;
	int i;

	for (i=0; i<paletteSize; ++i) {
	    pPal->palPalEntry[i].peRed =
		    (((i >> pfd.cRedShift) & redMask) * 255) / redMask;
	    pPal->palPalEntry[i].peGreen =
		    (((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
	    pPal->palPalEntry[i].peBlue =
		    (((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;
	    pPal->palPalEntry[i].peFlags = 0;
	}
    }

    HPALETTE hPalette = CreatePalette(pPal);
    free(pPal);

    wxPalette palette;
    palette.SetHPALETTE((WXHPALETTE) hPalette);

    return palette;
}

/*
 * wxGLCanvas implementation
 */

IMPLEMENT_CLASS(wxGLCanvas, wxScrolledWindow)

BEGIN_EVENT_TABLE(wxGLCanvas, wxScrolledWindow)
    EVT_SIZE(wxGLCanvas::OnSize)
    EVT_PALETTE_CHANGED(wxGLCanvas::OnPaletteChanged)
    EVT_QUERY_NEW_PALETTE(wxGLCanvas::OnQueryNewPalette)
END_EVENT_TABLE()

wxGLCanvas::wxGLCanvas(wxWindow *parent, wxWindowID id,
    const wxPoint& pos, const wxSize& size, long style, const wxString& name,
    int *attribList /* not used yet! */, const wxPalette& palette):
  wxScrolledWindow(parent, id, pos, size, style, name)
{
  m_glContext = new wxGLContext(TRUE, this, palette);
}

wxGLCanvas::~wxGLCanvas()
{
  if (m_glContext)
    delete m_glContext;
}

void wxGLCanvas::SwapBuffers()
{
  if (m_glContext)
    m_glContext->SwapBuffers();
}

void wxGLCanvas::OnSize(wxSizeEvent& event)
{
  int width, height;
  GetClientSize(& width, & height);

  if (m_glContext)
  {
    m_glContext->SetCurrent();

    glViewport(0, 0, (GLint)width, (GLint)height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 15.0 );
    glMatrixMode(GL_MODELVIEW);
  }
}

void wxGLCanvas::SetCurrent()
{
  if (m_glContext)
  {
    m_glContext->SetCurrent();
  }
}

void wxGLCanvas::SetColour(const char *colour)
{
  if (m_glContext)
    m_glContext->SetColour(colour);
}

// TODO: Have to have this called by parent frame (?)
// So we need wxFrame to call OnQueryNewPalette for all children...
void wxGLCanvas::OnQueryNewPalette(wxQueryNewPaletteEvent& event)
{
	/* realize palette if this is the current window */
	if (m_glContext && m_glContext->GetPalette()->Ok()) {
	    ::UnrealizeObject((HPALETTE) m_glContext->GetPalette()->GetHPALETTE());
	    ::SelectPalette((HDC) m_glContext->GetHDC(), (HPALETTE) m_glContext->GetPalette()->GetHPALETTE(), FALSE);
	    ::RealizePalette((HDC) m_glContext->GetHDC());
	    Refresh();
	    event.SetPaletteRealized(TRUE);
    }
    else
	    event.SetPaletteRealized(FALSE);
}

// I think this doesn't have to be propagated to child windows.
void wxGLCanvas::OnPaletteChanged(wxPaletteChangedEvent& event)
{
	/* realize palette if this is *not* the current window */
	if ( m_glContext &&
         m_glContext->GetPalette() &&
         m_glContext->GetPalette()->Ok() &&
         (this != event.GetChangedWindow()) )
    {
	    ::UnrealizeObject((HPALETTE) m_glContext->GetPalette()->GetHPALETTE());
	    ::SelectPalette((HDC) m_glContext->GetHDC(), (HPALETTE) m_glContext->GetPalette()->GetHPALETTE(), FALSE);
	    ::RealizePalette((HDC) m_glContext->GetHDC());
	    Refresh();
	}
}

/* Give extensions proper function names. */

/* EXT_vertex_array */
void glArrayElementEXT(GLint i)
{
}

void glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
{
}

void glDrawArraysEXT(GLenum mode, GLint first, GLsizei count)
{
#ifdef GL_EXT_vertex_array
    static PFNGLDRAWARRAYSEXTPROC proc = 0;

    if ( !proc )
    {
        proc = (PFNGLDRAWARRAYSEXTPROC) wglGetProcAddress("glDrawArraysEXT");
    }

    if ( proc )
        (* proc) (mode, first, count);
#endif
}

void glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer)
{
}

void glGetPointervEXT(GLenum pname, GLvoid* *params)
{
}

void glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
{
}

void glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
{
#ifdef GL_EXT_vertex_array
    static PFNGLNORMALPOINTEREXTPROC proc = 0;

    if ( !proc )
    {
        proc = (PFNGLNORMALPOINTEREXTPROC) wglGetProcAddress("glNormalPointerEXT");
    }

    if ( proc )
        (* proc) (type, stride, count, pointer);
#endif
}

void glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
{
}

void glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
{
#ifdef GL_EXT_vertex_array
    static PFNGLVERTEXPOINTEREXTPROC proc = 0;

    if ( !proc )
    {
        proc = (PFNGLVERTEXPOINTEREXTPROC) wglGetProcAddress("glVertexPointerEXT");
    }

    if ( proc )
        (* proc) (size, type, stride, count, pointer);
#endif
}

/* EXT_color_subtable */
void glColorSubtableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *table)
{
}

/* EXT_color_table */
void glColorTableEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
{
}

void glCopyColorTableEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
}

void glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid *table)
{
}

void glGetColorTableParamaterfvEXT(GLenum target, GLenum pname, GLfloat *params)
{
}

void glGetColorTavleParameterivEXT(GLenum target, GLenum pname, GLint *params)
{
}

/* SGI_compiled_vertex_array */
void glLockArraysSGI(GLint first, GLsizei count)
{
}

void glUnlockArraysSGI()
{
}


/* SGI_cull_vertex */
void glCullParameterdvSGI(GLenum pname, GLdouble* params)
{
}

void glCullParameterfvSGI(GLenum pname, GLfloat* params)
{
}

/* SGI_index_func */
void glIndexFuncSGI(GLenum func, GLclampf ref)
{
}

/* SGI_index_material */
void glIndexMaterialSGI(GLenum face, GLenum mode)
{
}

/* WIN_swap_hint */
void glAddSwapHintRectWin(GLint x, GLint y, GLsizei width, GLsizei height)
{
}
Commit	Line	Data
6a1120ad JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: glcanvas.cpp
	3	// Purpose: wxGLCanvas, for using OpenGL with wxWindows under MS Windows
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 04/01/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "glcanvas.h"
	14	#endif
	15
	16	#include "wx/wxprec.h"
	17
	18	#if defined(__BORLANDC__)
	19	#pragma hdrstop
	20	#endif
	21
	22	#ifndef WX_PRECOMP
	23	#include <wx/frame.h>
	24	#endif
	25
	26	#include "GL/gl.h"
	27
	28	#include "glcanvas.h"
	29
	30	/*
	31	* GLContext implementation
	32	*/
	33
	34	wxGLContext::wxGLContext(bool isRGB, wxWindow *win, const wxPalette& palette)
	35	{
	36	m_window = win;
	37
	38	m_hDC = (WXHDC) ::GetDC((HWND) win->GetHWND());
	39
	40	SetupPixelFormat();
	41	SetupPalette(palette);
	42
	43	m_glContext = wglCreateContext((HDC) m_hDC);
	44	wglMakeCurrent((HDC) m_hDC, m_glContext);
	45	}
	46
	47	wxGLContext::~wxGLContext()
	48	{
	49	if (m_glContext)
	50	{
	51	wglMakeCurrent(NULL, NULL);
	52	wglDeleteContext(m_glContext);
	53	}
	54
	55	::ReleaseDC((HWND) m_window->GetHWND(), (HDC) m_hDC);
	56	}
	57
	58	void wxGLContext::SwapBuffers()
	59	{
	60	if (m_glContext)
	61	{
	62	wglMakeCurrent((HDC) m_hDC, m_glContext);
	63	::SwapBuffers((HDC) m_hDC); //blits the backbuffer into DC
	64	}
65	}
66
67	void wxGLContext::SetCurrent()
68	{
69	if (m_glContext)
70	{
71	wglMakeCurrent((HDC) m_hDC, m_glContext);
72	}
73
74	/*
75	setupPixelFormat(hDC);
76	setupPalette(hDC);
77	*/
78	}
79
80	void wxGLContext::SetColour(const char *colour)
81	{
82	float r = 0.0;
83	float g = 0.0;
84	float b = 0.0;
85	wxColour *col = wxTheColourDatabase->FindColour(colour);
86	if (col)
87	{
88	r = (float)(col->Red()/256.0);
89	g = (float)(col->Green()/256.0);
90	b = (float)(col->Blue()/256.0);
91	glColor3f( r, g, b);
92	}
93	}
94
95	void wxGLContext::SetupPixelFormat() // (HDC hDC)
96	{
97	PIXELFORMATDESCRIPTOR pfd = {
98	sizeof(PIXELFORMATDESCRIPTOR), /* size */
99	1, /* version */
100	PFD_SUPPORT_OPENGL \|
101	PFD_DRAW_TO_WINDOW \|
102	PFD_DOUBLEBUFFER, /* support double-buffering */
103	PFD_TYPE_RGBA, /* color type */
104	16, /* prefered color depth */
105	0, 0, 0, 0, 0, 0, /* color bits (ignored) */
106	0, /* no alpha buffer */
107	0, /* alpha bits (ignored) */
108	0, /* no accumulation buffer */
109	0, 0, 0, 0, /* accum bits (ignored) */
110	16, /* depth buffer */
111	0, /* no stencil buffer */
112	0, /* no auxiliary buffers */
113	PFD_MAIN_PLANE, /* main layer */
114	0, /* reserved */
115	0, 0, 0, /* no layer, visible, damage masks */
116	};
117	int pixelFormat;
118
119	pixelFormat = ChoosePixelFormat((HDC) m_hDC, &pfd);
120	if (pixelFormat == 0) {
121	MessageBox(WindowFromDC((HDC) m_hDC), "ChoosePixelFormat failed.", "Error",
122	MB_ICONERROR \| MB_OK);
123	exit(1);
124	}
125
126	if (SetPixelFormat((HDC) m_hDC, pixelFormat, &pfd) != TRUE) {
127	MessageBox(WindowFromDC((HDC) m_hDC), "SetPixelFormat failed.", "Error",
128	MB_ICONERROR \| MB_OK);
129	exit(1);
130	}
131	}
132
133	void wxGLContext::SetupPalette(const wxPalette& palette)
134	{
135	int pixelFormat = GetPixelFormat((HDC) m_hDC);
136	PIXELFORMATDESCRIPTOR pfd;
137
138	DescribePixelFormat((HDC) m_hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
139
140	if (pfd.dwFlags & PFD_NEED_PALETTE)
141	{
142	}
143	else
144	{
145	return;
146	}
147
148	m_palette = palette;
149
150	if ( !m_palette.Ok() )
151	{
152	m_palette = CreateDefaultPalette();
153	}
154
155	if (m_palette.Ok())
156	{
157	SelectPalette((HDC) m_hDC, (HPALETTE) m_palette.GetHPALETTE(), FALSE);
158	RealizePalette((HDC) m_hDC);
159	}
160	}
161
162	wxPalette wxGLContext::CreateDefaultPalette()
163	{
164	PIXELFORMATDESCRIPTOR pfd;
165	int paletteSize;
166	int pixelFormat = GetPixelFormat((HDC) m_hDC);
167
168	DescribePixelFormat((HDC) m_hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
169
170	paletteSize = 1 << pfd.cColorBits;
171
172	LOGPALETTE* pPal =
173	(LOGPALETTE) malloc(sizeof(LOGPALETTE) + paletteSize sizeof(PALETTEENTRY));
174	pPal->palVersion = 0x300;
175	pPal->palNumEntries = paletteSize;
176
177	/* build a simple RGB color palette */
178	{
179	int redMask = (1 << pfd.cRedBits) - 1;
180	int greenMask = (1 << pfd.cGreenBits) - 1;
181	int blueMask = (1 << pfd.cBlueBits) - 1;
182	int i;
183
184	for (i=0; i<paletteSize; ++i) {
185	pPal->palPalEntry[i].peRed =
186	(((i >> pfd.cRedShift) & redMask) * 255) / redMask;
187	pPal->palPalEntry[i].peGreen =
188	(((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
189	pPal->palPalEntry[i].peBlue =
190	(((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;
191	pPal->palPalEntry[i].peFlags = 0;
192	}
193	}
194
195	HPALETTE hPalette = CreatePalette(pPal);
196	free(pPal);
197
198	wxPalette palette;
199	palette.SetHPALETTE((WXHPALETTE) hPalette);
200
201	return palette;
202	}
203
204	/*
205	* wxGLCanvas implementation
206	*/
207
208	IMPLEMENT_CLASS(wxGLCanvas, wxScrolledWindow)
209
210	BEGIN_EVENT_TABLE(wxGLCanvas, wxScrolledWindow)
211	EVT_SIZE(wxGLCanvas::OnSize)
212	EVT_PALETTE_CHANGED(wxGLCanvas::OnPaletteChanged)
213	EVT_QUERY_NEW_PALETTE(wxGLCanvas::OnQueryNewPalette)
214	END_EVENT_TABLE()
215
216	wxGLCanvas::wxGLCanvas(wxWindow *parent, wxWindowID id,
217	const wxPoint& pos, const wxSize& size, long style, const wxString& name,
218	int attribList / not used yet! */, const wxPalette& palette):
219	wxScrolledWindow(parent, id, pos, size, style, name)
220	{
221	m_glContext = new wxGLContext(TRUE, this, palette);
222	}
223
224	wxGLCanvas::~wxGLCanvas()
225	{
226	if (m_glContext)
227	delete m_glContext;
228	}
229
230	void wxGLCanvas::SwapBuffers()
231	{
232	if (m_glContext)
233	m_glContext->SwapBuffers();
234	}
235
236	void wxGLCanvas::OnSize(wxSizeEvent& event)
237	{
238	int width, height;
239	GetClientSize(& width, & height);
240
241	if (m_glContext)
242	{
243	m_glContext->SetCurrent();
244
245	glViewport(0, 0, (GLint)width, (GLint)height);
246	glMatrixMode(GL_PROJECTION);
247	glLoadIdentity();
248	glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 15.0 );
249	glMatrixMode(GL_MODELVIEW);
250	}
251	}
252
253	void wxGLCanvas::SetCurrent()
254	{
255	if (m_glContext)
256	{
257	m_glContext->SetCurrent();
258	}
259	}
260
261	void wxGLCanvas::SetColour(const char *colour)
262	{
263	if (m_glContext)
264	m_glContext->SetColour(colour);
265	}
266
267	// TODO: Have to have this called by parent frame (?)
268	// So we need wxFrame to call OnQueryNewPalette for all children...
269	void wxGLCanvas::OnQueryNewPalette(wxQueryNewPaletteEvent& event)
270	{
271	/* realize palette if this is the current window */
272	if (m_glContext && m_glContext->GetPalette()->Ok()) {
273	::UnrealizeObject((HPALETTE) m_glContext->GetPalette()->GetHPALETTE());
274	::SelectPalette((HDC) m_glContext->GetHDC(), (HPALETTE) m_glContext->GetPalette()->GetHPALETTE(), FALSE);
275	::RealizePalette((HDC) m_glContext->GetHDC());
276	Refresh();
277	event.SetPaletteRealized(TRUE);
278	}
279	else
280	event.SetPaletteRealized(FALSE);
281	}
282
283	// I think this doesn't have to be propagated to child windows.
284	void wxGLCanvas::OnPaletteChanged(wxPaletteChangedEvent& event)
285	{
286	/* realize palette if this is not the current window */
287	if ( m_glContext &&
288	m_glContext->GetPalette() &&
289	m_glContext->GetPalette()->Ok() &&
290	(this != event.GetChangedWindow()) )
291	{
292	::UnrealizeObject((HPALETTE) m_glContext->GetPalette()->GetHPALETTE());
293	::SelectPalette((HDC) m_glContext->GetHDC(), (HPALETTE) m_glContext->GetPalette()->GetHPALETTE(), FALSE);
294	::RealizePalette((HDC) m_glContext->GetHDC());
295	Refresh();
296	}
297	}
298
299	/* Give extensions proper function names. */
300
301	/* EXT_vertex_array */
302	void glArrayElementEXT(GLint i)
303	{
304	}
305
306	void glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
307	{
308	}
309
310	void glDrawArraysEXT(GLenum mode, GLint first, GLsizei count)
311	{
312	#ifdef GL_EXT_vertex_array
313	static PFNGLDRAWARRAYSEXTPROC proc = 0;
314
315	if ( !proc )
316	{
317	proc = (PFNGLDRAWARRAYSEXTPROC) wglGetProcAddress("glDrawArraysEXT");
318	}
319
320	if ( proc )
321	(* proc) (mode, first, count);
322	#endif
323	}
324
325	void glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer)
326	{
327	}
328
329	void glGetPointervEXT(GLenum pname, GLvoid* *params)
330	{
331	}
332
333	void glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
334	{
335	}
336
337	void glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
338	{
339	#ifdef GL_EXT_vertex_array
340	static PFNGLNORMALPOINTEREXTPROC proc = 0;
341
342	if ( !proc )
343	{
344	proc = (PFNGLNORMALPOINTEREXTPROC) wglGetProcAddress("glNormalPointerEXT");
345	}
346
347	if ( proc )
348	(* proc) (type, stride, count, pointer);
349	#endif
350	}
351
352	void glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
353	{
354	}
355
356	void glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
357	{
358	#ifdef GL_EXT_vertex_array
359	static PFNGLVERTEXPOINTEREXTPROC proc = 0;
360
361	if ( !proc )
362	{
363	proc = (PFNGLVERTEXPOINTEREXTPROC) wglGetProcAddress("glVertexPointerEXT");
364	}
365
366	if ( proc )
367	(* proc) (size, type, stride, count, pointer);
368	#endif
369	}
370
371	/* EXT_color_subtable */
372	void glColorSubtableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *table)
373	{
374	}
375
376	/* EXT_color_table */
377	void glColorTableEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
378	{
379	}
380
381	void glCopyColorTableEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
382	{
383	}
384
385	void glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid *table)
386	{
387	}
388
389	void glGetColorTableParamaterfvEXT(GLenum target, GLenum pname, GLfloat *params)
390	{
391	}
392
393	void glGetColorTavleParameterivEXT(GLenum target, GLenum pname, GLint *params)
394	{
395	}
396
397	/* SGI_compiled_vertex_array */
398	void glLockArraysSGI(GLint first, GLsizei count)
399	{
400	}
401
402	void glUnlockArraysSGI()
403	{
404	}
405
406
407	/* SGI_cull_vertex */
408	void glCullParameterdvSGI(GLenum pname, GLdouble* params)
409	{
410	}
411
412	void glCullParameterfvSGI(GLenum pname, GLfloat* params)
413	{
414	}
415
416	/* SGI_index_func */
417	void glIndexFuncSGI(GLenum func, GLclampf ref)
418	{
419	}
420
421	/* SGI_index_material */
422	void glIndexMaterialSGI(GLenum face, GLenum mode)
423	{
424	}
425
426	/* WIN_swap_hint */
427	void glAddSwapHintRectWin(GLint x, GLint y, GLsizei width, GLsizei height)
428	{
429	}
430