CS361
-
Upload
raphael-yang -
Category
Documents
-
view
32 -
download
5
description
Transcript of CS361
CS361Week 1 - Friday
Last time
What did we talk about last time? C# SharpDX
Questions?
More SharpDX Examples
Review of SharpDX
Program creates a MyGame (or similar) object and starts it running
MyGame has: Initialize() LoadContent() Update() Draw()
It runs an update-draw loop continuously until told to exit
Drawing text
Modern TrueType and OpenType fonts are vector descriptions of the shapes of characters Vector descriptions are good for quality,
but bad for speed SharpDX allows us to take a vector-
based font and turn it into a picture of characters that can be rendered as a texture Just like everything else
Drawing text continued
It's easiest to check the SpriteFont box when creating a SharpDX Toolkit project
It will create an XML file called Arial16.xml This file specifies the Arial font at size 16
Edit the XML to pick the font, size, and spacing You will need multiple Sprite Fonts even for
different sizes of the same font You can create your own XML file by copying it
Make sure you change the Build Action to ToolkitFont
Note: fonts have complex licensing and distribution requirements
Drawing a font continued
Load the font similar to texture content
Add a DrawString() call in the Draw() method:spriteBatch.Begin();
spriteBatch.DrawString(font, "Hello, World!", new Vector2(100, 100), Color.Black);
spriteBatch.End();
font = Content.Load<SpriteFont>("Arial16");
Why are they called sprites? They "float" above the
background like fairies… Multiple sprites are often
stored on one texture It's cheaper to store one big
image than a lot of small ones
This is an idea borrowed from old video games that rendered characters as sprites
Drawing sprites with rotation
It is possible to apply all kinds of 3D transformations to a sprite A sprite can be used for billboarding or
other image-based techniques in a fully 3D environment
But, we can also simply rotate them using an overloaded call to Draw()
spriteBatch.Draw(texture, location,sourceRectangle, Color.White, angle, origin, 1.0f, SpriteEffects.None, 1);
Let's unpack that
texture: Texture2D to draw location: Location to draw it sourceRectangle Portion of image Color.White Full brightness angle Angle in radians origin Origin of rotation 1.0f Scaling SpriteEffects.None No effects 1 Float level
Student Lecture: Graphics Rendering Pipeline and Application Stage
Graphics Rendering Pipeline
Rendering
What do we have? Virtual camera (viewpoint) 3D objects Light sources Shading Textures
What do we want? 2D image
Pipelines
The idea of a pipeline is to divide a task into independent steps, each of which can be performed by dedicated hardware
Example RISC pipeline:1. Instruction fetch2. Decode3. Execute4. Memory Access5. Writeback
Pipeline performance
If you have an n stage pipeline, what's the maximum speedup you can get?
Consider a TV show with the following pipeline1. Write2. Rewrite3. Film4. Edit
Assume each step takes 1 week How much total time does it take to produce a 13
episode season? What if there was no pipelining? Note that a pipeline's speed is limited by its
slowest stage, the bottleneck
Graphics rendering pipeline For API design, practical top-down problem
solving, and hardware design, and efficiency, rendering is described as a pipeline
This pipeline contains three conceptual stages:
Produces
material to be
rendered
Application
Decides what, how, and
where to
render
Geometry
Renders the final image
Rasterizer
Architecture
These conceptual stages may or may not be running at the same time
Each conceptual stage may contain its own internal pipelines or parallel execution
Speed
A critical concern of real time rendering is the rendering speed, determined by the slowest stage in the pipeline
We can measure speed in frames per second (fps), common for average performance over time
We can also measure speed in Hertz (Hz), common for hardware
Rendering speed example Output device has a maximum update
frequency of 60 Hz (very common for LCD's)
The bottleneck rendering stage is 62.5 ms What's our rendering speed?
1/0.0625 = 16 fps 60/1 = 60 fps 60/2 = 30 fps 60/3 = 20 fps 60/4 = 15 fps 60/5 = 12 fps
Application Stage
Application stage
The application stage is the stage completely controlled by the programmer
As the application develops, many changes of implementation may be done to improve performance
The output of the application stage are rendering primitives Points Lines Triangles
Important jobs of the application stage
Reading input Managing non-graphical output Texture animation Animation via transforms Collision detection Updating the state of the world in
general
Acceleration
The Application Stage also handles a lot of acceleration
Most of this acceleration is telling the renderer what NOT to render
Acceleration algorithms Hierarchical view frustum culling BSP trees Quadtrees Octrees
Hierarchical view frustum culling
An application can remove those objects that are not in the cone of visibility
Hierarchies of objects can be used to make these calculations easier
BSP Trees
Splitting planes are made through polygons to repeatedly subdivide the polygons in a scene in half
Often, BSP Trees are calculated a single time for complex, static scenes
Quadtrees and Octrees
Like BSP's, the space can be repeatedly subdivided as long as it contains a number of objects above a certain threshold
Octrees divide the space in three dimensions while quadtrees only focus on two
Upcoming
Next time…
Rendering pipeline Geometry stage
Reminders
Send me teams by today! Keep reading Chapter 2
Focus on 2.3No class on Monday