Changeset 2177 for GTP/trunk

Timestamp:

03/01/07 10:19:55 (18 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/Lib/Vis

Files:

• OnlineCullingCHC/scripts/terrainCulling.cfg (modified) (3 diffs)
• Preprocessing/manual/images/pvs.png (added)
• Preprocessing/manual/integration.tex (modified) (15 diffs)

GTP/trunk/Lib/Vis/OnlineCullingCHC/scripts/terrainCulling.cfg

@@ -27 +27 @@
 #Scene=../../../../../resources/media/house_test1.iv
 #Scene=../../../../../resources/media/city1500_flat_1.iv;../../../../../resources/media/roofs_1500.iv;../../../../../resources/media/CityRoads60.iv;../../../../../resources/media/CityPlane60.iv
-#Scene=../../../../../resources/media/city1.iv;../../../../../resources/media/roofs_1500.iv;../../../../../resources/media/CityRoads60.iv
+#Scene=../../../../../resources/media/city1.iv;../../../../../resources/media/roofs_1500.iv;../../../../../resources/media/CityRoads60.iv;../../../../../resources/media/CityPlane60.iv
 
 #
@@ -37 +37 @@
 
 #
-# should render queue be flushed after each frame?
+# render queue is flushed after some frames
 #
 
-#FlushQueue=true
+FlushQueue=1
 
+#
+# depth pass must be used together with illumination model
+#
+
+UseDepthPass=0
 
 
@@ -55 +60 @@
 # should render queue be flushed after each frame?
 #
-
-FlushQueue=false
-
-#UseDepthPass=false
 
 

GTP/trunk/Lib/Vis/Preprocessing/manual/integration.tex

@@ -1 +1 @@
 \section{Introduction}
 \label{sec:introduction}
+
+\label{fig:pvs}
+\end{figure*}
+\begin{figure*}
+\centering
+\includegraphics[width=0.33\textwidth]{images/pvs}
+\caption{The PVS Computation Module integrated in the Ogre3d engine. 
+A snapshot of Vienna is shown, with the rendered PVS shown in the lower right corner. Note 
+how the PVS closely fits to the geometry actually seen.}
 
 This manual provides a guide to apply preprocessed visibility in a particular target engine. It
@@ -87 +96 @@
 \end{itemize}
 
-This include directory must be added to your Solution.
+The following include directory must be added to your Solution.
 
 \begin{itemize}
@@ -97 +106 @@
 For this purpose we associate the entities of the engine with the PVS
 entries from the visibility solution. 
-For this purposse the user must implement a small number of interface classes
+For this purpose the user must implement a small number of interface classes
 of the preprocessor.
 We demonstrate this on a small example, which shows how to access preprocessed visibility 
@@ -118 +127 @@
 
 This piece of code is loading the view cells into the engine.
-Let's analyze this code. There are two constructs that need explanation, the
-BoundingBoxConverter and the ObjectContainer, and the view cells manager.
+Let's analyze this code. There are three constructs that need explanation, the
+BoundingBoxConverter and the ObjectContainer, and the ViewCellsManager.
 
 \paragraph{BoundingBoxConverter}
@@ -139 +148 @@
 \label{sec:ObjectContainer}
 
-The object container is basicly a vector of {\em Intersectable *}. It contains all
+An object container is a vector of {\em Intersectable *}. It contains all
 static entities of the scene.
 A PVS entry must be derived from this class. To get access to the PVS of a view cell,
@@ -148 +157 @@
 \label{sec:Loading}
 
-The loading function returns a view cells.
+The loading function returns a view cells manager.
 
 \begin{verbatim}
 static ViewCellsManager *LoadViewCells(const string &filename, 
-                                                                                   ObjectContainer *objects, 
-                                                                                   bool finalizeViewCells = false,
-                                                                                   BoundingBoxConverter *bconverter = NULL);
+                                       ObjectContainer *objects,
+                                       bool finalizeViewCells = false,
+                                       BoundingBoxConverter *bconverter = NULL);
 \end{verbatim}
 
@@ -167 +176 @@
 
 In this section we show an example implementation for the interface classes in Ogre3D.
-
-\subsection{Intersectable}
+First for the object class of the preprocessor, {\em Intersectable}, then for the converter class 
+{\em BoundingBoxConverter }.
+
+\subsection{Class Intersectable}
 \label{sec:intersectable}
 
@@ -204 +215 @@
 
 
-\subsection{Bounding Box Converter}
+\subsection{Class BoundingBoxConverter}
 \label{sec:Converter}
 
-This is maybe the most tricky part of the integration. The bounding box converter
-is necessary because we have to associate the objects of the visibility solution with
-the objects from the engine without having unique ids. This is the interface
-of the {\em BoundingBoxConverter }.
+This is the most involved part of the integration, but it shouldn't be too difficult, either. 
+A bounding box converter is necessary because we have to associate the objects of the 
+visibility solution with the objects from the engine without having unique ids. This is the 
+interface of the class {\em BoundingBoxConverter }.
 
 \begin{verbatim}
@@ -237 +248 @@
 \end{verbatim}
 
-We give an example of implementation of a Bounding Box Converter 
-for Ogre3D rendering engine. It is templated in order to works with any Ogre SceneManager.
+We give an example of implementation of a {\em BoundingBoxConverter } 
+for the Ogre3D rendering engine. It is templated in order to works with any {\em SceneManager } in Ogre3D
+(If you are not familiar with the {\em SceneManager} concept in Ogre3D, it does not matter).
 Again, the implementation of this interface must be adapted for the requirements 
 of the particular engine. 
@@ -272 +284 @@
 
 This class is inherited from {\em BoundingBoxConverter}.
-{\em BoundingBoxConverters} has only one virtual function {\em IdentifyObjects} that must
+This class has only one virtual function {\em IdentifyObjects} that must
 be implemented. Additionally we use a helper function {\em FindIntersectingObjects} that 
 is responsible for locating the corresponding objects in the scene. Let's now have a look 
@@ -306 +318 @@
 
 The function just loops over the bounding boxes of the PVS entries and finds the entities that
-are intersected by the bouding boxes. Let's have a look now at the function 
-{\em FindIntersectingObjects}, which is searching the intersections for each individual box.
+are intersected by the bounding boxes. Additionally we introduce a new class, the { \em OgreTypeConverter }.
+This class is just responsible for converting basic classes like {\em Vector3 } or { \em AxisAlignedBox }
+betwen Ogre3D types and Preprocessor types. Now we revisit the function 
+{\em FindIntersectingObjects}, which searches the intersections for each individual box.
 
 \begin{verbatim}
@@ -354 +368 @@
 
 Note that the implementation of this function is maybe the one that differs the most
-for another engine, as it is highly depending on the particular engine design. 
+for other engines, as it is highly depending on the particular engine design. 
 For the Ogre3D implementation, we use a two stage approach. First we find the 
 intersecting scene nodes. We apply a search function that is optimized for this engine. 
@@ -360 +374 @@
 The engine is responsible to provide a function for fast geometric search in the scene,
 in order to quickly find the objects intersecting the bounding box of a PVS entry. 
-A spatial data structure like Octree or Kd tree is very useful in this regard.
+A spatial data structure like octree or kd-tree is very useful in this regard.
 Second we traverse through the list of entities attached to the scene node. The intersection
 test is then applied for each indiviual bounding box. 
@@ -367 +381 @@
 \label{sec:usage}
 
-By now the view cells should be accessible within the target engine. The 
+At this point the view cells should be accessible within the target engine. The 
 view cells manager provides the necessary functionality to handle the view cells. 
 In order to query the current view cell, use the following function of the 
@@ -376 +390 @@
 \end{verbatim}
 
-In your engine, the function will called like this.
+In the target engine, the function is envoked like this.
 
 \begin{verbatim}