Lab 1 Sample Code. Giuseppe Maggiore

Transcription

1 Lab 1 Sample Code Giuseppe Maggiore

2 Preliminaries using Vertex = VertexPositionColor; First we define a shortcut for the type VertexPositionColor. This way we could change the type of Vertices used without having to change a lot in the remaining code.

3 Loading Effect effect; VertexDeclaration vertex_layout; VertexBuffer vertices; Camera.Camera main_camera; We declare inside the Game1 class a few members: 1. A n effect, the computation used to put vertices on screen and color them 2. A vertex declaration which describes byte per byte the layout of data found in a vertex; it contains an array of tuples (first_byte, num_bytes, type, semantics) which are, for VertexPositionColor: 1. (0,12,Vector3,POSITION0) 2. (11,4,byte4,COLOR0) 3. A vertex buffer which contains a copy of the array of vertices we wish to draw 4. A camera which handles a view and a projection matrix and some input; note that to use the Camera.Camera class you must add a reference to MainApp.exe, attached to this exercise on the course webpage

4 Loading protected override void LoadContent() vertices = new VertexBuffer(GraphicsDevice, Vertex.SizeInBytes * NumVertices, BufferUsage.WriteOnly); vertex_layout = new VertexDeclaration(GraphicsDevice, Vertex.VertexElements); vertices.setdata(vertices_array); effect = Content.Load<Effect>(@"Content\SimpleEffect"); main_camera = new Camera.Camera(GraphicsDevice, Vector3.Backward, Quaternion.Identity, 0.01f, f, GraphicsDevice.Viewport, GraphicsDevice.Viewport, Camera.WASDKeyboadMapping, 1.0f); First we initialize a vertex buffer. This is similar to a malloc, only it allocates a buffer in video memory. The vertex buffer constructor takes the video card where to allocate, the number of bytes to allocate and the kind of access we will do to the allocated memory.

5 Loading protected override void LoadContent() vertices = new VertexBuffer(GraphicsDevice, Vertex.SizeInBytes * NumVertices, BufferUsage.WriteOnly); vertex_layout = new VertexDeclaration(GraphicsDevice, Vertex.VertexElements); vertices.setdata(vertices_array); effect = Content.Load<Effect>(@"Content\SimpleEffect"); main_camera = new Camera.Camera(GraphicsDevice, Vector3.Backward, Quaternion.Identity, 0.01f, f, GraphicsDevice.Viewport, GraphicsDevice.Viewport, Camera.WASDKeyboadMapping, 1.0f); Secondly we initialize the vertex declaration, passing it the video card where the description will be active and the array of byte blocks-semantics which is the actual layout.

6 Loading protected override void LoadContent() vertices = new VertexBuffer(GraphicsDevice, Vertex.SizeInBytes * NumVertices, BufferUsage.WriteOnly); vertex_layout = new VertexDeclaration(GraphicsDevice, Vertex.VertexElements); vertices.setdata(vertices_array); effect = Content.Load<Effect>(@"Content\SimpleEffect"); main_camera = new Camera.Camera(GraphicsDevice, Vector3.Backward, Quaternion.Identity, 0.01f, f, GraphicsDevice.Viewport, GraphicsDevice.Viewport, Camera.WASDKeyboadMapping, 1.0f); Thirdly we copy an array of vertices into the vertex buffer.

7 Loading protected override void LoadContent() vertices = new VertexBuffer(GraphicsDevice, Vertex.SizeInBytes * NumVertices, BufferUsage.WriteOnly); vertex_layout = new VertexDeclaration(GraphicsDevice, Vertex.VertexElements); vertices.setdata(vertices_array); effect = Content.Load<Effect>(@"Content\SimpleEffect"); main_camera = new Camera.Camera(GraphicsDevice, Vector3.Backward, Quaternion.Identity, 0.01f, f, GraphicsDevice.Viewport, GraphicsDevice.Viewport, Camera.WASDKeyboadMapping, 1.0f); At this point we load the effect from a file or we initialize it as a basic effect with Effect = new BasicEffect(GaphicsDevice, null). The difference is that in one case we are writing the shader itself, while in the other case we are simply instancing a preexisting shader.

8 Loading protected override void LoadContent() vertices = new VertexBuffer(GraphicsDevice, Vertex.SizeInBytes * NumVertices, BufferUsage.WriteOnly); vertex_layout = new VertexDeclaration(GraphicsDevice, Vertex.VertexElements); vertices.setdata(vertices_array); effect = Content.Load<Effect>(@"Content\SimpleEffect"); main_camera = new Camera.Camera(GraphicsDevice, Vector3.Backward, Quaternion.Identity, 0.01f, f, GraphicsDevice.Viewport, GraphicsDevice.Viewport, Camera.WASDKeyboadMapping, 1.0f); Finally we initialize the camera, passing it the graphics device, the eye position, the initial rotation, the near and far planes, the viewport that this camera will draw its scene to and the viewport of the entire screen. Notice that main_camera draws on the entire screen.

9 Update protected override void Update(GameTime gametime) Utilities.keyboard_state = Keyboard.GetState(); base.update(gametime); In the Update method we read the keyboard state and we pass it to the camera so that it will be able to handle input.

10 Draw protected override void Draw(GameTime gametime) GraphicsDevice.Viewport = main_camera.viewport; draw_all(color.cornflowerblue, main_camera); base.draw(gametime); For each camera we set its viewport to the graphics device, this way enforcing all draw calls to write only the pixels in the area defined by the viewport. After setting the viewport we call the draw_all method which should use the effect we loaded to draw all of our vertex buffers.

11 Draw void draw_all(color clear_color, Camera.Camera camera) GraphicsDevice.Clear(clear_color); We start the draw operation by clearing the viewport to some uniform color. This way we remove from the screen all the effects of previous rendering operations which otherwise would leave the screen dirty.

12 Draw void draw_all(color clear_color, Camera.Camera camera) effect.begin(); effect.currenttechnique.passes[0].begin(); effect.parameters["world"].setvalue(matrix.identity); effect.parameters["view"].setvalue(camera.view); effect.parameters["projection"].setvalue(camera.projection); Then we set the global variables used by our shaders to draw our vertices.

13 Draw void draw_all(color clear_color, Camera.Camera camera) effect.commitchanges(); Now we flush those values to the graphics card. Note that until we call effect.commitchanges the parameters new values have been stored in the system memory (RAM) but not yet copied to the GPU memory (VRAM).

14 Draw void draw_all(color clear_color, Camera.Camera camera) GraphicsDevice.VertexDeclaration = vertex_layout; GraphicsDevice.Vertices[0].SetSource(vertices, 0, Vertex.SizeInBytes); Now we set the vertex declaration and the vertex buffer into the graphics device. These two are now the source of all subsequent rendering operations (until another set is made). To set a vertex buffer we have to tell the graphics device the byte where the first vertex starts (in our case 0) and the size of a single vertex.

15 Draw void draw_all(color clear_color, Camera.Camera camera) GraphicsDevice.DrawPrimitives(PrimitiveType.PointList, 0, vertices.sizeinbytes / Vertex.SizeInBytes); effect.currenttechnique.passes[0].end(); effect.end(); Finally we draw the points of our vertex buffer. The draw operation takes as input: 1. The type of primitives to daw (points, lines or triangles) 2. The index of the first vertex from which to stat dawing 3. The number of primitives to draw (in our case we know that the vertex buffer has a certain size, so the number of points is the buffer size divided by the vertex size) After drawing we close the effect.

16 Multiple cameras Camera.Camera main_camera, small_camera; protected override void LoadContent() var small_viewport = GraphicsDevice.Viewport; small_viewport.x = 300; small_viewport.y = 20; small_viewport.width = 200; small_viewport.height = 200; small_camera = new Camera.Camera(GraphicsDevice, Vector3.Backward, Quaternion.Identity, 0.01f, f, small_viewport, GraphicsDevice.Viewport, Camera.UHJKKeyboadMapping, 0.99f); We declare and initialize another camera in a smaller viewport.

17 Multiple cameras protected override void Draw(GameTime gametime) GraphicsDevice.Viewport = main_camera.viewport; draw_all(color.cornflowerblue, main_camera); small_camera.draw(main_camera, Color.Red); GraphicsDevice.Viewport = small_camera.viewport; draw_all(color.cornflowerblue, small_camera); base.draw(gametime); Now we can draw the scene from both cameras and even draw the smaller camera in the main_camera scene (as lines in red).

18 float4x4 World; float4x4 View; float4x4 Projection; Custom shader A shader uses some global variables for rendering operations. These variables are set with effect. Parameters[var_name].SetValue by the host application.

19 Custom shader struct VertexShaderInput float4 Position : POSITION0; float4 Color : COLOR0; ; struct VertexShaderOutput ; float4 Position : POSITION0; float4 Color : COLOR0; Next we define structures to map the data of our vertices into HLSL syntax. A vertex defines not only data types and field names, but also the semantics of vertex elements such as POSITION0 and COLOR0. These semantics must match those found in the vertex declaration. VetexPositionColor.VertexElements defines exactly the POSITION0 and COLOR0 semantics.

20 Custom shader VertexShaderOutput VertexShaderFunction(VertexShaderInput input) VertexShaderOutput output; float4 worldposition = mul(input.position, World); float4 viewposition = mul(worldposition, View); output.position = mul(viewposition, Projection); output.color = input.color; return output; float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0 return input.color; The vertex shader processes a vertex and sends it to the pixel shader. Between the vetex and the pixel shader the vertex position is used to define which pixel is drawn, and then the pixel shader is called to decide which colo that pixel will have.

21 Custom shader technique Technique1 pass Pass1 VertexShader = compile vs_1_1 VertexShaderFunction(); PixelShader = compile ps_1_1 PixelShaderFunction(); Finally we bind together the vertex and pixel shader in a technique with a pass. The technique is used whenever we call effect.begin, while the pass is used whenever we call effect.currenttechnique.passes[0].begin. Also note that we are compiling these shaders for video cards supporting at least shader model 1.1 (ge force 3 or greater). More complex shaders might require a higher profile (like vs_2_0 and ps_2_0), but at the cost of supporting less video cards.

22 GOOD LUCK!