GAM531DPS931 – Week 1Introduction
Professors
Joseph Hughes
Info:
• scs.senecac.on.ca/~jp.hughes
• T2104
Roles:
• Primary Lecturer
• Modern API Wizard
Chris Szalwinski
Info:
• scs.senecac.on.ca/~chris.szalwinski
• T2093
Roles:
• Mathematical Genius
• DPS931 Overlord
So what does this course teach you?
Not This This
So we will be making 3D games?
Not Games…Game Engines
What is an game engine?• Think of a car…
Gam
e L
ogic HP = 10;DMG = 20;Player.attack();LoadLevel(10);Enemy.Spawn();RenderScene();
Gam
e
Engin
e glEnable(GL_BLEND);glBindBuffer(bufferID);glBindTexture(textureID);glDrawElements(size, data);
Gam
e
Outp
ut
• And now for some code…
Some Examples…
???Engine
Game
Logic
How is an engine structured?
Engine
Core
Client Interfac
e
Operating
System API
Device API
Separation of concepts
HARDWARE
FIRMWARE
OS API DEVICE API
APPLICATION
CPUGPUCHIPSET
DRIVERS
Window CreationConsole WriteInput detection Your Program
Open GL 4.3DirectX 11
Why do we need Device APIs?• OS APIs are slow
• Indirect, limited functionality
• Unable to harness true potential of hardware
• Device APIs are fast!
• Give nearly direct control over the device
• Specialized to fit to fit programmer’s needs
What devices are we using?• We will be making use of the Graphics Processing Units (GPU)
• GPUs are highly parallelized processing units made for graphical processing
• GPUs can come as discrete Graphics Cards or Integrated Chips with your mother board or CPU (APUs)
To recap…
Application
Device APIs
Firmware
Hardware
// Set up the description of the static index buffer.indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount;indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;indexBufferDesc.CPUAccessFlags = 0;indexBufferDesc.MiscFlags = 0;indexBufferDesc.StructureByteStride = 0;
// Give the subresource structure a pointer to the index data.indexData.pSysMem = indices;
// Create the index buffer.result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer);
// Set the depth buffer to be entirely cleared to 1.0 values.glClearDepth(1.0f);
// Enable depth testing.glEnable(GL_DEPTH_TEST);
// Set the polygon winding to front facing for the left handed system.glFrontFace(GL_CW);
// Enable back face culling.glEnable(GL_CULL_FACE);glCullFace(GL_BACK);
// Initialize the world/model matrix to the identity matrix.BuildIdentityMatrix(m_worldMatrix);
The ultimate goal –
To render a 3D world to the screen
Engine recap
Engine
Core
Client Interfac
e
Operating
System API
Device API
Into the Emperor Engine
Engine
DX11 Devic
e
GL 4.3
Device
Controller
Manager
Model
DX11 Objec
t
GL 4.3
Object
DX 11 API
GL 4.3 API
DX 11 API
GL 4.3 API
1 m
1 m
1 m
1 1 or1
1 or 1
1
iEngine
iController iModel
Stepping into the Engine
iEngine.hpp
namespace Emperor { class iEngine {…}; }
Engine.hpp
namespace Emperor { template <RenderSystem RS> class Engine : public iEngine, public Singleton<Engine<RS>> {…}; }
Reviewing Namespaces
struct Foo { int a;};
namespace Bar { struct Foo { ::Foo a; }; namespace Derp { struct Foo { Bar::Foo a; }; }}
int main() { Foo a; Bar::Foo b; Bar::Derp::Foo c;}
or
using namespace Bar;int main() { ::Foo a; Bar::Foo b; Derp::Foo c;}
Reviewing Pure Virtual Classes (Interfaces) virtual
void doStuff()
= 0;
• Interface
virtual void
doStuff() {…}
• Derived Class
void doStuff()
{…}
• Most Derived Class
class iThing { virtual void doStuff() = 0;};class Thing : public iThing { virtual void doStuff() { std::cin << “Thing”; }};class BigThing : pulic Thing { void doStuff() { std::cin << “BigThing”; }};
int main() { Thing* a = new Thing(); a->doStuff();};
int main() { Thing* a = new BigThing(); a->doStuff();};
int main() { //iThing* a = new iThing(); iThing* a = new BigThing(); a->doStuff();};
The Engine Interface class iEngine { private: friend iEngine* createEngine(RenderSystem); friend void releaseEngine(iEngine*); protected: virtual ~iEngine() {} public: virtual void initialize() = 0; virtual void release() = 0; virtual void setFullScreen(bool) = 0; virtual bool isFullScreen() = 0; virtual void activateDevice(iWindow*) = 0; virtual iResourceController* getResourceController() = 0; virtual iSceneController* getSceneController() = 0; virtual void render() = 0; };
Create & Destroy Engine (Friends
for Dynamic Linking)
Retrieve Controllers
Activates Device for rendering
Render a Single Frame
Initialize and Release Engine Assets
Back to the Engine
iEngine.hpp
namespace Emperor { class iEngine {…}; }
Engine.hpp
namespace Emperor { template <RenderSystem RS> class Engine : public iEngine, public Singleton<Engine<RS>> {…}; }
Template Reviewtemplate <class T>class Foo { T a; public: Foo() {a = 0;} void doStuff();};
int main() {
}
Foo<int> a; Foo<float> b; Foo<char*> c;
class Foo_of_int { int a; public: Foo() {a = 0;} void doStuff() { std::cout << “Foo”; }};class Foo_of_float { float a; public: Foo() {a = 0;} void doStuff() { std::cout << “Foo”; }};
template <>void Foo<char*>::doStuff() { std::cout << “Char* Foo”;};
template <class T>void Foo<T>::doStuff() { std::cout << “Foo”;};
class Foo_of_char_ptr { char* a; public: Foo() {a = 0;} void doStuff() { std::cout << “Char* Foo”; }};
Template Specialization Review…template <RenderSystem RS>class Device{};template <>class Device<RS_DX11> { private: IDXGISwapChain* swap; ID3D11Device* dev; ID3D11DeviceContext* con; …};
template<>class Device<RS_GL43> { private: HGLRC context; HDC hdc; …};
int main() {
}
Device<RS_DX11> a; Device<RS_GL43> b; Device<RS_GL43 + 1> c;
Template Misc. Reviewtemplate <class T = int, int N = 4>class Foo { T a[N];};
int main() {
}
Foo<int, 4> a; Foo<int> b; Foo<> c;
All three are the same!
file.hpp
template <class T>class Foo { T a; public: void doStuff();};
file.cpp
template <class T>void Foo<T>::doStuff() { std::cout << “Foo”;};
Compiler does
nothing!Linker can’t
find function!
template class Foo<int>;template class Foo<float>;
Compiles for int and float, can only be
bound to those!
Finishing Recap• This course is all about engine development!
• An engine is framework that enables programmers to accomplish complex tasks with relative ease
• A system API is an interface that exposes a set of functions to provide programmers with control and functionality that would otherwise be out of grasp
• Device APIs like DirectX 11 and OpenGL 4.3 allow a more direct and more efficient method interfacing with the firmware controlling the hardware
• The GPU is a highly parallelized processing unit designed for 3D graphic rendering
• You got a glimpse of the Emperor Engine’s design
Course Breakdown• Please read the course outline on the ICT website!
• Mark breakdown:
• Labs are worth 2% each, if a lab is not complete by the end of the day the highest mark achievable on the lab is ½.
• You are expected to know how to use git and Visual Studio 2013, there will be a review of them next class
• A laptop or desktop computer with a modern GPU is highly recommended
Labs (10) 20%
Assignment (1) 30%
Mid-term 20%
Exam 30%
To Do• Install Visual Studio 2013 on your personal computers
• Install most recent DirectX SDK on your personal computers
• Update the graphics drivers of you personal computer (must support OpenGL 4.3)
• Create a BitBucket account if you don’t already have one