Context Navigation

OgreGLRenderSystem.cpp @ 692

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

Rev	Line
[692]	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: