Transcript The Personal Interaction Panel

Computergraphik 2 & 3 LU
1. Repetitorium
http://www.cg.tuwien.ac.at/courses/CG23/LU.html
Smart Pointers
2 ways to create objects in C++
int myVar(5);
// same as: int myVar = 5;
int* myVar = new int(5);
objects created with new must be deleted!
delete myVar;
problem: what part of the code is responsible for
deleting objects? - solution: smart pointers
www.boost.org/libs/smart_ptr/smart_ptr.htm
...or roll your own:
Handle<int> myVar = new int(5);
Handle<> Template Class
in handle.h
template<class T> class Handle {
T* pointer;
int* count;
public:
Handle(T* t) : pointer(t), count(new int(1))
{}
Handle(const Handle& copy) :
pointer(copy.pointer),
count(copy.count)
{ ++*count; }
//...
Handle<> Template Class
to access the handled object‘s members
T& operator*() const
{
if (pointer) return *pointer;
throw runtime_error("unbound Handle");
}
T* operator->() const
{
if (pointer) return pointer;
throw runtime_error("unbound Handle");
}
//...
Handle<> Template Class
even more operator overloading
Handle<T>& operator=(const Handle& assign)
{
++*assign.count;
if (--*count == 0) {
delete count;
delete pointer;
}
count = assign.count;
pointer = assign.pointer;
return *this;
}
//...
Handle<> Template Class
we‘re almost done...
operator bool() const
{
return pointer;
}
~Handle()
{
if (--*count == 0) {
delete count;
delete pointer;
}
}
} // class Handle
STL
the STL (standard template library) provides:
a string class (std::string)
container templates:
linked lists (std::list)
resizable arrays (std::vector)
maps (std::map)
hash tables (stdext::hash_map in VS.net 2003)
docs: http://www.sgi.com/tech/stl/
Using the STL
keeping track of game entities
typedef std::vector<Handle<Entity> > entityVec;
entityVec weapons;
// ... we add a new gun to the container
Handle<Entity> gun = new Railgun;
weapons.push_back(gun);
// ... at some point we may want to render the weapons
for (entityVec::iterator iter = weapons.begin();
iter < weapons.end(); ++iter)
(*iter)->render();
OpenGL Extensions
on Windows:
to access features of OpenGL >1.1
to access vendor specific features
to access very new features
OpenGL Extension Registry
http://oss.sgi.com/projects/ogl-sample/registry/
description of functions and how to use them
OpenGL Extensions: GLEW
OpenGL Extension Wrangler Library
http://glew.sourceforge.net/
#include <GL/glew.h>
#include <GL/glut.h>
// initialization
glutInit(&argc, argv);
glutCreateWindow("GLEW Test");
GLenum err = glewInit();
if (err != GLEW_OK) {
cerr << "GLEW Error: " << glewGetErrorString(err);
exit(1);
}
OpenGL Extensions: GLEW
usage:
if (GLEW_ARB_vertex_program) {
// it is safe to use the ARB_vertex_program here
glGenProgramsARB(...);
}
// checking with strings
if (glewIsSupported("GL_VERSION_1_4 GL_ARB_point_sprite")) {
// great, we have OpenGL 1.4 + point sprites
}
Querying OpenGL Errors
at least once after each iteration of the game
loop:
GLenum err = glGetError();
if (err != GL_NO_ERROR)
cerr << "GL Error: " << gluErrorString(err) << endl;
Querying OpenGL Errors
querying the GLSL info log:
GLint logLength;
glGetObjectParameterivARB(programObject,
GL_OBJECT_INFO_LOG_LENGTH_ARB, &logLength);
if (logLength > 1) {
GLcharARB* logString = new GLcharARB[logLength];
glGetInfoLogARB(programObject, logLength, NULL, logString);
cout << "GLSL Info: " << logString << endl;
delete[] logString;
}
Low-Level Data Structures
Vector class to ease the use of cross product, dotproduct...
Matrix class to simplify matrix-matrix
multiplications, matrix-vector multiplications,
matrix inversions...
Plane/Line class for
Intersection/distance
Ray casting
Low-Level Data Structures
Bounding spheres/boxes
Faster collision and visibility calculations
Axis aligned bounding box
Oriented bounding box
Frustum class for view-frustum calculations
List/stack of bounding planes
View-frustum culling
Portals
Basic Rendering
View-frustum culling
What we do not see, we do not render.
Test Bounding Volume of each object against
view-frustum.
Make it hierarchical for faster execution
Basic Rendering
Backface culling
Removes half the triangles
Done by HW glEnable(GL_CULL_FACE)..
Basic Rendering
Simple „scene graph“ - a list of objects
For each object do view-frustum culling with its
bounding volume
If visible render it
Set state (activate texture, transformation, color...)
Draw geometry
Make it hierarchical
From list to bounding volume tree
From list to state tree
Camera
Position
Orientation, some possibilities:
Store angles around different axes
Incremental multiplication (e.g. each frame)
Depends on the game type and the DOF needed
Transformations: Treat cameras like objects!
Collision Detection
The best tests are those never executed!
Depends on the scenario / game genre
General:
Broadphase: Bounding Volumes, spatial
coherence, sweep-and-prune
Narrowphase: Bounding Volume Hierarchies,
Polyhedra, Triangles
Depending on game type:
Bounding sphere / AABB / OBB often will suffice
Collision Detection - 2
Different types:
Spheres (simple; efficient testing; not very accurate)
Axis-aligned Bounding Boxes (simple; efficient testing,
but slower than spheres)
Oriented Bounding Boxes (very accurate; construction
is a non-trivial task for complex objects)
Bounding Volume Hierarchies:
A parent contains/bounds his leaves
Each leave bounds a primitive
Collision Detection - 3
If Bounding Volumes collide:
One step down the hierarchy
E.g. triangle vs. triangle
Depends on the scene / game type
http://www.realtimerendering.com/int/
Contains about every intersection-routine ever
developed ;)
2. Hand-In: Bounding Volume tests sufficient
Terrain Rendering - 1
Regular Grids
use triangle strips!
Height Maps
color encodes height at (x, y)
Space Partitioning
Each block 1 efficient triangle
strip
Geometry splitting along block
borders
Terrain Rendering - 2
Advanced Techniques
Occlusion Culling
Levels of Detail (adapt complexity dynamically)
But: efficient preparation for hardware more important
than LOD!
Heightmaps
Draw manually
Use tools (Terragen)
Generate (fractals/midpoint displacement, …)
Space Partitioning - 1
Needed for various culling/visibility techniques
Reduces amount of calculations needed
Quadtrees, Octrees, BSP Trees, …
Beware of memory requirements
Balance tree height VS geometry per partition
(empirically)
View Frustum Culling
Fast approach with false positives better than slower,
accurate approach (for games)
Make use of hierarchical data structure!
Space Partitioning - 2
Traverse Tree (DFS)
Discard blocks as big as possible as
soon as possible, example:
A visible
A1, A2, A3, A4 visible
B invisible
C visible
C1 invisible
C2 visible
C3, C4 invisible
D invisible
→ render A1, A2, A3, A4, C2
Efficient OpenGL - Geometry
Use OpenGL vertex arrays for
Normals
Texture-coordinates
Vertex-coordinates
Use indexed geometry
Saves memory (re-use of vertices)
Index-array: provide it when calling
glDrawElements(…) or bind it before when
using vertex buffer objects
Efficient OpenGL – Geometry 2
Indexed Geometry
Not always best/applicable
(e.g. cube: no shared vertices!)
Good for highly tessellated, curved surfaces
(e.g. cylinder)
Shared vertices also have to share
Normals
Texture-coordinates
Color
Efficient OpenGL – Geometry 3
Today’s hardware:
able to transform up to 100 million triangles per second
One million triangles per frame at 100 fps!
Special requirements:
Complex objects
(many triangles per render-call)
Appropriate conditioned objects
(triangle strips, many shared vertices)
Use of extensions
(avoids unnecessary copy operations, …)
Efficient OpenGL – Extensions
Some useful extensions:
GL_ARB_vertex_buffer_object
GL_SGIS_generate_mipmap (OpenGL 1.4)
GL_ARB_texture_compression
Vertex Buffer Objects
Allows for storing vertex data in video memory
Further information (strongly recommended!):
http://developer.nvidia.com/object/using_VBOs.html
http://oss.sgi.com/projects/oglsample/registry/ARB/vertex_buffer_object.txt
Efficient OpenGL – Extensions
SGI Mipmapping
Uses hardware to generate mipmaps automatically
Faster than gluBuild2DMipmaps(…)
Further information:
http://developer.nvidia.com/object/gdc2001_automati
c_mipmap.html
http://oss.sgi.com/projects/oglsample/registry/SGIS/generate_mipmap.txt
Efficient OpenGL – Extensions
Texture compression
Reduces traffic on memory bus
Decreases load-time when stored compressed on harddisk
Further information:
http://developer.nvidia.com/object/texture_compressi
on_OpenGL.html
http://oss.sgi.com/projects/oglsample/registry/ARB/texture_compression.txt