Context Navigation

OgreGLRenderSystem.cpp @ 692

Revision 692, 92.3 KB checked in by mattausch, 18 years ago (diff)
adding ogre 1.2 and dependencies

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

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

Context Navigation

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

Download in other formats: