Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/OgreMain/src/OgreFrustum.cpp @ 1

Last change on this file since 1 was 1, checked in by landauf, 17 years ago

File size: 43.0 KB

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-2006 Torus Knot Software Ltd
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	You may alternatively use this source under the terms of a specific version of
25	the OGRE Unrestricted License provided you have obtained such a license from
26	Torus Knot Software Ltd.
27	-----------------------------------------------------------------------------
28	*/
29	#include "OgreStableHeaders.h"
30	#include "OgreFrustum.h"
31
32	#include "OgreMath.h"
33	#include "OgreMatrix3.h"
34	#include "OgreSceneNode.h"
35	#include "OgreSphere.h"
36	#include "OgreLogManager.h"
37	#include "OgreException.h"
38	#include "OgreRoot.h"
39	#include "OgreCamera.h"
40	#include "OgreHardwareBufferManager.h"
41	#include "OgreHardwareVertexBuffer.h"
42	#include "OgreHardwareIndexBuffer.h"
43	#include "OgreMaterialManager.h"
44	#include "OgreRenderSystem.h"
45
46	namespace Ogre {
47
48	String Frustum::msMovableType = "Frustum";
49	const Real Frustum::INFINITE_FAR_PLANE_ADJUST = 0.00001;
50	//-----------------------------------------------------------------------
51	Frustum::Frustum() :
52	mProjType(PT_PERSPECTIVE),
53	mFOVy(Radian(Math::PI/4.0)),
54	mFarDist(100000.0f),
55	mNearDist(100.0f),
56	mAspect(1.33333333333333f),
57	mFrustumOffset(Vector2::ZERO),
58	mFocalLength(1.0f),
59	mLastParentOrientation(Quaternion::IDENTITY),
60	mLastParentPosition(Vector3::ZERO),
61	mRecalcFrustum(true),
62	mRecalcView(true),
63	mRecalcFrustumPlanes(true),
64	mRecalcWorldSpaceCorners(true),
65	mRecalcVertexData(true),
66	mCustomViewMatrix(false),
67	mCustomProjMatrix(false),
68	mReflect(false),
69	mLinkedReflectPlane(0),
70	mObliqueDepthProjection(false),
71	mLinkedObliqueProjPlane(0)
72	{
73	// Initialise material
74	mMaterial = MaterialManager::getSingleton().getByName("BaseWhiteNoLighting");
75
76	// Alter superclass members
77	mVisible = false;
78	mParentNode = 0;
79
80	mLastLinkedReflectionPlane.normal = Vector3::ZERO;
81	mLastLinkedObliqueProjPlane.normal = Vector3::ZERO;
82
83
84	updateView();
85	updateFrustum();
86	}
87
88	//-----------------------------------------------------------------------
89	Frustum::~Frustum()
90	{
91	// Do nothing
92	}
93
94	//-----------------------------------------------------------------------
95	void Frustum::setFOVy(const Radian& fov)
96	{
97	mFOVy = fov;
98	invalidateFrustum();
99	}
100
101	//-----------------------------------------------------------------------
102	const Radian& Frustum::getFOVy(void) const
103	{
104	return mFOVy;
105	}
106
107
108	//-----------------------------------------------------------------------
109	void Frustum::setFarClipDistance(Real farPlane)
110	{
111	mFarDist = farPlane;
112	invalidateFrustum();
113	}
114
115	//-----------------------------------------------------------------------
116	Real Frustum::getFarClipDistance(void) const
117	{
118	return mFarDist;
119	}
120
121	//-----------------------------------------------------------------------
122	void Frustum::setNearClipDistance(Real nearPlane)
123	{
124	if (nearPlane <= 0)
125	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Near clip distance must be greater than zero.",
126	"Frustum::setNearClipDistance");
127	mNearDist = nearPlane;
128	invalidateFrustum();
129	}
130
131	//-----------------------------------------------------------------------
132	Real Frustum::getNearClipDistance(void) const
133	{
134	return mNearDist;
135	}
136
137	//---------------------------------------------------------------------
138	void Frustum::setFrustumOffset(const Vector2& offset)
139	{
140	mFrustumOffset = offset;
141	invalidateFrustum();
142	}
143	//---------------------------------------------------------------------
144	void Frustum::setFrustumOffset(Real horizontal, Real vertical)
145	{
146	setFrustumOffset(Vector2(horizontal, vertical));
147	}
148	//---------------------------------------------------------------------
149	const Vector2& Frustum::getFrustumOffset() const
150	{
151	return mFrustumOffset;
152	}
153	//---------------------------------------------------------------------
154	void Frustum::setFocalLength(Real focalLength)
155	{
156	if (focalLength <= 0)
157	{
158	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
159	"Focal length must be greater than zero.",
160	"Frustum::setFocalLength");
161	}
162
163	mFocalLength = focalLength;
164	invalidateFrustum();
165	}
166	//---------------------------------------------------------------------
167	Real Frustum::getFocalLength() const
168	{
169	return mFocalLength;
170	}
171	//-----------------------------------------------------------------------
172	const Matrix4& Frustum::getProjectionMatrix(void) const
173	{
174
175	updateFrustum();
176
177	return mProjMatrix;
178	}
179	//-----------------------------------------------------------------------
180	const Matrix4& Frustum::getProjectionMatrixWithRSDepth(void) const
181	{
182
183	updateFrustum();
184
185	return mProjMatrixRSDepth;
186	}
187	//-----------------------------------------------------------------------
188	const Matrix4& Frustum::getProjectionMatrixRS(void) const
189	{
190
191	updateFrustum();
192
193	return mProjMatrixRS;
194	}
195	//-----------------------------------------------------------------------
196	const Matrix4& Frustum::getViewMatrix(void) const
197	{
198	updateView();
199
200	return mViewMatrix;
201
202	}
203
204	//-----------------------------------------------------------------------
205	const Plane* Frustum::getFrustumPlanes(void) const
206	{
207	// Make any pending updates to the calculated frustum planes
208	updateFrustumPlanes();
209
210	return mFrustumPlanes;
211	}
212
213	//-----------------------------------------------------------------------
214	const Plane& Frustum::getFrustumPlane(unsigned short plane) const
215	{
216	// Make any pending updates to the calculated frustum planes
217	updateFrustumPlanes();
218
219	return mFrustumPlanes[plane];
220
221	}
222
223	//-----------------------------------------------------------------------
224	bool Frustum::isVisible(const AxisAlignedBox& bound, FrustumPlane* culledBy) const
225	{
226	// Null boxes always invisible
227	if (bound.isNull()) return false;
228
229	// Infinite boxes always visible
230	if (bound.isInfinite()) return true;
231
232	// Make any pending updates to the calculated frustum planes
233	updateFrustumPlanes();
234
235	// Get centre of the box
236	Vector3 centre = bound.getCenter();
237	// Get the half-size of the box
238	Vector3 halfSize = bound.getHalfSize();
239
240	// For each plane, see if all points are on the negative side
241	// If so, object is not visible
242	for (int plane = 0; plane < 6; ++plane)
243	{
244	// Skip far plane if infinite view frustum
245	if (plane == FRUSTUM_PLANE_FAR && mFarDist == 0)
246	continue;
247
248	Plane::Side side = mFrustumPlanes[plane].getSide(centre, halfSize);
249	if (side == Plane::NEGATIVE_SIDE)
250	{
251	// ALL corners on negative side therefore out of view
252	if (culledBy)
253	*culledBy = (FrustumPlane)plane;
254	return false;
255	}
256
257	}
258
259	return true;
260	}
261
262	//-----------------------------------------------------------------------
263	bool Frustum::isVisible(const Vector3& vert, FrustumPlane* culledBy) const
264	{
265	// Make any pending updates to the calculated frustum planes
266	updateFrustumPlanes();
267
268	// For each plane, see if all points are on the negative side
269	// If so, object is not visible
270	for (int plane = 0; plane < 6; ++plane)
271	{
272	// Skip far plane if infinite view frustum
273	if (plane == FRUSTUM_PLANE_FAR && mFarDist == 0)
274	continue;
275
276	if (mFrustumPlanes[plane].getSide(vert) == Plane::NEGATIVE_SIDE)
277	{
278	// ALL corners on negative side therefore out of view
279	if (culledBy)
280	*culledBy = (FrustumPlane)plane;
281	return false;
282	}
283
284	}
285
286	return true;
287	}
288
289	//-----------------------------------------------------------------------
290	bool Frustum::isVisible(const Sphere& sphere, FrustumPlane* culledBy) const
291	{
292	// Make any pending updates to the calculated frustum planes
293	updateFrustumPlanes();
294
295	// For each plane, see if sphere is on negative side
296	// If so, object is not visible
297	for (int plane = 0; plane < 6; ++plane)
298	{
299	// Skip far plane if infinite view frustum
300	if (plane == FRUSTUM_PLANE_FAR && mFarDist == 0)
301	continue;
302
303	// If the distance from sphere center to plane is negative, and 'more negative'
304	// than the radius of the sphere, sphere is outside frustum
305	if (mFrustumPlanes[plane].getDistance(sphere.getCenter()) < -sphere.getRadius())
306	{
307	// ALL corners on negative side therefore out of view
308	if (culledBy)
309	*culledBy = (FrustumPlane)plane;
310	return false;
311	}
312
313	}
314
315	return true;
316	}
317	//-----------------------------------------------------------------------
318	void Frustum::calcProjectionParameters(Real& left, Real& right, Real& bottom, Real& top) const
319	{
320	if (mCustomProjMatrix)
321	{
322	// Convert clipspace corners to camera space
323	Matrix4 invProj = mProjMatrix.inverse();
324	Vector3 topLeft(-0.5f, 0.5f, 0.0f);
325	Vector3 bottomRight(0.5f, -0.5f, 0.0f);
326
327	topLeft = invProj * topLeft;
328	bottomRight = invProj * bottomRight;
329
330	left = topLeft.x;
331	top = topLeft.y;
332	right = bottomRight.x;
333	bottom = bottomRight.y;
334
335	}
336	else
337	{
338	// Calculate general projection parameters
339
340	Radian thetaY (mFOVy * 0.5f);
341	Real tanThetaY = Math::Tan(thetaY);
342	Real tanThetaX = tanThetaY * mAspect;
343
344	// Unknow how to apply frustum offset to orthographic camera, just ignore here
345	Real nearFocal = (mProjType == PT_PERSPECTIVE) ? mNearDist / mFocalLength : 0;
346	Real nearOffsetX = mFrustumOffset.x * nearFocal;
347	Real nearOffsetY = mFrustumOffset.y * nearFocal;
348	Real half_w = tanThetaX * mNearDist;
349	Real half_h = tanThetaY * mNearDist;
350
351	left = - half_w + nearOffsetX;
352	right = + half_w + nearOffsetX;
353	bottom = - half_h + nearOffsetY;
354	top = + half_h + nearOffsetY;
355	}
356	}
357	//-----------------------------------------------------------------------
358	void Frustum::updateFrustumImpl(void) const
359	{
360	// Common calcs
361	Real left, right, bottom, top;
362	calcProjectionParameters(left, right, bottom, top);
363
364	if (!mCustomProjMatrix)
365	{
366
367	// The code below will dealing with general projection
368	// parameters, similar glFrustum and glOrtho.
369	// Doesn't optimise manually except division operator, so the
370	// code more self-explaining.
371
372	Real inv_w = 1 / (right - left);
373	Real inv_h = 1 / (top - bottom);
374	Real inv_d = 1 / (mFarDist - mNearDist);
375
376	// Recalc if frustum params changed
377	if (mProjType == PT_PERSPECTIVE)
378	{
379	// Calc matrix elements
380	Real A = 2 * mNearDist * inv_w;
381	Real B = 2 * mNearDist * inv_h;
382	Real C = (right + left) * inv_w;
383	Real D = (top + bottom) * inv_h;
384	Real q, qn;
385	if (mFarDist == 0)
386	{
387	// Infinite far plane
388	q = Frustum::INFINITE_FAR_PLANE_ADJUST - 1;
389	qn = mNearDist * (Frustum::INFINITE_FAR_PLANE_ADJUST - 2);
390	}
391	else
392	{
393	q = - (mFarDist + mNearDist) * inv_d;
394	qn = -2 * (mFarDist * mNearDist) * inv_d;
395	}
396
397	// NB: This creates 'uniform' perspective projection matrix,
398	// which depth range [-1,1], right-handed rules
399	//
400	// [ A 0 C 0 ]
401	// [ 0 B D 0 ]
402	// [ 0 0 q qn ]
403	// [ 0 0 -1 0 ]
404	//
405	// A = 2 * near / (right - left)
406	// B = 2 * near / (top - bottom)
407	// C = (right + left) / (right - left)
408	// D = (top + bottom) / (top - bottom)
409	// q = - (far + near) / (far - near)
410	// qn = - 2 * (far * near) / (far - near)
411
412	mProjMatrix = Matrix4::ZERO;
413	mProjMatrix[0][0] = A;
414	mProjMatrix[0][2] = C;
415	mProjMatrix[1][1] = B;
416	mProjMatrix[1][2] = D;
417	mProjMatrix[2][2] = q;
418	mProjMatrix[2][3] = qn;
419	mProjMatrix[3][2] = -1;
420
421	if (mObliqueDepthProjection)
422	{
423	// Translate the plane into view space
424
425	// Don't use getViewMatrix here, incase overrided by
426	// camera and return a cull frustum view matrix
427	updateView();
428	Plane plane = mViewMatrix * mObliqueProjPlane;
429
430	// Thanks to Eric Lenyel for posting this calculation
431	// at www.terathon.com
432
433	// Calculate the clip-space corner point opposite the
434	// clipping plane
435	// as (sgn(clipPlane.x), sgn(clipPlane.y), 1, 1) and
436	// transform it into camera space by multiplying it
437	// by the inverse of the projection matrix
438
439	/* generalised version
440	Vector4 q = matrix.inverse() *
441	Vector4(Math::Sign(plane.normal.x),
442	Math::Sign(plane.normal.y), 1.0f, 1.0f);
443	*/
444	Vector4 q;
445	q.x = (Math::Sign(plane.normal.x) + mProjMatrix[0][2]) / mProjMatrix[0][0];
446	q.y = (Math::Sign(plane.normal.y) + mProjMatrix[1][2]) / mProjMatrix[1][1];
447	q.z = -1;
448	q.w = (1 + mProjMatrix[2][2]) / mProjMatrix[2][3];
449
450	// Calculate the scaled plane vector
451	Vector4 clipPlane4d(plane.normal.x, plane.normal.y, plane.normal.z, plane.d);
452	Vector4 c = clipPlane4d * (2 / (clipPlane4d.dotProduct(q)));
453
454	// Replace the third row of the projection matrix
455	mProjMatrix[2][0] = c.x;
456	mProjMatrix[2][1] = c.y;
457	mProjMatrix[2][2] = c.z + 1;
458	mProjMatrix[2][3] = c.w;
459	}
460	} // perspective
461	else if (mProjType == PT_ORTHOGRAPHIC)
462	{
463	Real A = 2 * inv_w;
464	Real B = 2 * inv_h;
465	Real C = - (right + left) * inv_w;
466	Real D = - (top + bottom) * inv_h;
467	Real q, qn;
468	if (mFarDist == 0)
469	{
470	// Can not do infinite far plane here, avoid divided zero only
471	q = - Frustum::INFINITE_FAR_PLANE_ADJUST / mNearDist;
472	qn = - Frustum::INFINITE_FAR_PLANE_ADJUST - 1;
473	}
474	else
475	{
476	q = - 2 * inv_d;
477	qn = - (mFarDist + mNearDist) * inv_d;
478	}
479
480	// NB: This creates 'uniform' orthographic projection matrix,
481	// which depth range [-1,1], right-handed rules
482	//
483	// [ A 0 0 C ]
484	// [ 0 B 0 D ]
485	// [ 0 0 q qn ]
486	// [ 0 0 0 1 ]
487	//
488	// A = 2 * / (right - left)
489	// B = 2 * / (top - bottom)
490	// C = - (right + left) / (right - left)
491	// D = - (top + bottom) / (top - bottom)
492	// q = - 2 / (far - near)
493	// qn = - (far + near) / (far - near)
494
495	mProjMatrix = Matrix4::ZERO;
496	mProjMatrix[0][0] = A;
497	mProjMatrix[0][3] = C;
498	mProjMatrix[1][1] = B;
499	mProjMatrix[1][3] = D;
500	mProjMatrix[2][2] = q;
501	mProjMatrix[2][3] = qn;
502	mProjMatrix[3][3] = 1;
503	} // ortho
504	} // !mCustomProjMatrix
505
506	RenderSystem* renderSystem = Root::getSingleton().getRenderSystem();
507	// API specific
508	renderSystem->_convertProjectionMatrix(mProjMatrix, mProjMatrixRS);
509	// API specific for Gpu Programs
510	renderSystem->_convertProjectionMatrix(mProjMatrix, mProjMatrixRSDepth, true);
511
512
513	// Calculate bounding box (local)
514	// Box is from 0, down -Z, max dimensions as determined from far plane
515	// If infinite view frustum just pick a far value
516	Real farDist = (mFarDist == 0) ? 100000 : mFarDist;
517	// Near plane bounds
518	Vector3 min(left, bottom, -farDist);
519	Vector3 max(right, top, 0);
520
521	if (mCustomProjMatrix)
522	{
523	// Some custom projection matrices can have unusual inverted settings
524	// So make sure the AABB is the right way around to start with
525	Vector3 tmp = min;
526	min.makeFloor(max);
527	max.makeCeil(tmp);
528	}
529
530	if (mProjType == PT_PERSPECTIVE)
531	{
532	// Merge with far plane bounds
533	Real radio = farDist / mNearDist;
534	min.makeFloor(Vector3(left * radio, bottom * radio, -farDist));
535	max.makeCeil(Vector3(right * radio, top * radio, 0));
536	}
537	mBoundingBox.setExtents(min, max);
538
539	mRecalcFrustum = false;
540
541	// Signal to update frustum clipping planes
542	mRecalcFrustumPlanes = true;
543	}
544	//-----------------------------------------------------------------------
545	void Frustum::updateFrustum(void) const
546	{
547	if (isFrustumOutOfDate())
548	{
549	updateFrustumImpl();
550	}
551	}
552
553	//-----------------------------------------------------------------------
554	void Frustum::updateVertexData(void) const
555	{
556	if (mRecalcVertexData)
557	{
558	if (mVertexData.vertexBufferBinding->getBufferCount() <= 0)
559	{
560	// Initialise vertex & index data
561	mVertexData.vertexDeclaration->addElement(0, 0, VET_FLOAT3, VES_POSITION);
562	mVertexData.vertexCount = 32;
563	mVertexData.vertexStart = 0;
564	mVertexData.vertexBufferBinding->setBinding( 0,
565	HardwareBufferManager::getSingleton().createVertexBuffer(
566	sizeof(float)*3, 32, HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY) );
567	}
568
569	// Note: Even though we can dealing with general projection matrix here,
570	// but because it's incompatibly with infinite far plane, thus, we
571	// still need to working with projection parameters.
572
573	// Calc near plane corners
574	Real vpLeft, vpRight, vpBottom, vpTop;
575	calcProjectionParameters(vpLeft, vpRight, vpBottom, vpTop);
576
577	// Treat infinite fardist as some arbitrary far value
578	Real farDist = (mFarDist == 0) ? 100000 : mFarDist;
579
580	// Calc far palne corners
581	Real radio = mProjType == PT_PERSPECTIVE ? farDist / mNearDist : 1;
582	Real farLeft = vpLeft * radio;
583	Real farRight = vpRight * radio;
584	Real farBottom = vpBottom * radio;
585	Real farTop = vpTop * radio;
586
587	// Calculate vertex positions (local)
588	// 0 is the origin
589	// 1, 2, 3, 4 are the points on the near plane, top left first, clockwise
590	// 5, 6, 7, 8 are the points on the far plane, top left first, clockwise
591	HardwareVertexBufferSharedPtr vbuf = mVertexData.vertexBufferBinding->getBuffer(0);
592	float* pFloat = static_cast<float*>(vbuf->lock(HardwareBuffer::HBL_DISCARD));
593
594	// near plane (remember frustum is going in -Z direction)
595	pFloat++ = vpLeft; pFloat++ = vpTop; *pFloat++ = -mNearDist;
596	pFloat++ = vpRight; pFloat++ = vpTop; *pFloat++ = -mNearDist;
597
598	pFloat++ = vpRight; pFloat++ = vpTop; *pFloat++ = -mNearDist;
599	pFloat++ = vpRight; pFloat++ = vpBottom; *pFloat++ = -mNearDist;
600
601	pFloat++ = vpRight; pFloat++ = vpBottom; *pFloat++ = -mNearDist;
602	pFloat++ = vpLeft; pFloat++ = vpBottom; *pFloat++ = -mNearDist;
603
604	pFloat++ = vpLeft; pFloat++ = vpBottom; *pFloat++ = -mNearDist;
605	pFloat++ = vpLeft; pFloat++ = vpTop; *pFloat++ = -mNearDist;
606
607	// far plane (remember frustum is going in -Z direction)
608	pFloat++ = farLeft; pFloat++ = farTop; *pFloat++ = -farDist;
609	pFloat++ = farRight; pFloat++ = farTop; *pFloat++ = -farDist;
610
611	pFloat++ = farRight; pFloat++ = farTop; *pFloat++ = -farDist;
612	pFloat++ = farRight; pFloat++ = farBottom; *pFloat++ = -farDist;
613
614	pFloat++ = farRight; pFloat++ = farBottom; *pFloat++ = -farDist;
615	pFloat++ = farLeft; pFloat++ = farBottom; *pFloat++ = -farDist;
616
617	pFloat++ = farLeft; pFloat++ = farBottom; *pFloat++ = -farDist;
618	pFloat++ = farLeft; pFloat++ = farTop; *pFloat++ = -farDist;
619
620	// Sides of the pyramid
621	pFloat++ = 0.0f; pFloat++ = 0.0f; *pFloat++ = 0.0f;
622	pFloat++ = vpLeft; pFloat++ = vpTop; *pFloat++ = -mNearDist;
623
624	pFloat++ = 0.0f; pFloat++ = 0.0f; *pFloat++ = 0.0f;
625	pFloat++ = vpRight; pFloat++ = vpTop; *pFloat++ = -mNearDist;
626
627	pFloat++ = 0.0f; pFloat++ = 0.0f; *pFloat++ = 0.0f;
628	pFloat++ = vpRight; pFloat++ = vpBottom; *pFloat++ = -mNearDist;
629
630	pFloat++ = 0.0f; pFloat++ = 0.0f; *pFloat++ = 0.0f;
631	pFloat++ = vpLeft; pFloat++ = vpBottom; *pFloat++ = -mNearDist;
632
633	// Sides of the box
634
635	pFloat++ = vpLeft; pFloat++ = vpTop; *pFloat++ = -mNearDist;
636	pFloat++ = farLeft; pFloat++ = farTop; *pFloat++ = -farDist;
637
638	pFloat++ = vpRight; pFloat++ = vpTop; *pFloat++ = -mNearDist;
639	pFloat++ = farRight; pFloat++ = farTop; *pFloat++ = -farDist;
640
641	pFloat++ = vpRight; pFloat++ = vpBottom; *pFloat++ = -mNearDist;
642	pFloat++ = farRight; pFloat++ = farBottom; *pFloat++ = -farDist;
643
644	pFloat++ = vpLeft; pFloat++ = vpBottom; *pFloat++ = -mNearDist;
645	pFloat++ = farLeft; pFloat++ = farBottom; *pFloat++ = -farDist;
646
647
648	vbuf->unlock();
649
650	mRecalcVertexData = false;
651	}
652	}
653
654	//-----------------------------------------------------------------------
655	bool Frustum::isViewOutOfDate(void) const
656	{
657	// Attached to node?
658	if (mParentNode)
659	{
660	if (mRecalcView \|\|
661	mParentNode->_getDerivedOrientation() != mLastParentOrientation \|\|
662	mParentNode->_getDerivedPosition() != mLastParentPosition)
663	{
664	// Ok, we're out of date with SceneNode we're attached to
665	mLastParentOrientation = mParentNode->_getDerivedOrientation();
666	mLastParentPosition = mParentNode->_getDerivedPosition();
667	mRecalcView = true;
668	}
669	}
670	// Deriving reflection from linked plane?
671	if (mLinkedReflectPlane &&
672	!(mLastLinkedReflectionPlane == mLinkedReflectPlane->_getDerivedPlane()))
673	{
674	mReflectPlane = mLinkedReflectPlane->_getDerivedPlane();
675	mReflectMatrix = Math::buildReflectionMatrix(mReflectPlane);
676	mLastLinkedReflectionPlane = mLinkedReflectPlane->_getDerivedPlane();
677	mRecalcView = true;
678	}
679
680	return mRecalcView;
681	}
682
683	//-----------------------------------------------------------------------
684	bool Frustum::isFrustumOutOfDate(void) const
685	{
686	// Deriving custom near plane from linked plane?
687	if (mObliqueDepthProjection)
688	{
689	// Out of date when view out of data since plane needs to be in view space
690	if (isViewOutOfDate())
691	{
692	mRecalcFrustum = true;
693	}
694	// Update derived plane
695	if (mLinkedObliqueProjPlane &&
696	!(mLastLinkedObliqueProjPlane == mLinkedObliqueProjPlane->_getDerivedPlane()))
697	{
698	mObliqueProjPlane = mLinkedObliqueProjPlane->_getDerivedPlane();
699	mLastLinkedObliqueProjPlane = mObliqueProjPlane;
700	mRecalcFrustum = true;
701	}
702	}
703
704	return mRecalcFrustum;
705	}
706
707	//-----------------------------------------------------------------------
708	void Frustum::updateViewImpl(void) const
709	{
710	// ----------------------
711	// Update the view matrix
712	// ----------------------
713
714	// View matrix is:
715	//
716	// [ Lx Uy Dz Tx ]
717	// [ Lx Uy Dz Ty ]
718	// [ Lx Uy Dz Tz ]
719	// [ 0 0 0 1 ]
720	//
721	// Where T = -(Transposed(Rot) * Pos)
722
723	// This is most efficiently done using 3x3 Matrices
724
725	// Get orientation from quaternion
726
727	if (!mCustomViewMatrix)
728	{
729	Matrix3 rot;
730	const Quaternion& orientation = getOrientationForViewUpdate();
731	const Vector3& position = getPositionForViewUpdate();
732	orientation.ToRotationMatrix(rot);
733
734	// Make the translation relative to new axes
735	Matrix3 rotT = rot.Transpose();
736	Vector3 trans = -rotT * position;
737
738	// Make final matrix
739	mViewMatrix = Matrix4::IDENTITY;
740	mViewMatrix = rotT; // fills upper 3x3
741	mViewMatrix[0][3] = trans.x;
742	mViewMatrix[1][3] = trans.y;
743	mViewMatrix[2][3] = trans.z;
744
745	// Deal with reflections
746	if (mReflect)
747	{
748	mViewMatrix = mViewMatrix * mReflectMatrix;
749	}
750	}
751
752	mRecalcView = false;
753
754	// Signal to update frustum clipping planes
755	mRecalcFrustumPlanes = true;
756	// Signal to update world space corners
757	mRecalcWorldSpaceCorners = true;
758	// Signal to update frustum if oblique plane enabled,
759	// since plane needs to be in view space
760	if (mObliqueDepthProjection)
761	{
762	mRecalcFrustum = true;
763	}
764	}
765	//-----------------------------------------------------------------------
766	void Frustum::updateView(void) const
767	{
768	if (isViewOutOfDate())
769	{
770	updateViewImpl();
771	}
772	}
773
774	//-----------------------------------------------------------------------
775	void Frustum::updateFrustumPlanesImpl(void) const
776	{
777	// -------------------------
778	// Update the frustum planes
779	// -------------------------
780	Matrix4 combo = mProjMatrix * mViewMatrix;
781
782	mFrustumPlanes[FRUSTUM_PLANE_LEFT].normal.x = combo[3][0] + combo[0][0];
783	mFrustumPlanes[FRUSTUM_PLANE_LEFT].normal.y = combo[3][1] + combo[0][1];
784	mFrustumPlanes[FRUSTUM_PLANE_LEFT].normal.z = combo[3][2] + combo[0][2];
785	mFrustumPlanes[FRUSTUM_PLANE_LEFT].d = combo[3][3] + combo[0][3];
786
787	mFrustumPlanes[FRUSTUM_PLANE_RIGHT].normal.x = combo[3][0] - combo[0][0];
788	mFrustumPlanes[FRUSTUM_PLANE_RIGHT].normal.y = combo[3][1] - combo[0][1];
789	mFrustumPlanes[FRUSTUM_PLANE_RIGHT].normal.z = combo[3][2] - combo[0][2];
790	mFrustumPlanes[FRUSTUM_PLANE_RIGHT].d = combo[3][3] - combo[0][3];
791
792	mFrustumPlanes[FRUSTUM_PLANE_TOP].normal.x = combo[3][0] - combo[1][0];
793	mFrustumPlanes[FRUSTUM_PLANE_TOP].normal.y = combo[3][1] - combo[1][1];
794	mFrustumPlanes[FRUSTUM_PLANE_TOP].normal.z = combo[3][2] - combo[1][2];
795	mFrustumPlanes[FRUSTUM_PLANE_TOP].d = combo[3][3] - combo[1][3];
796
797	mFrustumPlanes[FRUSTUM_PLANE_BOTTOM].normal.x = combo[3][0] + combo[1][0];
798	mFrustumPlanes[FRUSTUM_PLANE_BOTTOM].normal.y = combo[3][1] + combo[1][1];
799	mFrustumPlanes[FRUSTUM_PLANE_BOTTOM].normal.z = combo[3][2] + combo[1][2];
800	mFrustumPlanes[FRUSTUM_PLANE_BOTTOM].d = combo[3][3] + combo[1][3];
801
802	mFrustumPlanes[FRUSTUM_PLANE_NEAR].normal.x = combo[3][0] + combo[2][0];
803	mFrustumPlanes[FRUSTUM_PLANE_NEAR].normal.y = combo[3][1] + combo[2][1];
804	mFrustumPlanes[FRUSTUM_PLANE_NEAR].normal.z = combo[3][2] + combo[2][2];
805	mFrustumPlanes[FRUSTUM_PLANE_NEAR].d = combo[3][3] + combo[2][3];
806
807	mFrustumPlanes[FRUSTUM_PLANE_FAR].normal.x = combo[3][0] - combo[2][0];
808	mFrustumPlanes[FRUSTUM_PLANE_FAR].normal.y = combo[3][1] - combo[2][1];
809	mFrustumPlanes[FRUSTUM_PLANE_FAR].normal.z = combo[3][2] - combo[2][2];
810	mFrustumPlanes[FRUSTUM_PLANE_FAR].d = combo[3][3] - combo[2][3];
811
812	// Renormalise any normals which were not unit length
813	for(int i=0; i<6; i++ )
814	{
815	float length = mFrustumPlanes[i].normal.normalise();
816	mFrustumPlanes[i].d /= length;
817	}
818
819	mRecalcFrustumPlanes = false;
820	}
821	//-----------------------------------------------------------------------
822	void Frustum::updateFrustumPlanes(void) const
823	{
824	updateView();
825	updateFrustum();
826
827	if (mRecalcFrustumPlanes)
828	{
829	updateFrustumPlanesImpl();
830	}
831	}
832	//-----------------------------------------------------------------------
833	void Frustum::updateWorldSpaceCornersImpl(void) const
834	{
835	Matrix4 eyeToWorld = mViewMatrix.inverseAffine();
836
837	// Note: Even though we can dealing with general projection matrix here,
838	// but because it's incompatibly with infinite far plane, thus, we
839	// still need to working with projection parameters.
840
841	// Calc near plane corners
842	Real nearLeft, nearRight, nearBottom, nearTop;
843	calcProjectionParameters(nearLeft, nearRight, nearBottom, nearTop);
844
845	// Treat infinite fardist as some arbitrary far value
846	Real farDist = (mFarDist == 0) ? 100000 : mFarDist;
847
848	// Calc far palne corners
849	Real radio = mProjType == PT_PERSPECTIVE ? farDist / mNearDist : 1;
850	Real farLeft = nearLeft * radio;
851	Real farRight = nearRight * radio;
852	Real farBottom = nearBottom * radio;
853	Real farTop = nearTop * radio;
854
855	// near
856	mWorldSpaceCorners[0] = eyeToWorld.transformAffine(Vector3(nearRight, nearTop, -mNearDist));
857	mWorldSpaceCorners[1] = eyeToWorld.transformAffine(Vector3(nearLeft, nearTop, -mNearDist));
858	mWorldSpaceCorners[2] = eyeToWorld.transformAffine(Vector3(nearLeft, nearBottom, -mNearDist));
859	mWorldSpaceCorners[3] = eyeToWorld.transformAffine(Vector3(nearRight, nearBottom, -mNearDist));
860	// far
861	mWorldSpaceCorners[4] = eyeToWorld.transformAffine(Vector3(farRight, farTop, -farDist));
862	mWorldSpaceCorners[5] = eyeToWorld.transformAffine(Vector3(farLeft, farTop, -farDist));
863	mWorldSpaceCorners[6] = eyeToWorld.transformAffine(Vector3(farLeft, farBottom, -farDist));
864	mWorldSpaceCorners[7] = eyeToWorld.transformAffine(Vector3(farRight, farBottom, -farDist));
865
866
867	mRecalcWorldSpaceCorners = false;
868	}
869	//-----------------------------------------------------------------------
870	void Frustum::updateWorldSpaceCorners(void) const
871	{
872	updateView();
873
874	if (mRecalcWorldSpaceCorners)
875	{
876	updateWorldSpaceCornersImpl();
877	}
878
879	}
880
881	//-----------------------------------------------------------------------
882	Real Frustum::getAspectRatio(void) const
883	{
884	return mAspect;
885	}
886
887	//-----------------------------------------------------------------------
888	void Frustum::setAspectRatio(Real r)
889	{
890	mAspect = r;
891	invalidateFrustum();
892	}
893
894	//-----------------------------------------------------------------------
895	const AxisAlignedBox& Frustum::getBoundingBox(void) const
896	{
897	return mBoundingBox;
898	}
899	//-----------------------------------------------------------------------
900	void Frustum::_updateRenderQueue(RenderQueue* queue)
901	{
902	// Add self
903	queue->addRenderable(this);
904	}
905	//-----------------------------------------------------------------------
906	const String& Frustum::getMovableType(void) const
907	{
908	return msMovableType;
909	}
910	//-----------------------------------------------------------------------
911	Real Frustum::getBoundingRadius(void) const
912	{
913	return (mFarDist == 0)? 100000 : mFarDist;
914	}
915	//-----------------------------------------------------------------------
916	const MaterialPtr& Frustum::getMaterial(void) const
917	{
918	return mMaterial;
919	}
920	//-----------------------------------------------------------------------
921	void Frustum::getRenderOperation(RenderOperation& op)
922	{
923	updateVertexData();
924	op.operationType = RenderOperation::OT_LINE_LIST;
925	op.useIndexes = false;
926	op.vertexData = &mVertexData;
927	}
928	//-----------------------------------------------------------------------
929	void Frustum::getWorldTransforms(Matrix4* xform) const
930	{
931	if (mParentNode)
932	*xform = mParentNode->_getFullTransform();
933	else
934	*xform = Matrix4::IDENTITY;
935	}
936	//-----------------------------------------------------------------------
937	const Quaternion& Frustum::getWorldOrientation(void) const
938	{
939	if (mParentNode)
940	return mParentNode->_getDerivedOrientation();
941	else
942	return Quaternion::IDENTITY;
943	}
944	//-----------------------------------------------------------------------
945	const Vector3& Frustum::getWorldPosition(void) const
946	{
947	if (mParentNode)
948	return mParentNode->_getDerivedPosition();
949	else
950	return Vector3::ZERO;
951	}
952	//-----------------------------------------------------------------------
953	Real Frustum::getSquaredViewDepth(const Camera* cam) const
954	{
955	// Calc from centre
956	if (mParentNode)
957	return (cam->getDerivedPosition()
958	- mParentNode->_getDerivedPosition()).squaredLength();
959	else
960	return 0;
961	}
962	//-----------------------------------------------------------------------
963	const LightList& Frustum::getLights(void) const
964	{
965	// N/A
966	static LightList ll;
967	return ll;
968	}
969	//-----------------------------------------------------------------------
970	void Frustum::_notifyCurrentCamera(Camera* cam)
971	{
972	// Make sure bounding box up-to-date
973	updateFrustum();
974
975	MovableObject::_notifyCurrentCamera(cam);
976	}
977
978	// -------------------------------------------------------------------
979	void Frustum::invalidateFrustum() const
980	{
981	mRecalcFrustum = true;
982	mRecalcFrustumPlanes = true;
983	mRecalcWorldSpaceCorners = true;
984	mRecalcVertexData = true;
985	}
986	// -------------------------------------------------------------------
987	void Frustum::invalidateView() const
988	{
989	mRecalcView = true;
990	mRecalcFrustumPlanes = true;
991	mRecalcWorldSpaceCorners = true;
992	}
993	// -------------------------------------------------------------------
994	const Vector3* Frustum::getWorldSpaceCorners(void) const
995	{
996	updateWorldSpaceCorners();
997
998	return mWorldSpaceCorners;
999	}
1000	//-----------------------------------------------------------------------
1001	void Frustum::setProjectionType(ProjectionType pt)
1002	{
1003	mProjType = pt;
1004	invalidateFrustum();
1005	}
1006
1007	//-----------------------------------------------------------------------
1008	ProjectionType Frustum::getProjectionType(void) const
1009	{
1010	return mProjType;
1011	}
1012	//-----------------------------------------------------------------------
1013	const Vector3& Frustum::getPositionForViewUpdate(void) const
1014	{
1015	return mLastParentPosition;
1016	}
1017	//-----------------------------------------------------------------------
1018	const Quaternion& Frustum::getOrientationForViewUpdate(void) const
1019	{
1020	return mLastParentOrientation;
1021	}
1022	//-----------------------------------------------------------------------
1023	void Frustum::enableReflection(const Plane& p)
1024	{
1025	mReflect = true;
1026	mReflectPlane = p;
1027	mLinkedReflectPlane = 0;
1028	mReflectMatrix = Math::buildReflectionMatrix(p);
1029	invalidateView();
1030
1031	}
1032	//-----------------------------------------------------------------------
1033	void Frustum::enableReflection(const MovablePlane* p)
1034	{
1035	mReflect = true;
1036	mLinkedReflectPlane = p;
1037	mReflectPlane = mLinkedReflectPlane->_getDerivedPlane();
1038	mReflectMatrix = Math::buildReflectionMatrix(mReflectPlane);
1039	mLastLinkedReflectionPlane = mLinkedReflectPlane->_getDerivedPlane();
1040	invalidateView();
1041	}
1042	//-----------------------------------------------------------------------
1043	void Frustum::disableReflection(void)
1044	{
1045	mReflect = false;
1046	mLinkedReflectPlane = 0;
1047	mLastLinkedReflectionPlane.normal = Vector3::ZERO;
1048	invalidateView();
1049	}
1050	//---------------------------------------------------------------------
1051	bool Frustum::projectSphere(const Sphere& sphere,
1052	Real* left, Real* top, Real* right, Real* bottom) const
1053	{
1054	// See http://www.gamasutra.com/features/20021011/lengyel_06.htm
1055	// Transform light position into camera space
1056
1057	updateView();
1058	Vector3 eyeSpacePos = mViewMatrix.transformAffine(sphere.getCenter());
1059
1060	// initialise
1061	left = bottom = -1.0f;
1062	right = top = 1.0f;
1063
1064	if (eyeSpacePos.z < 0)
1065	{
1066	updateFrustum();
1067	const Matrix4& projMatrix = getProjectionMatrix();
1068	Real r = sphere.getRadius();
1069	Real rsq = r * r;
1070
1071	// early-exit
1072	if (eyeSpacePos.squaredLength() <= rsq)
1073	return false;
1074
1075	Real Lxz = Math::Sqr(eyeSpacePos.x) + Math::Sqr(eyeSpacePos.z);
1076	Real Lyz = Math::Sqr(eyeSpacePos.y) + Math::Sqr(eyeSpacePos.z);
1077
1078	// Find the tangent planes to the sphere
1079	// XZ first
1080	// calculate quadratic discriminant: b*b - 4ac
1081	// x = Nx
1082	// a = Lx^2 + Lz^2
1083	// b = -2rLx
1084	// c = r^2 - Lz^2
1085	Real a = Lxz;
1086	Real b = -2.0 * r * eyeSpacePos.x;
1087	Real c = rsq - Math::Sqr(eyeSpacePos.z);
1088	Real D = bb - 4a*c;
1089
1090	// two roots?
1091	if (D > 0)
1092	{
1093	Real sqrootD = Math::Sqrt(D);
1094	// solve the quadratic to get the components of the normal
1095	Real Nx0 = (-b + sqrootD) / (2 * a);
1096	Real Nx1 = (-b - sqrootD) / (2 * a);
1097
1098	// Derive Z from this
1099	Real Nz0 = (r - Nx0 * eyeSpacePos.x) / eyeSpacePos.z;
1100	Real Nz1 = (r - Nx1 * eyeSpacePos.x) / eyeSpacePos.z;
1101
1102	// Get the point of tangency
1103	// Only consider points of tangency in front of the camera
1104	Real Pz0 = (Lxz - rsq) / (eyeSpacePos.z - ((Nz0 / Nx0) * eyeSpacePos.x));
1105	if (Pz0 < 0)
1106	{
1107	// Project point onto near plane in worldspace
1108	Real nearx0 = (Nz0 * mNearDist) / Nx0;
1109	// now we need to map this to viewport coords
1110	// use projection matrix since that will take into account all factors
1111	Vector3 relx0 = projMatrix * Vector3(nearx0, 0, -mNearDist);
1112
1113	// find out whether this is a left side or right side
1114	Real Px0 = -(Pz0 * Nz0) / Nx0;
1115	if (Px0 > eyeSpacePos.x)
1116	{
1117	right = std::min(right, relx0.x);
1118	}
1119	else
1120	{
1121	left = std::max(left, relx0.x);
1122	}
1123	}
1124	Real Pz1 = (Lxz - rsq) / (eyeSpacePos.z - ((Nz1 / Nx1) * eyeSpacePos.x));
1125	if (Pz1 < 0)
1126	{
1127	// Project point onto near plane in worldspace
1128	Real nearx1 = (Nz1 * mNearDist) / Nx1;
1129	// now we need to map this to viewport coords
1130	// use projection matrix since that will take into account all factors
1131	Vector3 relx1 = projMatrix * Vector3(nearx1, 0, -mNearDist);
1132
1133	// find out whether this is a left side or right side
1134	Real Px1 = -(Pz1 * Nz1) / Nx1;
1135	if (Px1 > eyeSpacePos.x)
1136	{
1137	right = std::min(right, relx1.x);
1138	}
1139	else
1140	{
1141	left = std::max(left, relx1.x);
1142	}
1143	}
1144	}
1145
1146
1147	// Now YZ
1148	// calculate quadratic discriminant: b*b - 4ac
1149	// x = Ny
1150	// a = Ly^2 + Lz^2
1151	// b = -2rLy
1152	// c = r^2 - Lz^2
1153	a = Lyz;
1154	b = -2.0 * r * eyeSpacePos.y;
1155	c = rsq - Math::Sqr(eyeSpacePos.z);
1156	D = bb - 4a*c;
1157
1158	// two roots?
1159	if (D > 0)
1160	{
1161	Real sqrootD = Math::Sqrt(D);
1162	// solve the quadratic to get the components of the normal
1163	Real Ny0 = (-b + sqrootD) / (2 * a);
1164	Real Ny1 = (-b - sqrootD) / (2 * a);
1165
1166	// Derive Z from this
1167	Real Nz0 = (r - Ny0 * eyeSpacePos.y) / eyeSpacePos.z;
1168	Real Nz1 = (r - Ny1 * eyeSpacePos.y) / eyeSpacePos.z;
1169
1170	// Get the point of tangency
1171	// Only consider points of tangency in front of the camera
1172	Real Pz0 = (Lyz - rsq) / (eyeSpacePos.z - ((Nz0 / Ny0) * eyeSpacePos.y));
1173	if (Pz0 < 0)
1174	{
1175	// Project point onto near plane in worldspace
1176	Real neary0 = (Nz0 * mNearDist) / Ny0;
1177	// now we need to map this to viewport coords
1178	// use projection matriy since that will take into account all factors
1179	Vector3 rely0 = projMatrix * Vector3(0, neary0, -mNearDist);
1180
1181	// find out whether this is a top side or bottom side
1182	Real Py0 = -(Pz0 * Nz0) / Ny0;
1183	if (Py0 > eyeSpacePos.y)
1184	{
1185	top = std::min(top, rely0.y);
1186	}
1187	else
1188	{
1189	bottom = std::max(bottom, rely0.y);
1190	}
1191	}
1192	Real Pz1 = (Lyz - rsq) / (eyeSpacePos.z - ((Nz1 / Ny1) * eyeSpacePos.y));
1193	if (Pz1 < 0)
1194	{
1195	// Project point onto near plane in worldspace
1196	Real neary1 = (Nz1 * mNearDist) / Ny1;
1197	// now we need to map this to viewport coords
1198	// use projection matriy since that will take into account all factors
1199	Vector3 rely1 = projMatrix * Vector3(0, neary1, -mNearDist);
1200
1201	// find out whether this is a top side or bottom side
1202	Real Py1 = -(Pz1 * Nz1) / Ny1;
1203	if (Py1 > eyeSpacePos.y)
1204	{
1205	top = std::min(top, rely1.y);
1206	}
1207	else
1208	{
1209	bottom = std::max(bottom, rely1.y);
1210	}
1211	}
1212	}
1213	}
1214
1215	return (left != -1.0f) \|\| (top != 1.0f) \|\| (right != 1.0f) \|\| (bottom != -1.0f);
1216
1217	}
1218	//---------------------------------------------------------------------
1219	void Frustum::enableCustomNearClipPlane(const MovablePlane* plane)
1220	{
1221	mObliqueDepthProjection = true;
1222	mLinkedObliqueProjPlane = plane;
1223	mObliqueProjPlane = plane->_getDerivedPlane();
1224	invalidateFrustum();
1225	}
1226	//---------------------------------------------------------------------
1227	void Frustum::enableCustomNearClipPlane(const Plane& plane)
1228	{
1229	mObliqueDepthProjection = true;
1230	mLinkedObliqueProjPlane = 0;
1231	mObliqueProjPlane = plane;
1232	invalidateFrustum();
1233	}
1234	//---------------------------------------------------------------------
1235	void Frustum::disableCustomNearClipPlane(void)
1236	{
1237	mObliqueDepthProjection = false;
1238	mLinkedObliqueProjPlane = 0;
1239	invalidateFrustum();
1240	}
1241	//---------------------------------------------------------------------
1242	void Frustum::setCustomViewMatrix(bool enable, const Matrix4& viewMatrix)
1243	{
1244	mCustomViewMatrix = enable;
1245	if (enable)
1246	{
1247	assert(viewMatrix.isAffine());
1248	mViewMatrix = viewMatrix;
1249	}
1250	invalidateView();
1251	}
1252	//---------------------------------------------------------------------
1253	void Frustum::setCustomProjectionMatrix(bool enable, const Matrix4& projMatrix)
1254	{
1255	mCustomProjMatrix = enable;
1256	if (enable)
1257	{
1258	mProjMatrix = projMatrix;
1259	}
1260	invalidateFrustum();
1261	}
1262
1263
1264
1265	} // namespace Ogre

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

Download in other formats: