Outline. CE318: Games Console Programming Lecture 3: 3D Games and Cameras. Outline. 3D Vectors. Diego Perez. 3D Principles. 3D Models.

Transcription

1 Outline Lecture 3: 3D Games and Cameras 1 3D Principles Diego Perez 2 3D Models 3 Cameras 4 Lab Session 3 dperez@essex.ac.uk Office 3A /15 Outline 2 / 50 3D Vectors A 3D vector is a geometric object that has magnitude (or length) and direction. 1 3D Principles 2 3D Models 3 Cameras 4 Vectors can be used to represent a point in space or a direction with a magnitude. The magnitude of a vector can be determined by the magnitude attribute. 3D Vectors in Unity have many properties and methods, and all of them can be consulted in the reference: Lab Session / 50 4 / 50

2 Operations with 3D vectors (1/4) Operations with 3D vectors (2/4) In Unity, you can use the normal operators for adding or subtracting to vectors, and also for multiplying or dividing a vector by a number: 1 Vector3 a = new Vector3 (1,2, -1); 2 Vector3 b = new Vector3 (3,4,0) ; 3 int val = 2; 4 5 Vector3 sum = a + b; // or a-b 6 Vector3 mult = a * val ; // or a/ val A unit vector is any vector with a length of 1; normally unit vectors are used simply to indicate direction. A vector of arbitrary length can be divided by its length to create a unit vector. This is known as normalizing a vector. A vector can be normalized in Unity by calling the function public void Normalize. 1 Vector3 a = new Vector3 (1,2, -7); 2 a. Normalize (); 3 Debug. Log (a. magnitude ); // =1 Addition: (1, 3, 1) + (2, 2, 0) = (3, 5, 1) a + b b + a Subtraction: (4, 3, 5) (3, 1, 6) = (1, 2, 1) a b b a Scalar multiplication: x(2, 3, 1) = (2, 3, 1)x = (2x, 3x, 1x) 2(2, 3, 2) = (4, 6, 4) Negation: a = (3, 0, 1), a = ( 3, 0, 1) b = (2, 2, 3), b = ( 2, 2, 3) Dot product: a b = b a = n i=1 a ib i a b = a b cos(θ) Cross product: a b = a b sin(θ)n a b (b a) n is the unit vector perpendicular to the plane containing a and b. 5 / 50 6 / 50 Operations with 3D vectors (3/4) The Cross Product operation (also called vector product) is a binary operation on two vectors in three-dimensional space, denoted as a b = a b sin(θ)n. The cross product a b of the vectors a and b is a vector that is perpendicular to both and therefore normal to the plane containing them. If the vectors have the same direction or one has zero length, then their cross product is zero. You can determine the direction of the result vector using the right hand rule. Operations with 3D vectors (4/4) An example of use of the cross product is finding the axis around which to apply torque in order to rotate a tank s turret. With the direction the turret is facing now, and the direction that it needs to face, the cross product gives the vector to rotate around. 1 Vector3 GetNormal ( Vector3 a, Vector3 b, Vector3 c) { 2 Vector3 side1 = c - a; 3 Vector3 side2 = b - a; 4 return Vector3. Cross ( side1, side2 ). normalized ; 5 } 7 / 50 Cross product can also be used to determine the normal of a plane (i.e. a triangle in a surface), in order to calculate directions for collisions and lighting. 8 / 50

3 Smooth Damp public static Vector3 SmoothDamp(Vector3 current, Vector3 target, Vector3 currentvelocity, float smoothtime, float maxspeed = Mathf.Infinity, float deltatime = Time.deltaTime); Gradually changes a position towards a desired goal. The vector is smoothed by some spring-damper like function, which will never overshoot. A common use is for smoothing a follow camera. It returns the new position (as moved in a frame towards the goal) and sets the velocity that the object must keep. current: The current position. target: The position we are trying to reach. currentvelocity: Current velocity, which value is modified by the function at every call (to smoothly continue the movement in the next frame). smoothtime: Approximately the time it will take to reach the target. A smaller value will reach the target faster. maxspeed: Optionally allows you to clamp the maximum speed. deltatime: The time since the last call to this function. By default Time.deltaTime. 1 transform. position = Vector3. SmoothDamp ( transform. position, 2 targetposition, ref velocity, 0.3 f); Transforms Every object in a scene has a Transform, that determines its position, rotation and scale. Position: Position of the Transform in X, Y, and Z coordinates. Rotation: Rotation of the Transform around the X, Y, and Z axes, measured in degrees. Scale: Scale of the Transform along X, Y, and Z axes. Value 1 is the original size (size at which the object was imported). Every Transform can have a parent, which allows you to apply position, rotation and scale hierarchically. (There are equivalent functions in Mathf and Vector2) 9 / / 50 Local versus World/Global Coordinates (1/2) The Transform component of a game object contains several vectors, such as forward, up and right. These vectors determine the local coordinate system of the game object. The local coordinate system (also known as local space, model space or object space) has all its three axes at right angles to each other: they are orthogonal, and can be used to know which part of the object is the front, which is the top and which is the side. Actually, they are orthonormal, as these three vectors are unit vectors. When a rotation operation is applied to modify the Transform, all axes will be rotated to reflect the change while keeping their relationship to one another. Local versus World/Global Coordinates (2/2)* On the other hand, the world coordinate system defines Vector3.forward, Vector3.up and Vector3.right, that determine the directions of positive Z, Y and X respectively, and it is a common coordinate system for all objects in the scene. Note that the local and global coordinate systems need not be aligned. It s thus more accurate to say that you rotate around the object s forward vector, rather than the z-axis. 11 / / 50

4 Transforms.Translate (1/2) Transform.Translate: public void Translate(Vector3 translation, Space relativeto = Space.Self); Moves the transform in the direction and distance of translation. If relativeto is left out or set to Space.Self the movement is applied relative to the transform s local axes. (the x, y and z axes shown when selecting the object inside the Scene View.) If relativeto is Space.World the movement is applied relative to the world coordinate system. Examples: A) Move the transform in the forward direction. 1 void Update () { 2 transform. Translate ( Vector3. forward ); 3 } B) The previous example moves the game object forward, one unit per frame. But maybe one unit per frame is not precise enough (i.e. too fast). Multiply by Time.deltaTime to move the game object forward, one unit per second. 1 void Update () { 2 transform. Translate ( Vector3. forward * Time. deltatime ); 3 } Transforms.Translate (2/2) C) In the previous examples, the speed was fixed to one unit per second/frame. We can change this: 1 public float speed = 5; // speed of this game object 2 void Update () { 3 // (5 units forward per second ) 4 transform. Translate ( Vector3. forward * Time. deltatime * speed ); 5 } D) The previous example is equivalent to supplying Space.Self as a second parameter: the movement is relative to the local coordinates of the object. If we want to move the object in the world coordinates space (where Vector3. Forward Positive Z axis), we would do: 1 public float speed = 5; // speed of this game object 2 void Update () { 3 // (5 units forward per second ) 4 transform. Translate ( Vector3. forward * Time. deltatime * speed, 5 Space. World ); 6 } Note that Time.deltaTime is set (by default) to 1/60 = It s set to a frame rate of 60 frames per second. 13 / / 50 Lerp Rotations in 3D There are three different rotations that can be done around a 3D point: Linearly interpolates between from and to by the fraction t: public static Vector3 Lerp(Vector3 from, Vector3 to, float t); This is most commonly used to find a point some fraction of the way along a line between two endpoints (eg, to move an object gradually between those points). This fraction is clamped to the range [0...1]. When t = 0 returns from. When t = 1 returns to. When t = 0.5 returns the point midway between from and to. 1 Transform target ; 2 Vector3 offset = transform. position - target. position ; 3 Vector3 targetcampos = target. position + offset ; 4 float smoothing = 5f; 5 6 transform. position = Vector3. Lerp ( transform. position, targetcampos, 7 smoothing * Time. deltatime ); (There are equivalent functions in Mathf, Vector2, Color and Material) 15 / 50 Each one of these rotates around a specific vector: Pitch: rotation around X axis. Yaw: rotation around the Y axis. Roll: rotation around Z axis. 16 / 50

