1. Computer Graphics Introducing DirectX
CO2409 Computer Graphics
Week 5-2

2. Today’s Lecture Terminology A History DirectX Components
DirectX 10 and 11
Overview of the Direct3D Pipeline
Programming Direct3D – First Steps

3. Terminology DirectX is an SDK DirectX contains a set of APIs
Software Development Kit
Set of software tools, APIs and documentation to enable development of specialist software
DirectX contains a set of APIs
Application Program Interface
An API is a definition of how to interface with (i.e. use) some other software or device
DirectX interfaces with the hardware drivers
These APIs take the form of libraries of functions and types that can be used in C++, C# etc.
[Gamers: The TL-Engine is also an API]

4. DirectX – A History Conceived in 1994
Intended to provide low-level access to system resources within a high-level OS
First few iterations were fairly unusable
However, by DirectX 5 provided a reasonable development platform
Later versions have been developed in close collaboration with hardware vendors
Windows XP supports up to DirectX 9.0c
Windows Vista and 7 can use DirectX 11
Vista needs an update for DX11
DirectX is now part of the core Windows SDK rather than a stand-alone download

5. DirectX Components DirectX contains many components
We are mainly interested in Direct3D:
2D and 3D graphics
Low level control for performance
Higher level “helper” classes and functions for ease of use
DirectX also contains:
DirectInput
For keyboard, mouse, joystick & other input devices.
Replaced in part by the XInput API (Xbox related)
GDI+, for drawing high quality text
A large number of deprecated components…

6. Older Components
DirectX is generally backwards compatible with previous versions
So a DX9 program will work in DX11 for example
Many out-of-date components are still usable:
DirectSound – Replaced by XAudio2 or XACT
DirectDraw – 2D drawing, superseded
DirectPlay – Network gaming, deprecated
DirectShow – Video playback, superseded
DirectMusic – Music playback, deprecated
These components should be avoided
Ensure you read the latest documentation
Avoid tutorials for older versions of DirectX

7. DirectX Graphics The DirectX SDK provides:
An API: a set of functions and classes
We will use this extensively (in C++)
Full documentation, tutorials and samples
Very useful reference
Development Tools, mainly regarding textures, and pixel, vertex & geometry shaders
We will see a little of these
To use the SDK you should
Get the last standalone version (June 2010)
Ensure your windows is up to date
Optionally get the Windows SDK for the latest tools / support
CM142 is ready for DirectX development

8. DirectX 10
DirectX 10 is a major update over DirectX 9, compatible only with Windows Vista and above
Key changes:
Refined architecture to suit Vista / Win 7
The Windows GUI is now DirectX driven (Aero)
Requires minimum specification for hardware
Less need for fall-back techniques on weaker hardware
Adds geometry shaders
Manipulate/generate triangles at render-time
Shaders can write back to GPU memory
Shaders can dynamically update geometry
Reduce CPU work, e.g. particle system entirely on GPU

9. DirectX 11 DirectX 11 is strict superset of DirectX 10
Far fewer changes than from DX9 to DX10
DX10 code works almost without change in DX11
Supported on Windows 7 natively
Windows Vista needs an update
Officially released October 2000
DirectX 11.1 is supported by Windows 8 only
Mainly improved multi-core / multi-threading support
Only minor changes regarding graphics
Will use Direct3D 10 on Windows 7 in this module
D3D10 is different in many features/details to D3D9
DX11 contains only a few graphics changes which are not important for this module

10. DirectX Graphics Pipeline
The operation of D3D can be illustrated as a ‘pipeline’ of operations
From input 3D geometry to final pixel rendering
This diagram is for DX10
We will look at most stages over the next few weeks
Roughly in order
Reproduced from the DirectX SDK documentation

11. Pipeline: Input Stage We first send 3D geometry to the input-assembler
The 3D elements in our scene
Artistic, technical or abstract, whatever suits our application
In any case the input is 3D meshes: vertices / polygons
2D elements can be rendered by using flat 3D geometry
Usual to create/load geometry in CPU memory, then send to DX
This 3D geometry is in the form of “triangle strips”, a method of storing geometry using less memory

12. Pipeline: Shaders Intro
Most stages of the pipeline operate automatically with only some limited setup:
We set states that determine how that stage will work
E.g. We can set states to perform additive or multiplicative blending in the final output stage
However, 3 pipeline stages are programmable
The vertex, geometry and pixel stages
We write programs to make these parts operate
These programs are called shaders
Written in a new language – we will use HLSL
Shaders gives immense flexibility in exactly how the pipeline will operate

13. Pipeline: Vertex Shader
The vertex shader stage is primarily responsible for:
Positioning the geometry in the overall 3D scene
Transforming 3D geometry into 2D geometry ready to render
Other geometry processing
E.g. animation, deformation
Transformation from 3D to 2D geometry
Will need to introduce some maths concepts
Matrices and transformations
Plus the idea of a camera and 2D projection
Will revisit the idea of different coordinate systems
E.g. World space, camera space

14. Geometry Shader & Rasterisation
The vertex shader just described works on vertices one-by-one
Next the geometry shader works on entire triangles in a mesh
Used for special purposes
Will not see this stage in this module
The rasterization stage processes each finalized triangle
Determine all the pixels that are inside
Calls the pixel shader for each
Automated stage (no shader)
Rasterization stage scans the 2D triangle geometry to determine all the pixels within
The Pixel Shader stage is called for each one

15. Pixel Shader Stage
The pixel shader stage works on every pixel in our scene
This shader program needs to be efficient – millions of pixels
The pixel shader simply determines the colour required for each pixel
This is a simple concept but involves many techniques:
Textures, lighting, normal mapping, environment mapping, special effects (like cell shading), etc.
Pixel shader effect to give the impression of depth to a surface that is actually flat

16. Pipeline: Lighting
We can calculate lighting in one of the shader stages
Usually the pixel shader
Three main kinds of lights
Directional lights
Point lights
Spot lights
The effects are calculated with some simple vector mathematics
Note that shadows are dealt with separately from lights
Shadows are much more complex and require processing at several stages
Light Types

17. Output Stage The final stage outputs pixels onto the viewport
However, we may wish to blend the new pixel colours with those already on the viewport
To create transparency effects
Same effects we saw when working with sprites
E.g. Additive, multiplicative, alpha blending
So this stage is actually called the output-merger stage
This summary has covered all the pipeline stages
Except the Stream-Output stage, which we won’t use (it allows the graphics pipeline to update the geometry it is working on)
The overall process is similar for other graphics APIs

18. Direct3D Programming – First Steps
First create a bare minimum Windows application
Need a window to render into (even for a full screen app)
Initialise DirectX and point it at our window
This stage is fairly standard for all DX applications
Prepare some 3D geometry to render
Type in something simple (e.g. a single triangle or a cube)
Or load geometry from a file (involves parsing)
Send the geometry to DirectX
Set the minimum states to initialise the pipeline stages
Then render: a single call will now trigger the pipeline and process / draw our geometry