Index: /GTP/trunk/App/Demos/Vis/FriendlyCulling/Readme.txt
===================================================================
--- /GTP/trunk/App/Demos/Vis/FriendlyCulling/Readme.txt	(revision 2785)
+++ /GTP/trunk/App/Demos/Vis/FriendlyCulling/Readme.txt	(revision 2789)
@@ -2,16 +2,10 @@
 ======================================
 
-This programn is a demonstration of the Coherent Hierarchical Culling algorithm 
-described in the chapter "Hardware Occlusion Queries Made Useful" of the book GPU 
-Gems II. Additional information and sample images are available at
-
-http://www.cg.tuwien.ac.at/research/vr/chcull/
-
-Updates to this demo can can be found on the same webpage.
+This programn is a demonstration of the CHC++ algorithm 
+described in the chapter "Game Engine Friendly Occlusion Culling" of the book ShaderX 7. 
 
 Copyright and Disclaimer:
 
-This code is copyright Vienna University of Technology, 2004.
-
+This code is copyright Vienna University of Technology, 2008.
 
 Please feel FREE to COPY and USE the code to include it in your own work,
@@ -27,8 +21,10 @@
 Authors of the book chapter:
 
+Jiri Bittner (bittner@cg.tuwien.ac.at)
+Oliver Mattausch (matt@cg.tuwien.ac.at)
 Michael Wimmer (wimmer@cg.tuwien.ac.at)
-Jiri Bittner (bittner@cg.tuwien.ac.at)
 
-Date: December 18, 2004
+
+Date: June 20, 2008
 
 ----------
@@ -38,12 +34,9 @@
 Help for keybord and mouse is available with F1.
 
-You can switch between the different occlusion modes described in the book chapter using the 
-SPACE key (view-frustum culling, hierarchical stop and wait, coherent hierarchical culling).
+You can switch between different known occlusion modes using the 
+SPACE key (view-frustum culling, hierarchical stop and wait, coherent hierarchical culling, chc++).
 
-A visualization of the culling algorithm from can be shown by pressing '1' on the keyboard. Note that the 
-classification of nodes usually changes in consecutive frames, so that the hierarchy seems to oscillate. 
-This is expected, since the classification of previously visible interior nodes is based on the classification 
-of their children, which might be more accurate (leading to the interior node to become occluded) than the 
-query for the node itself.
+A bird eye view visualization of the culling algorithm from can be shown by pressing '1' on the keyboard.
+
 
 ----------
@@ -51,14 +44,21 @@
 ----------
 
-The scene used in this program consists of basic objects randomly placed in a box. The extent of the box and the 
-number and size of objects can be changed (see F1).
+The scene used in this program is model of the city Vienna, which has a long history in the visibility research comunity as a scene to test and showcase various algorihms. 
 
-The hierarchical structure is a kd-tree with objects intersecting a split plane placed into multiple leaf nodes.
+The hierarchical structure is a bounding volume hierarchy which was precomputed (using Surface Area Heuristics) in order to not pollute the demo with lenghty construction code not relevant to the algorithm to keep the demo as simple and educationional as possible. Note that the original construction would also not take more than some seconds.
 
-By playing with the parameters and moving around, the user can explore situtations where occlusion culling is extremly 
-useful, and where it is not (because the objects are too sparse or there is too much to see from this viewpoint).
+---------------
+The algorithm
+---------------
 
-The hierarchical coherent culling algorithm is compared to simple view-frustum culling and the hierarchical stop and wait 
-algorithm (which also uses hardware occlusion queries, but in a less sophisticated way).
+The CHC ++ algorithm is build on the CHC alorithm and removes most of it's shortcomings while maintaining simplicity. By playing with the parameters and moving around, the user can explore situtations where occlusion culling is extremly useful, and where it is not (because the objects are too sparse or there is too much to see from this viewpoint). One can observe that the CHC++ algorithm provides good frame rates even in these difficult cases, even when the CHC algorithm breaks down and falls behind view frustum culling in terms of performance
+
+
+--------------
+The engine
+-------------
+
+We use a simple OpenGL based engine which was designed to be as simple as possible while providing the necessary feature list to simulate the behaviour of full-fledged game engines like Ogre3D. The engine supports simple material sorting mainly based on the texture size, avoiding the mix of differently sized textures, which according to various sources induces one of the costliest state change. We demonstrate the integration of the culling algorithm into the engine, and show how occlusion cullig and state sorting are possible within one framework, two paradigms that were previously considered to be cancelling out each other ("either you do front-back-sorting or material sorting").
+
 
 ----------
@@ -66,10 +66,6 @@
 ----------
 
-A binary for Win32 is included.
+A binary for Win32 and a solution for visual studio 2005 included. The program should work under XP and Windows Vista.
 
-The program should compile under Windows and Linux, a CMAKE makefile for multi-platform
-compilation is included (see www.cmake.org for details).
-
-For Linux, you need to have a working GLUT and GLEW installation.
 
 ----------
@@ -77,25 +73,11 @@
 ----------
 
-This demo is written in C++ and partly C and uses OpenGL.
-It has few external needs like limits.h, stdlib.h, math.h, string.h, stdio.h, or time.h.
-We also make heavy use of stl classes, like priority_queue.
+This demo is written in C++. We make heavy use of stl classes, like priority_queue. The program expects the GL_ARB_occlusion_query extension.
 
-The program expects the GL_ARB_occlusion_query extension.
+The rendering core of the engine is provided by the class RenderTraverser, which provides front to back scene traversal based on a priority queue. It's subclasses implement the various culling algorithms. The new algorithm is represented by the class CHCPlusPlusTraverser.
 
-The program and especially the mathematical routines are not designed for speed or
-efficiency, but for simplicity and clarity.
+The main routine is implemented in chcdemo.cpp. Also it contains the OpenGl setup code, glut stuff, and sets up of the scene hierarchy.
 
-RenderTraverser.cpp: implements the core algorithm described in the paper
+The project is separated into one section containing supportive code (utils), the traversal algorithms (traversal), and the basic engine classes like Camera, Geometry, Material, or RenderState (scene). 
 
-occquery.cpp: contains the OpenGl setup code, glut stuff, and sets up of the scene hierarchy
-HierarchyNode.cpp: contains a kd-tree hierarchy implementation, which can be traversed by the culling algorithm
-Geometry.cpp: represents simple drawable geometry, so that we have something to cull for the algorithm
-
-Timers.cpp: contains exact timer functions in order to accurately measure the frame render time
-stdafx.cpp: source file that includes just the standard includes
-glInterface.h: includes gl, glut and glew headers
-DataTypes.c: defines basic geometric datatypes
-MathStuff.c: declares some handy mathematical routines
-teapot.h: contains the teapot geometry
-
-If you find any problem with the code or have any comments, we would like to hear from you!
+If you find any problem with the code or have any comments, please feel free to ask us at any time.