5 Transforms.Rotate Transform.LookAt Transform.Rotate: public void Rotate(Vector3 axis, float angle, Space relativeto = Space.Self); Rotates the transform around axis by angle degrees. If relativeto is left out or set to Space.Self the rotation is applied around the transform s local axes. (The x, y and z axes shown when selecting the object inside the Scene View.) If relativeto is Space.World the rotation is applied around the world x, y, z axes. Examples: A) A normal rotation around the Y axis (Yaw), providing the angle: 1 public float turnspeed = 15f; 2 void Update () { 3 transform. Rotate ( Vector3.up, turnspeed * Time. deltatime ); 4 } B) And the rotation could be applied around the local or the world coordinates space. 1 public float turnspeed = 15f; 2 void Update () { 3 transform. Rotate ( Vector3.up, turnspeed * Time. deltatime, 4 Space. World ); 5 } Transform.LookAt: Rotates the transform so the forward vector points at target s current position or worldposition. public void LookAt(Transform target, Vector3 worldup = Vector3.up); public void LookAt(Vector3 worldposition, Vector3 worldup = Vector3.up); Example: A nice use is for targeting the camera to a position: 1 public class CameraLookAt : MonoBehaviour 2 { 3 public Transform target ; 4 5 void Update () 6 { 7 transform. LookAt ( target ); 8 } 9 } 17 / / 50 Transform.localScale Unity does not include any Transform.Scale function. However, it is possible to modify the field localscale, to modify the scale of the transform. 1 using UnityEngine ; 2 using System. Collections ; 3 4 public class ExampleClass : MonoBehaviour { 5 void Example () { 6 transform. localscale += new Vector3 (0.1F, 0, 0); 7 transform. localscale *= 1.005f; 8 } 9 } Important: Remember that if you want to move an object with a collider (it will interact with physics), you should not use Transform.Translate or Transform. Rotate. Instead, you should use the physics functions instead (see next lecture). You should use Transform.Translate or Transform.Rotate when the object has a rigidbody marked as kinematic. 19 / 50 The Gimbal Lock Problem (1/2) * Rotating a game object directly using Euler degrees is very intuitive. In a translation, a quantity on each one of the axis is given to change the position. If an object s transform position is (x, y, z) and we want to change this by moving it with (δx, δy, δz), the final position will be (x + δx, y + δy, z + δz). The same holds true for rotations. Internally, the Transform holds a Matrix formed by the (local) vectors Right, Up and Forward. When applying a rotation in (radians), the following matrix are used to multiply and change the transform matrix: X-Rotation - Pitch: cos sin 0 sin cos Y-Rotation - Yaw: cos 0 sin sin 0 cos Z-Rotation - Roll: cos sin 0 sin cos This way of applying rotations works fine, but it is exposed to the gimbal lock problem: the loss of one degree of freedom in a three-dimensional space that occurs when the axes of two of the three gimbals are driven into a parallel configuration. 20 / 50

