Context Navigation

source: OGRE/trunk/ogrenew/RenderSystems/GL/src/OgreGLRenderSystem.cpp @ 657

Revision 657, 96.6 KB checked in by mattausch, 19 years ago (diff)
added ogre dependencies and patched ogre sources

Line
1	/*
2	-----------------------------------------------------------------------------
3	This source file is part of OGRE
4	(Object-oriented Graphics Rendering Engine)
5	For the latest info, see http://ogre.sourceforge.net/
6
7	Copyright (c) 2000-2005 The OGRE Team
8	Also see acknowledgements in Readme.html
9
10	This program is free software; you can redistribute it and/or modify it under
11	the terms of the GNU Lesser General Public License as published by the Free Software
12	Foundation; either version 2 of the License, or (at your option) any later
13	version.
14
15	This program is distributed in the hope that it will be useful, but WITHOUT
16	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17	FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18
19	You should have received a copy of the GNU Lesser General Public License along with
20	this program; if not, write to the Free Software Foundation, Inc., 59 Temple
21	Place - Suite 330, Boston, MA 02111-1307, USA, or go to
22	http://www.gnu.org/copyleft/lesser.txt.s
23	-----------------------------------------------------------------------------
24	*/
25
26
27	#include "OgreGLRenderSystem.h"
28	#include "OgreRenderSystem.h"
29	#include "OgreLogManager.h"
30	#include "OgreStringConverter.h"
31	#include "OgreLight.h"
32	#include "OgreCamera.h"
33	#include "OgreGLTextureManager.h"
34	#include "OgreGLHardwareVertexBuffer.h"
35	#include "OgreGLHardwareIndexBuffer.h"
36	#include "OgreGLDefaultHardwareBufferManager.h"
37	#include "OgreGLUtil.h"
38	#include "OgreGLGpuProgram.h"
39	#include "OgreGLGpuNvparseProgram.h"
40	#include "ATI_FS_GLGpuProgram.h"
41	#include "OgreGLGpuProgramManager.h"
42	#include "OgreException.h"
43	#include "OgreGLATIFSInit.h"
44	#include "OgreGLSLExtSupport.h"
45	#include "OgreGLHardwareOcclusionQuery.h"
46	#include "OgreGLContext.h"
47
48
49	#ifdef HAVE_CONFIG_H
50	# include "config.h"
51	#endif
52
53	// Convenience macro from ARB_vertex_buffer_object spec
54	#define VBO_BUFFER_OFFSET(i) ((char *)NULL + (i))
55
56	// Pointers to extension functions
57	GL_ActiveTextureARB_Func glActiveTextureARB_ptr;
58	GL_ClientActiveTextureARB_Func glClientActiveTextureARB_ptr;
59	GL_SecondaryColorPointerEXT_Func glSecondaryColorPointerEXT_ptr;
60	GL_SecondaryColor3fEXT_Func glSecondaryColor3fEXT_ptr;
61	GL_GenBuffersARB_Func glGenBuffersARB_ptr;
62	GL_BindBufferARB_Func glBindBufferARB_ptr;
63	GL_DeleteBuffersARB_Func glDeleteBuffersARB_ptr;
64	GL_MapBufferARB_Func glMapBufferARB_ptr;
65	GL_UnmapBufferARB_Func glUnmapBufferARB_ptr;
66	GL_BufferDataARB_Func glBufferDataARB_ptr;
67	GL_BufferSubDataARB_Func glBufferSubDataARB_ptr;
68	GL_GetBufferSubDataARB_Func glGetBufferSubDataARB_ptr;
69	GL_GenProgramsARB_Func glGenProgramsARB_ptr;
70	GL_DeleteProgramsARB_Func glDeleteProgramsARB_ptr;
71	GL_BindProgramARB_Func glBindProgramARB_ptr;
72	GL_ProgramStringARB_Func glProgramStringARB_ptr;
73	GL_ProgramLocalParameter4fvARB_Func glProgramLocalParameter4fvARB_ptr;
74	GL_ProgramParameter4fvNV_Func glProgramParameter4fvNV_ptr;
75	GL_VertexAttribPointerARB_Func glVertexAttribPointerARB_ptr;
76	GL_EnableVertexAttribArrayARB_Func glEnableVertexAttribArrayARB_ptr;
77	GL_DisableVertexAttribArrayARB_Func glDisableVertexAttribArrayARB_ptr;
78	GL_CombinerStageParameterfvNV_Func glCombinerStageParameterfvNV_ptr;
79	GL_CombinerParameterfvNV_Func glCombinerParameterfvNV_ptr;
80	GL_CombinerParameteriNV_Func glCombinerParameteriNV_ptr;
81	GL_GetProgramivARB_Func glGetProgramivARB_ptr;
82	GL_LoadProgramNV_Func glLoadProgramNV_ptr;
83	GL_CombinerInputNV_Func glCombinerInputNV_ptr;
84	GL_CombinerOutputNV_Func glCombinerOutputNV_ptr;
85	GL_FinalCombinerInputNV_Func glFinalCombinerInputNV_ptr;
86	GL_TrackMatrixNV_Func glTrackMatrixNV_ptr;
87	PFNGLCOMPRESSEDTEXIMAGE1DARBPROC glCompressedTexImage1DARB_ptr;
88	PFNGLCOMPRESSEDTEXIMAGE2DARBPROC glCompressedTexImage2DARB_ptr;
89	PFNGLCOMPRESSEDTEXIMAGE3DARBPROC glCompressedTexImage3DARB_ptr;
90	PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC glCompressedTexSubImage1DARB_ptr;
91	PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC glCompressedTexSubImage2DARB_ptr;
92	PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC glCompressedTexSubImage3DARB_ptr;
93	PFNGLGETCOMPRESSEDTEXIMAGEARBPROC glGetCompressedTexImageARB_ptr;
94	GL_ActiveStencilFaceEXT_Func glActiveStencilFaceEXT_ptr;
95	GL_GenOcclusionQueriesNV_Func glGenOcclusionQueriesNV_ptr;
96	GL_DeleteOcclusionQueriesNV_Func glDeleteOcclusionQueriesNV_ptr;
97	GL_BeginOcclusionQueryNV_Func glBeginOcclusionQueryNV_ptr;
98	GL_EndOcclusionQueryNV_Func glEndOcclusionQueryNV_ptr;
99	GL_GetOcclusionQueryuivNV_Func glGetOcclusionQueryuivNV_ptr;
100	GL_GenQueriesARB_Func glGenQueriesARB_ptr;
101	GL_DeleteQueriesARB_Func glDeleteQueriesARB_ptr;
102	GL_BeginQueryARB_Func glBeginQueryARB_ptr;
103	GL_EndQueryARB_Func glEndQueryARB_ptr;
104	#ifdef GTP_VISIBILITY_MODIFIED_OGRE
105	GL_GetQueryivARB_Func glGetQueryivARB_ptr;
106	GL_GetQueryObjectivARB_Func glGetQueryObjectivARB_ptr;
107	#endif // GTP_VISIBILITY_MODIFIED_OGRE
108	GL_GetQueryObjectuivARB_Func glGetQueryObjectuivARB_ptr;
109
110	namespace Ogre {
111
112	// Callback function used when registering GLGpuPrograms
113	GpuProgram* createGLArbGpuProgram(ResourceManager* creator,
114	const String& name, ResourceHandle handle,
115	const String& group, bool isManual, ManualResourceLoader* loader,
116	GpuProgramType gptype, const String& syntaxCode)
117	{
118	GLArbGpuProgram* ret = new GLArbGpuProgram(
119	creator, name, handle, group, isManual, loader);
120	ret->setType(gptype);
121	ret->setSyntaxCode(syntaxCode);
122	return ret;
123	}
124
125	GpuProgram* createGLGpuNvparseProgram(ResourceManager* creator,
126	const String& name, ResourceHandle handle,
127	const String& group, bool isManual, ManualResourceLoader* loader,
128	GpuProgramType gptype, const String& syntaxCode)
129	{
130	GLGpuNvparseProgram* ret = new GLGpuNvparseProgram(
131	creator, name, handle, group, isManual, loader);
132	ret->setType(gptype);
133	ret->setSyntaxCode(syntaxCode);
134	return ret;
135	}
136
137	GpuProgram* createGL_ATI_FS_GpuProgram(ResourceManager* creator,
138	const String& name, ResourceHandle handle,
139	const String& group, bool isManual, ManualResourceLoader* loader,
140	GpuProgramType gptype, const String& syntaxCode)
141	{
142
143	ATI_FS_GLGpuProgram* ret = new ATI_FS_GLGpuProgram(
144	creator, name, handle, group, isManual, loader);
145	ret->setType(gptype);
146	ret->setSyntaxCode(syntaxCode);
147	return ret;
148	}
149
150	GLRenderSystem::GLRenderSystem()
151	: mDepthWrite(true), mHardwareBufferManager(0),
152	mGpuProgramManager(0)
153	{
154	size_t i;
155
156	OgreGuard( "GLRenderSystem::GLRenderSystem" );
157
158	LogManager::getSingleton().logMessage(getName() + " created.");
159
160	// Get our GLSupport
161	mGLSupport = getGLSupport();
162
163	for( i=0; i<MAX_LIGHTS; i++ )
164	mLights[i] = NULL;
165
166	mWorldMatrix = Matrix4::IDENTITY;
167	mViewMatrix = Matrix4::IDENTITY;
168
169	initConfigOptions();
170
171	mColourWrite[0] = mColourWrite[1] = mColourWrite[2] = mColourWrite[3] = true;
172
173	for (i = 0; i < OGRE_MAX_TEXTURE_COORD_SETS; i++)
174	{
175	// Dummy value
176	mTextureCoordIndex[i] = 99;
177	}
178
179	for (i = 0; i < OGRE_MAX_TEXTURE_LAYERS; i++)
180	{
181	mTextureTypes[i] = 0;
182	}
183
184	mActiveRenderTarget = 0;
185	mCurrentContext = 0;
186	mMainContext = 0;
187
188	mGLInitialized = false;
189
190	glActiveTextureARB_ptr = 0;
191	glClientActiveTextureARB_ptr = 0;
192	glSecondaryColorPointerEXT_ptr = 0;
193	glSecondaryColor3fEXT_ptr = 0;
194	glGenBuffersARB_ptr = 0;
195	glBindBufferARB_ptr = 0;
196	glDeleteBuffersARB_ptr = 0;
197	glMapBufferARB_ptr = 0;
198	glUnmapBufferARB_ptr = 0;
199	glBufferDataARB_ptr = 0;
200	glBufferSubDataARB_ptr = 0;
201	glGetBufferSubDataARB_ptr = 0;
202	glGenProgramsARB_ptr = 0;
203	glDeleteProgramsARB_ptr = 0;
204	glBindProgramARB_ptr = 0;
205	glProgramStringARB_ptr = 0;
206	glProgramLocalParameter4fvARB_ptr = 0;
207	glProgramParameter4fvNV_ptr = 0;
208	glCombinerStageParameterfvNV_ptr = 0;
209	glCombinerParameterfvNV_ptr = 0;
210	glCombinerParameteriNV_ptr = 0;
211	glGetProgramivARB_ptr = 0;
212	glLoadProgramNV_ptr = 0;
213	glCombinerInputNV_ptr = 0;
214	glCombinerOutputNV_ptr = 0;
215	glFinalCombinerInputNV_ptr = 0;
216	glTrackMatrixNV_ptr = 0;
217	glActiveStencilFaceEXT_ptr = 0;
218	glGenOcclusionQueriesNV_ptr = 0;
219	glDeleteOcclusionQueriesNV_ptr = 0;
220	glBeginOcclusionQueryNV_ptr = 0;
221	glEndOcclusionQueryNV_ptr = 0;
222	glGetOcclusionQueryuivNV_ptr = 0;
223	glGenQueriesARB_ptr = 0;
224	glDeleteQueriesARB_ptr = 0;
225	glBeginQueryARB_ptr = 0;
226	glEndQueryARB_ptr = 0;
227	#ifdef GTP_VISIBILITY_MODIFIED_OGRE
228	glGetQueryivARB_ptr = 0;
229	glGetQueryObjectivARB_ptr = 0;
230	#endif // GTP_VISIBILITY_MODIFIED_OGRE
231	glGetQueryObjectuivARB_ptr = 0;
232
233	mCurrentLights = 0;
234	mMinFilter = FO_LINEAR;
235	mMipFilter = FO_POINT;
236	mCurrentVertexProgram = 0;
237	mCurrentFragmentProgram = 0;
238
239	mClipPlanes.reserve(6);
240
241	OgreUnguard();
242	}
243
244	GLRenderSystem::~GLRenderSystem()
245	{
246	shutdown();
247
248	// Destroy render windows
249	RenderTargetMap::iterator i;
250	for (i = mRenderTargets.begin(); i != mRenderTargets.end(); ++i)
251	{
252	delete i->second;
253	}
254	mRenderTargets.clear();
255
256	if (mTextureManager)
257	delete mTextureManager;
258
259	delete mGLSupport;
260	}
261
262	const String& GLRenderSystem::getName(void) const
263	{
264	static String strName("OpenGL Rendering Subsystem");
265	return strName;
266	}
267
268	void GLRenderSystem::initConfigOptions(void)
269	{
270	OgreGuard("GLRenderSystem::initConfigOptions");
271	mGLSupport->addConfig();
272	OgreUnguard();
273	}
274
275	ConfigOptionMap& GLRenderSystem::getConfigOptions(void)
276	{
277	return mGLSupport->getConfigOptions();
278	}
279
280	void GLRenderSystem::setConfigOption(const String &name, const String &value)
281	{
282	// set occlusion query
283	#ifdef GTP_VISIBILITY_MODIFIED_OGRE
284	if ( name == "ArbQueries" )
285	{
286	if ( value == "No" )
287	{
288	GLHardwareOcclusionQuery::sUseArbQueries = false;
289	}
290	else if ( value == "Yes" )
291	{
292	GLHardwareOcclusionQuery::sUseArbQueries = true;
293	}
294	return;
295	}
296	#endif
297
298	mGLSupport->setConfigOption(name, value);
299	}
300
301	String GLRenderSystem::validateConfigOptions(void)
302	{
303	// XXX Return an error string if something is invalid
304	return mGLSupport->validateConfig();
305	}
306
307	RenderWindow* GLRenderSystem::initialise(bool autoCreateWindow, const String& windowTitle)
308	{
309	mGLSupport->start();
310
311	RenderWindow* autoWindow = mGLSupport->createWindow(autoCreateWindow, this, windowTitle);
312
313
314	_setCullingMode( mCullingMode );
315
316	return autoWindow;
317	}
318
319	void GLRenderSystem::initGL(void)
320	{
321	mGLSupport->initialiseExtensions();
322
323	LogManager::getSingleton().logMessage(
324	"***************************\n"
325	"* GL Renderer Started *\n"
326	"***************************");
327
328
329	// Check for hardware mipmapping support.
330	// Note: This is disabled for ATI cards until they fix their drivers
331	if(mGLSupport->getGLVendor() != "ATI" &&
332	(mGLSupport->checkMinGLVersion("1.4.0") \|\|
333	mGLSupport->checkExtension("GL_SGIS_generate_mipmap")))
334	{
335	mCapabilities->setCapability(RSC_AUTOMIPMAP);
336	}
337
338	// Check for blending support
339	if(mGLSupport->checkMinGLVersion("1.3.0") \|\|
340	mGLSupport->checkExtension("GL_ARB_texture_env_combine") \|\|
341	mGLSupport->checkExtension("GL_EXT_texture_env_combine"))
342	{
343	mCapabilities->setCapability(RSC_BLENDING);
344	}
345
346	// Check for Multitexturing support and set number of texture units
347	if(mGLSupport->checkMinGLVersion("1.3.0") \|\|
348	mGLSupport->checkExtension("GL_ARB_multitexture"))
349	{
350	GLint units;
351	glGetIntegerv( GL_MAX_TEXTURE_UNITS, &units );
352	mFixedFunctionTextureUnits = units;
353
354	if (mGLSupport->checkExtension("GL_ARB_fragment_program"))
355	{
356	// Also check GL_MAX_TEXTURE_IMAGE_UNITS_ARB since NV at least
357	// only increased this on the FX/6x00 series
358	GLint arbUnits;
359	glGetIntegerv( GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &arbUnits );
360	if (arbUnits > units)
361	units = arbUnits;
362	}
363
364	mCapabilities->setNumTextureUnits(units);
365
366	}
367	else
368	{
369	// If no multitexture support then set one texture unit
370	mCapabilities->setNumTextureUnits(1);
371	}
372
373	// Check for Anisotropy support
374	if(mGLSupport->checkExtension("GL_EXT_texture_filter_anisotropic"))
375	{
376	mCapabilities->setCapability(RSC_ANISOTROPY);
377	}
378
379	// Check for DOT3 support
380	if(mGLSupport->checkMinGLVersion("1.3.0") \|\|
381	mGLSupport->checkExtension("GL_ARB_texture_env_dot3") \|\|
382	mGLSupport->checkExtension("GL_EXT_texture_env_dot3"))
383	{
384	mCapabilities->setCapability(RSC_DOT3);
385	}
386
387	// Check for cube mapping
388	if(mGLSupport->checkMinGLVersion("1.3.0") \|\|
389	mGLSupport->checkExtension("GL_ARB_texture_cube_map") \|\|
390	mGLSupport->checkExtension("GL_EXT_texture_cube_map"))
391	{
392	mCapabilities->setCapability(RSC_CUBEMAPPING);
393	}
394
395	// Check for hardware stencil support and set bit depth
396	GLint stencil;
397	glGetIntegerv(GL_STENCIL_BITS,&stencil);
398
399	if(stencil)
400	{
401	mCapabilities->setCapability(RSC_HWSTENCIL);
402	mCapabilities->setStencilBufferBitDepth(stencil);
403	}
404
405	// Check for VBO support
406	if(mGLSupport->checkExtension("GL_ARB_vertex_buffer_object"))
407	{
408	mCapabilities->setCapability(RSC_VBO);
409
410	mHardwareBufferManager = new GLHardwareBufferManager;
411	}
412	else
413	{
414	mHardwareBufferManager = new GLDefaultHardwareBufferManager;
415	}
416
417	// XXX Need to check for nv2 support and make a program manager for it
418	// XXX Probably nv1 as well for older cards
419	// GPU Program Manager setup
420	mGpuProgramManager = new GLGpuProgramManager();
421
422	if(mGLSupport->checkExtension("GL_ARB_vertex_program"))
423	{
424	mCapabilities->setCapability(RSC_VERTEX_PROGRAM);
425
426	// Vertex Program Properties
427	mCapabilities->setMaxVertexProgramVersion("arbvp1");
428	mCapabilities->setVertexProgramConstantBoolCount(0);
429	mCapabilities->setVertexProgramConstantIntCount(0);
430	mCapabilities->setVertexProgramConstantFloatCount(
431	GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB);
432
433	mGpuProgramManager->_pushSyntaxCode("arbvp1");
434	mGpuProgramManager->registerProgramFactory("arbvp1", createGLArbGpuProgram);
435	if (mGLSupport->checkExtension("GL_NV_vertex_program2_option"))
436	{
437	mCapabilities->setMaxVertexProgramVersion("vp30");
438	mGpuProgramManager->_pushSyntaxCode("vp30");
439	mGpuProgramManager->registerProgramFactory("vp30", createGLArbGpuProgram);
440	}
441
442	if (mGLSupport->checkExtension("GL_NV_vertex_program3"))
443	{
444	mCapabilities->setMaxVertexProgramVersion("vp40");
445	mGpuProgramManager->_pushSyntaxCode("vp40");
446	mGpuProgramManager->registerProgramFactory("vp40", createGLArbGpuProgram);
447	}
448	}
449
450	if (mGLSupport->checkExtension("GL_NV_register_combiners2") &&
451	mGLSupport->checkExtension("GL_NV_texture_shader"))
452	{
453	mCapabilities->setCapability(RSC_FRAGMENT_PROGRAM);
454	mCapabilities->setMaxFragmentProgramVersion("fp20");
455
456	mGpuProgramManager->_pushSyntaxCode("fp20");
457	mGpuProgramManager->registerProgramFactory("fp20", createGLGpuNvparseProgram);
458	}
459
460
461	// NFZ - check for ATI fragment shader support
462	if (mGLSupport->checkExtension("GL_ATI_fragment_shader"))
463	{
464	mCapabilities->setCapability(RSC_FRAGMENT_PROGRAM);
465	mCapabilities->setMaxFragmentProgramVersion("ps_1_4");
466	// no boolean params allowed
467	mCapabilities->setFragmentProgramConstantBoolCount(0);
468	// no integer params allowed
469	mCapabilities->setFragmentProgramConstantIntCount(0);
470
471	// only 8 Vector4 constant floats supported
472	mCapabilities->setFragmentProgramConstantFloatCount(8);
473
474	mGpuProgramManager->_pushSyntaxCode("ps_1_4");
475	mGpuProgramManager->_pushSyntaxCode("ps_1_3");
476	mGpuProgramManager->_pushSyntaxCode("ps_1_2");
477	mGpuProgramManager->_pushSyntaxCode("ps_1_1");
478
479	mGpuProgramManager->registerProgramFactory("ps_1_4", createGL_ATI_FS_GpuProgram);
480	mGpuProgramManager->registerProgramFactory("ps_1_3", createGL_ATI_FS_GpuProgram);
481	mGpuProgramManager->registerProgramFactory("ps_1_2", createGL_ATI_FS_GpuProgram);
482	mGpuProgramManager->registerProgramFactory("ps_1_1", createGL_ATI_FS_GpuProgram);
483	}
484
485
486	if (mGLSupport->checkExtension("GL_ARB_fragment_program"))
487	{
488	mCapabilities->setCapability(RSC_FRAGMENT_PROGRAM);
489	// Fragment Program Properties
490	mCapabilities->setMaxFragmentProgramVersion("arbfp1");
491	mCapabilities->setFragmentProgramConstantBoolCount(0);
492	mCapabilities->setFragmentProgramConstantIntCount(0);
493	mCapabilities->setFragmentProgramConstantFloatCount(
494	GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB);
495
496	mGpuProgramManager->_pushSyntaxCode("arbfp1");
497	mGpuProgramManager->registerProgramFactory("arbfp1", createGLArbGpuProgram);
498	if (mGLSupport->checkExtension("GL_NV_fragment_program_option"))
499	{
500	mCapabilities->setMaxFragmentProgramVersion("fp30");
501	mGpuProgramManager->_pushSyntaxCode("fp30");
502	mGpuProgramManager->registerProgramFactory("fp30", createGLArbGpuProgram);
503	}
504
505	if (mGLSupport->checkExtension("GL_NV_fragment_program2"))
506	{
507	mCapabilities->setMaxFragmentProgramVersion("fp40");
508	mGpuProgramManager->_pushSyntaxCode("fp40");
509	mGpuProgramManager->registerProgramFactory("fp40", createGLArbGpuProgram);
510	}
511	}
512
513	// NFZ - check if GLSL is supported
514	if ( mGLSupport->checkExtension("GL_ARB_shading_language_100") &&
515	mGLSupport->checkExtension("GL_ARB_shader_objects") &&
516	mGLSupport->checkExtension("GL_ARB_fragment_shader") &&
517	mGLSupport->checkExtension("GL_ARB_vertex_shader") )
518	{
519	// NFZ - check for GLSL vertex and fragment shader support successful
520	mGpuProgramManager->_pushSyntaxCode("glsl");
521	LogManager::getSingleton().logMessage("GLSL support detected");
522	}
523
524	// Check for texture compression
525	if(mGLSupport->checkMinGLVersion("1.3.0") \|\|
526	mGLSupport->checkExtension("GL_ARB_texture_compression"))
527	{
528	mCapabilities->setCapability(RSC_TEXTURE_COMPRESSION);
529
530	// Check for dxt compression
531	if(mGLSupport->checkExtension("GL_EXT_texture_compression_s3tc"))
532	{
533	mCapabilities->setCapability(RSC_TEXTURE_COMPRESSION_DXT);
534	}
535	// Check for vtc compression
536	if(mGLSupport->checkExtension("GL_NV_texture_compression_vtc"))
537	{
538	mCapabilities->setCapability(RSC_TEXTURE_COMPRESSION_VTC);
539	}
540	}
541
542	// Scissor test is standard in GL 1.2 (is it emulated on some cards though?)
543	mCapabilities->setCapability(RSC_SCISSOR_TEST);
544	// As are user clipping planes
545	mCapabilities->setCapability(RSC_USER_CLIP_PLANES);
546
547	// 2-sided stencil?
548	if (mGLSupport->checkExtension("GL_EXT_stencil_two_side"))
549	{
550	mCapabilities->setCapability(RSC_TWO_SIDED_STENCIL);
551	}
552	// stencil wrapping?
553	if (mGLSupport->checkExtension("GL_EXT_stencil_wrap"))
554	{
555	mCapabilities->setCapability(RSC_STENCIL_WRAP);
556	}
557
558	// Check for hardware occlusion support
559	if(mGLSupport->checkExtension("GL_NV_occlusion_query"))
560	{
561	mCapabilities->setCapability(RSC_HWOCCLUSION);
562	}
563
564	// UBYTE4 always supported
565	mCapabilities->setCapability(RSC_VERTEX_FORMAT_UBYTE4);
566
567	// Inifinite far plane always supported
568	mCapabilities->setCapability(RSC_INFINITE_FAR_PLANE);
569
570	// Check for non-power-of-2 texture support
571	if(mGLSupport->checkExtension("GL_ARB_texture_non_power_of_two"))
572	{
573	mCapabilities->setCapability(RSC_NON_POWER_OF_2_TEXTURES);
574	}
575
576	// Check for Float textures
577	if(mGLSupport->checkExtension("GL_ATI_texture_float") \|\|
578	// mGLSupport->checkExtension("GL_NV_float_buffer") \|\|
579	mGLSupport->checkExtension("GL_ARB_texture_float"))
580	{
581	mCapabilities->setCapability(RSC_TEXTURE_FLOAT);
582	}
583
584	// 3D textures should be supported by GL 1.2, which is our minimum version
585	mCapabilities->setCapability(RSC_TEXTURE_3D);
586
587	// Check for GLSupport specific extensions
588	mGLSupport->initialiseCapabilities(*mCapabilities);
589
590	// Get extension function pointers
591	glActiveTextureARB_ptr =
592	(GL_ActiveTextureARB_Func)mGLSupport->getProcAddress("glActiveTextureARB");
593	glClientActiveTextureARB_ptr =
594	(GL_ClientActiveTextureARB_Func)mGLSupport->getProcAddress("glClientActiveTextureARB");
595	glSecondaryColorPointerEXT_ptr =
596	(GL_SecondaryColorPointerEXT_Func)mGLSupport->getProcAddress("glSecondaryColorPointerEXT");
597	glSecondaryColor3fEXT_ptr =
598	(GL_SecondaryColor3fEXT_Func)mGLSupport->getProcAddress("glSecondaryColor3fEXT");
599	glGenBuffersARB_ptr =
600	(GL_GenBuffersARB_Func)mGLSupport->getProcAddress("glGenBuffersARB");
601	glBindBufferARB_ptr =
602	(GL_BindBufferARB_Func)mGLSupport->getProcAddress("glBindBufferARB");
603	glDeleteBuffersARB_ptr =
604	(GL_DeleteBuffersARB_Func)mGLSupport->getProcAddress("glDeleteBuffersARB");
605	glMapBufferARB_ptr =
606	(GL_MapBufferARB_Func)mGLSupport->getProcAddress("glMapBufferARB");
607	glUnmapBufferARB_ptr =
608	(GL_UnmapBufferARB_Func)mGLSupport->getProcAddress("glUnmapBufferARB");
609	glBufferDataARB_ptr =
610	(GL_BufferDataARB_Func)mGLSupport->getProcAddress("glBufferDataARB");
611	glBufferSubDataARB_ptr =
612	(GL_BufferSubDataARB_Func)mGLSupport->getProcAddress("glBufferSubDataARB");
613	glGetBufferSubDataARB_ptr =
614	(GL_GetBufferSubDataARB_Func)mGLSupport->getProcAddress("glGetBufferSubDataARB");
615	glGenProgramsARB_ptr =
616	(GL_GenProgramsARB_Func)mGLSupport->getProcAddress("glGenProgramsARB");
617	glDeleteProgramsARB_ptr =
618	(GL_DeleteProgramsARB_Func)mGLSupport->getProcAddress("glDeleteProgramsARB");
619	glBindProgramARB_ptr =
620	(GL_BindProgramARB_Func)mGLSupport->getProcAddress("glBindProgramARB");
621	glProgramStringARB_ptr =
622	(GL_ProgramStringARB_Func)mGLSupport->getProcAddress("glProgramStringARB");
623	glProgramLocalParameter4fvARB_ptr =
624	(GL_ProgramLocalParameter4fvARB_Func)mGLSupport->getProcAddress("glProgramLocalParameter4fvARB");
625	glProgramParameter4fvNV_ptr =
626	(GL_ProgramParameter4fvNV_Func)mGLSupport->getProcAddress("glProgramParameter4fvNV");
627	glVertexAttribPointerARB_ptr =
628	(GL_VertexAttribPointerARB_Func)mGLSupport->getProcAddress("glVertexAttribPointerARB");
629	glEnableVertexAttribArrayARB_ptr =
630	(GL_EnableVertexAttribArrayARB_Func)mGLSupport->getProcAddress("glEnableVertexAttribArrayARB");
631	glDisableVertexAttribArrayARB_ptr =
632	(GL_DisableVertexAttribArrayARB_Func)mGLSupport->getProcAddress("glDisableVertexAttribArrayARB");
633	glCombinerStageParameterfvNV_ptr =
634	(GL_CombinerStageParameterfvNV_Func)mGLSupport->getProcAddress("glCombinerStageParameterfvNV");
635	glCombinerParameterfvNV_ptr =
636	(GL_CombinerParameterfvNV_Func)mGLSupport->getProcAddress("glCombinerParameterfvNV");
637	glCombinerParameteriNV_ptr = (GL_CombinerParameteriNV_Func)mGLSupport->getProcAddress("glCombinerParameteriNV");
638	glGetProgramivARB_ptr =
639	(GL_GetProgramivARB_Func)mGLSupport->getProcAddress("glGetProgramivARB");
640	glLoadProgramNV_ptr =
641	(GL_LoadProgramNV_Func)mGLSupport->getProcAddress("glLoadProgramNV");
642	glCombinerInputNV_ptr =
643	(GL_CombinerInputNV_Func)mGLSupport->getProcAddress("glCombinerInputNV");
644	glCombinerOutputNV_ptr =
645	(GL_CombinerOutputNV_Func)mGLSupport->getProcAddress("glCombinerOutputNV");
646	glFinalCombinerInputNV_ptr =
647	(GL_FinalCombinerInputNV_Func)mGLSupport->getProcAddress("glFinalCombinerInputNV");
648	glTrackMatrixNV_ptr =
649	(GL_TrackMatrixNV_Func)mGLSupport->getProcAddress("glTrackMatrixNV");
650	glCompressedTexImage1DARB_ptr =
651	(PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)mGLSupport->getProcAddress("glCompressedTexImage1DARB");
652	glCompressedTexImage2DARB_ptr =
653	(PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)mGLSupport->getProcAddress("glCompressedTexImage2DARB");
654	glCompressedTexImage3DARB_ptr =
655	(PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)mGLSupport->getProcAddress("glCompressedTexImage3DARB");
656	glCompressedTexSubImage1DARB_ptr =
657	(PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)mGLSupport->getProcAddress("glCompressedTexSubImage1DARB");
658	glCompressedTexSubImage2DARB_ptr =
659	(PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)mGLSupport->getProcAddress("glCompressedTexSubImage2DARB");
660	glCompressedTexSubImage3DARB_ptr =
661	(PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)mGLSupport->getProcAddress("glCompressedTexSubImage3DARB");
662	glGetCompressedTexImageARB_ptr =
663	(PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)mGLSupport->getProcAddress("glGetCompressedTexImageARB");
664	InitATIFragmentShaderExtensions(*mGLSupport);
665	InitGLShaderLanguageExtensions(*mGLSupport);
666	glActiveStencilFaceEXT_ptr =
667	(GL_ActiveStencilFaceEXT_Func)mGLSupport->getProcAddress("glActiveStencilFaceEXT");
668	glGenOcclusionQueriesNV_ptr =
669	(GL_GenOcclusionQueriesNV_Func)mGLSupport->getProcAddress("glGenOcclusionQueriesNV");
670	glDeleteOcclusionQueriesNV_ptr =
671	(GL_DeleteOcclusionQueriesNV_Func)mGLSupport->getProcAddress("glDeleteOcclusionQueriesNV");
672	glBeginOcclusionQueryNV_ptr =
673	(GL_BeginOcclusionQueryNV_Func)mGLSupport->getProcAddress("glBeginOcclusionQueryNV");
674	glEndOcclusionQueryNV_ptr =
675	(GL_EndOcclusionQueryNV_Func)mGLSupport->getProcAddress("glEndOcclusionQueryNV");
676	glGetOcclusionQueryuivNV_ptr =
677	(GL_GetOcclusionQueryuivNV_Func)mGLSupport->getProcAddress("glGetOcclusionQueryuivNV");
678
679	glGenQueriesARB_ptr =
680	(GL_GenQueriesARB_Func)mGLSupport->getProcAddress("glGenQueriesARB");
681	glDeleteQueriesARB_ptr =
682	(GL_DeleteQueriesARB_Func)mGLSupport->getProcAddress("glDeleteQueriesARB");
683	glBeginQueryARB_ptr =
684	(GL_BeginQueryARB_Func)mGLSupport->getProcAddress("glBeginQueryARB");
685	glEndQueryARB_ptr =
686	(GL_EndQueryARB_Func)mGLSupport->getProcAddress("glEndQueryARB");
687	#ifdef GTP_VISIBILITY_MODIFIED_OGRE
688	glGetQueryivARB_ptr =
689	(GL_GetQueryivARB_Func)mGLSupport->getProcAddress("glGetQueryivARB");
690	glGetQueryObjectivARB_ptr =
691	(GL_GetQueryObjectivARB_Func)mGLSupport->getProcAddress("glGetQueryObjectivARB");
692	#endif // GTP_VISIBILITY_MODIFIED_OGRE
693	glGetQueryObjectuivARB_ptr =
694	(GL_GetQueryObjectuivARB_Func)mGLSupport->getProcAddress("glGetQueryObjectuivARB");
695
696	mCapabilities->log(LogManager::getSingleton().getDefaultLog());
697	mGLInitialized = true;
698	}
699
700	void GLRenderSystem::reinitialise(void)
701	{
702	this->shutdown();
703	this->initialise(true);
704	}
705
706	void GLRenderSystem::shutdown(void)
707	{
708	RenderSystem::shutdown();
709
710	// Deleting the GPU program manager and hardware buffer manager. Has to be done before the mGLSupport->stop().
711	if (mGpuProgramManager)
712	{
713	delete mGpuProgramManager;
714	mGpuProgramManager = 0;
715	}
716
717	if (mHardwareBufferManager)
718	{
719	delete mHardwareBufferManager;
720	mHardwareBufferManager = 0;
721	}
722
723
724	mGLSupport->stop();
725	mStopRendering = true;
726	}
727
728	void GLRenderSystem::setAmbientLight(float r, float g, float b)
729	{
730	GLfloat lmodel_ambient[] = {r, g, b, 1.0};
731	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
732	}
733
734	void GLRenderSystem::setShadingType(ShadeOptions so)
735	{
736	switch(so)
737	{
738	case SO_FLAT:
739	glShadeModel(GL_FLAT);
740	break;
741	default:
742	glShadeModel(GL_SMOOTH);
743	break;
744	}
745	}
746
747	RenderWindow* GLRenderSystem::createRenderWindow(const String &name,
748	unsigned int width, unsigned int height, bool fullScreen,
749	const NameValuePairList *miscParams)
750	{
751	if (mRenderTargets.find(name) != mRenderTargets.end())
752	{
753	OGRE_EXCEPT(
754	Exception::ERR_INVALIDPARAMS,
755	"Window with name '" + name + "' already exists",
756	"GLRenderSystem::createRenderWindow" );
757	}
758	// Log a message
759	std::stringstream ss;
760	ss << "GLRenderSystem::createRenderWindow \"" << name << "\", " <<
761	width << "x" << height << " ";
762	if(fullScreen)
763	ss << "fullscreen ";
764	else
765	ss << "windowed ";
766	if(miscParams)
767	{
768	ss << " miscParams: ";
769	NameValuePairList::const_iterator it;
770	for(it=miscParams->begin(); it!=miscParams->end(); ++it)
771	{
772	ss << it->first << "=" << it->second << " ";
773	}
774	LogManager::getSingleton().logMessage(ss.str());
775	}
776
777	// Create the window
778	RenderWindow* win = mGLSupport->newWindow(name, width, height,
779	fullScreen, miscParams);
780
781	attachRenderTarget( *win );
782
783	if (!mGLInitialized)
784	{
785	// Initialise GL after the first window has been created
786	initGL();
787	mTextureManager = new GLTextureManager(*mGLSupport);
788	// Set main and current context
789	ContextMap::iterator i = mContextMap.find(win);
790	if(i != mContextMap.end()) {
791	mCurrentContext = i->second;
792	mMainContext = i->second;
793	mCurrentContext->setCurrent();
794	}
795	// Initialise the main context
796	_oneTimeContextInitialization();
797	}
798
799
800	// XXX Do more?
801
802	return win;
803	}
804
805	RenderTexture * GLRenderSystem::createRenderTexture( const String & name, unsigned int width, unsigned int height,
806	TextureType texType, PixelFormat internalFormat, const NameValuePairList *miscParams )
807	{
808	// Log a message
809	std::stringstream ss;
810	ss << "GLRenderSystem::createRenderTexture \"" << name << "\", " <<
811	width << "x" << height << " texType=" << texType <<
812	" internalFormat=" << PixelUtil::getFormatName(internalFormat) << " ";
813	if(miscParams)
814	{
815	ss << "miscParams: ";
816	NameValuePairList::const_iterator it;
817	for(it=miscParams->begin(); it!=miscParams->end(); ++it)
818	{
819	ss << it->first << "=" << it->second << " ";
820	}
821	LogManager::getSingleton().logMessage(ss.str());
822	}
823	// Pass on the create call
824	RenderTexture *rt = mGLSupport->createRenderTexture(name, width, height, texType, internalFormat, miscParams);
825	attachRenderTarget( *rt );
826	return rt;
827	}
828
829	//-----------------------------------------------------------------------
830	void GLRenderSystem::destroyRenderWindow(RenderWindow* pWin)
831	{
832	// Find it to remove from list
833	RenderTargetMap::iterator i = mRenderTargets.begin();
834
835	while (i != mRenderTargets.end())
836	{
837	if (i->second == pWin)
838	{
839	mRenderTargets.erase(i);
840	delete pWin;
841	break;
842	}
843	}
844	}
845
846	//---------------------------------------------------------------------
847	void GLRenderSystem::_useLights(const LightList& lights, unsigned short limit)
848	{
849	// Save previous modelview
850	glMatrixMode(GL_MODELVIEW);
851	glPushMatrix();
852	// just load view matrix (identity world)
853	GLfloat mat[16];
854	makeGLMatrix(mat, mViewMatrix);
855	glLoadMatrixf(mat);
856
857	LightList::const_iterator i, iend;
858	iend = lights.end();
859	unsigned short num = 0;
860	for (i = lights.begin(); i != iend && num < limit; ++i, ++num)
861	{
862	setGLLight(num, *i);
863	mLights[num] = *i;
864	}
865	// Disable extra lights
866	for (; num < mCurrentLights; ++num)
867	{
868	setGLLight(num, NULL);
869	mLights[num] = NULL;
870	}
871	mCurrentLights = std::min(limit, static_cast<unsigned short>(lights.size()));
872
873	setLights();
874
875	// restore previous
876	glPopMatrix();
877
878	}
879
880	void GLRenderSystem::setGLLight(size_t index, Light* lt)
881	{
882	GLenum gl_index = GL_LIGHT0 + index;
883
884	if (!lt)
885	{
886	// Disable in the scene
887	glDisable(gl_index);
888	}
889	else
890	{
891	switch (lt->getType())
892	{
893	case Light::LT_SPOTLIGHT:
894	glLightf( gl_index, GL_SPOT_CUTOFF, 0.5f * lt->getSpotlightOuterAngle().valueDegrees() );
895	glLightf(gl_index, GL_SPOT_EXPONENT, lt->getSpotlightFalloff());
896	break;
897	default:
898	glLightf( gl_index, GL_SPOT_CUTOFF, 180.0 );
899	break;
900	}
901
902	// Color
903	ColourValue col;
904	col = lt->getDiffuseColour();
905
906
907	GLfloat f4vals[4] = {col.r, col.g, col.b, col.a};
908	glLightfv(gl_index, GL_DIFFUSE, f4vals);
909
910	col = lt->getSpecularColour();
911	f4vals[0] = col.r;
912	f4vals[1] = col.g;
913	f4vals[2] = col.b;
914	f4vals[3] = col.a;
915	glLightfv(gl_index, GL_SPECULAR, f4vals);
916
917
918	// Disable ambient light for movables;
919	f4vals[0] = 0;
920	f4vals[1] = 0;
921	f4vals[2] = 0;
922	f4vals[3] = 1;
923	glLightfv(gl_index, GL_AMBIENT, f4vals);
924
925	setGLLightPositionDirection(lt, gl_index);
926
927
928	// Attenuation
929	glLightf(gl_index, GL_CONSTANT_ATTENUATION, lt->getAttenuationConstant());
930	glLightf(gl_index, GL_LINEAR_ATTENUATION, lt->getAttenuationLinear());
931	glLightf(gl_index, GL_QUADRATIC_ATTENUATION, lt->getAttenuationQuadric());
932	// Enable in the scene
933	glEnable(gl_index);
934
935	}
936
937	}
938
939	//-----------------------------------------------------------------------------
940	void GLRenderSystem::makeGLMatrix(GLfloat gl_matrix[16], const Matrix4& m)
941	{
942	size_t x = 0;
943	for (size_t i = 0; i < 4; i++)
944	{
945	for (size_t j = 0; j < 4; j++)
946	{
947	gl_matrix[x] = m[j][i];
948	x++;
949	}
950	}
951	}
952	//-----------------------------------------------------------------------------
953	void GLRenderSystem::_setWorldMatrix( const Matrix4 &m )
954	{
955	GLfloat mat[16];
956	mWorldMatrix = m;
957	makeGLMatrix( mat, mViewMatrix * mWorldMatrix );
958	glMatrixMode(GL_MODELVIEW);
959	glLoadMatrixf(mat);
960	}
961
962	//-----------------------------------------------------------------------------
963	void GLRenderSystem::_setViewMatrix( const Matrix4 &m )
964	{
965	mViewMatrix = m;
966
967	GLfloat mat[16];
968	makeGLMatrix( mat, mViewMatrix * mWorldMatrix );
969	glMatrixMode(GL_MODELVIEW);
970	glLoadMatrixf(mat);
971
972	setGLClipPlanes();
973	}
974	//-----------------------------------------------------------------------------
975	void GLRenderSystem::_setProjectionMatrix(const Matrix4 &m)
976	{
977	GLfloat mat[16];
978	makeGLMatrix(mat, m);
979	if (mActiveRenderTarget->requiresTextureFlipping())
980	{
981	// Invert y
982	mat[5] = -mat[5];
983	}
984	glMatrixMode(GL_PROJECTION);
985	glLoadMatrixf(mat);
986	glMatrixMode(GL_MODELVIEW);
987	}
988	//-----------------------------------------------------------------------------
989	void GLRenderSystem::_setSurfaceParams(const ColourValue &ambient,
990	const ColourValue &diffuse, const ColourValue &specular,
991	const ColourValue &emissive, Real shininess,
992	TrackVertexColourType tracking)
993	{
994	// XXX Cache previous values?
995	// XXX Front or Front and Back?
996
997	GLfloat f4val[4] = {diffuse.r, diffuse.g, diffuse.b, diffuse.a};
998	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, f4val);
999	f4val[0] = ambient.r;
1000	f4val[1] = ambient.g;
1001	f4val[2] = ambient.b;
1002	f4val[3] = ambient.a;
1003	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, f4val);
1004	f4val[0] = specular.r;
1005	f4val[1] = specular.g;
1006	f4val[2] = specular.b;
1007	f4val[3] = specular.a;
1008	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, f4val);
1009	f4val[0] = emissive.r;
1010	f4val[1] = emissive.g;
1011	f4val[2] = emissive.b;
1012	f4val[3] = emissive.a;
1013	glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, f4val);
1014	glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
1015
1016	// Track vertex colour
1017	if(tracking != TVC_NONE)
1018	{
1019	GLenum gt = GL_DIFFUSE;
1020	// There are actually 15 different combinations for tracking, of which
1021	// GL only supports the most used 5. This means that we have to do some
1022	// magic to find the best match. NOTE:
1023	// GL_AMBIENT_AND_DIFFUSE != GL_AMBIENT \| GL__DIFFUSE
1024	if(tracking & TVC_AMBIENT)
1025	{
1026	if(tracking & TVC_DIFFUSE)
1027	{
1028	gt = GL_AMBIENT_AND_DIFFUSE;
1029	}
1030	else
1031	{
1032	gt = GL_AMBIENT;
1033	}
1034	}
1035	else if(tracking & TVC_DIFFUSE)
1036	{
1037	gt = GL_DIFFUSE;
1038	}
1039	else if(tracking & TVC_SPECULAR)
1040	{
1041	gt = GL_SPECULAR;
1042	}
1043	else if(tracking & TVC_EMISSIVE)
1044	{
1045	gt = GL_EMISSION;
1046	}
1047	glColorMaterial(GL_FRONT_AND_BACK, gt);
1048
1049	glEnable(GL_COLOR_MATERIAL);
1050	}
1051	else
1052	{
1053	glDisable(GL_COLOR_MATERIAL);
1054	}
1055	}
1056
1057	//-----------------------------------------------------------------------------
1058	void GLRenderSystem::_setTexture(size_t stage, bool enabled, const String &texname)
1059	{
1060	GLTexturePtr tex = TextureManager::getSingleton().getByName(texname);
1061
1062	GLenum lastTextureType = mTextureTypes[stage];
1063
1064	glActiveTextureARB_ptr( GL_TEXTURE0 + stage );
1065	if (enabled)
1066	{
1067	if (!tex.isNull())
1068	{
1069	// note used
1070	tex->touch();
1071	mTextureTypes[stage] = tex->getGLTextureTarget();
1072	}
1073	else
1074	// assume 2D
1075	mTextureTypes[stage] = GL_TEXTURE_2D;
1076
1077	if(lastTextureType != mTextureTypes[stage] && lastTextureType != 0)
1078	{
1079	if (stage < mFixedFunctionTextureUnits)
1080	{
1081	glDisable( lastTextureType );
1082	}
1083	}
1084
1085	if (stage < mFixedFunctionTextureUnits)
1086	{
1087	glEnable( mTextureTypes[stage] );
1088	}
1089
1090	if(!tex.isNull())
1091	glBindTexture( mTextureTypes[stage], tex->getGLID() );
1092	else
1093	glBindTexture( mTextureTypes[stage], static_cast<GLTextureManager*>(mTextureManager)->getWarningTextureID() );
1094	}
1095	else
1096	{
1097	if (stage < mFixedFunctionTextureUnits)
1098	{
1099	if (lastTextureType != 0)
1100	{
1101	glDisable( mTextureTypes[stage] );
1102	}
1103	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1104	}
1105	}
1106
1107	glActiveTextureARB_ptr( GL_TEXTURE0 );
1108
1109	}
1110
1111	//-----------------------------------------------------------------------------
1112	void GLRenderSystem::_setTextureCoordSet(size_t stage, size_t index)
1113	{
1114	mTextureCoordIndex[stage] = index;
1115	}
1116	//-----------------------------------------------------------------------------
1117	void GLRenderSystem::_setTextureCoordCalculation(size_t stage, TexCoordCalcMethod m,
1118	const Frustum* frustum)
1119	{
1120	if (stage >= mFixedFunctionTextureUnits)
1121	{
1122	// Can't do this
1123	return;
1124	}
1125
1126
1127	GLfloat M[16];
1128	Matrix4 projectionBias;
1129
1130	// Default to no extra auto texture matrix
1131	mUseAutoTextureMatrix = false;
1132
1133	GLfloat eyePlaneS[] = {1.0, 0.0, 0.0, 0.0};
1134	GLfloat eyePlaneT[] = {0.0, 1.0, 0.0, 0.0};
1135	GLfloat eyePlaneR[] = {0.0, 0.0, 1.0, 0.0};
1136	GLfloat eyePlaneQ[] = {0.0, 0.0, 0.0, 1.0};
1137
1138	glActiveTextureARB_ptr( GL_TEXTURE0 + stage );
1139
1140	switch( m )
1141	{
1142	case TEXCALC_NONE:
1143	glDisable( GL_TEXTURE_GEN_S );
1144	glDisable( GL_TEXTURE_GEN_T );
1145	glDisable( GL_TEXTURE_GEN_R );
1146	glDisable( GL_TEXTURE_GEN_Q );
1147	break;
1148
1149	case TEXCALC_ENVIRONMENT_MAP:
1150	glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
1151	glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
1152
1153	glEnable( GL_TEXTURE_GEN_S );
1154	glEnable( GL_TEXTURE_GEN_T );
1155	glDisable( GL_TEXTURE_GEN_R );
1156	glDisable( GL_TEXTURE_GEN_Q );
1157
1158	// Need to use a texture matrix to flip the spheremap
1159	mUseAutoTextureMatrix = true;
1160	memset(mAutoTextureMatrix, 0, sizeof(GLfloat)*16);
1161	mAutoTextureMatrix[0] = mAutoTextureMatrix[10] = mAutoTextureMatrix[15] = 1.0f;
1162	mAutoTextureMatrix[5] = -1.0f;
1163
1164	break;
1165
1166	case TEXCALC_ENVIRONMENT_MAP_PLANAR:
1167	// XXX This doesn't seem right?!
1168	#ifdef GL_VERSION_1_3
1169	glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
1170	glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
1171	glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
1172
1173	glEnable( GL_TEXTURE_GEN_S );
1174	glEnable( GL_TEXTURE_GEN_T );
1175	glEnable( GL_TEXTURE_GEN_R );
1176	glDisable( GL_TEXTURE_GEN_Q );
1177	#else
1178	glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
1179	glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
1180
1181	glEnable( GL_TEXTURE_GEN_S );
1182	glEnable( GL_TEXTURE_GEN_T );
1183	glDisable( GL_TEXTURE_GEN_R );
1184	glDisable( GL_TEXTURE_GEN_Q );
1185	#endif
1186	break;
1187	case TEXCALC_ENVIRONMENT_MAP_REFLECTION:
1188
1189	glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
1190	glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
1191	glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
1192
1193	glEnable( GL_TEXTURE_GEN_S );
1194	glEnable( GL_TEXTURE_GEN_T );
1195	glEnable( GL_TEXTURE_GEN_R );
1196	glDisable( GL_TEXTURE_GEN_Q );
1197
1198	// We need an extra texture matrix here
1199	// This sets the texture matrix to be the inverse of the modelview matrix
1200	mUseAutoTextureMatrix = true;
1201	glGetFloatv( GL_MODELVIEW_MATRIX, M );
1202
1203	// Transpose 3x3 in order to invert matrix (rotation)
1204	// Note that we need to invert the Z _before_ the rotation
1205	// No idea why we have to invert the Z at all, but reflection is wrong without it
1206	mAutoTextureMatrix[0] = M[0]; mAutoTextureMatrix[1] = M[4]; mAutoTextureMatrix[2] = -M[8];
1207	mAutoTextureMatrix[4] = M[1]; mAutoTextureMatrix[5] = M[5]; mAutoTextureMatrix[6] = -M[9];
1208	mAutoTextureMatrix[8] = M[2]; mAutoTextureMatrix[9] = M[6]; mAutoTextureMatrix[10] = -M[10];
1209	mAutoTextureMatrix[3] = mAutoTextureMatrix[7] = mAutoTextureMatrix[11] = 0.0f;
1210	mAutoTextureMatrix[12] = mAutoTextureMatrix[13] = mAutoTextureMatrix[14] = 0.0f;
1211	mAutoTextureMatrix[15] = 1.0f;
1212
1213	break;
1214	case TEXCALC_ENVIRONMENT_MAP_NORMAL:
1215	glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP );
1216	glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP );
1217	glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP );
1218
1219	glEnable( GL_TEXTURE_GEN_S );
1220	glEnable( GL_TEXTURE_GEN_T );
1221	glEnable( GL_TEXTURE_GEN_R );
1222	glDisable( GL_TEXTURE_GEN_Q );
1223	break;
1224	case TEXCALC_PROJECTIVE_TEXTURE:
1225	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1226	glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1227	glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1228	glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1229	glTexGenfv(GL_S, GL_EYE_PLANE, eyePlaneS);
1230	glTexGenfv(GL_T, GL_EYE_PLANE, eyePlaneT);
1231	glTexGenfv(GL_R, GL_EYE_PLANE, eyePlaneR);
1232	glTexGenfv(GL_Q, GL_EYE_PLANE, eyePlaneQ);
1233	glEnable(GL_TEXTURE_GEN_S);
1234	glEnable(GL_TEXTURE_GEN_T);
1235	glEnable(GL_TEXTURE_GEN_R);
1236	glEnable(GL_TEXTURE_GEN_Q);
1237
1238	mUseAutoTextureMatrix = true;
1239
1240	// Set scale and translation matrix for projective textures
1241	projectionBias = Matrix4::CLIPSPACE2DTOIMAGESPACE;
1242
1243	projectionBias = projectionBias * frustum->getProjectionMatrix();
1244	projectionBias = projectionBias * frustum->getViewMatrix();
1245	projectionBias = projectionBias * mWorldMatrix;
1246
1247	makeGLMatrix(mAutoTextureMatrix, projectionBias);
1248	break;
1249	default:
1250	break;
1251	}
1252	glActiveTextureARB_ptr( GL_TEXTURE0 );
1253	}
1254	//-----------------------------------------------------------------------------
1255	void GLRenderSystem::_setTextureAddressingMode(size_t stage, TextureUnitState::TextureAddressingMode tam)
1256	{
1257	GLint type;
1258	switch(tam)
1259	{
1260	default:
1261	case TextureUnitState::TAM_WRAP:
1262	type = GL_REPEAT;
1263	break;
1264	case TextureUnitState::TAM_MIRROR:
1265	type = GL_MIRRORED_REPEAT;
1266	break;
1267	case TextureUnitState::TAM_CLAMP:
1268	type = GL_CLAMP_TO_EDGE;
1269	break;
1270	}
1271
1272	glActiveTextureARB_ptr( GL_TEXTURE0 + stage );
1273	glTexParameteri( mTextureTypes[stage], GL_TEXTURE_WRAP_S, type );
1274	glTexParameteri( mTextureTypes[stage], GL_TEXTURE_WRAP_T, type );
1275	glTexParameteri( mTextureTypes[stage], GL_TEXTURE_WRAP_R, type );
1276	glActiveTextureARB_ptr( GL_TEXTURE0 );
1277	}
1278	//-----------------------------------------------------------------------------
1279	void GLRenderSystem::_setTextureMatrix(size_t stage, const Matrix4& xform)
1280	{
1281	if (stage >= mFixedFunctionTextureUnits)
1282	{
1283	// Can't do this
1284	return;
1285	}
1286
1287	GLfloat mat[16];
1288	makeGLMatrix(mat, xform);
1289
1290	if(mTextureTypes[stage] != GL_TEXTURE_3D &&
1291	mTextureTypes[stage] != GL_TEXTURE_CUBE_MAP)
1292	{
1293	// Convert 3x3 rotation/translation matrix to 4x4
1294	mat[12] = mat[8];
1295	mat[13] = mat[9];
1296	mat[8] = 0;
1297	mat[9] = 0;
1298	}
1299	// mat[14] = mat[10];
1300	// mat[15] = mat[11];
1301
1302	// for (int j=0; j< 4; j++)
1303	// {
1304	// int x = 0;
1305	// for (x = 0; x < 4; x++)
1306	// {
1307	// printf("[%2d]=%0.2f\t", (x4) + j, mat[(x4) + j]);
1308	// }
1309	// printf("\n");
1310	// }
1311
1312	glActiveTextureARB_ptr(GL_TEXTURE0 + stage);
1313	glMatrixMode(GL_TEXTURE);
1314
1315	// Load this matrix in
1316	glLoadMatrixf(mat);
1317
1318	if (mUseAutoTextureMatrix)
1319	{
1320	// Concat auto matrix
1321	glMultMatrixf(mAutoTextureMatrix);
1322	}
1323
1324	glMatrixMode(GL_MODELVIEW);
1325	glActiveTextureARB_ptr(GL_TEXTURE0);
1326	}
1327	//-----------------------------------------------------------------------------
1328	GLint GLRenderSystem::getBlendMode(SceneBlendFactor ogreBlend) const
1329	{
1330	switch(ogreBlend)
1331	{
1332	case SBF_ONE:
1333	return GL_ONE;
1334	case SBF_ZERO:
1335	return GL_ZERO;
1336	case SBF_DEST_COLOUR:
1337	return GL_DST_COLOR;
1338	case SBF_SOURCE_COLOUR:
1339	return GL_SRC_COLOR;
1340	case SBF_ONE_MINUS_DEST_COLOUR:
1341	return GL_ONE_MINUS_DST_COLOR;
1342	case SBF_ONE_MINUS_SOURCE_COLOUR:
1343	return GL_ONE_MINUS_SRC_COLOR;
1344	case SBF_DEST_ALPHA:
1345	return GL_DST_ALPHA;
1346	case SBF_SOURCE_ALPHA:
1347	return GL_SRC_ALPHA;
1348	case SBF_ONE_MINUS_DEST_ALPHA:
1349	return GL_ONE_MINUS_DST_ALPHA;
1350	case SBF_ONE_MINUS_SOURCE_ALPHA:
1351	return GL_ONE_MINUS_SRC_ALPHA;
1352	};
1353	// to keep compiler happy
1354	return GL_ONE;
1355	}
1356
1357	void GLRenderSystem::_setSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor)
1358	{
1359	GLint sourceBlend = getBlendMode(sourceFactor);
1360	GLint destBlend = getBlendMode(destFactor);
1361	if(sourceFactor == SBF_ONE && destFactor == SBF_ZERO)
1362	{
1363	glDisable(GL_BLEND);
1364	}
1365	else
1366	{
1367	glEnable(GL_BLEND);
1368	glBlendFunc(sourceBlend, destBlend);
1369	}
1370	}
1371	//-----------------------------------------------------------------------------
1372	void GLRenderSystem::_setAlphaRejectSettings(CompareFunction func, unsigned char value)
1373	{
1374	if(func == CMPF_ALWAYS_PASS)
1375	{
1376	glDisable(GL_ALPHA_TEST);
1377	}
1378	else
1379	{
1380	glEnable(GL_ALPHA_TEST);
1381	glAlphaFunc(convertCompareFunction(func), value / 255.0f);
1382	}
1383	}
1384	//-----------------------------------------------------------------------------
1385	void GLRenderSystem::_setViewport(Viewport *vp)
1386	{
1387	// Check if viewport is different
1388	if (vp != mActiveViewport \|\| vp->_isUpdated())
1389	{
1390	RenderTarget* target;
1391	target = vp->getTarget();
1392	_setRenderTarget(target);
1393	mActiveViewport = vp;
1394
1395	GLsizei x, y, w, h;
1396
1397	// Calculate the "lower-left" corner of the viewport
1398	w = vp->getActualWidth();
1399	h = vp->getActualHeight();
1400	x = vp->getActualLeft();
1401	y = vp->getActualTop();
1402	if (!target->requiresTextureFlipping())
1403	{
1404	// Convert "upper-left" corner to "lower-left"
1405	y = target->getHeight() - h - y;
1406	}
1407	glViewport(x, y, w, h);
1408
1409	// Configure the viewport clipping
1410	glScissor(x, y, w, h);
1411
1412	vp->_clearUpdatedFlag();
1413	}
1414	}
1415
1416	void GLRenderSystem::setLights()
1417	{
1418	for (size_t i = 0; i < MAX_LIGHTS; ++i)
1419	{
1420	if (mLights[i] != NULL)
1421	{
1422	Light* lt = mLights[i];
1423	setGLLightPositionDirection(lt, GL_LIGHT0 + i);
1424	}
1425	}
1426	}
1427
1428	//-----------------------------------------------------------------------------
1429	void GLRenderSystem::_beginFrame(void)
1430	{
1431	OgreGuard( "GLRenderSystem::_beginFrame" );
1432
1433	if (!mActiveViewport)
1434	OGRE_EXCEPT(999, "Cannot begin frame - no viewport selected.",
1435	"GLRenderSystem::_beginFrame");
1436
1437	// Activate the viewport clipping
1438	glEnable(GL_SCISSOR_TEST);
1439	// Clear the viewport if required
1440	if (mActiveViewport->getClearEveryFrame())
1441	{
1442	clearFrameBuffer(FBT_COLOUR \| FBT_DEPTH,
1443	mActiveViewport->getBackgroundColour());
1444	}
1445
1446	OgreUnguard();
1447	}
1448
1449	//-----------------------------------------------------------------------------
1450	void GLRenderSystem::_endFrame(void)
1451	{
1452	// Deactivate the viewport clipping.
1453	glDisable(GL_SCISSOR_TEST);
1454	}
1455
1456	//-----------------------------------------------------------------------------
1457	void GLRenderSystem::_setCullingMode(CullingMode mode)
1458	{
1459	// NB: Because two-sided stencil API dependence of the front face, we must
1460	// use the same 'winding' for the front face everywhere. As the OGRE default
1461	// culling mode is clockwise, we also treat anticlockwise winding as front
1462	// face for consistently. On the assumption that, we can't change the front
1463	// face by glFrontFace anywhere.
1464
1465	GLenum cullMode;
1466
1467	switch( mode )
1468	{
1469	case CULL_NONE:
1470	glDisable( GL_CULL_FACE );
1471	return;
1472	case CULL_CLOCKWISE:
1473	if (mActiveRenderTarget &&
1474	((mActiveRenderTarget->requiresTextureFlipping() && !mInvertVertexWinding) \|\|
1475	(!mActiveRenderTarget->requiresTextureFlipping() && mInvertVertexWinding)))
1476	{
1477	cullMode = GL_FRONT;
1478	}
1479	else
1480	{
1481	cullMode = GL_BACK;
1482	}
1483	break;
1484	case CULL_ANTICLOCKWISE:
1485	if (mActiveRenderTarget &&
1486	((mActiveRenderTarget->requiresTextureFlipping() && !mInvertVertexWinding) \|\|
1487	(!mActiveRenderTarget->requiresTextureFlipping() && mInvertVertexWinding)))
1488	{
1489	cullMode = GL_BACK;
1490	}
1491	else
1492	{
1493	cullMode = GL_FRONT;
1494	}
1495	break;
1496	}
1497
1498	glEnable( GL_CULL_FACE );
1499	glCullFace( cullMode );
1500	}
1501	//-----------------------------------------------------------------------------
1502	void GLRenderSystem::_setDepthBufferParams(bool depthTest, bool depthWrite, CompareFunction depthFunction)
1503	{
1504	_setDepthBufferCheckEnabled(depthTest);
1505	_setDepthBufferWriteEnabled(depthWrite);
1506	_setDepthBufferFunction(depthFunction);
1507	}
1508	//-----------------------------------------------------------------------------
1509	void GLRenderSystem::_setDepthBufferCheckEnabled(bool enabled)
1510	{
1511	if (enabled)
1512	{
1513	glClearDepth(1.0f);
1514	glEnable(GL_DEPTH_TEST);
1515	}
1516	else
1517	{
1518	glDisable(GL_DEPTH_TEST);
1519	}
1520	}
1521	//-----------------------------------------------------------------------------
1522	void GLRenderSystem::_setDepthBufferWriteEnabled(bool enabled)
1523	{
1524	GLboolean flag = enabled ? GL_TRUE : GL_FALSE;
1525	glDepthMask( flag );
1526	// Store for reference in _beginFrame
1527	mDepthWrite = enabled;
1528	}
1529	//-----------------------------------------------------------------------------
1530	void GLRenderSystem::_setDepthBufferFunction(CompareFunction func)
1531	{
1532	glDepthFunc(convertCompareFunction(func));
1533	}
1534	//-----------------------------------------------------------------------------
1535	void GLRenderSystem::_setDepthBias(ushort bias)
1536	{
1537	if (bias > 0)
1538	{
1539	glEnable(GL_POLYGON_OFFSET_FILL);
1540	glEnable(GL_POLYGON_OFFSET_POINT);
1541	glEnable(GL_POLYGON_OFFSET_LINE);
1542	// Bias is in {0, 16}, scale the unit addition appropriately
1543	glPolygonOffset(0.0f, -bias);
1544	}
1545	else
1546	{
1547	glDisable(GL_POLYGON_OFFSET_FILL);
1548	glDisable(GL_POLYGON_OFFSET_POINT);
1549	glDisable(GL_POLYGON_OFFSET_LINE);
1550	}
1551	}
1552	//-----------------------------------------------------------------------------
1553	void GLRenderSystem::_setColourBufferWriteEnabled(bool red, bool green, bool blue, bool alpha)
1554	{
1555	glColorMask(red, green, blue, alpha);
1556	// record this
1557	mColourWrite[0] = red;
1558	mColourWrite[1] = blue;
1559	mColourWrite[2] = green;
1560	mColourWrite[3] = alpha;
1561	}
1562	//-----------------------------------------------------------------------------
1563	String GLRenderSystem::getErrorDescription(long errCode) const
1564	{
1565	const GLubyte *errString = gluErrorString (errCode);
1566	return String((const char*) errString);
1567	}
1568	//-----------------------------------------------------------------------------
1569	void GLRenderSystem::setLightingEnabled(bool enabled)
1570	{
1571	if (enabled)
1572	{
1573	glEnable(GL_LIGHTING);
1574	}
1575	else
1576	{
1577	glDisable(GL_LIGHTING);
1578	}
1579	}
1580	//-----------------------------------------------------------------------------
1581	void GLRenderSystem::_setFog(FogMode mode, const ColourValue& colour, Real density, Real start, Real end)
1582	{
1583
1584	GLint fogMode;
1585	switch (mode)
1586	{
1587	case FOG_EXP:
1588	fogMode = GL_EXP;
1589	break;
1590	case FOG_EXP2:
1591	fogMode = GL_EXP2;
1592	break;
1593	case FOG_LINEAR:
1594	fogMode = GL_LINEAR;
1595	break;
1596	default:
1597	// Give up on it
1598	glDisable(GL_FOG);
1599	return;
1600	}
1601
1602	glEnable(GL_FOG);
1603	glFogi(GL_FOG_MODE, fogMode);
1604	GLfloat fogColor[4] = {colour.r, colour.g, colour.b, colour.a};
1605	glFogfv(GL_FOG_COLOR, fogColor);
1606	glFogf(GL_FOG_DENSITY, density);
1607	glFogf(GL_FOG_START, start);
1608	glFogf(GL_FOG_END, end);
1609	// XXX Hint here?
1610	}
1611
1612	void GLRenderSystem::convertColourValue(const ColourValue& colour, uint32* pDest)
1613	{
1614	#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
1615	*pDest = colour.getAsRGBA();
1616	#else
1617	// GL accesses by byte, so use ABGR so little-endian format will make it RGBA in byte mode
1618	*pDest = colour.getAsABGR();
1619	#endif
1620	}
1621
1622	void GLRenderSystem::_makeProjectionMatrix(const Radian& fovy, Real aspect, Real nearPlane,
1623	Real farPlane, Matrix4& dest, bool forGpuProgram)
1624	{
1625	Radian thetaY ( fovy / 2.0f );
1626	Real tanThetaY = Math::Tan(thetaY);
1627	//Real thetaX = thetaY * aspect;
1628	//Real tanThetaX = Math::Tan(thetaX);
1629
1630	// Calc matrix elements
1631	Real w = (1.0f / tanThetaY) / aspect;
1632	Real h = 1.0f / tanThetaY;
1633	Real q, qn;
1634	if (farPlane == 0)
1635	{
1636	// Infinite far plane
1637	q = Frustum::INFINITE_FAR_PLANE_ADJUST - 1;
1638	qn = nearPlane * (Frustum::INFINITE_FAR_PLANE_ADJUST - 2);
1639	}
1640	else
1641	{
1642	q = -(farPlane + nearPlane) / (farPlane - nearPlane);
1643	qn = -2 * (farPlane * nearPlane) / (farPlane - nearPlane);
1644	}
1645
1646	// NB This creates Z in range [-1,1]
1647	//
1648	// [ w 0 0 0 ]
1649	// [ 0 h 0 0 ]
1650	// [ 0 0 q qn ]
1651	// [ 0 0 -1 0 ]
1652
1653	dest = Matrix4::ZERO;
1654	dest[0][0] = w;
1655	dest[1][1] = h;
1656	dest[2][2] = q;
1657	dest[2][3] = qn;
1658	dest[3][2] = -1;
1659
1660	}
1661
1662	void GLRenderSystem::_makeOrthoMatrix(const Radian& fovy, Real aspect, Real nearPlane,
1663	Real farPlane, Matrix4& dest, bool forGpuProgram)
1664	{
1665	Radian thetaY (fovy / 2.0f);
1666	Real tanThetaY = Math::Tan(thetaY);
1667
1668	//Real thetaX = thetaY * aspect;
1669	Real tanThetaX = tanThetaY * aspect; //Math::Tan(thetaX);
1670	Real half_w = tanThetaX * nearPlane;
1671	Real half_h = tanThetaY * nearPlane;
1672	Real iw = 1.0 / half_w;
1673	Real ih = 1.0 / half_h;
1674	Real q;
1675	if (farPlane == 0)
1676	{
1677	q = 0;
1678	}
1679	else
1680	{
1681	q = 2.0 / (farPlane - nearPlane);
1682	}
1683	dest = Matrix4::ZERO;
1684	dest[0][0] = iw;
1685	dest[1][1] = ih;
1686	dest[2][2] = -q;
1687	dest[2][3] = - (farPlane + nearPlane)/(farPlane - nearPlane);
1688	dest[3][3] = 1;
1689	}
1690
1691	void GLRenderSystem::_setRasterisationMode(SceneDetailLevel level)
1692	{
1693	GLenum glmode;
1694	switch(level)
1695	{
1696	case SDL_POINTS:
1697	glmode = GL_POINT;
1698	break;
1699	case SDL_WIREFRAME:
1700	glmode = GL_LINE;
1701	break;
1702	case SDL_SOLID:
1703	glmode = GL_FILL;
1704	break;
1705	}
1706	glPolygonMode(GL_FRONT_AND_BACK, glmode);
1707	}
1708	//---------------------------------------------------------------------
1709	void GLRenderSystem::setStencilCheckEnabled(bool enabled)
1710	{
1711	if (enabled)
1712	{
1713	glEnable(GL_STENCIL_TEST);
1714	}
1715	else
1716	{
1717	glDisable(GL_STENCIL_TEST);
1718	}
1719	}
1720	//---------------------------------------------------------------------
1721	void GLRenderSystem::setStencilBufferParams(CompareFunction func,
1722	uint32 refValue, uint32 mask, StencilOperation stencilFailOp,
1723	StencilOperation depthFailOp, StencilOperation passOp,
1724	bool twoSidedOperation)
1725	{
1726	bool flip;
1727
1728	if (twoSidedOperation)
1729	{
1730	if (!mCapabilities->hasCapability(RSC_TWO_SIDED_STENCIL))
1731	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "2-sided stencils are not supported",
1732	"GLRenderSystem::setStencilBufferParams");
1733	glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
1734	// NB: We should always treat CCW as front face for consistent with default
1735	// culling mode. Therefore, we must take care with two-sided stencil settings.
1736	flip = (mInvertVertexWinding && !mActiveRenderTarget->requiresTextureFlipping()) \|\|
1737	(!mInvertVertexWinding && mActiveRenderTarget->requiresTextureFlipping());
1738
1739	// Set alternative versions of ops
1740	glActiveStencilFaceEXT_ptr(GL_BACK);
1741	glStencilMask(mask);
1742	glStencilFunc(convertCompareFunction(func), refValue, mask);
1743	glStencilOp(
1744	convertStencilOp(stencilFailOp, !flip),
1745	convertStencilOp(depthFailOp, !flip),
1746	convertStencilOp(passOp, !flip));
1747	// reset
1748	glActiveStencilFaceEXT_ptr(GL_FRONT);
1749	}
1750	else
1751	{
1752	glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
1753	flip = false;
1754	}
1755
1756	glStencilMask(mask);
1757	glStencilFunc(convertCompareFunction(func), refValue, mask);
1758	glStencilOp(
1759	convertStencilOp(stencilFailOp, flip),
1760	convertStencilOp(depthFailOp, flip),
1761	convertStencilOp(passOp, flip));
1762	}
1763	//---------------------------------------------------------------------
1764	GLint GLRenderSystem::convertCompareFunction(CompareFunction func) const
1765	{
1766	switch(func)
1767	{
1768	case CMPF_ALWAYS_FAIL:
1769	return GL_NEVER;
1770	case CMPF_ALWAYS_PASS:
1771	return GL_ALWAYS;
1772	case CMPF_LESS:
1773	return GL_LESS;
1774	case CMPF_LESS_EQUAL:
1775	return GL_LEQUAL;
1776	case CMPF_EQUAL:
1777	return GL_EQUAL;
1778	case CMPF_NOT_EQUAL:
1779	return GL_NOTEQUAL;
1780	case CMPF_GREATER_EQUAL:
1781	return GL_GEQUAL;
1782	case CMPF_GREATER:
1783	return GL_GREATER;
1784	};
1785	// to keep compiler happy
1786	return GL_ALWAYS;
1787	}
1788	//---------------------------------------------------------------------
1789	GLint GLRenderSystem::convertStencilOp(StencilOperation op, bool invert) const
1790	{
1791	switch(op)
1792	{
1793	case SOP_KEEP:
1794	return GL_KEEP;
1795	case SOP_ZERO:
1796	return GL_ZERO;
1797	case SOP_REPLACE:
1798	return GL_REPLACE;
1799	case SOP_INCREMENT:
1800	return invert ? GL_DECR : GL_INCR;
1801	case SOP_DECREMENT:
1802	return invert ? GL_INCR : GL_DECR;
1803	case SOP_INCREMENT_WRAP:
1804	return invert ? GL_DECR_WRAP_EXT : GL_INCR_WRAP_EXT;
1805	case SOP_DECREMENT_WRAP:
1806	return invert ? GL_INCR_WRAP_EXT : GL_DECR_WRAP_EXT;
1807	case SOP_INVERT:
1808	return GL_INVERT;
1809	};
1810	// to keep compiler happy
1811	return SOP_KEEP;
1812	}
1813	//---------------------------------------------------------------------
1814	GLuint GLRenderSystem::getCombinedMinMipFilter(void) const
1815	{
1816	switch(mMinFilter)
1817	{
1818	case FO_ANISOTROPIC:
1819	case FO_LINEAR:
1820	switch(mMipFilter)
1821	{
1822	case FO_ANISOTROPIC:
1823	case FO_LINEAR:
1824	// linear min, linear mip
1825	return GL_LINEAR_MIPMAP_LINEAR;
1826	case FO_POINT:
1827	// linear min, point mip
1828	return GL_LINEAR_MIPMAP_NEAREST;
1829	case FO_NONE:
1830	// linear min, no mip
1831	return GL_LINEAR;
1832	}
1833	break;
1834	case FO_POINT:
1835	case FO_NONE:
1836	switch(mMipFilter)
1837	{
1838	case FO_ANISOTROPIC:
1839	case FO_LINEAR:
1840	// nearest min, linear mip
1841	return GL_NEAREST_MIPMAP_LINEAR;
1842	case FO_POINT:
1843	// nearest min, point mip
1844	return GL_NEAREST_MIPMAP_NEAREST;
1845	case FO_NONE:
1846	// nearest min, no mip
1847	return GL_NEAREST;
1848	}
1849	break;
1850	}
1851
1852	// should never get here
1853	return 0;
1854
1855	}
1856	//---------------------------------------------------------------------
1857	void GLRenderSystem::_setTextureUnitFiltering(size_t unit,
1858	FilterType ftype, FilterOptions fo)
1859	{
1860	OgreGuard( "GLRenderSystem::_setTextureUnitFiltering" );
1861
1862	glActiveTextureARB_ptr( GL_TEXTURE0 + unit );
1863	switch(ftype)
1864	{
1865	case FT_MIN:
1866	mMinFilter = fo;
1867	// Combine with existing mip filter
1868	glTexParameteri(
1869	mTextureTypes[unit],
1870	GL_TEXTURE_MIN_FILTER,
1871	getCombinedMinMipFilter());
1872	break;
1873	case FT_MAG:
1874	switch (fo)
1875	{
1876	case FO_ANISOTROPIC: // GL treats linear and aniso the same
1877	case FO_LINEAR:
1878	glTexParameteri(
1879	mTextureTypes[unit],
1880	GL_TEXTURE_MAG_FILTER,
1881	GL_LINEAR);
1882	break;
1883	case FO_POINT:
1884	case FO_NONE:
1885	glTexParameteri(
1886	mTextureTypes[unit],
1887	GL_TEXTURE_MAG_FILTER,
1888	GL_NEAREST);
1889	break;
1890	}
1891	break;
1892	case FT_MIP:
1893	mMipFilter = fo;
1894	// Combine with existing min filter
1895	glTexParameteri(
1896	mTextureTypes[unit],
1897	GL_TEXTURE_MIN_FILTER,
1898	getCombinedMinMipFilter());
1899	break;
1900	}
1901
1902	glActiveTextureARB_ptr( GL_TEXTURE0 );
1903
1904	OgreUnguard();
1905	}
1906	//---------------------------------------------------------------------
1907	GLfloat GLRenderSystem::_getCurrentAnisotropy(size_t unit)
1908	{
1909	GLfloat curAniso = 0;
1910	glGetTexParameterfv(mTextureTypes[unit],
1911	GL_TEXTURE_MAX_ANISOTROPY_EXT, &curAniso);
1912	return curAniso ? curAniso : 1;
1913	}
1914	//---------------------------------------------------------------------
1915	void GLRenderSystem::_setTextureLayerAnisotropy(size_t unit, unsigned int maxAnisotropy)
1916	{
1917	if (!mCapabilities->hasCapability(RSC_ANISOTROPY))
1918	return;
1919
1920	GLfloat largest_supported_anisotropy = 0;
1921	glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &largest_supported_anisotropy);
1922	if (maxAnisotropy > largest_supported_anisotropy)
1923	maxAnisotropy = largest_supported_anisotropy ? largest_supported_anisotropy : 1;
1924	if (_getCurrentAnisotropy(unit) != maxAnisotropy)
1925	glTexParameterf(mTextureTypes[unit], GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy);
1926	}
1927	//-----------------------------------------------------------------------------
1928	void GLRenderSystem::_setTextureBlendMode(size_t stage, const LayerBlendModeEx& bm)
1929	{
1930	if (stage >= mFixedFunctionTextureUnits)
1931	{
1932	// Can't do this
1933	return;
1934	}
1935
1936	// Check to see if blending is supported
1937	if(!mCapabilities->hasCapability(RSC_BLENDING))
1938	return;
1939
1940	GLenum src1op, src2op, cmd;
1941	GLfloat cv1[4], cv2[4];
1942
1943	if (bm.blendType == LBT_COLOUR)
1944	{
1945	cv1[0] = bm.colourArg1.r;
1946	cv1[1] = bm.colourArg1.g;
1947	cv1[2] = bm.colourArg1.b;
1948	cv1[3] = bm.colourArg1.a;
1949	mManualBlendColours[stage][0] = bm.colourArg1;
1950
1951
1952	cv2[0] = bm.colourArg2.r;
1953	cv2[1] = bm.colourArg2.g;
1954	cv2[2] = bm.colourArg2.b;
1955	cv2[3] = bm.colourArg2.a;
1956	mManualBlendColours[stage][1] = bm.colourArg2;
1957	}
1958
1959	if (bm.blendType == LBT_ALPHA)
1960	{
1961	cv1[0] = mManualBlendColours[stage][0].r;
1962	cv1[1] = mManualBlendColours[stage][0].g;
1963	cv1[2] = mManualBlendColours[stage][0].b;
1964	cv1[3] = bm.alphaArg1;
1965
1966	cv2[0] = mManualBlendColours[stage][1].r;
1967	cv2[1] = mManualBlendColours[stage][1].g;
1968	cv2[2] = mManualBlendColours[stage][1].b;
1969	cv2[3] = bm.alphaArg2;
1970	}
1971
1972	switch (bm.source1)
1973	{
1974	case LBS_CURRENT:
1975	src1op = GL_PREVIOUS;
1976	break;
1977	case LBS_TEXTURE:
1978	src1op = GL_TEXTURE;
1979	break;
1980	case LBS_MANUAL:
1981	src1op = GL_CONSTANT;
1982	break;
1983	case LBS_DIFFUSE:
1984	src1op = GL_PRIMARY_COLOR;
1985	break;
1986	// XXX
1987	case LBS_SPECULAR:
1988	default:
1989	src1op = 0;
1990	}
1991
1992	switch (bm.source2)
1993	{
1994	case LBS_CURRENT:
1995	src2op = GL_PREVIOUS;
1996	break;
1997	case LBS_TEXTURE:
1998	src2op = GL_TEXTURE;
1999	break;
2000	case LBS_MANUAL:
2001	src2op = GL_CONSTANT;
2002	break;
2003	case LBS_DIFFUSE:
2004	src2op = GL_PRIMARY_COLOR;
2005	break;
2006	// XXX
2007	case LBS_SPECULAR:
2008	default:
2009	src2op = 0;
2010	}
2011
2012	switch (bm.operation)
2013	{
2014	case LBX_SOURCE1:
2015	cmd = GL_REPLACE;
2016	break;
2017	case LBX_SOURCE2:
2018	cmd = GL_REPLACE;
2019	break;
2020	case LBX_MODULATE:
2021	cmd = GL_MODULATE;
2022	break;
2023	case LBX_MODULATE_X2:
2024	cmd = GL_MODULATE;
2025	break;
2026	case LBX_MODULATE_X4:
2027	cmd = GL_MODULATE;
2028	break;
2029	case LBX_ADD:
2030	cmd = GL_ADD;
2031	break;
2032	case LBX_ADD_SIGNED:
2033	cmd = GL_ADD_SIGNED;
2034	break;
2035	case LBX_SUBTRACT:
2036	cmd = GL_SUBTRACT;
2037	break;
2038	case LBX_BLEND_DIFFUSE_ALPHA:
2039	cmd = GL_INTERPOLATE;
2040	break;
2041	case LBX_BLEND_TEXTURE_ALPHA:
2042	cmd = GL_INTERPOLATE;
2043	break;
2044	case LBX_BLEND_CURRENT_ALPHA:
2045	cmd = GL_INTERPOLATE;
2046	break;
2047	case LBX_BLEND_MANUAL:
2048	cmd = GL_INTERPOLATE;
2049	break;
2050	case LBX_DOTPRODUCT:
2051	cmd = mCapabilities->hasCapability(RSC_DOT3)
2052	? GL_DOT3_RGB : GL_MODULATE;
2053	break;
2054	default:
2055	cmd = 0;
2056	}
2057
2058	glActiveTextureARB_ptr(GL_TEXTURE0 + stage);
2059	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
2060
2061	if (bm.blendType == LBT_COLOUR)
2062	{
2063	glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, cmd);
2064	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, src1op);
2065	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, src2op);
2066	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_CONSTANT);
2067	}
2068	else
2069	{
2070	glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, cmd);
2071	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, src1op);
2072	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, src2op);
2073	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
2074	}
2075
2076	float blendValue[4] = {0, 0, 0, bm.factor};
2077	switch (bm.operation)
2078	{
2079	case LBX_BLEND_DIFFUSE_ALPHA:
2080	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_PRIMARY_COLOR);
2081	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_PRIMARY_COLOR);
2082	break;
2083	case LBX_BLEND_TEXTURE_ALPHA:
2084	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_TEXTURE);
2085	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_TEXTURE);
2086	break;
2087	case LBX_BLEND_CURRENT_ALPHA:
2088	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_PREVIOUS);
2089	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_PREVIOUS);
2090	break;
2091	case LBX_BLEND_MANUAL:
2092	glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, blendValue);
2093	break;
2094	default:
2095	break;
2096	};
2097
2098	switch (bm.operation)
2099	{
2100	case LBX_MODULATE_X2:
2101	glTexEnvi(GL_TEXTURE_ENV, bm.blendType == LBT_COLOUR ?
2102	GL_RGB_SCALE : GL_ALPHA_SCALE, 2);
2103	break;
2104	case LBX_MODULATE_X4:
2105	glTexEnvi(GL_TEXTURE_ENV, bm.blendType == LBT_COLOUR ?
2106	GL_RGB_SCALE : GL_ALPHA_SCALE, 4);
2107	break;
2108	default:
2109	glTexEnvi(GL_TEXTURE_ENV, bm.blendType == LBT_COLOUR ?
2110	GL_RGB_SCALE : GL_ALPHA_SCALE, 1);
2111	break;
2112	}
2113
2114	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
2115	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
2116	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
2117	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
2118	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
2119	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
2120	if(bm.source1 == LBS_MANUAL)
2121	glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, cv1);
2122	if (bm.source2 == LBS_MANUAL)
2123	glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, cv2);
2124
2125	glActiveTextureARB_ptr(GL_TEXTURE0);
2126	}
2127	//---------------------------------------------------------------------
2128	void GLRenderSystem::setGLLightPositionDirection(Light* lt, GLenum lightindex)
2129	{
2130	// Set position / direction
2131	Vector4 vec;
2132	// Use general 4D vector which is the same as GL's approach
2133	vec = lt->getAs4DVector();
2134
2135	#if OGRE_DOUBLE_PRECISION
2136	// Must convert to float*
2137	float tmp[4] = {vec.x, vec.y, vec.z, vec.w};
2138	glLightfv(lightindex, GL_POSITION, tmp);
2139	#else
2140	glLightfv(lightindex, GL_POSITION, vec.val);
2141	#endif
2142	// Set spotlight direction
2143	if (lt->getType() == Light::LT_SPOTLIGHT)
2144	{
2145	vec = lt->getDerivedDirection();
2146	vec.w = 0.0;
2147	#if OGRE_DOUBLE_PRECISION
2148	// Must convert to float*
2149	float tmp2[4] = {vec.x, vec.y, vec.z, vec.w};
2150	glLightfv(lightindex, GL_SPOT_DIRECTION, tmp2);
2151	#else
2152	glLightfv(lightindex, GL_SPOT_DIRECTION, vec.val);
2153	#endif
2154	}
2155	}
2156	//---------------------------------------------------------------------
2157	void GLRenderSystem::setVertexDeclaration(VertexDeclaration* decl)
2158	{
2159	}
2160	//---------------------------------------------------------------------
2161	void GLRenderSystem::setVertexBufferBinding(VertexBufferBinding* binding)
2162	{
2163	}
2164	//---------------------------------------------------------------------
2165	void GLRenderSystem::_render(const RenderOperation& op)
2166	{
2167	// Guard
2168	OgreGuard ("GLRenderSystem::_render");
2169	// Call super class
2170	RenderSystem::_render(op);
2171
2172	void* pBufferData = 0;
2173
2174	const VertexDeclaration::VertexElementList& decl =
2175	op.vertexData->vertexDeclaration->getElements();
2176	VertexDeclaration::VertexElementList::const_iterator elem, elemEnd;
2177	elemEnd = decl.end();
2178
2179	for (elem = decl.begin(); elem != elemEnd; ++elem)
2180	{
2181	HardwareVertexBufferSharedPtr vertexBuffer =
2182	op.vertexData->vertexBufferBinding->getBuffer(elem->getSource());
2183	if(mCapabilities->hasCapability(RSC_VBO))
2184	{
2185	glBindBufferARB_ptr(GL_ARRAY_BUFFER_ARB,
2186	static_cast<const GLHardwareVertexBuffer*>(vertexBuffer.get())->getGLBufferId());
2187	pBufferData = VBO_BUFFER_OFFSET(elem->getOffset());
2188	}
2189	else
2190	{
2191	pBufferData = static_cast<const GLDefaultHardwareVertexBuffer*>(vertexBuffer.get())->getDataPtr(elem->getOffset());
2192	}
2193	if (op.vertexData->vertexStart)
2194	{
2195	pBufferData = static_cast<char>(pBufferData) + op.vertexData->vertexStart vertexBuffer->getVertexSize();
2196	}
2197
2198	unsigned int i = 0;
2199
2200	switch(elem->getSemantic())
2201	{
2202	case VES_POSITION:
2203	glVertexPointer(VertexElement::getTypeCount(
2204	elem->getType()),
2205	GLHardwareBufferManager::getGLType(elem->getType()),
2206	static_cast<GLsizei>(vertexBuffer->getVertexSize()),
2207	pBufferData);
2208	glEnableClientState( GL_VERTEX_ARRAY );
2209	break;
2210	case VES_NORMAL:
2211	glNormalPointer(
2212	GLHardwareBufferManager::getGLType(elem->getType()),
2213	static_cast<GLsizei>(vertexBuffer->getVertexSize()),
2214	pBufferData);
2215	glEnableClientState( GL_NORMAL_ARRAY );
2216	break;
2217	case VES_DIFFUSE:
2218	glColorPointer(4,
2219	GLHardwareBufferManager::getGLType(elem->getType()),
2220	static_cast<GLsizei>(vertexBuffer->getVertexSize()),
2221	pBufferData);
2222	glEnableClientState( GL_COLOR_ARRAY );
2223	break;
2224	case VES_SPECULAR:
2225	glSecondaryColorPointerEXT_ptr(4,
2226	GLHardwareBufferManager::getGLType(elem->getType()),
2227	static_cast<GLsizei>(vertexBuffer->getVertexSize()),
2228	pBufferData);
2229	glEnableClientState( GL_SECONDARY_COLOR_ARRAY );
2230	break;
2231	case VES_TEXTURE_COORDINATES:
2232
2233	for (i = 0; i < OGRE_MAX_TEXTURE_COORD_SETS; i++)
2234	{
2235	// Only set this texture unit's texcoord pointer if it
2236	// is supposed to be using this element's index
2237	if (mTextureCoordIndex[i] == elem->getIndex())
2238	{
2239	glClientActiveTextureARB_ptr(GL_TEXTURE0 + i);
2240	glTexCoordPointer(
2241	VertexElement::getTypeCount(elem->getType()),
2242	GLHardwareBufferManager::getGLType(elem->getType()),
2243	static_cast<GLsizei>(vertexBuffer->getVertexSize()),
2244	pBufferData);
2245	glEnableClientState( GL_TEXTURE_COORD_ARRAY );
2246	}
2247	}
2248	break;
2249	case VES_BLEND_INDICES:
2250	assert(mCapabilities->hasCapability(RSC_VERTEX_PROGRAM));
2251	glVertexAttribPointerARB_ptr(
2252	7, // matrix indices are vertex attribute 7 (no def?)
2253	VertexElement::getTypeCount(elem->getType()),
2254	GLHardwareBufferManager::getGLType(elem->getType()),
2255	GL_FALSE, // normalisation disabled
2256	static_cast<GLsizei>(vertexBuffer->getVertexSize()),
2257	pBufferData);
2258	glEnableVertexAttribArrayARB_ptr(7);
2259	break;
2260	case VES_BLEND_WEIGHTS:
2261	assert(mCapabilities->hasCapability(RSC_VERTEX_PROGRAM));
2262	glVertexAttribPointerARB_ptr(
2263	1, // weights are vertex attribute 1 (no def?)
2264	VertexElement::getTypeCount(elem->getType()),
2265	GLHardwareBufferManager::getGLType(elem->getType()),
2266	GL_FALSE, // normalisation disabled
2267	static_cast<GLsizei>(vertexBuffer->getVertexSize()),
2268	pBufferData);
2269	glEnableVertexAttribArrayARB_ptr(1);
2270	break;
2271	default:
2272	break;
2273	};
2274
2275	}
2276
2277	glClientActiveTextureARB_ptr(GL_TEXTURE0);
2278
2279	// Find the correct type to render
2280	GLint primType;
2281	switch (op.operationType)
2282	{
2283	case RenderOperation::OT_POINT_LIST:
2284	primType = GL_POINTS;
2285	break;
2286	case RenderOperation::OT_LINE_LIST:
2287	primType = GL_LINES;
2288	break;
2289	case RenderOperation::OT_LINE_STRIP:
2290	primType = GL_LINE_STRIP;
2291	break;
2292	case RenderOperation::OT_TRIANGLE_LIST:
2293	primType = GL_TRIANGLES;
2294	break;
2295	case RenderOperation::OT_TRIANGLE_STRIP:
2296	primType = GL_TRIANGLE_STRIP;
2297	break;
2298	case RenderOperation::OT_TRIANGLE_FAN:
2299	primType = GL_TRIANGLE_FAN;
2300	break;
2301	}
2302
2303	if (op.useIndexes)
2304	{
2305	if(mCapabilities->hasCapability(RSC_VBO))
2306	{
2307	glBindBufferARB_ptr(GL_ELEMENT_ARRAY_BUFFER_ARB,
2308	static_cast<GLHardwareIndexBuffer*>(
2309	op.indexData->indexBuffer.get())->getGLBufferId());
2310
2311	pBufferData = VBO_BUFFER_OFFSET(
2312	op.indexData->indexStart * op.indexData->indexBuffer->getIndexSize());
2313	}
2314	else
2315	{
2316	pBufferData = static_cast<GLDefaultHardwareIndexBuffer*>(
2317	op.indexData->indexBuffer.get())->getDataPtr(
2318	op.indexData->indexStart * op.indexData->indexBuffer->getIndexSize());
2319	}
2320
2321	GLenum indexType = (op.indexData->indexBuffer->getType() == HardwareIndexBuffer::IT_16BIT) ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT;
2322
2323	glDrawElements(primType, op.indexData->indexCount, indexType, pBufferData);
2324
2325	}
2326	else
2327	{
2328	glDrawArrays(primType, 0, op.vertexData->vertexCount);
2329	}
2330
2331	glDisableClientState( GL_VERTEX_ARRAY );
2332	for (int i = 0; i < OGRE_MAX_TEXTURE_COORD_SETS; i++)
2333	{
2334	glClientActiveTextureARB_ptr(GL_TEXTURE0 + i);
2335	glDisableClientState( GL_TEXTURE_COORD_ARRAY );
2336	}
2337	glClientActiveTextureARB_ptr(GL_TEXTURE0);
2338	glDisableClientState( GL_NORMAL_ARRAY );
2339	glDisableClientState( GL_COLOR_ARRAY );
2340	glDisableClientState( GL_SECONDARY_COLOR_ARRAY );
2341	if (mCapabilities->hasCapability(RSC_VERTEX_PROGRAM))
2342	{
2343	glDisableVertexAttribArrayARB_ptr(7); // disable indices
2344	glDisableVertexAttribArrayARB_ptr(1); // disable weights
2345	}
2346	glColor4f(1,1,1,1);
2347	glSecondaryColor3fEXT_ptr(0.0f, 0.0f, 0.0f);
2348
2349	// UnGuard
2350	OgreUnguard();
2351	}
2352	//---------------------------------------------------------------------
2353	void GLRenderSystem::setNormaliseNormals(bool normalise)
2354	{
2355	if (normalise)
2356	glEnable(GL_NORMALIZE);
2357	else
2358	glDisable(GL_NORMALIZE);
2359
2360	}
2361	//---------------------------------------------------------------------
2362	void GLRenderSystem::bindGpuProgram(GpuProgram* prg)
2363	{
2364	GLGpuProgram* glprg = static_cast<GLGpuProgram*>(prg);
2365	glprg->bindProgram();
2366	if (glprg->getType() == GPT_VERTEX_PROGRAM)
2367	{
2368	mCurrentVertexProgram = glprg;
2369	}
2370	else
2371	{
2372	mCurrentFragmentProgram = glprg;
2373	}
2374	}
2375	//---------------------------------------------------------------------
2376	void GLRenderSystem::unbindGpuProgram(GpuProgramType gptype)
2377	{
2378
2379	if (gptype == GPT_VERTEX_PROGRAM && mCurrentVertexProgram)
2380	{
2381	mCurrentVertexProgram->unbindProgram();
2382	mCurrentVertexProgram = 0;
2383	}
2384	else if (gptype == GPT_FRAGMENT_PROGRAM && mCurrentFragmentProgram)
2385	{
2386	mCurrentFragmentProgram->unbindProgram();
2387	mCurrentFragmentProgram = 0;
2388	}
2389
2390
2391	}
2392	//---------------------------------------------------------------------
2393	void GLRenderSystem::bindGpuProgramParameters(GpuProgramType gptype, GpuProgramParametersSharedPtr params)
2394	{
2395	if (gptype == GPT_VERTEX_PROGRAM)
2396	{
2397	mCurrentVertexProgram->bindProgramParameters(params);
2398	}
2399	else
2400	{
2401	mCurrentFragmentProgram->bindProgramParameters(params);
2402	}
2403	}
2404	//---------------------------------------------------------------------
2405	void GLRenderSystem::setClipPlanes(const PlaneList& clipPlanes)
2406	{
2407	size_t i;
2408	size_t numClipPlanes;
2409	GLdouble clipPlane[4];
2410
2411	numClipPlanes = clipPlanes.size();
2412	for (i = 0; i < numClipPlanes; ++i)
2413	{
2414	GLenum clipPlaneId = static_cast<GLenum>(GL_CLIP_PLANE0 + i);
2415	const Plane& plane = clipPlanes[i];
2416
2417	if (i >= 6/GL_MAX_CLIP_PLANES/)
2418	{
2419	OGRE_EXCEPT(0, "Unable to set clip plane",
2420	"GLRenderSystem::setClipPlanes");
2421	}
2422
2423	clipPlane[0] = plane.normal.x;
2424	clipPlane[1] = plane.normal.y;
2425	clipPlane[2] = plane.normal.z;
2426	clipPlane[3] = plane.d;
2427
2428	glClipPlane(clipPlaneId, clipPlane);
2429	glEnable(clipPlaneId);
2430	}
2431
2432	// disable remaining clip planes
2433	for ( ; i < 6/GL_MAX_CLIP_PLANES/; ++i)
2434	{
2435	glDisable(static_cast<GLenum>(GL_CLIP_PLANE0 + i));
2436	}
2437	}
2438	//---------------------------------------------------------------------
2439	void GLRenderSystem::setScissorTest(bool enabled, size_t left,
2440	size_t top, size_t right, size_t bottom)
2441	{
2442	// If request texture flipping, use "upper-left", otherwise use "lower-left"
2443	bool flipping = mActiveRenderTarget->requiresTextureFlipping();
2444	// GL measures from the bottom, not the top
2445	size_t targetHeight = mActiveRenderTarget->getHeight();
2446	// Calculate the "lower-left" corner of the viewport
2447	GLsizei w, h, x, y;
2448
2449	if (enabled)
2450	{
2451	glEnable(GL_SCISSOR_TEST);
2452	// NB GL uses width / height rather than right / bottom
2453	x = left;
2454	if (flipping)
2455	y = top;
2456	else
2457	y = targetHeight - bottom;
2458	w = right - left;
2459	h = bottom - top;
2460	glScissor(x, y, w, h);
2461	}
2462	else
2463	{
2464	glDisable(GL_SCISSOR_TEST);
2465	// GL requires you to reset the scissor when disabling
2466	w = mActiveViewport->getActualWidth();
2467	h = mActiveViewport->getActualHeight();
2468	x = mActiveViewport->getActualLeft();
2469	if (flipping)
2470	y = mActiveViewport->getActualTop();
2471	else
2472	y = targetHeight - mActiveViewport->getActualTop() - h;
2473	glScissor(x, y, w, h);
2474	}
2475	}
2476	//---------------------------------------------------------------------
2477	void GLRenderSystem::clearFrameBuffer(unsigned int buffers,
2478	const ColourValue& colour, Real depth, unsigned short stencil)
2479	{
2480
2481	GLbitfield flags = 0;
2482	if (buffers & FBT_COLOUR)
2483	{
2484	flags \|= GL_COLOR_BUFFER_BIT;
2485	}
2486	if (buffers & FBT_DEPTH)
2487	{
2488	flags \|= GL_DEPTH_BUFFER_BIT;
2489	}
2490	if (buffers & FBT_STENCIL)
2491	{
2492	flags \|= GL_STENCIL_BUFFER_BIT;
2493	}
2494
2495
2496	// Enable depth & colour buffer for writing if it isn't
2497
2498	if (!mDepthWrite)
2499	{
2500	glDepthMask( GL_TRUE );
2501	}
2502	bool colourMask = !mColourWrite[0] \|\| !mColourWrite[1]
2503	\|\| !mColourWrite[2] \|\| mColourWrite[3];
2504	if (colourMask)
2505	{
2506	glColorMask(true, true, true, true);
2507	}
2508	// Set values
2509	glClearColor(colour.r, colour.g, colour.b, colour.a);
2510	glClearDepth(depth);
2511	glClearStencil(stencil);
2512	// Clear buffers
2513	glClear(flags);
2514	// Reset depth write state if appropriate
2515	// Enable depth buffer for writing if it isn't
2516	if (!mDepthWrite)
2517	{
2518	glDepthMask( GL_FALSE );
2519	}
2520	if (colourMask)
2521	{
2522	glColorMask(mColourWrite[0], mColourWrite[1], mColourWrite[2], mColourWrite[3]);
2523	}
2524
2525	}
2526	// ------------------------------------------------------------------
2527	void GLRenderSystem::_makeProjectionMatrix(Real left, Real right,
2528	Real bottom, Real top, Real nearPlane, Real farPlane, Matrix4& dest,
2529	bool forGpuProgram)
2530	{
2531	Real width = right - left;
2532	Real height = top - bottom;
2533	Real q, qn;
2534	if (farPlane == 0)
2535	{
2536	// Infinite far plane
2537	q = Frustum::INFINITE_FAR_PLANE_ADJUST - 1;
2538	qn = nearPlane * (Frustum::INFINITE_FAR_PLANE_ADJUST - 2);
2539	}
2540	else
2541	{
2542	q = -(farPlane + nearPlane) / (farPlane - nearPlane);
2543	qn = -2 * (farPlane * nearPlane) / (farPlane - nearPlane);
2544	}
2545	dest = Matrix4::ZERO;
2546	dest[0][0] = 2 * nearPlane / width;
2547	dest[0][2] = (right+left) / width;
2548	dest[1][1] = 2 * nearPlane / height;
2549	dest[1][2] = (top+bottom) / height;
2550	dest[2][2] = q;
2551	dest[2][3] = qn;
2552	dest[3][2] = -1;
2553	}
2554
2555	// ------------------------------------------------------------------
2556	void GLRenderSystem::setClipPlane (ushort index, Real A, Real B, Real C, Real D)
2557	{
2558	if (ushort(mClipPlanes.size()) < index+1)
2559	mClipPlanes.resize(index+1);
2560	mClipPlanes[index] = Vector4 (A, B, C, D);
2561	GLdouble plane[4] = { A, B, C, D };
2562	glClipPlane (GL_CLIP_PLANE0 + index, plane);
2563	}
2564
2565	// ------------------------------------------------------------------
2566	void GLRenderSystem::setGLClipPlanes() const
2567	{
2568	size_t size = mClipPlanes.size();
2569	for (size_t i=0; i<size; i++)
2570	{
2571	const Vector4 &p = mClipPlanes[i];
2572	GLdouble plane[4] = { p.x, p.y, p.z, p.w };
2573	glClipPlane (GL_CLIP_PLANE0 + i, plane);
2574	}
2575	}
2576
2577	// ------------------------------------------------------------------
2578	void GLRenderSystem::enableClipPlane (ushort index, bool enable)
2579	{
2580	glEnable (GL_CLIP_PLANE0 + index);
2581	}
2582	//---------------------------------------------------------------------
2583	HardwareOcclusionQuery* GLRenderSystem::createHardwareOcclusionQuery(void)
2584	{
2585	GLHardwareOcclusionQuery* ret = new GLHardwareOcclusionQuery();
2586	mHwOcclusionQueries.push_back(ret);
2587	return ret;
2588	}
2589	//---------------------------------------------------------------------
2590	Real GLRenderSystem::getHorizontalTexelOffset(void)
2591	{
2592	// No offset in GL
2593	return 0.0f;
2594	}
2595	//---------------------------------------------------------------------
2596	Real GLRenderSystem::getVerticalTexelOffset(void)
2597	{
2598	// No offset in GL
2599	return 0.0f;
2600	}
2601	//---------------------------------------------------------------------
2602	void GLRenderSystem::_applyObliqueDepthProjection(Matrix4& matrix, const Plane& plane,
2603	bool forGpuProgram)
2604	{
2605	// Thanks to Eric Lenyel for posting this calculation at www.terathon.com
2606
2607	// Calculate the clip-space corner point opposite the clipping plane
2608	// as (sgn(clipPlane.x), sgn(clipPlane.y), 1, 1) and
2609	// transform it into camera space by multiplying it
2610	// by the inverse of the projection matrix
2611
2612	Vector4 q;
2613	q.x = (Math::Sign(plane.normal.x) + matrix[0][2]) / matrix[0][0];
2614	q.y = (Math::Sign(plane.normal.y) + matrix[1][2]) / matrix[1][1];
2615	q.z = -1.0F;
2616	q.w = (1.0F + matrix[2][2]) / matrix[2][3];
2617
2618	// Calculate the scaled plane vector
2619	Vector4 clipPlane4d(plane.normal.x, plane.normal.y, plane.normal.z, plane.d);
2620	Vector4 c = clipPlane4d * (2.0F / (clipPlane4d.dotProduct(q)));
2621
2622	// Replace the third row of the projection matrix
2623	matrix[2][0] = c.x;
2624	matrix[2][1] = c.y;
2625	matrix[2][2] = c.z + 1.0F;
2626	matrix[2][3] = c.w;
2627	}
2628	//---------------------------------------------------------------------
2629	void GLRenderSystem::_oneTimeContextInitialization()
2630	{
2631	// Set nicer lighting model -- d3d9 has this by default
2632	glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
2633	glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
2634	glEnable(GL_COLOR_SUM);
2635	glDisable(GL_DITHER);
2636
2637	// Check for FSAA
2638	// Enable the extension if it was enabled by the GLSupport
2639	if (mGLSupport->checkExtension("GL_ARB_multisample"))
2640	{
2641	int fsaa_active = false;
2642	glGetIntegerv(GL_SAMPLE_BUFFERS_ARB,(GLint*)&fsaa_active);
2643	if(fsaa_active)
2644	{
2645	glEnable(GL_MULTISAMPLE_ARB);
2646	LogManager::getSingleton().logMessage("Using FSAA from GL_ARB_multisample extension.");
2647	}
2648	}
2649	}
2650	//---------------------------------------------------------------------
2651	void GLRenderSystem::_switchContext(GLContext *context)
2652	{
2653	// Unbind GPU programs and rebind to new context later, because
2654	// scene manager treat render system as ONE 'context' ONLY, and it
2655	// cached the GPU programs using state.
2656	if (mCurrentVertexProgram)
2657	mCurrentVertexProgram->unbindProgram();
2658	if (mCurrentFragmentProgram)
2659	mCurrentFragmentProgram->unbindProgram();
2660
2661	// It's ready to switching
2662	mCurrentContext->endCurrent();
2663	mCurrentContext = context;
2664	mCurrentContext->setCurrent();
2665
2666	// Check if the context has already done one-time initialisation
2667	if(!mCurrentContext->getInitialized())
2668	{
2669	_oneTimeContextInitialization();
2670	mCurrentContext->setInitialized();
2671	}
2672
2673	// Rebind GPU programs to new context
2674	if (mCurrentVertexProgram)
2675	mCurrentVertexProgram->bindProgram();
2676	if (mCurrentFragmentProgram)
2677	mCurrentFragmentProgram->bindProgram();
2678
2679	// Must reset depth/colour write mask to according with user desired, otherwise,
2680	// clearFrameBuffer would be wrong because the value we are recorded may be
2681	// difference with the really state stored in GL context.
2682	glDepthMask(mDepthWrite);
2683	glColorMask(mColourWrite[0], mColourWrite[1], mColourWrite[2], mColourWrite[3]);
2684
2685	}
2686	//---------------------------------------------------------------------
2687	void GLRenderSystem::_setRenderTarget(RenderTarget *target)
2688	{
2689	mActiveRenderTarget = target;
2690	// Switch context if different from current one
2691	ContextMap::iterator i = mContextMap.find(target);
2692	if(i != mContextMap.end() && mCurrentContext != i->second) {
2693	_switchContext(i->second);
2694	}
2695	}
2696	//---------------------------------------------------------------------
2697	void GLRenderSystem::_registerContext(RenderTarget target, GLContext context)
2698	{
2699	mContextMap[target] = context;
2700	}
2701	//---------------------------------------------------------------------
2702	void GLRenderSystem::_unregisterContext(RenderTarget *target)
2703	{
2704	ContextMap::iterator i = mContextMap.find(target);
2705	if(i != mContextMap.end() && mCurrentContext == i->second) {
2706	// Change the context to something else so that a valid context
2707	// remains active. When this is the main context being unregistered,
2708	// we set the main context to 0.
2709	if(mCurrentContext != mMainContext) {
2710	_switchContext(mMainContext);
2711	} else {
2712	mMainContext = 0;
2713	}
2714	}
2715	mContextMap.erase(target);
2716	}
2717	//---------------------------------------------------------------------
2718	GLContext *GLRenderSystem::_getMainContext() {
2719	return mMainContext;
2720	}
2721	//---------------------------------------------------------------------
2722	Real GLRenderSystem::getMinimumDepthInputValue(void)
2723	{
2724	// Range [-1.0f, 1.0f]
2725	return -1.0f;
2726	}
2727	//---------------------------------------------------------------------
2728	Real GLRenderSystem::getMaximumDepthInputValue(void)
2729	{
2730	// Range [-1.0f, 1.0f]
2731	return 1.0f;
2732	}
2733
2734	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: