Context Navigation

source: GTP/trunk/Lib/Vis/OnlineCullingCHC/src/CoherentHierarchicalCullingManager2.cpp @ 2360

Revision 2360, 9.0 KB checked in by mattausch, 18 years ago (diff)

Rev	Line
[2360]	1	#include "CoherentHierarchicalCullingManager2.h"
	2	#include "CullingLogManager.h"
	3
	4	#include <time.h>
	5	#include <sstream>
	6
	7	namespace GtpVisibility {
	8
	9	//-----------------------------------------------------------------------
	10	CoherentHierarchicalCullingManager2::CoherentHierarchicalCullingManager2()
	11	{
	12	SetAssumedVisibility(0);
	13	// initialise random generator in case we use assumed visibility
	14	//srand(time(NULL));
	15	}
	16	//-----------------------------------------------------------------------
	17	CoherentHierarchicalCullingManager2::CoherentHierarchicalCullingManager2(
	18	const unsigned int assumedVisibility)
	19	{
	20	SetAssumedVisibility(assumedVisibility);
	21	// initialise random generator in case we use assumed visibility
	22	//srand(time(NULL));
	23	}
	24	//-----------------------------------------------------------------------
	25	#if 1
	26
	27	void CoherentHierarchicalCullingManager2::RenderScene()
	28	{
	29	//CullingLogManager::GetSingleton()->LogMessage("chc");
	30	QueryQueue queryQueue;
	31	unsigned int visiblePixels = 0;
	32
	33	/////////////
	34	//-- PART 1: process finished occlusion queries
	35
	36	while (!mHierarchyInterface->GetQueue()->empty() \|\| !queryQueue.empty())
	37	{
	38	bool resultAvailable = false;
	39
	40	const bool nodeQueueEmpty = mHierarchyInterface->GetQueue()->empty();
	41	const int queryQueueSize = (int)queryQueue.size();
	42	bool queryAvailable = true;
	43
	44	//-- only wait for result if there are no nodes to process
	45	while (!queryQueue.empty() &&
	46	(queryAvailable = queryQueue.front().second->GetQueryResult(visiblePixels, false)))
	47	{
	48	HierarchyNode *node = queryQueue.front().first;
	49	queryQueue.pop();
	50
	51	// render nodes if queue is still idle ...
	52
	53	if (1&&nodeQueueEmpty)
	54	{
	55	std::stringstream d; d << "qu: " << queryQueueSize;
	56	CullingLogManager::GetSingleton()->LogMessage(d.str());
	57	}
	58
	59
	60	if (visiblePixels > mVisibilityThreshold)
	61	{
	62	// check visibility to ensure that we traverse node only once
	63	// (important for interior nodes with geometry
	64	if (!mHierarchyInterface->IsNodeVisible(node))
	65	{
	66	mHierarchyInterface->TraverseNode(node);
	67	}
	68
	69	mHierarchyInterface->PullUpVisibility(node);
	70	}
	71	else
	72	{
	73	mHierarchyInterface->SetNodeVisible(node, false);
	74
	75	++ mNumQueryCulledNodes;
	76
	77	if (mVisualizeCulledNodes)
	78	{
	79	mHierarchyInterface->VisualizeCulledNode(node, QUERY_CULLED);
	80	}
	81	}
	82	}
	83
	84
	85	if (!queryAvailable)
	86	{
	87	// query not yet available => render some geometry
	88	HierarchyNode *node = queryQueue.front().first;
	89
	90	// check visibility to ensure that we traverse node only once
	91	// (important for interior nodes with geometry
	92	if (!mHierarchyInterface->IsNodeVisible(node))
	93	{
	94	mHierarchyInterface->SetNodeVisible(node, true);
	95	mHierarchyInterface->TraverseNode(node);
	96	}
	97	}
	98
	99
	100	//-- PART 2: hierarchical traversal
	101	if (!mHierarchyInterface->GetQueue()->empty())
	102	{
	103	HierarchyNode *node = mHierarchyInterface->GetQueue()->top();
	104
	105	mHierarchyInterface->GetQueue()->pop();
	106
	107	bool intersects = false;
	108
	109	if (!mHierarchyInterface->CheckFrustumVisible(node, intersects))
	110	{
	111	++ mNumFrustumCulledNodes;
	112
	113	if (mVisualizeCulledNodes)
	114	{
	115	mHierarchyInterface->VisualizeCulledNode(node, FRUSTUM_CULLED);
	116	}
	117	}
	118	//-- if node intersects near plane, skip query because wrong results possible
	119	else if (intersects)
	120	{
	121	SkipQuery(node);
	122	}
	123	else
	124	{
	125	// identify previously visible nodes
	126	bool wasVisible = mHierarchyInterface->IsNodeVisible(node) &&
	127	(mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1);
	128
	129	// if we assume node to be visible in this frame => skip query
	130	bool skipQuery = wasVisible && (mAssumedVisibility > 0) &&
	131	DecideVisible(node) && mHierarchyInterface->HasGeometry(node);
	132
	133	if (skipQuery)
	134	{
	135	SkipQuery(node);
	136	continue;
	137	}
	138
	139	// identify nodes that we cannot skip queries for
	140	// geometry not only in leaves => test for renderable geometry
	141	bool issueQuery = !wasVisible \|\| mHierarchyInterface->HasGeometry(node);
	142
	143	// reset node's visibility classification
	144	// set visibe if geometry in node so we only traverse once
	145	mHierarchyInterface->SetNodeVisible(node, wasVisible && issueQuery);
	146
	147	// update node's visited flag
	148	mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
	149
	150	// skip testing previously visible nodes without geometry
	151	if (issueQuery)
	152	{
	153	++ mNumQueriesIssued;
	154
	155	queryQueue.push(QueryPair(node, mHierarchyInterface->
	156	IssueNodeOcclusionQuery(node, wasVisible)));
	157	}
	158
	159	// always traverse a node if it was visible
	160	if (wasVisible)
	161	{
	162	mHierarchyInterface->TraverseNode(node);
	163	}
	164	}
	165	}
	166	}
	167	}
	168
	169	#else
	170
	171	void CoherentHierarchicalCullingManager2::RenderScene()
	172	{
	173	//CullingLogManager::GetSingleton()->LogMessage("chc");
	174	QueryQueue queryQueue;
	175	unsigned int visiblePixels = 0;
	176
	177	/////////////
	178	//-- PART 1: process finished occlusion queries
	179
	180	while (!mHierarchyInterface->GetQueue()->empty() \|\| !queryQueue.empty())
	181	{
	182	bool resultAvailable = false;
	183
	184	const bool nodeQueueEmpty = mHierarchyInterface->GetQueue()->empty();
	185	const int queryQueueSize = (int)queryQueue.size();
	186
	187	//-- only wait for result if there are no nodes to process
	188	while (!queryQueue.empty() &&
	189	queryQueue.front().second->GetQueryResult(visiblePixels,
	190	nodeQueueEmpty))
	191	{
	192	HierarchyNode *node = queryQueue.front().first;
	193	queryQueue.pop();
	194
	195	// render nodes if queue is still idle ...
	196
	197	if (1&&nodeQueueEmpty)
	198	{
	199	std::stringstream d; d << "qu: " << queryQueueSize;
	200	CullingLogManager::GetSingleton()->LogMessage(d.str());
	201	}
	202
	203
	204	if (visiblePixels > mVisibilityThreshold)
	205	{
	206	// in case geometry is in omterior node: ensure that we only traverse once
	207	if (!mHierarchyInterface->IsNodeVisible(node))
	208	{
	209	mHierarchyInterface->TraverseNode(node);
	210	}
	211
	212	mHierarchyInterface->PullUpVisibility(node);
	213	}
	214	else
	215	{
	216	mHierarchyInterface->SetNodeVisible(node, false);
	217
	218	++ mNumQueryCulledNodes;
	219
	220	if (mVisualizeCulledNodes)
	221	{
	222	mHierarchyInterface->VisualizeCulledNode(node, QUERY_CULLED);
	223	}
	224	}
	225	}
	226
	227	//-- PART 2: hierarchical traversal
	228	if (!mHierarchyInterface->GetQueue()->empty())
	229	{
	230	HierarchyNode *node = mHierarchyInterface->GetQueue()->top();
	231	mHierarchyInterface->GetQueue()->pop();
	232
	233	bool intersects = false;
	234
	235	if (!mHierarchyInterface->CheckFrustumVisible(node, intersects))
	236	{
	237	++ mNumFrustumCulledNodes;
	238
	239	if (mVisualizeCulledNodes)
	240	{
	241	mHierarchyInterface->VisualizeCulledNode(node, FRUSTUM_CULLED);
	242	}
	243	}
	244	//-- if node intersects near plane, skip query because wrong results possible
	245	else if (intersects)
	246	{
	247	SkipQuery(node);
	248	}
	249	else
	250	{
	251	// identify previously visible nodes
	252	bool wasVisible = mHierarchyInterface->IsNodeVisible(node) &&
	253	(mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1);
	254
	255	// if we assume node to be visible in this frame => skip query
	256	bool skipQuery = wasVisible && (mAssumedVisibility > 0) &&
	257	DecideVisible(node) && mHierarchyInterface->HasGeometry(node);
	258
	259	if (skipQuery)
	260	{
	261	SkipQuery(node);
	262	continue;
	263	}
	264
	265	// identify nodes that we cannot skip queries for
	266	// geometry not only in leaves => test for renderable geometry
	267	bool issueQuery = !wasVisible \|\| mHierarchyInterface->HasGeometry(node);
	268
	269	// reset node's visibility classification
	270	// set visibe if geometry in node so we only traverse once
	271	mHierarchyInterface->SetNodeVisible(node, wasVisible && issueQuery);
	272
	273	// update node's visited flag
	274	mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
	275
	276	// skip testing previously visible nodes without geometry
	277	if (issueQuery)
	278	{
	279	++ mNumQueriesIssued;
	280
	281	queryQueue.push(QueryPair(node, mHierarchyInterface->
	282	IssueNodeOcclusionQuery(node, wasVisible)));
	283	}
	284
	285	// always traverse a node if it was visible
	286	if (wasVisible)
	287	{
	288	mHierarchyInterface->TraverseNode(node);
	289	}
	290	}
	291	}
	292	}
	293	}
	294
	295	#endif
	296	//-----------------------------------------------------------------------
	297	void CoherentHierarchicalCullingManager2::SetAssumedVisibility(const unsigned int assumedVisibility)
	298	{
	299	mAssumedVisibility = assumedVisibility;
	300
	301	mThreshold = 0;
	302
	303	if (mAssumedVisibility > 0)
	304	{
	305	mThreshold = RAND_MAX - RAND_MAX / mAssumedVisibility;
	306	// fix visibility
	307	if (mAssumedVisibility > 100)
	308	mThreshold = RAND_MAX;
	309	}
	310
	311	}
	312	//-----------------------------------------------------------------------
	313	inline bool CoherentHierarchicalCullingManager2::DecideVisible(HierarchyNode *node) const
	314	{
	315	return rand() < mThreshold;
	316	}
	317	//-----------------------------------------------------------------------
	318	inline void CoherentHierarchicalCullingManager2::SkipQuery(HierarchyNode *node) const
	319	{
	320	// -- set node to be visible in this frame, then traverse it
	321	mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
	322
	323	mHierarchyInterface->PullUpVisibility(node);
	324	mHierarchyInterface->TraverseNode(node);
	325	}
	326
	327	} // namespace GtpVisibility

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

Download in other formats: