Context Navigation

OgreGLHardwarePixelBuffer.cpp @ 692

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

Line
1	/*
2	-----------------------------------------------------------------------------
3	This source file is part of OGRE
4	(Object-oriented Graphics Rendering Engine)
5	For the latest info, see http://www.ogre3d.org/
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	#include "OgreGLHardwarePixelBuffer.h"
26	#include "OgreGLTexture.h"
27	#include "OgreGLSupport.h"
28	#include "OgreGLPixelFormat.h"
29	#include "OgreException.h"
30	#include "OgreLogManager.h"
31	#include "OgreStringConverter.h"
32	#include "OgreBitwise.h"
33	#include "OgreGLFBORenderTexture.h"
34	#include "OgreRoot.h"
35
36	namespace Ogre {
37	//-----------------------------------------------------------------------------
38	GLHardwarePixelBuffer::GLHardwarePixelBuffer(size_t mWidth, size_t mHeight, size_t mDepth,
39	PixelFormat mFormat,
40	HardwareBuffer::Usage usage):
41	HardwarePixelBuffer(mWidth, mHeight, mDepth, mFormat, usage, false, false),
42	mBuffer(mWidth, mHeight, mDepth, mFormat),
43	mGLInternalFormat(GL_NONE)
44	{
45	}
46
47	//-----------------------------------------------------------------------------
48	GLHardwarePixelBuffer::~GLHardwarePixelBuffer()
49	{
50	// Force free buffer
51	delete [] (uint8*)mBuffer.data;
52	}
53	//-----------------------------------------------------------------------------
54	void GLHardwarePixelBuffer::allocateBuffer()
55	{
56	if(mBuffer.data)
57	// Already allocated
58	return;
59	mBuffer.data = new uint8[mSizeInBytes];
60	// TODO: use PBO if we're HBU_DYNAMIC
61	}
62	//-----------------------------------------------------------------------------
63	void GLHardwarePixelBuffer::freeBuffer()
64	{
65	// Free buffer if we're STATIC to save memory
66	if(mUsage & HBU_STATIC)
67	{
68	delete [] (uint8*)mBuffer.data;
69	mBuffer.data = 0;
70	}
71	}
72	//-----------------------------------------------------------------------------
73	PixelBox GLHardwarePixelBuffer::lockImpl(const Image::Box lockBox, LockOptions options)
74	{
75	allocateBuffer();
76	//if(!(mUsage & HBU_WRITEONLY) && options!=HBU_DISCARD)
77	if(options == HBL_READ_ONLY)
78	// Download the old contents of the texture
79	download(mBuffer);
80	return mBuffer.getSubVolume(lockBox);
81	}
82	//-----------------------------------------------------------------------------
83	void GLHardwarePixelBuffer::unlockImpl(void)
84	{
85	// From buffer to card
86	upload(mCurrentLock);
87
88	freeBuffer();
89	}
90
91	//-----------------------------------------------------------------------------
92	void GLHardwarePixelBuffer::blitFromMemory(const PixelBox &src, const Image::Box &dstBox)
93	{
94	if(!mBuffer.contains(dstBox))
95	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "destination box out of range",
96	"GLHardwarePixelBuffer::blitFromMemory");
97	PixelBox scaled;
98
99	if(src.getWidth() != dstBox.getWidth() \|\|
100	src.getHeight() != dstBox.getHeight() \|\|
101	src.getDepth() != dstBox.getDepth())
102	{
103	// Scale to destination size. Use DevIL and not iluScale because ILU screws up for
104	// floating point textures and cannot cope with 3D images.
105	// This also does pixel format conversion if needed
106	allocateBuffer();
107	scaled = mBuffer.getSubVolume(dstBox);
108	Image::scale(src, scaled, Image::FILTER_BILINEAR);
109	}
110	else if(GLPixelUtil::getGLOriginFormat(src.format) == 0)
111	{
112	// Extents match, but format is not accepted as valid source format for GL
113	// do conversion in temporary buffer
114	allocateBuffer();
115	scaled = mBuffer.getSubVolume(dstBox);
116	PixelUtil::bulkPixelConversion(src, scaled);
117	}
118	else
119	{
120	// No scaling or conversion needed
121	scaled = src;
122	// Set extents for upload
123	scaled.left = dstBox.left;
124	scaled.right = dstBox.right;
125	scaled.top = dstBox.top;
126	scaled.bottom = dstBox.bottom;
127	scaled.front = dstBox.front;
128	scaled.back = dstBox.back;
129	}
130
131	upload(scaled);
132	freeBuffer();
133	}
134	//-----------------------------------------------------------------------------
135	void GLHardwarePixelBuffer::blitToMemory(const Image::Box &srcBox, const PixelBox &dst)
136	{
137	if(!mBuffer.contains(srcBox))
138	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "source box out of range",
139	"GLHardwarePixelBuffer::blitToMemory");
140	if(srcBox.left == 0 && srcBox.right == getWidth() &&
141	srcBox.top == 0 && srcBox.bottom == getHeight() &&
142	srcBox.front == 0 && srcBox.back == getDepth() &&
143	dst.getWidth() == getWidth() &&
144	dst.getHeight() == getHeight() &&
145	dst.getDepth() == getDepth() &&
146	GLPixelUtil::getGLOriginFormat(dst.format) != 0)
147	{
148	// The direct case: the user wants the entire texture in a format supported by GL
149	// so we don't need an intermediate buffer
150	download(dst);
151	}
152	else
153	{
154	// Use buffer for intermediate copy
155	allocateBuffer();
156	// Download entire buffer
157	download(mBuffer);
158	if(srcBox.getWidth() != dst.getWidth() \|\|
159	srcBox.getHeight() != dst.getHeight() \|\|
160	srcBox.getDepth() != dst.getDepth())
161	{
162	// We need scaling
163	Image::scale(mBuffer.getSubVolume(srcBox), dst, Image::FILTER_BILINEAR);
164	}
165	else
166	{
167	// Just copy the bit that we need
168	PixelUtil::bulkPixelConversion(mBuffer.getSubVolume(srcBox), dst);
169	}
170	freeBuffer();
171	}
172	}
173	//-----------------------------------------------------------------------------
174	void GLHardwarePixelBuffer::upload(const PixelBox &data)
175	{
176	OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
177	"Upload not possible for this pixelbuffer type",
178	"GLHardwarePixelBuffer::upload");
179	}
180	//-----------------------------------------------------------------------------
181	void GLHardwarePixelBuffer::download(const PixelBox &data)
182	{
183	OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Download not possible for this pixelbuffer type",
184	"GLHardwarePixelBuffer::download");
185	}
186	//-----------------------------------------------------------------------------
187	void GLHardwarePixelBuffer::bindToFramebuffer(GLenum attachment, size_t zoffset)
188	{
189	OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Framebuffer bind not possible for this pixelbuffer type",
190	"GLHardwarePixelBuffer::bindToFramebuffer");
191	}
192	//********* GLTextureBuffer
193	GLTextureBuffer::GLTextureBuffer(const String &baseName, GLenum target, GLuint id, GLint face, GLint level, Usage usage, bool crappyCard):
194	GLHardwarePixelBuffer(0, 0, 0, PF_UNKNOWN, usage),
195	mTarget(target), mTextureID(id), mFace(face), mLevel(level), mSoftwareMipmap(crappyCard)
196	{
197	// devise mWidth, mHeight and mDepth and mFormat
198	GLint value;
199
200	glBindTexture( mTarget, mTextureID );
201
202	// Get face identifier
203	mFaceTarget = mTarget;
204	if(mTarget == GL_TEXTURE_CUBE_MAP)
205	mFaceTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X + face;
206
207	// Get width
208	glGetTexLevelParameteriv(mFaceTarget, level, GL_TEXTURE_WIDTH, &value);
209	mWidth = value;
210
211	// Get height
212	if(target == GL_TEXTURE_1D)
213	value = 1; // Height always 1 for 1D textures
214	else
215	glGetTexLevelParameteriv(mFaceTarget, level, GL_TEXTURE_HEIGHT, &value);
216	mHeight = value;
217
218	// Get depth
219	if(target != GL_TEXTURE_3D)
220	value = 1; // Depth always 1 for non-3D textures
221	else
222	glGetTexLevelParameteriv(mFaceTarget, level, GL_TEXTURE_DEPTH, &value);
223	mDepth = value;
224
225	// Get format
226	glGetTexLevelParameteriv(mFaceTarget, level, GL_TEXTURE_INTERNAL_FORMAT, &value);
227	mGLInternalFormat = value;
228	mFormat = GLPixelUtil::getClosestOGREFormat(value);
229
230	// Default
231	mRowPitch = mWidth;
232	mSlicePitch = mHeight*mWidth;
233	mSizeInBytes = PixelUtil::getMemorySize(mWidth, mHeight, mDepth, mFormat);
234
235	// Log a message
236	/*
237	std::stringstream str;
238	str << "GLHardwarePixelBuffer constructed for texture " << mTextureID
239	<< " face " << mFace << " level " << mLevel << ": "
240	<< "width=" << mWidth << " height="<< mHeight << " depth=" << mDepth
241	<< "format=" << PixelUtil::getFormatName(mFormat) << "(internal 0x"
242	<< std::hex << value << ")";
243	LogManager::getSingleton().logMessage(
244	LML_NORMAL, str.str());
245	*/
246	// Set up pixel box
247	mBuffer = PixelBox(mWidth, mHeight, mDepth, mFormat);
248
249	if(mWidth==0 \|\| mHeight==0 \|\| mDepth==0)
250	/// We are invalid, do not allocate a buffer
251	return;
252	// Allocate buffer
253	//if(mUsage & HBU_STATIC)
254	// allocateBuffer();
255	// Is this a render target?
256	if(mUsage & TU_RENDERTARGET)
257	{
258	// Create render target for each slice
259	mSliceTRT.reserve(mDepth);
260	for(size_t zoffset=0; zoffset<mDepth; ++zoffset)
261	{
262	String name;
263	name = baseName+
264	"/"+Ogre::StringConverter::toString(face)+
265	"/"+Ogre::StringConverter::toString(level)+
266	"/"+Ogre::StringConverter::toString(zoffset);
267	GLSurfaceDesc target;
268	target.buffer = this;
269	target.zoffset = zoffset;
270	RenderTexture *trt = GLRTTManager::getSingleton().createRenderTexture(name, target);
271	mSliceTRT.push_back(trt);
272	Root::getSingleton().getRenderSystem()->attachRenderTarget(*mSliceTRT[zoffset]);
273	}
274	}
275	}
276	GLTextureBuffer::~GLTextureBuffer()
277	{
278	if(mUsage & TU_RENDERTARGET)
279	{
280	// Delete all render targets that are not yet deleted via _clearSliceRTT because the rendertarget
281	// was deleted by the user.
282	for(size_t zoffset=0; zoffset<mDepth; ++zoffset)
283	{
284	if(mSliceTRT[zoffset])
285	Root::getSingleton().getRenderSystem()->destroyRenderTarget(mSliceTRT[zoffset]->getName());
286	}
287	}
288	}
289	//-----------------------------------------------------------------------------
290	void GLTextureBuffer::upload(const PixelBox &data)
291	{
292	glBindTexture( mTarget, mTextureID );
293	if(PixelUtil::isCompressed(data.format))
294	{
295	if(data.format != mFormat \|\| !data.isConsecutive())
296	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
297	"Compressed images must be consecutive, in the source format",
298	"GLHardwarePixelBuffer::upload");
299	GLenum format = GLPixelUtil::getClosestGLInternalFormat(mFormat);
300	// Data must be consecutive and at beginning of buffer as PixelStorei not allowed
301	// for compressed formats
302	switch(mTarget) {
303	case GL_TEXTURE_1D:
304	glCompressedTexSubImage1DARB(GL_TEXTURE_1D, mLevel,
305	data.left,
306	data.getWidth(),
307	format, data.getConsecutiveSize(),
308	data.data);
309	break;
310	case GL_TEXTURE_2D:
311	case GL_TEXTURE_CUBE_MAP:
312	glCompressedTexSubImage2DARB(mFaceTarget, mLevel,
313	data.left, data.top,
314	data.getWidth(), data.getHeight(),
315	format, data.getConsecutiveSize(),
316	data.data);
317	break;
318	case GL_TEXTURE_3D:
319	glCompressedTexSubImage3DARB(GL_TEXTURE_3D, mLevel,
320	data.left, data.top, data.front,
321	data.getWidth(), data.getHeight(), data.getDepth(),
322	format, data.getConsecutiveSize(),
323	data.data);
324	break;
325	}
326
327	}
328	else if(mSoftwareMipmap)
329	{
330	GLint internalFormat;
331	glGetTexLevelParameteriv(mTarget, mLevel, GL_TEXTURE_INTERNAL_FORMAT, &internalFormat);
332	if(data.getWidth() != data.rowPitch)
333	glPixelStorei(GL_UNPACK_ROW_LENGTH, data.rowPitch);
334	if(data.getHeight()*data.getWidth() != data.slicePitch)
335	glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, (data.slicePitch/data.getWidth()));
336	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
337
338	switch(mTarget)
339	{
340	case GL_TEXTURE_1D:
341	gluBuild1DMipmaps(
342	GL_TEXTURE_1D, internalFormat,
343	data.getWidth(),
344	GLPixelUtil::getGLOriginFormat(data.format), GLPixelUtil::getGLOriginDataType(data.format),
345	data.data);
346	break;
347	case GL_TEXTURE_2D:
348	case GL_TEXTURE_CUBE_MAP:
349	gluBuild2DMipmaps(
350	mFaceTarget,
351	internalFormat, data.getWidth(), data.getHeight(),
352	GLPixelUtil::getGLOriginFormat(data.format), GLPixelUtil::getGLOriginDataType(data.format),
353	data.data);
354	break;
355	case GL_TEXTURE_3D:
356	/* Requires GLU 1.3 which is harder to come by than cards doing hardware mipmapping
357	Most 3D textures don't need mipmaps?
358	gluBuild3DMipmaps(
359	GL_TEXTURE_3D, internalFormat,
360	data.getWidth(), data.getHeight(), data.getDepth(),
361	GLPixelUtil::getGLOriginFormat(data.format), GLPixelUtil::getGLOriginDataType(data.format),
362	data.data);
363	*/
364	glTexImage3D(
365	GL_TEXTURE_3D, 0, internalFormat,
366	data.getWidth(), data.getHeight(), data.getDepth(), 0,
367	GLPixelUtil::getGLOriginFormat(data.format), GLPixelUtil::getGLOriginDataType(data.format),
368	data.data );
369	break;
370	}
371	}
372	else
373	{
374	if(data.getWidth() != data.rowPitch)
375	glPixelStorei(GL_UNPACK_ROW_LENGTH, data.rowPitch);
376	if(data.getHeight()*data.getWidth() != data.slicePitch)
377	glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, (data.slicePitch/data.getWidth()));
378	if((data.getWidth()*PixelUtil::getNumElemBytes(data.format)) & 3) {
379	// Standard alignment of 4 is not right
380	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
381	}
382	switch(mTarget) {
383	case GL_TEXTURE_1D:
384	glTexSubImage1D(GL_TEXTURE_1D, mLevel,
385	data.left,
386	data.getWidth(),
387	GLPixelUtil::getGLOriginFormat(data.format), GLPixelUtil::getGLOriginDataType(data.format),
388	data.data);
389	break;
390	case GL_TEXTURE_2D:
391	case GL_TEXTURE_CUBE_MAP:
392	glTexSubImage2D(mFaceTarget, mLevel,
393	data.left, data.top,
394	data.getWidth(), data.getHeight(),
395	GLPixelUtil::getGLOriginFormat(data.format), GLPixelUtil::getGLOriginDataType(data.format),
396	data.data);
397	break;
398	case GL_TEXTURE_3D:
399	glTexSubImage3D(
400	GL_TEXTURE_3D, mLevel,
401	data.left, data.top, data.front,
402	data.getWidth(), data.getHeight(), data.getDepth(),
403	GLPixelUtil::getGLOriginFormat(data.format), GLPixelUtil::getGLOriginDataType(data.format),
404	data.data);
405	break;
406	}
407	}
408	// Restore defaults
409	glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
410	glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
411	glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
412	}
413	//-----------------------------------------------------------------------------
414	void GLTextureBuffer::download(const PixelBox &data)
415	{
416	if(data.getWidth() != getWidth() \|\|
417	data.getHeight() != getHeight() \|\|
418	data.getDepth() != getDepth())
419	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "only download of entire buffer is supported by GL",
420	"GLHardwarePixelBuffer::download");
421	glBindTexture( mTarget, mTextureID );
422	if(PixelUtil::isCompressed(data.format))
423	{
424	if(data.format != mFormat \|\| !data.isConsecutive())
425	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
426	"Compressed images must be consecutive, in the source format",
427	"GLHardwarePixelBuffer::upload");
428	// Data must be consecutive and at beginning of buffer as PixelStorei not allowed
429	// for compressed formate
430	glGetCompressedTexImageARB(mFaceTarget, mLevel, data.data);
431	}
432	else
433	{
434	if(data.getWidth() != data.rowPitch)
435	glPixelStorei(GL_PACK_ROW_LENGTH, data.rowPitch);
436	if(data.getHeight()*data.getWidth() != data.slicePitch)
437	glPixelStorei(GL_PACK_IMAGE_HEIGHT, (data.slicePitch/data.getWidth()));
438	if((data.getWidth()*PixelUtil::getNumElemBytes(data.format)) & 3) {
439	// Standard alignment of 4 is not right
440	glPixelStorei(GL_PACK_ALIGNMENT, 1);
441	}
442	// We can only get the entire texture
443	glGetTexImage(mFaceTarget, mLevel,
444	GLPixelUtil::getGLOriginFormat(data.format), GLPixelUtil::getGLOriginDataType(data.format),
445	data.data);
446	// Restore defaults
447	glPixelStorei(GL_PACK_ROW_LENGTH, 0);
448	glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0);
449	glPixelStorei(GL_PACK_ALIGNMENT, 4);
450	}
451	}
452	//-----------------------------------------------------------------------------
453	void GLTextureBuffer::bindToFramebuffer(GLenum attachment, size_t zoffset)
454	{
455	assert(zoffset < mDepth);
456	switch(mTarget)
457	{
458	case GL_TEXTURE_1D:
459	glFramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT, attachment,
460	mFaceTarget, mTextureID, mLevel);
461	break;
462	case GL_TEXTURE_2D:
463	case GL_TEXTURE_CUBE_MAP:
464	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, attachment,
465	mFaceTarget, mTextureID, mLevel);
466	break;
467	case GL_TEXTURE_3D:
468	glFramebufferTexture3DEXT(GL_FRAMEBUFFER_EXT, attachment,
469	mFaceTarget, mTextureID, mLevel, zoffset);
470	break;
471	}
472	}
473	//-----------------------------------------------------------------------------
474	void GLTextureBuffer::copyFromFramebuffer(size_t zoffset)
475	{
476	glBindTexture(mTarget, mTextureID);
477	switch(mTarget)
478	{
479	case GL_TEXTURE_1D:
480	glCopyTexSubImage1D(mFaceTarget, mLevel, 0, 0, 0, mWidth);
481	break;
482	case GL_TEXTURE_2D:
483	case GL_TEXTURE_CUBE_MAP:
484	glCopyTexSubImage2D(mFaceTarget, mLevel, 0, 0, 0, 0, mWidth, mHeight);
485	break;
486	case GL_TEXTURE_3D:
487	glCopyTexSubImage3D(mFaceTarget, mLevel, 0, 0, zoffset, 0, 0, mWidth, mHeight);
488	break;
489	}
490	}
491	//-----------------------------------------------------------------------------
492	void GLTextureBuffer::blit(const HardwarePixelBufferSharedPtr &src, const Image::Box &srcBox, const Image::Box &dstBox)
493	{
494	GLTextureBuffer srct = static_cast<GLTextureBuffer >(src.getPointer());
495	/// Check for FBO support first
496	/// Destination texture must be 1D, 2D, 3D, or Cube
497	/// Source texture must be 1D, 2D or 3D
498	if(GLEW_EXT_framebuffer_object &&
499	(srct->mTarget==GL_TEXTURE_1D\|\|srct->mTarget==GL_TEXTURE_2D\|\|srct->mTarget==GL_TEXTURE_3D))
500	{
501	blitFromTexture(srct, srcBox, dstBox);
502	}
503	else
504	{
505	GLHardwarePixelBuffer::blit(src, srcBox, dstBox);
506	}
507	}
508
509	//-----------------------------------------------------------------------------
510	/// Very fast texture-to-texture blitter and hardware bi/trilinear scaling implementation using FBO
511	/// Destination texture must be 1D, 2D, 3D, or Cube
512	/// Source texture must be 1D, 2D or 3D
513	/// Supports compressed formats as both source and destination format, it will use the hardware DXT compressor
514	/// if available.
515	/// @author W.J. van der Laan
516	void GLTextureBuffer::blitFromTexture(GLTextureBuffer *src, const Image::Box &srcBox, const Image::Box &dstBox)
517	{
518	//std::cerr << "GLTextureBuffer::blitFromTexture " <<
519	//src->mTextureID << ":" << srcBox.left << "," << srcBox.top << "," << srcBox.right << "," << srcBox.bottom << " " <<
520	//mTextureID << ":" << dstBox.left << "," << dstBox.top << "," << dstBox.right << "," << dstBox.bottom << std::endl;
521	/// Store reference to FBO manager
522	GLFBOManager fboMan = static_cast<GLFBOManager >(GLRTTManager::getSingletonPtr());
523
524	/// Save and clear GL state for rendering
525	glPushAttrib(GL_COLOR_BUFFER_BIT \| GL_CURRENT_BIT \| GL_DEPTH_BUFFER_BIT \| GL_ENABLE_BIT \|
526	GL_FOG_BIT \| GL_LIGHTING_BIT \| GL_POLYGON_BIT \| GL_SCISSOR_BIT \| GL_STENCIL_BUFFER_BIT \|
527	GL_TEXTURE_BIT \| GL_VIEWPORT_BIT);
528
529	/// Disable alpha, depth and scissor testing, disable blending,
530	/// disable culling, disble lighting, disable fog and reset foreground
531	/// colour.
532	glDisable(GL_ALPHA_TEST);
533	glDisable(GL_DEPTH_TEST);
534	glDisable(GL_SCISSOR_TEST);
535	glDisable(GL_BLEND);
536	glDisable(GL_CULL_FACE);
537	glDisable(GL_LIGHTING);
538	glDisable(GL_FOG);
539	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
540
541	/// Save and reset matrices
542	glMatrixMode(GL_MODELVIEW);
543	glPushMatrix();
544	glLoadIdentity();
545	glMatrixMode(GL_PROJECTION);
546	glPushMatrix();
547	glLoadIdentity();
548	glMatrixMode(GL_TEXTURE);
549	glPushMatrix();
550	glLoadIdentity();
551
552	/// Set up source texture
553	glBindTexture(src->mTarget, src->mTextureID);
554
555	/// Set filtering modes depending on the dimensions and source
556	if(srcBox.getWidth()==dstBox.getWidth() &&
557	srcBox.getHeight()==dstBox.getHeight() &&
558	srcBox.getDepth()==dstBox.getDepth())
559	{
560	/// Dimensions match -- use nearest filtering (fastest and pixel correct)
561	glTexParameteri(src->mTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
562	glTexParameteri(src->mTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
563	}
564	else
565	{
566	/// Dimensions don't match -- use bi or trilinear filtering depending on the
567	/// source texture.
568	if(src->mUsage & TU_AUTOMIPMAP)
569	{
570	/// Automatic mipmaps, we can safely use trilinear filter which
571	/// brings greatly imporoved quality for minimisation.
572	glTexParameteri(src->mTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
573	glTexParameteri(src->mTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
574	}
575	else
576	{
577	/// Manual mipmaps, stay safe with bilinear filtering so that no
578	/// intermipmap leakage occurs.
579	glTexParameteri(src->mTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
580	glTexParameteri(src->mTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
581	}
582	}
583	/// Clamp to edge (fastest)
584	glTexParameteri(src->mTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
585	glTexParameteri(src->mTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
586	glTexParameteri(src->mTarget, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
587
588	/// Set origin base level mipmap to make sure we source from the right mip
589	/// level.
590	glTexParameteri(src->mTarget, GL_TEXTURE_BASE_LEVEL, src->mLevel);
591
592	/// Store old binding so it can be restored later
593	GLint oldfb;
594	glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &oldfb);
595
596	/// Set up temporary FBO
597	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboMan->getTemporaryFBO());
598
599	GLuint tempTex = 0;
600	if(!fboMan->checkFormat(mFormat))
601	{
602	/// If target format not directly supported, create intermediate texture
603	GLenum tempFormat = GLPixelUtil::getClosestGLInternalFormat(fboMan->getSupportedAlternative(mFormat));
604	glGenTextures(1, &tempTex);
605	glBindTexture(GL_TEXTURE_2D, tempTex);
606	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
607	/// Allocate temporary texture of the size of the destination area
608	glTexImage2D(GL_TEXTURE_2D, 0, tempFormat,
609	GLPixelUtil::optionalPO2(dstBox.getWidth()), GLPixelUtil::optionalPO2(dstBox.getHeight()),
610	0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
611	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
612	GL_TEXTURE_2D, tempTex, 0);
613	/// Set viewport to size of destination slice
614	glViewport(0, 0, dstBox.getWidth(), dstBox.getHeight());
615	}
616	else
617	{
618	/// We are going to bind directly, so set viewport to size and position of destination slice
619	glViewport(dstBox.left, dstBox.top, dstBox.getWidth(), dstBox.getHeight());
620	}
621
622	/// Process each destination slice
623	for(size_t slice=dstBox.front; slice<dstBox.back; ++slice)
624	{
625	if(!tempTex)
626	{
627	/// Bind directly
628	bindToFramebuffer(GL_COLOR_ATTACHMENT0_EXT, slice);
629	}
630	/// Calculate source texture coordinates
631	float u1 = (float)srcBox.left / (float)src->mWidth;
632	float v1 = (float)srcBox.top / (float)src->mHeight;
633	float u2 = (float)srcBox.right / (float)src->mWidth;
634	float v2 = (float)srcBox.bottom / (float)src->mHeight;
635	/// Calculate source slice for this destination slice
636	float w = (float)(slice - dstBox.front) / (float)dstBox.getDepth();
637	/// Get slice # in source
638	w = w * (float)srcBox.getDepth() + srcBox.front;
639	/// Normalise to texture coordinate in 0.0 .. 1.0
640	w = (w+0.5f) / (float)src->mDepth;
641
642	/// Finally we're ready to rumble
643	glBindTexture(src->mTarget, src->mTextureID);
644	glEnable(src->mTarget);
645	glBegin(GL_QUADS);
646	glTexCoord3f(u1, v1, w);
647	glVertex2f(-1.0f, -1.0f);
648	glTexCoord3f(u2, v1, w);
649	glVertex2f(1.0f, -1.0f);
650	glTexCoord3f(u2, v2, w);
651	glVertex2f(1.0f, 1.0f);
652	glTexCoord3f(u1, v2, w);
653	glVertex2f(-1.0f, 1.0f);
654	glEnd();
655	glDisable(src->mTarget);
656
657	if(tempTex)
658	{
659	/// Copy temporary texture
660	glBindTexture(mTarget, mTextureID);
661	switch(mTarget)
662	{
663	case GL_TEXTURE_1D:
664	glCopyTexSubImage1D(mFaceTarget, mLevel,
665	dstBox.left,
666	0, 0, dstBox.getWidth());
667	break;
668	case GL_TEXTURE_2D:
669	case GL_TEXTURE_CUBE_MAP:
670	glCopyTexSubImage2D(mFaceTarget, mLevel,
671	dstBox.left, dstBox.top,
672	0, 0, dstBox.getWidth(), dstBox.getHeight());
673	break;
674	case GL_TEXTURE_3D:
675	glCopyTexSubImage3D(mFaceTarget, mLevel,
676	dstBox.left, dstBox.top, slice,
677	0, 0, dstBox.getWidth(), dstBox.getHeight());
678	break;
679	}
680	}
681	}
682	/// Finish up
683	if(!tempTex)
684	{
685	/// Generate mipmaps
686	if(mUsage & TU_AUTOMIPMAP)
687	{
688	glBindTexture(mTarget, mTextureID);
689	glGenerateMipmapEXT(mTarget);
690	}
691	}
692
693	/// Reset source texture to sane state
694	glBindTexture(src->mTarget, src->mTextureID);
695	glTexParameteri(src->mTarget, GL_TEXTURE_BASE_LEVEL, 0);
696
697	/// Detach texture from temporary framebuffer
698	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
699	GL_RENDERBUFFER_EXT, 0);
700	/// Restore old framebuffer
701	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, oldfb);
702	/// Restore matrix stacks and render state
703	glMatrixMode(GL_TEXTURE);
704	glPopMatrix();
705	glMatrixMode(GL_PROJECTION);
706	glPopMatrix();
707	glMatrixMode(GL_MODELVIEW);
708	glPopMatrix();
709	glPopAttrib();
710	glDeleteTextures(1, &tempTex);
711	}
712	//-----------------------------------------------------------------------------
713	/// blitFromMemory doing hardware trilinear scaling
714	void GLTextureBuffer::blitFromMemory(const PixelBox &src_orig, const Image::Box &dstBox)
715	{
716	/// Fall back to normal GLHardwarePixelBuffer::blitFromMemory in case
717	/// - FBO is not supported
718	/// - the source dimensions match the destination ones, in which case no scaling is needed
719	if(!GLEW_EXT_framebuffer_object \|\|
720	(src_orig.getWidth() == dstBox.getWidth() &&
721	src_orig.getHeight() == dstBox.getHeight() &&
722	src_orig.getDepth() == dstBox.getDepth()))
723	{
724	GLHardwarePixelBuffer::blitFromMemory(src_orig, dstBox);
725	return;
726	}
727	if(!mBuffer.contains(dstBox))
728	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "destination box out of range",
729	"GLHardwarePixelBuffer::blitFromMemory");
730	/// For scoped deletion of conversion buffer
731	MemoryDataStreamPtr buf;
732	PixelBox src;
733
734	/// First, convert the srcbox to a OpenGL compatible pixel format
735	if(GLPixelUtil::getGLOriginFormat(src_orig.format) == 0)
736	{
737	/// Convert to buffer internal format
738	buf.bind(new MemoryDataStream(
739	PixelUtil::getMemorySize(src_orig.getWidth(), src_orig.getHeight(), src_orig.getDepth(),
740	mFormat)));
741	src = PixelBox(src_orig.getWidth(), src_orig.getHeight(), src_orig.getDepth(), mFormat, buf->getPtr());
742	PixelUtil::bulkPixelConversion(src_orig, src);
743	}
744	else
745	{
746	/// No conversion needed
747	src = src_orig;
748	}
749
750	/// Create temporary texture to store source data
751	GLuint id;
752	GLenum target = (src.getDepth()!=1)?GL_TEXTURE_3D:GL_TEXTURE_2D;
753	GLsizei width = GLPixelUtil::optionalPO2(src.getWidth());
754	GLsizei height = GLPixelUtil::optionalPO2(src.getHeight());
755	GLsizei depth = GLPixelUtil::optionalPO2(src.getDepth());
756	GLenum format = GLPixelUtil::getClosestGLInternalFormat(src.format);
757
758	/// Generate texture name
759	glGenTextures(1, &id);
760
761	/// Set texture type
762	glBindTexture(target, id);
763
764	/// Set automatic mipmap generation; nice for minimisation
765	glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, 1000 );
766	glTexParameteri(target, GL_GENERATE_MIPMAP, GL_TRUE );
767
768	/// Allocate texture memory
769	if(target == GL_TEXTURE_3D)
770	glTexImage3D(target, 0, format, width, height, depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
771	else
772	glTexImage2D(target, 0, format, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
773
774	/// GL texture buffer
775	GLTextureBuffer tex("", target, id, 0, 0, (Usage)(TU_AUTOMIPMAP\|HBU_STATIC_WRITE_ONLY), false);
776
777	/// Upload data to 0,0,0 in temporary texture
778	PixelBox tempTarget(src.getWidth(), src.getHeight(), src.getDepth(), src.format, src.data);
779	tex.upload(tempTarget);
780
781	/// Blit
782	blitFromTexture(&tex, tempTarget, dstBox);
783
784	/// Delete temp texture
785	glDeleteTextures(1, &id);
786	}
787	//-----------------------------------------------------------------------------
788
789	RenderTexture *GLTextureBuffer::getRenderTarget(size_t zoffset)
790	{
791	assert(mUsage & TU_RENDERTARGET);
792	assert(zoffset < mDepth);
793	return mSliceTRT[zoffset];
794	}
795	//********* GLRenderBuffer
796	//-----------------------------------------------------------------------------
797	GLRenderBuffer::GLRenderBuffer(GLenum format, size_t width, size_t height):
798	GLHardwarePixelBuffer(width, height, 1, GLPixelUtil::getClosestOGREFormat(format),HBU_WRITE_ONLY)
799	{
800	mGLInternalFormat = format;
801	/// Generate renderbuffer
802	glGenRenderbuffersEXT(1, &mRenderbufferID);
803	/// Bind it to FBO
804	glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mRenderbufferID);
805
806	/// Allocate storage for depth buffer
807	glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, format,
808	width, height);
809	}
810	//-----------------------------------------------------------------------------
811	GLRenderBuffer::~GLRenderBuffer()
812	{
813	/// Generate renderbuffer
814	glDeleteRenderbuffersEXT(1, &mRenderbufferID);
815	}
816	//-----------------------------------------------------------------------------
817	void GLRenderBuffer::bindToFramebuffer(GLenum attachment, size_t zoffset)
818	{
819	assert(zoffset < mDepth);
820	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, attachment,
821	GL_RENDERBUFFER_EXT, mRenderbufferID);
822	}
823
824	};

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

Context Navigation

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

Download in other formats: