soc research
TRANSCRIPT
![Page 1: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/1.jpg)
Dr Bryan DugganDIT School of Computing
[email protected]@ditcomputing
http://facebook.com/ditschoolofcomputing
BGE: An open-source framework for teaching component
based games development in C++
![Page 2: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/2.jpg)
Questions we will answer today
• What is BGE?• Motivation• How are 3D Graphics rendered?• Calculating the world transform• Calculating the view & projection transforms• Component based development• Examples in BGE
![Page 3: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/3.jpg)
Motivation
• Game Engines• DirectX/ODE• XNA/BEPU• Unity? OpenGL? Havok?• Anarchy?• BGE• Learning loads of new tech• Improve my C++• Learn best practices
![Page 4: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/4.jpg)
How does BGE Work?
• OpenGL for rendering– Vertex shaders & Fragment shaders (OpenGL 4)
• GLEW– The OpenGL Extension Wrangler Library (GLEW) is a cross-
platform open-source C/C++ extension loading library. GLEW provides efficient run-time mechanisms for determining which OpenGL extensions are supported on the target platform. OpenGL core and extension functionality is exposed in a single header file. GLEW has been tested on a variety of operating systems, including Windows, Linux, Mac OS X, FreeBSD, Irix, and Solaris.
• GLM– OpenGL Maths Library
![Page 5: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/5.jpg)
• SDL - Simple DirectMedia Library– A cross-platform multimedia library designed to provide fast access to the
graphics framebuffer and audio device.– Initialises OpenGL– Creates the OpenGL context– Provides an abstraction for keyboard/mouse/joystick– SDL_TTF for TTF Font support
• FMOD – Closed source Xplatform audio library– FMOD is a programming library and toolkit for the creation and playback of
interactive audio.– MP3/WAV/MIDI playback– 3D Audio– Occlusion/doppler/effects etc– Free for non-commercial use
![Page 6: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/6.jpg)
• Bullet– Bullet 3D Game Multiphysics Library provides state of the art
collision detection, soft body and rigid body dynamics.– Rigid bodies, constraints etc– A solver
• C++– Smart pointers – shared pointers– STL
• git– Labs, lectures, solutions– Git/github is amazing. You should use it.– Mandated for all DT228/DT211 students now
![Page 7: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/7.jpg)
How are 3D Graphics Rendered in BGE?
Vertex data in world
spaceVertex shader
Fragment Shader
Model/World MatrixView Matrix
Projection MatrixNormal Matrix
MVP Matrix
Textures
Screen
![Page 8: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/8.jpg)
I prefer…
Model/World View Projection
ViewportClippingVertices
Places the model in the world
relative to all the other objects
Transforms everything
relative to the camera (0,0,0) looking down
the –Z Axis
Projects everything
onto a 2D plane. Far away
objects aresmaller
Often does nothing special
but can be a different
render target(such as a texture)
The vertices as they come outof a 3D modelling
program.The centre of the model isusually the
origin
![Page 9: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/9.jpg)
Calculating the world transform
• Combination of the position, orientation and scale– Position & scale & vectors– Orientation is a quaternion
• world = glm::translate(glm::mat4(1), position) * glm::mat4_cast(orientation) * glm::scale(glm::mat4(1), scale);
![Page 10: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/10.jpg)
Movement/rotation
• Walk• Strafe• Yaw• Pitch• Roll
![Page 11: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/11.jpg)
Calculating the View Transform
view = glm::lookAt(position, position + look, basisUp);GLM_FUNC_QUALIFIER detail::tmat4x4<T> lookAt(detail::tvec3<T> const & eye,detail::tvec3<T> const & center,detail::tvec3<T> const & up)
![Page 12: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/12.jpg)
Calculating the Projection Transform
• projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 10000.0f);GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspective(valType const & fovy, valType const & aspect, valType const & zNear, valType const & zFar)
![Page 13: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/13.jpg)
The Game loop
• Initialise()• While (true)– Update(timeDelta)– Draw()
• End while• Cleanup()
![Page 14: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/14.jpg)
What are design patterns?
• A very famous book• Published in 1994• Common solutions to
problems in software developmnent
• Part 1– The capabilities and pitfalls of
object-oriented programming• Part 2
– 23 classic software design patterns
![Page 15: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/15.jpg)
Principles• Program to an 'interface', not an 'implementation‘
– Clients are unaware of the specific types of objects they use, as long as the object adheres to the interface
– Clients remain unaware of the classes that implement these objects; clients only know about the abstract class(es) defining the interface
• Interfaces lead to dynamic binding and polymorphism (central features of object-oriented programming).
• Inheritance is referred to as white-box reuse– The internals of parent classes are often visible to subclasses
• Object composition is black-box reuse – No internal details of composed objects need be visible in the code using them
• "Because inheritance exposes a subclass to details of its parent's implementation, it's often said that 'inheritance breaks encapsulation'“
• Using inheritance is recommended mainly when adding to the functionality of existing components, reusing most of the old code and adding relatively small amounts of new code
![Page 16: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/16.jpg)
Some examples• Creational
– Factory– Prototype– Singleton
• Structural– Adapter– Composite– Decorator– Proxy
• Behaviorable– Interpreter– Iterator– Observer– State
![Page 17: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/17.jpg)
Some more!
• Lazy loading– Loading on demand. Defer initialization of an
object until the point at which it is needed• Instancing– Rendering multiple copies of the same mesh in a
scene at once• Controller– Update a game objects state based on
circumstance
![Page 18: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/18.jpg)
Some goals for BGE (or any other game engine)
• Keep track of everything in the scene• Allow game objects to be assembled from
components – increase code reuse and flexibility
• Allow easy creation of composite objects such as physics objects
• Allow lazy loading of game assets• Support instancing• State management of game components
![Page 19: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/19.jpg)
Object Oriented Game Engines• Are terrible. I know I made one (Dalek World)• Consider:
![Page 20: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/20.jpg)
Problems!
• Each new piece of functionality you want to add to a class becomes a new (more specific class)
• Too many classes• No flexibility• Tight coupling
![Page 21: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/21.jpg)
A better approach
• The aggregate design pattern
Game Component
Initialise()Update(timeDelta)Draw()Cleanup()Attach(GameComponent c)list<GameComponent> children
0..*
![Page 22: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/22.jpg)
Architecture?
• GameObjects, GameComponents and Transforms– Circular dependancies – Difficult to compile in C++
• GameComponents with own transforms– Rules for copying transforms– Lots of duplication
• GameComponents with shared transforms– BGENA2– How to store transform hierarchies?– Duplicated calculations
![Page 23: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/23.jpg)
Component Based Games Engines
• Everything in BGE is a component• Most things extend GameComponent– virtual bool Initialise();– virtual void Update(float timeDelta);– virtual void Draw();– virtual void Cleanup();
• GameComponent’s keep track of a list of children components & parent component– std::list<std::shared_ptr<GameComponent>> children;
• This is known as the aggregate design pattern
![Page 24: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/24.jpg)
Each GameComponent has:
• GameComponent * parent;• glm::vec3 velocity;• std::list<std::shared_ptr<GameComponent>>
children;• std::shared_ptr<Transform> transform;• Shared!
![Page 25: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/25.jpg)
The base class GameComponent
• Holds a list of GameComponent children references• Use Attach() to add something to the list.• Calls Initialise, Update and Draw on all children• All subclasses do their own work first then• Must call the base class member function so that the
children get Initialised, Updated and Drawn!– Are these depth first or breadth first?
• This means that the scene is a graph of objects each contained by a parent object
• The parent object in BGE is the Game instance
![Page 26: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/26.jpg)
bool GameComponent::Initialise(){
// Initialise all the childrenstd::list<std::shared_ptr<GameComponent>>::iterator it = children.begin();while (it != children.end()){
(*it ++)->initialised = (*it)->Initialise();}return true;
}
![Page 27: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/27.jpg)
void GameComponent::Cleanup(){
// Cleanup all the childrenstd::list<std::shared_ptr<GameComponent>>::iterator it =
children.begin();while (it != children.end()){
(*it ++)->Cleanup(); }
}void GameComponent::Draw(){
// Draw all the childrenstd::list<std::shared_ptr<GameComponent>>::iterator it =
children.begin();while (it != children.end()){
if ((*it)->worldMode == GameComponent::from_parent){
(*it)->parent = this;(*it)->UpdateFromParent();
}(*it ++)->Draw();
}}
The child object is controlled by the parent it is attached toAn example is a model
![Page 28: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/28.jpg)
The parent is controlled by a childThe child is known as a Controller
void GameComponent::Update(float timeDelta) {
switch (worldMode){
case world_modes::from_self:world = glm::translate(glm::mat4(1), position) * glm::mat4_cast(orientation) * glm::scale(glm::mat4(1), scale);break;case world_modes::from_self_with_parent:world = glm::translate(glm::mat4(1), position) * glm::mat4_cast(orientation) * glm::scale(glm::mat4(1), scale);if (parent != NULL){world = (glm::translate(glm::mat4(1), parent->position) * glm::mat4_cast(parent->orientation)) * world;}break;case world_modes::to_parent:
world = glm::translate(glm::mat4(1), position) * glm::mat4_cast(orientation) * glm::scale(glm::mat4(1), scale);parent->world = glm::scale(world, parent->scale);parent->position = this->position;parent->up = this->up;parent->look = this->look;parent->right = this->right;parent->orientation = this->orientation;
break;
}RecalculateVectors();moved = false;
// Update all the childrenstd::list<std::shared_ptr<GameComponent>>::iterator it = children.begin();while (it != children.end()){
if (!(*it)->alive){it = children.erase(it);}else{(*it ++)->Update(timeDelta);}
}}
![Page 29: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/29.jpg)
![Page 30: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/30.jpg)
Attaching!
• You can attach a component to another component:
child->parent = this;// All my children share the same transform if they dont already have one...if (child->transform == nullptr){child->transform = transform; }children.push_back(child);
![Page 31: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/31.jpg)
Transform object
• glm::vec3 position;• glm::vec3 look;• glm::vec3 up;• glm::vec3 right;• glm::vec3 scale;• glm::vec3 velocity;• glm::mat4 world;• glm::quat orientation;• glm::vec3 ambient;• glm::vec3 specular;• glm::vec3 diffuse;
![Page 32: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/32.jpg)
Member functions
• void Strafe(float units); • void Fly(float units); • void Walk(float units);
• void Pitch(float angle); // rotate on right vector
• void Yaw(float angle); // rotate on up vector• void Roll(float angle); // rotate on look vector
![Page 33: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/33.jpg)
Yaw Example
• void GameComponent::Yaw(float angle)• {• // A yaw is a rotation around the global up
vector• glm::quat rot = glm::angleAxis(angle,
GameComponent::basisUp);• orientation = rot * orientation;• }
![Page 34: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/34.jpg)
![Page 35: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/35.jpg)
Making game objects from components
• You can use these rules to assemble composite objects together. For example:– A component with a model attached and a
steeringcontroller attached– The steeringcontroller shares the parent world
transform – The model gets its world from the parent– You can attach different controllers to get different
effects. – Examples…
![Page 36: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/36.jpg)
1
8 7
65
432
911
10
![Page 37: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/37.jpg)
Using steeringbehaviours
• SteeringController implements lots of cool steering behaviours such as follow_path, seek, obstacle_avoidance
• Can be attached to anything and it will update the world transform of the thing it’s attached to
• See 9 & 11 for examples• 12 is just a textured model. Nothing special• An example in code…
![Page 38: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/38.jpg)
• //// from_self_with_parent• station = make_shared<GameComponent>();• station->worldMode = world_modes::from_self;• station->ambient = glm::vec3(0.2f, 0.2, 0.2f);• station->specular = glm::vec3(0,0,0);• station->scale = glm::vec3(1,1,1);• std::shared_ptr<Model> cmodel = Content::LoadModel("coriolis", glm::rotate(glm::mat4(1),
90.0f, GameComponent::basisUp));• station->Attach(cmodel);• station->Attach(make_shared<VectorDrawer>(glm::vec3(5,5,5)));• Attach(station);
• // Add a child to the station and update by including the parent's world transform• std::shared_ptr<GameComponent> ship1 = make_shared<GameComponent>();• ship1->worldMode = world_modes::from_self_with_parent;• ship1->ambient = glm::vec3(0.2f, 0.2, 0.2f);• ship1->specular = glm::vec3(1.2f, 1.2f, 1.2f);• std::shared_ptr<Model> ana = Content::LoadModel("anaconda", glm::rotate(glm::mat4(1),
180.0f, GameComponent::basisUp));• ship1->Attach(ana);• ship1->position = glm::vec3(0, 0, -10); // NOTE the ship is attached to the station at an offset
of 10• station->Attach(ship1);.
![Page 39: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/39.jpg)
VR
• Render the scene twice– Left eye and right eye
• Split the screen in two• Combine quaternion from Xbox controller
with quaternion from rift
![Page 40: Soc research](https://reader035.vdocuments.net/reader035/viewer/2022062313/55858d90d8b42ae41d8b53d2/html5/thumbnails/40.jpg)
What I learned
• OpenGL• Shaders• Game engine deisign• OO with components• Git• Circular depedancies• 2 leap motion projects, 5 pull requests!• I love programming!