computergraphik 2 & 3 lu 1. repetitorium
Post on 03-Jan-2016
34 Views
Preview:
DESCRIPTION
TRANSCRIPT
Computergraphik 2 & 3 LU1. 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 containerHandle<Entity> gun = new Railgun;weapons.push_back(gun);
// ... at some point we may want to render the weaponsfor (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 Registryhttp://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>
// initializationglutInit(&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 stringsif (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, dot-product...
Matrix class to simplify matrix-matrix multiplications, matrix-vector multiplications, matrix inversions...
Plane/Line class forIntersection/distance
Ray casting
Low-Level Data Structures
Bounding spheres/boxesFaster collision and visibility calculations
Axis aligned bounding box
Oriented bounding box
Frustum class for view-frustum calculationsList/stack of bounding planes
View-frustum culling
Portals
Basic Rendering
View-frustum cullingWhat 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 cullingRemoves half the triangles
Done by HW glEnable(GL_CULL_FACE)..
Basic Rendering
Simple „scene graph“ - a list of objectsFor each object do view-frustum culling with its bounding volume
If visible render itSet state (activate texture, transformation, color...)
Draw geometry
Make it hierarchicalFrom 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 genreGeneral:
Broadphase: Bounding Volumes, spatial coherence, sweep-and-pruneNarrowphase: 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 leavesEach leave bounds a primitive
Collision Detection - 3
If Bounding Volumes collide:
One step down the hierarchyE.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 Gridsuse triangle strips!
Height Maps color encodes height at (x, y)
Space PartitioningEach block 1 efficient triangle strip
Geometry splitting along block borders
Terrain Rendering - 2
Advanced TechniquesOcclusion Culling
Levels of Detail (adapt complexity dynamically)
But: efficient preparation for hardware more important than LOD!
HeightmapsDraw manually
Use tools (Terragen)
Generate (fractals/midpoint displacement, …)
Space Partitioning - 1
Needed for various culling/visibility techniquesReduces amount of calculations needed
Quadtrees, Octrees, BSP Trees, …
Beware of memory requirementsBalance tree height VS geometry per partition (empirically)
View Frustum CullingFast 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 visibleA1, A2, A3, A4 visible
B invisibleC visible
C1 invisibleC2 visibleC3, C4 invisible
D invisible→ render A1, A2, A3, A4, C2
Efficient OpenGL - Geometry
Use OpenGL vertex arrays forNormals
Texture-coordinates
Vertex-coordinates
Use indexed geometrySaves 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 GeometryNot 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 ObjectsAllows for storing vertex data in video memory
Further information (strongly recommended!):
http://developer.nvidia.com/object/using_VBOs.html
http://oss.sgi.com/projects/ogl-sample/registry/ARB/vertex_buffer_object.txt
Efficient OpenGL – Extensions
SGI MipmappingUses hardware to generate mipmaps automatically
Faster than gluBuild2DMipmaps(…)
Further information:
http://developer.nvidia.com/object/gdc2001_automatic_mipmap.html
http://oss.sgi.com/projects/ogl-sample/registry/SGIS/generate_mipmap.txt
Efficient OpenGL – Extensions
Texture compressionReduces traffic on memory bus
Decreases load-time when stored compressed on hard-disk
Further information:
http://developer.nvidia.com/object/texture_compression_OpenGL.html
http://oss.sgi.com/projects/ogl-sample/registry/ARB/texture_compression.txt
top related