6 The Gimbal Lock Problem (2/2) A possible set of rotations is the following combination of matrices. If β = 0: cos α sin α cos γ sin γ 0 R = sin α cos α 0 0 cos β sin β sin γ cos γ 0 = sin β cos β cos α sin α cos γ sin γ 0 = sin α cos α sin γ cos γ 0 = cos(α + γ) sin(α + γ) 0 sin(α + γ) cos(α + γ) In this configuration, there are two angles available, but effectively only one angle changes the transform (α + γ). Changing the values of α and γ in the above matrix has the same effects: the rotation angle α + γ changes. The rotation axis remains in the Z direction: the last column and the last row in the matrix won t change. For a detailed description of the gimbal lock problem (in this, and other engineering problems), check: 21 / 50 Quaternions (1/2) * Quaternions are four dimensional vectors of real numbers that allow three operations: addition, scalar multiplication and quaternion multiplication. They are used to represent rotations. They don t suffer from gimbal lock and can easily be interpolated. Unity internally uses Quaternions to represent all rotations. Quaternions work with four components: w, x, y and z. These components work together, and they should never be modified individually. The class Quaternion offers the following functionality: Quaternion.LookRotation: public static Quaternion LookRotation(Vector3 forward, Vector3 upwards = Vector3.up); Creates a rotation with the specified forward and upwards directions. If used to orient a Transform, the Z axis will be aligned with forward/ and the Y axis with upwards if these vectors are orthogonal. 1 public class ExampleClass : MonoBehaviour { 2 public Transform target ; 3 void Update () { 4 Vector3 relativepos = target. position - transform. position ; 5 Quaternion rotation = Quaternion. LookRotation ( relativepos ); 6 transform. rotation = rotation ; 7 } 8 } 22 / 50 Quaternions (2/2) * Outline Quaternion.Slerp: public static Quaternion Slerp(Quaternion from, Quaternion to, float t); Spherically interpolates between from and to by t. 1 public class ExampleClass : MonoBehaviour { 2 public Transform from ; 3 public Transform to; 4 public float speed = 0.1 F; 5 void Update () { 6 transform. rotation = Quaternion. Slerp ( from. rotation, to. rotation, Time. time * speed ); 7 } 8 } (There is an equivalent function in Vector3) 1 3D Principles 2 3D Models 3 Cameras Quaternion.identity: public static Quaternion identity; 4 Lab Session 3 The identity rotation (Read Only). This quaternion corresponds to no rotation. Is perfectly aligned with the world or parent axes. 1 transform. rotation = Quaternion. identity ; 23 / / 50

7 The 3D Mode Analogous to the 2D mode, there is an option when creating a new project to set the editor for a 3D mode: 3D Game Objects (Primitive Meshes) Unity has some pre-defined primitive meshes: Cube Sphere Capsule By default, the Scene View will be set to 3D view, although it is possible to switch to 2D view at any time. 25 / 50 Cylinder Plane Quad 26 / 50 3D Transforms As in 2D mode, all 3D game objects have a Transform component: Vertices, Triangles, Meshes A mesh is a collection of 3D points (vertices) that, when combined together, define a physical presence of an object. Every mesh is made up of a series of triangles, given by its vertices. Translation, Rotation and Scale can be set in the transform or applied directly on the Scene View using the control gizmos. Translation Rotation Scale Triangles are used because: 3 points determine a unique triangle with sides that don t cross each other. 3 points determine a triangle in a unique plane (flat shape). 27 / / 50

8 Mesh Filter and Renderer Models (1/2) A model is a mesh with its applied material, texture and shader. Mesh Filter: The Mesh Filter takes a mesh from your assets and passes it to the Mesh Renderer for rendering on the screen. Mesh Renderer: Takes the geometry of the object from the mesh filter and renders it at the position defined by the objects Transform component. Cast Shadows: If enabled, this Mesh will create shadows when a shadowcreating light shines on it. Receive Shadows: If enabled, this Mesh will display any shadows being cast upon it. Materials : A list of Materials to render model with (see later). Use Light Probes: Enable probe-based lighting for this mesh (see further lectures). 29 / 50 Supported formats: Importing meshes into Unity can be achieved from two main types of files: Exported 3D file formats, such as.fbx or.obj. Proprietary 3D application files, such as.max and.blend file formats from 3D Studio Max or Blender for example. Unity can read.fbx,.dae (Collada),.3DS,.dxf and.obj files. 30 / 50 Models (2/2) Materials * Unity provides a default material for every mesh (simple, plain grey material). One of its basic parameters is a texture. A texture is a simple image file: A model has a Model Material applied to it. A material can be seen as the skin of the mesh. Every mesh needs a material in order to be seen on the screen. The model material (saved in a file) has two parts: the texture and the shader. 31 / 50 We can create a new material in Unity and assign the texture to it. Then, it is possible to apply the new material to the object: 32 / 50

9 Shaders Built-in Shaders (1/4) Shaders in Unity are used through Materials, which essentially combine shader code with parameters like textures. The shader is responsible for telling the material which properties it takes, such as colors, sliders, textures, numbers, or vectors. The default shader is Diffuse: it is a very basic, flat shader, evenly lit (equal amount of lighting on each vertex). Two placement options are available for each Texture: Main Color. Tiling: Scales the texture along the different axes. Offset: Slides the texture around. 33 / 50 Built-in Shaders (2/4) A set of built-in Shaders are installed with the Unity editor, grouped in families: Normal: The basic shaders in Unity, for opaque textured objects. Examples: Diffuse: Diffuse computes a simple (Lambertian) lighting model: The lighting on the surface decreases as the angle between it and the light decreases. Vertex Lit: All lights shining on it are rendered in a single pass and calculated at vertices only. You specify specular color, emissive color and shininess. Normal Bumped Diffuse: Normal mapping simulates small surface details using a texture, instead of spending more polygons to actually carve out details. It does not actually change the shape of the object, but uses a special texture called a Normal Map to achieve this effect. Normal Bumped Specular : Like the Normal Bumped Diffuse shader, but it includes specular color and shininess. 34 / 50 Built-in Shaders (3/4) Transparent: The Transparent shaders are used for fully- or semi-transparent objects. Using the alpha channel of the Base texture, you can determine areas of the object which can be more or less transparent than others. This can create a great effect for glass, HUD interfaces, or sci-fi effects. TransparentCutOut: The Transparent Cutout shaders are used for objects that have fully opaque and fully transparent parts (no partial transparency). Things like chain fences, trees, grass, etc. Self-Illuminated: The Self-Illuminated shaders will emit light only onto themselves based on an attached alpha channel. They do not require any Lights to shine on them to emit this light. This is mostly used for light emitting objects. For example, parts of the wall texture could be self-illuminated to simulate lights or displays. Reflective: Reflective shaders will allow you to define areas of more or less reflectivity on your opaque object through the alpha channel of the Base texture. High reflectivity is a great effect for glosses, oils, chrome, etc. Low reflectivity can add effect for metals, liquid surfaces, or video monitors. 35 / / 50

10 Built-in Shaders (4/4) Outline Unity also provides different shaders grouped into categories. Here are some examples: Nature. Particles. Sprites. Graphical User Interface. Unlit (ignore lights on the material). Mobile. Mobile shaders are optimized for mobile platforms. Although their quality is lower, sometimes they are good enough to be used in other platforms, providing a better performance. 1 3D Principles 2 3D Models 3 Cameras 4 Lab Session 3 37 / / 50 Cameras Cameras are the devices that capture and display the world to the player. They can be customized, scripted, or parented just as any other game object. You can create multiple cameras in the scene. Every scene in Unity needs to have a camera, or nothing will be shown. Screen Space is a 2D area with the origin in the lower left corner, and with a size equal to your resolution. Viewport Space is a normalized area, from (0, 0) to (1, 1). Camera Projection The Viewing Frustum is the shape of the region that can be seen and rendered by a camera. The projection of the camera allows it to simulate perspective in the rendered scene. In a Perspective Projection, the viewing frustum of the camera takes the shape of a pyramid. In an Orthographic Projection the size of the near plane and the far plane is the same (therefore, the viewing frustum is shaped as a cube). Thus all objects of equal size are rendered the same size independent of distance to the camera (i.e. the perspective is lost). 39 / / 50

11 Camera objects (1/4) Camera objects (2/4) Transform: transform component of the camera. Camera: camera component (can be attached to any game object!). GUILayer: to enable/disable rendering of 2D GUIs. Flare Layer: to enable/disable Lens Flares (lights refracting inside camera lens) in the image. Audio Listener: calculates the output audio. There can only be one audio listener in the scene! Settings of the Camera Component: Clear Flags: Each Camera stores color and depth information when it renders its view. The portions of the screen that are not drawn in are empty. You can set the clear flags setting to specify what to draw in these empty areas: Skybox: Any empty portions of the screen will display the current Cameras skybox (chosen in the Render Settings: Edit Render Settings). It will then fall back to the Background Color. Alternatively a Skybox Component can be added to the camera. Solid Color: Any empty portions of the screen will display the current Cameras Background Color. Depth Only: Nothing is drawn in the empty portions of the screen. This is typically used with more than one layered cameras (bad setting for only one camera). Don t Clear: Scene rendered in the previous screen does not get deleted. 41 / / 50 Camera objects (3/4) Background Color: Color for the background. Culling Mask: used for selectively rendering groups of objects using Layers. Example: All user interface elements are set to a UI Layer, that is rendered by a separate camera. A scene camera draws the rest of the scene. In order for the UI to display on top of the scene Camera, you need to set the Clear Flags to Depth only and make sure that the UI Cameras Depth is higher than the scene Camera. Projection: Perspective or Orthographic. Orthographic projection lacks perspective, and it is mostly useful for making isometric or 2D games, and they are great for making 3D user interfaces. Field Of View: Width of the Cameras view angle, measured in degrees along the local Y axis. Clipping planes: Far and Near planes, specified in Unity units. Near is the closest point relative to the camera that drawing will occur, while Far is the furthest point relative to the camera that drawing will occur. 43 / 50 Camera objects (4/4) * Viewport Rect: Four values that indicate where on the screen this camera view will be drawn (values 01). (X, Y ) are the beginning position where the camera view will be drawn, and (W, H) are the width and height of the camera output on the screen. Depth: The cameras position in the draw order. Cameras with a larger value will be drawn on top of cameras with a smaller value. Rendering Path: Options for defining what rendering methods will be used by the camera. For more details see: RenderingPaths.html Target Texture: (Unity Pro Feature) Reference to a Render Texture that will contain the output of the Camera view. It can be used to create sports arena video monitors, surveillance cameras, transparencies, etc. Occlusion Culling: (Unity Pro Feature) disables rendering of objects when they are not currently seen by the camera because they are obscured by other objects. HDR: Enables High Dynamic Range rendering for this camera. unity3d.com/manual/hdr.html 44 / 50

12 An Example of a Follow Camera Using Multiple Cameras (1/3) * 1 public class CameraFollow : MonoBehaviour 2 { 3 // The position that that camera will be following. 4 public Transform target ; 5 // The speed with which the camera will be following. 6 public float smoothing = 5f; 7 // The initial offset from the target. 8 Vector3 offset ; 9 10 void Start () 11 { 12 // Calculate the initial offset. 13 offset = new Vector3 (0,10, -10) ; 14 } void LateUpdate () 18 { 19 // Create a postion the camera is aiming for 20 // based on the offset from the target. 21 Vector3 targetcampos = target. position + offset ; // Smoothly interpolate between the camera s 24 // current position and it s target position. 25 transform. position = Vector3. Lerp ( transform. position, targetcampos, smoothing * Time. deltatime ); 26 } 27 } When having multiple cameras, the Depth parameter controls the order in which the cameras draw the scene. If the values are different, the camera with the lower Depth value will be drawn first. If the values are equal, the first camera added to the scene will be drawn first. Note that all cameras actually draw the scene, but the last one overrides all the others if its Clear Flags is not set to Depth Only. Also: Consider using Transform.LookAt to set the camera s transform forward vector. 45 / / 50 Using Multiple Cameras (2/3) * It is possible to avoid this overriding by setting the property Clear Flags to Depth Only in one of the cameras. Using Multiple Cameras (3/3) * Split Screen: 2 cameras drawing in different parts of the viewport. They can both be assigned to the same Depth, as they are not overriding each other. In order to indicate which parts of the viewport each camera draws, modify the Viewport Rect attribute of the cameras. Clear Flags = Skybox. Clear Flags = Depth Only. The camera with Clear Flags = Depth Only only draws those objects hit by the camera. The rest is not drawn. Culling Masks: By assigning objects to layers, and setting the culling mask property of the cameras, it is possible to make cameras draw objects from specific layers: 47 / / 50

13 Outline Lab Preview 1 3D Principles 2 3D Models 3 Cameras During this and next week s lab you will create a 3D game: The game will consist of a 3D space shooter, although it only expands in two dimensions, as it is seen from above. You will learn how to set a project up, create a scene, place game objects, process input to move the player, etc. The game implemented is described in this online tutorial: 4 Lab Session 3 Next lecture: 3D Physics and Audio. 49 / / 50