Context Navigation

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

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

Rev	Line
[657]	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.
	23	-----------------------------------------------------------------------------
	24	*/
	25
	26	#include "OgreGLTexture.h"
	27	#include "OgreGLSupport.h"
	28	#include "OgreGLPixelFormat.h"
	29	#include "OgreGLHardwarePixelBuffer.h"
	30
	31	#include "OgreTextureManager.h"
	32	#include "OgreImage.h"
	33	#include "OgreLogManager.h"
	34	#include "OgreCamera.h"
	35	#include "OgreException.h"
	36	#include "OgreRoot.h"
	37	#include "OgreCodec.h"
	38	#include "OgreImageCodec.h"
	39	#include "OgreStringConverter.h"
	40
	41	#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
	42	# include <windows.h>
	43	# include <wingdi.h>
	44	#endif
	45
	46	namespace Ogre {
	47
	48	unsigned int mostSignificantBitSet(unsigned int value)
	49	{
	50	unsigned int result = 0;
	51	while (value != 0) {
	52	++result;
	53	value >>= 1;
	54	}
	55	return result-1;
	56	}
	57
	58	GLTexture::GLTexture(ResourceManager* creator, const String& name,
	59	ResourceHandle handle, const String& group, bool isManual,
	60	ManualResourceLoader* loader, GLSupport& support)
	61	: Texture(creator, name, handle, group, isManual, loader),
	62	mTextureID(0), mGLSupport(support)
	63	{
	64	}
	65
	66
	67	GLTexture::~GLTexture()
	68	{
	69	// have to call this here reather than in Resource destructor
	70	// since calling virtual methods in base destructors causes crash
	71	if (mIsLoaded)
	72	{
	73	unload();
	74	}
	75	else
	76	{
	77	freeInternalResources();
	78	}
	79	}
	80
	81	GLenum GLTexture::getGLTextureTarget(void) const
	82	{
	83	switch(mTextureType)
	84	{
	85	case TEX_TYPE_1D:
	86	return GL_TEXTURE_1D;
	87	case TEX_TYPE_2D:
	88	return GL_TEXTURE_2D;
	89	case TEX_TYPE_3D:
	90	return GL_TEXTURE_3D;
	91	case TEX_TYPE_CUBE_MAP:
	92	return GL_TEXTURE_CUBE_MAP;
	93	default:
	94	return 0;
	95	};
	96	}
	97
	98	//* Creation / loading methods ********************************************
	99	void GLTexture::createInternalResourcesImpl(void)
	100	{
	101	// Adjust requested parameters to capabilities
	102
	103	// Check power-of-two size if required
	104	unsigned int newWidth = (1 << mostSignificantBitSet(mWidth));
	105	if (newWidth != mWidth)
	106	newWidth <<= 1;
	107
	108	unsigned int newHeight = (1 << mostSignificantBitSet(mHeight));
	109	if (newHeight != mHeight)
	110	newHeight <<= 1;
	111
	112	unsigned int newDepth = (1 << mostSignificantBitSet(mDepth));
	113	if (newDepth != mDepth)
	114	newDepth <<= 1;
	115
	116	if(!Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_NON_POWER_OF_2_TEXTURES))
	117	{
	118	mHeight = newHeight;
	119	mWidth = newWidth;
	120	mDepth = newDepth;
	121	}
	122
	123	// Check compressed texture support
	124	// if a compressed format not supported, revert to PF_A8R8G8B8
	125	if(PixelUtil::isCompressed(mFormat) &&
	126	!Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability( RSC_TEXTURE_COMPRESSION_DXT ))
	127	{
	128	mFormat = PF_A8R8G8B8;
	129	}
	130	// if floating point textures not supported, revert to PF_A8R8G8B8
	131	if(PixelUtil::isFloatingPoint(mFormat) &&
	132	!Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability( RSC_TEXTURE_FLOAT ))
	133	{
	134	mFormat = PF_A8R8G8B8;
	135	}
	136
	137	// Check requested number of mipmaps
	138	// Zero means create mip levels until 1x1
	139	size_t maxMips = GLPixelUtil::getMaxMipmaps(mWidth, mHeight, mDepth, mFormat);
	140	mNumMipmaps = mNumRequestedMipmaps;
	141	if(mNumMipmaps>maxMips)
	142	mNumMipmaps = maxMips;
	143
	144	// Generate texture name
	145	glGenTextures( 1, &mTextureID );
	146
	147	// Set texture type
	148	glBindTexture( getGLTextureTarget(), mTextureID );
	149
	150	// This needs to be set otherwise the texture doesn't get rendered
	151	glTexParameteri( getGLTextureTarget(), GL_TEXTURE_MAX_LEVEL, mNumMipmaps );
	152
	153	// If we can do automip generation and the user desires this, do so
	154	mMipmapsHardwareGenerated =
	155	Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP);
	156	if((mUsage & TU_AUTOMIPMAP) &&
	157	mNumRequestedMipmaps && mMipmapsHardwareGenerated)
	158	{
	159	glTexParameteri( getGLTextureTarget(), GL_GENERATE_MIPMAP, GL_TRUE );
	160	}
	161
	162	// Allocate internal buffer so that glTexSubImageXD can be used
	163	// Internal format
	164	GLenum format = GLPixelUtil::getClosestGLInternalFormat(mFormat);
	165	size_t width = mWidth;
	166	size_t height = mHeight;
	167	size_t depth = mDepth;
	168	if(PixelUtil::isCompressed(mFormat))
	169	{
	170	// Compressed formats
	171	size_t size = PixelUtil::getMemorySize(mWidth, mHeight, mDepth, mFormat);
	172	// Provide temporary buffer filled with zeroes as glCompressedTexImageXD does not
	173	// accept a 0 pointer like normal glTexImageXD
	174	// Run through this process for every mipmap to pregenerate mipmap piramid
	175	uint8 *tmpdata = new uint8[size];
	176	memset(tmpdata, 0, size);
	177
	178	for(int mip=0; mip<=mNumMipmaps; mip++)
	179	{
	180	//int mip = 0;
	181	size = PixelUtil::getMemorySize(width, height, depth, mFormat);
	182	switch(mTextureType)
	183	{
	184	case TEX_TYPE_1D:
	185	glCompressedTexImage1DARB_ptr(GL_TEXTURE_1D, mip, format,
	186	width, 0,
	187	size, tmpdata);
	188	break;
	189	case TEX_TYPE_2D:
	190	glCompressedTexImage2DARB_ptr(GL_TEXTURE_2D, mip, format,
	191	width, height, 0,
	192	size, tmpdata);
	193	break;
	194	case TEX_TYPE_3D:
	195	glCompressedTexImage3DARB_ptr(GL_TEXTURE_3D, mip, format,
	196	width, height, depth, 0,
	197	size, tmpdata);
	198	break;
	199	case TEX_TYPE_CUBE_MAP:
	200	for(int face=0; face<6; face++) {
	201	glCompressedTexImage2DARB_ptr(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format,
	202	width, height, 0,
	203	size, tmpdata);
	204	}
	205	break;
	206	};
	207	if(width>1) width = width/2;
	208	if(height>1) height = height/2;
	209	if(depth>1) depth = depth/2;
	210	}
	211	delete [] tmpdata;
	212	}
	213	else
	214	{
	215	// Run through this process to pregenerate mipmap piramid
	216	for(int mip=0; mip<=mNumMipmaps; mip++)
	217	{
	218	// Normal formats
	219	switch(mTextureType)
	220	{
	221	case TEX_TYPE_1D:
	222	glTexImage1D(GL_TEXTURE_1D, mip, format,
	223	width, 0,
	224	GL_RGBA, GL_UNSIGNED_BYTE, 0);
	225
	226	break;
	227	case TEX_TYPE_2D:
	228	glTexImage2D(GL_TEXTURE_2D, mip, format,
	229	width, height, 0,
	230	GL_RGBA, GL_UNSIGNED_BYTE, 0);
	231	break;
	232	case TEX_TYPE_3D:
	233	glTexImage3D(GL_TEXTURE_3D, mip, format,
	234	width, height, depth, 0,
	235	GL_RGBA, GL_UNSIGNED_BYTE, 0);
	236	break;
	237	case TEX_TYPE_CUBE_MAP:
	238	for(int face=0; face<6; face++) {
	239	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format,
	240	width, height, 0,
	241	GL_RGBA, GL_UNSIGNED_BYTE, 0);
	242	}
	243	break;
	244	};
	245	if(width>1) width = width/2;
	246	if(height>1) height = height/2;
	247	if(depth>1) depth = depth/2;
	248	}
	249	}
	250	_createSurfaceList();
	251	// Get final internal format
	252	mFormat = getBuffer(0,0)->getFormat();
	253	}
	254
	255	void GLTexture::createRenderTexture(void)
	256	{
	257	if (this->getTextureType() != TEX_TYPE_2D)
	258	OGRE_EXCEPT( Exception::UNIMPLEMENTED_FEATURE, "** Create render texture implemented only for 2D textures!!! **", "GLTexture::createRenderTexture" );
	259
	260	// Create the GL texture
	261	// This already does everything neccessary
	262	createInternalResources();
	263	}
	264
	265	void GLTexture::loadImage( const Image& img )
	266	{
	267	std::vector<const Image*> images;
	268
	269	images.push_back(&img);
	270	_loadImages(images);
	271	images.clear();
	272	}
	273
	274	void GLTexture::loadImpl()
	275	{
	276	if( mUsage & TU_RENDERTARGET )
	277	{
	278	createRenderTexture();
	279	mIsLoaded = true;
	280	}
	281	else
	282	{
	283	if(mTextureType == TEX_TYPE_1D \|\| mTextureType == TEX_TYPE_2D \|\|
	284	mTextureType == TEX_TYPE_3D)
	285	{
	286	Image img;
	287	img.load(mName, mGroup);
	288
	289	// If this is a cube map, set the texture type flag accordingly.
	290	if (img.hasFlag(IF_CUBEMAP))
	291	mTextureType = TEX_TYPE_CUBE_MAP;
	292	// If this is a volumetric texture set the texture type flag accordingly.
	293	if(img.getDepth() > 1)
	294	mTextureType = TEX_TYPE_3D;
	295
	296	loadImage( img );
	297	}
	298	else if (mTextureType == TEX_TYPE_CUBE_MAP)
	299	{
	300	if(StringUtil::endsWith(getName(), ".dds"))
	301	{
	302	// XX HACK there should be a better way to specify wether
	303	// all faces are in the same file or not
	304	Image img;
	305	img.load(mName, mGroup);
	306	loadImage( img );
	307	}
	308	else
	309	{
	310	String baseName, ext;
	311	std::vector<Image> images(6);
	312	std::vector<const Image*> imagePtrs;
	313	static const String suffixes[6] = {"_rt", "_lf", "_up", "_dn", "_fr", "_bk"};
	314
	315	for(size_t i = 0; i < 6; i++)
	316	{
	317	size_t pos = mName.find_last_of(".");
	318	baseName = mName.substr(0, pos);
	319	ext = mName.substr(pos);
	320	String fullName = baseName + suffixes[i] + ext;
	321
	322	images[i].load(fullName, mGroup);
	323	imagePtrs.push_back(&images[i]);
	324	}
	325
	326	_loadImages( imagePtrs );
	327	}
	328	}
	329	else
	330	OGRE_EXCEPT( Exception::UNIMPLEMENTED_FEATURE, "** Unknown texture type **", "GLTexture::load" );
	331	}
	332	}
	333
	334	//*************************************************************************
	335
	336	void GLTexture::freeInternalResourcesImpl()
	337	{
	338	mSurfaceList.clear();
	339	glDeleteTextures( 1, &mTextureID );
	340	}
	341
	342
	343	//---------------------------------------------------------------------------------------------
	344	void GLTexture::_createSurfaceList()
	345	{
	346	mSurfaceList.clear();
	347
	348	// For all faces and mipmaps, store surfaces as HardwarePixelBufferSharedPtr
	349	bool wantGeneratedMips = (mUsage & TU_AUTOMIPMAP)!=0;
	350
	351	// Do mipmapping in software? (uses GLU) For some cards, this is still needed. Of course,
	352	// only when mipmap generation is desired.
	353	bool doSoftware = wantGeneratedMips && !mMipmapsHardwareGenerated && getNumMipmaps();
	354
	355	for(int face=0; face<getNumFaces(); face++)
	356	{
	357	for(int mip=0; mip<=getNumMipmaps(); mip++)
	358	{
	359	GLHardwarePixelBuffer *buf = new GLHardwarePixelBuffer(getGLTextureTarget(), mTextureID, face, mip,
	360	static_cast<HardwareBuffer::Usage>(mUsage), doSoftware && mip==0);
	361	mSurfaceList.push_back(HardwarePixelBufferSharedPtr(buf));
	362
	363	/// Check for error
	364	if(buf->getWidth()==0 \|\| buf->getHeight()==0 \|\| buf->getDepth()==0)
	365	{
	366	OGRE_EXCEPT(
	367	Exception::ERR_RENDERINGAPI_ERROR,
	368	"Zero sized texture surface on texture "+getName()+
	369	" face "+StringConverter::toString(face)+
	370	" mipmap "+StringConverter::toString(mip)+
	371	". Probably, the GL driver refused to create the texture.",
	372	"GLTexture::_createSurfaceList");
	373	}
	374	}
	375	}
	376	}
	377
	378	//---------------------------------------------------------------------------------------------
	379	HardwarePixelBufferSharedPtr GLTexture::getBuffer(size_t face, size_t mipmap)
	380	{
	381	if(face >= getNumFaces())
	382	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Face index out of range",
	383	"GLTexture::getBuffer");
	384	if(mipmap > mNumMipmaps)
	385	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Mipmap index out of range",
	386	"GLTexture::getBuffer");
	387	unsigned int idx = face*(mNumMipmaps+1) + mipmap;
	388	assert(idx < mSurfaceList.size());
	389	return mSurfaceList[idx];
	390	}
	391
	392	//---------------------------------------------------------------------------------------------
	393	void GLRenderTexture::_copyToTexture(void)
	394	{
	395	glBindTexture(GL_TEXTURE_2D, mGLTexture->getGLID());
	396
	397	glCopyTexSubImage2D(GL_TEXTURE_2D, mGLTexture->getNumMipmaps(), 0, 0,
	398	0, 0, mWidth, mHeight);
	399
	400	}
	401
	402	void GLRenderTexture::writeContentsToFile( const String & filename )
	403	{
	404	ImageCodec::ImageData *imgData = new ImageCodec::ImageData();
	405
	406	imgData->width = mGLTexture->getWidth();
	407	imgData->height = mGLTexture->getHeight();
	408	imgData->depth = 1;
	409	imgData->format = PF_BYTE_RGB;
	410
	411	// Allocate buffer
	412	uchar* pBuffer = new uchar[imgData->width * imgData->height * 3];
	413
	414	// Read pixels
	415	// I love GL: it does all the locking & colour conversion for us
	416	glBindTexture(GL_TEXTURE_2D, mGLTexture->getGLID());
	417	glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_UNSIGNED_BYTE, pBuffer);
	418
	419	// Wrap buffer in a chunk
	420	DataStreamPtr stream(new MemoryDataStream(
	421	pBuffer, imgData->width * imgData->height * 3, false));
	422
	423	// Need to flip the read data over in Y though
	424	Image img;
	425	img.loadRawData(stream, imgData->width, imgData->height, imgData->format );
	426	img.flipAroundX();
	427
	428	MemoryDataStreamPtr streamFlipped(
	429	new MemoryDataStream(img.getData(), stream->size(), false));
	430
	431	// Get codec
	432	size_t pos = filename.find_last_of(".");
	433	String extension;
	434	if( pos == String::npos )
	435	OGRE_EXCEPT(
	436	Exception::ERR_INVALIDPARAMS,
	437	"Unable to determine image type for '" + filename + "' - invalid extension.",
	438	"GLRenderTexture::writeContentsToFile" );
	439
	440	while( pos != filename.length() - 1 )
	441	extension += filename[++pos];
	442
	443	// Get the codec
	444	Codec * pCodec = Codec::getCodec(extension);
	445
	446	// Write out
	447	Codec::CodecDataPtr codecDataPtr(imgData);
	448	pCodec->codeToFile(streamFlipped, filename, codecDataPtr);
	449
	450	delete [] pBuffer;
	451	}
	452	#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	453	uchar *GLRenderTexture::getBufferContents(int &dimx, int &dimy)
	454	{
	455	dimx = mWidth;
	456	dimy = mHeight;
	457
	458	// Allocate buffer
	459	uchar* pBuffer = new uchar[mWidth * mHeight * 3];
	460
	461	// Read pixels
	462	// I love GL: it does all the locking & colour conversion for us
	463	glReadPixels(0, 0, mWidth-1, mHeight-1, GL_RGB, GL_UNSIGNED_BYTE, pBuffer);
	464
	465	return pBuffer;
	466	}
	467	#endif // GTP_VISIBILITY_MODIFIED_OGRE
	468	}
	469

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

Download in other formats: