Unity

Question 1

one declares an instance, the other references the component shared on all versions. This is used on materials.

Answer 1

.mat vs .sharedmat

Question 2

used to store data we reference repeatedly that changes infrequently.

Answer 2

caching

Question 3

data containers, reduce project memory by avoiding value copies.

Answer 3

scriptable object

Question 4

Scenes, prefabs, and other unity files(assets) reference _____ to uniquely identify files within a single project, and between different projects.

Answer 4

GUID(Globally Unique Identifier)

Question 5

Temporary heap allocations, instantiations, coroutines, passing strings around, using .material or .tag calls are what common pitfalls when using Unity’s API?

Answer 5

common garbage collection pitfalls

Question 6

is a function that can suspend its execution (yield) until the given Yield-Instruction finishes. Yield where you dictate, acting like jugglers that hand off at rehearsed points. Threads, however, are auto-managed by the operating system.

Answer 6

coroutine

Question 7

Used in creating a basic asset menu tool that updates certain object components. Like lights, transforms, etc.

Answer 7

Editor scripting

Question 8

object interpolates between start and end point, with third value being rate of interpolation.

Answer 8

Mathf.lerp

Question 9

assets referenced and loaded into the scene take this. Additionally pre-baking or mesh optimization on build can affect this. Static and baked objects, especially lightmap data have this.

Answer 9

Load times

Question 10

Clones the object original and returns the clone.

Answer 10

Instantiation

Question 11

Element that can be used for screen rendering. Elements on the ______ are rendered AFTER Scene rendering, either from an attached camera or using overlay mode.

Answer 11

Canvas

Question 12

a process which prevents Unity from performing rendering calculations for GameObjects
that are completely hidden from view by other GameObjects. Every frame, Cameras
perform these operations that examine the Renderers in the Scene
and exclude those that do not need to be drawn.

Answer 12

Occlusion culling

Question 13

Two colliders can’t have collision Behavior without this?

Answer 13

Rigidbody on at least one of the objects

Question 14

Why should moving colliders have a rigidbody?

Answer 14

when there is no rigidbody, then unity assumes the object is static. Unity doesn’t bother testing collisions between static objects. As a result, this is very efficient for objects in the world the player can bump into. Having kinematic rigidbodies rather than none, is to turn on collision detection between this object and all other colliders in the scene. Effectively you are letting unity know that this object moves around, so unity will then do collision detection between it and everything else.

Question 15

character joints, configurable joints, fixed joints, hinge joints, and spring joints are all under this umbrella term?

Answer 15

Physics Joints

Question 16

This type of joint is used to simulate chains, and for break-action shotguns.

Answer 16

Hinge joints

Question 17

this type of joint can be used for webs shooter slinging.

Answer 17

Spring joints

Question 18

Used to represent rotations. They are compact, don’t suffer from gimbal lock and can easily be interpolated. Unity internally uses ______ to represent all rotations.

Answer 18

Quaternion

Question 19

max amount unity allows of these is things is 32 (0-31).

Answer 19

physics layers

Question 20

is called every frame, if the MonoBehaviour is enabled. Is the most commonly used function to implement any kind of game script. Not every MonoBehaviour script needs ____.

Answer 20

Update()

Question 21

Returns the component of Type type if the game object has one attached, null if it doesn’t.

Answer 21

GetComponent

Question 22

A mesh collider allows you to do collision detection between meshes and primitives.

Answer 22

MeshCollider

Question 23

This method involves disabling normals in import settings, because the physics system doesn’t need them. Additionally going into modeling software and making abstract low-poly representations of the higher tri model.

Answer 23

Mesh collider optimization

Question 24

________ shader is a script that runs for each _________ of the mesh, allowing the developer to apply transformation matrixes, and other operations, in order to control where this _________ is in the 3D space, and how it will be projected on the screen.

Answer 24

Vertex Shader

Question 25

________ shader is a script that runs for each fragment (_______ candidate to be rendered) after three vertexes are processed in a mesh’s triangle. The developer can use information like the UV / TextureCoords and sample textures in order to control the final color that will be rendered on screen.

Answer 25

Pixel shader

Question 26

During rendering, each pixel is calculated whether it should be illuminated and recieve lighting influence, and this is repeated for each light. After approximately eight repeated calculations for different lights in the scene, the overhead becomes significant.

For large scenes, the number of pixels rendered is usually bigger than the number of pixels in the screen itself.

________ Lighting makes the scene render all pixels without illumination (which is fast), and with extra information (at a cost of low overhead) it calculates the illumination step only for the pixels of the screen buffer (which is less than all pixels processed for each element). This technique allows much more light instance in the project.

Answer 26

Deferred Lighting

Question 27

Real time applications, such as games, have a variable FPS. They sometimes run at 60fps, or when suffering slowdowns, they will run on 40fps or less.

If you want to change a value from A to B in 1.0 seconds you can’t simply increase A by B-A between two frames because frames can run fast or slow, so one frame can have different durations.

The way to correct this is to measure the time taken from frame X to X+1 and increment A, leveraging the change with the frame duration deltaTime by doing A += (B-A) * DeltaTime.

When the accumulated DeltaTime reaches 1.0 second, A will have assumed B value.

Answer 27

Time.deltaTime being used to make things that depend on time operate correctly.

Question 28

Explain why vectors should be normalized when used to move an object?

Answer 28

Normalization makes the vector unit length. It means, for instance, that if you want to move with speed 20.0, multiplying speed * vector will result in a precise 20.0 units per step. If the vector had a random length, the step would be different than 20.0 units.

Question 29

Finish this code so the GameObject containing this script moves with constant speed towards target, and stop moving once it reaches 1.0, or less, units of distance.

class Mover : MonoBehaviour
{
  Vector3 target;
  float speed;

  void Update()
  {

}
}

Answer 29

class Mover : MonoBehaviour
{

Vector3 target;
float speed;

  void Update()
  {
      float distance = Vector3.Distance(target,transform.position);

      // will only move while the distance is bigger than 1.0 units
      if(distance > 1.0f)
      {
        Vector3 dir = target - transform.position;
        dir.Normalize();                                    // normalization is obligatory
        transform.position += dir * speed * Time.deltaTime; // using deltaTime and speed is obligatory
      }     
  }
}

Question 30

Can two GameObjects, each with only an SphereCollider, both set as trigger and raise OnTrigger events? Explain your answer.

Answer 30

No. Collision events between two objects can only be raised when one of them has a RigidBody attached to it. This is a common error when implementing applications that use “physics.”

Question 31

Which of the following examples will run faster?

1. 1000 GameObjects, each with a MonoBehaviour implementing the Update callback.
2. One GameObject with one MonoBehaviour with an Array of 1000 classes, each implementing a custom Update() callback.

Answer 31

The correct answer is 2.

The Update callback is called using a C# Reflection, which is significantly slower than calling a function directly. In our example, 1000 GameObjects each with a MonoBehaviour means 1000 Reflection calls per frame.

Creating one MonoBehaviour with one Update, and using this single callback to Update a given number of elements, is a lot faster, due to the direct access to the method.

Question 32

Explain, in a few words, the role of the inspector is?

Answer 32

The inspector panel allows users to modify numeric values (such as position, rotation and scale), drag and drop references of scene objects (like Prefabs, Materials and Game Objects), and others. Also it can show a custom-made UI, created by the user, by using Editor scripts.

Question 33

Explain, in a few words, what the project panel is?

Answer 33

The project panel contains files from the file system of the assets folder in the project’s root folder. It shows all the available scripts, textures, materials and shaders available for use in the project.

Question 34

Explain, in a few words, what role the hierarchy panel has?

Answer 34

The hierarchy panel shows the current scene structure, with its GameObjects and its children. It also helps users organize them by name and order relative to the GameObject’s siblings. Order dependent features, such as UI, make use of this categorization.

Question 35

Which panel is responsible for referencing the content that will be included in the build process?

Answer 35

The panel responsible for referencing content in the build process is the hierarchy panel. The panel contains references to the objects that exist, or will exist, when the application is executed. When building the project, Unity searches for them in the project panel, and adds them to the bundle.

Question 36

Arrange the event functions listed below in the order in which they will be invoked when an application is closed:

Update()
OnGUI()
Awake()
OnDisable()
Start()
LateUpdate()
OnEnable()
OnApplicationQuit()
OnDestroy()

Answer 36

The correct execution order of these event functions when an application closes is as follows:

Awake()
OnEnable()
Start()
Update()
LateUpdate()
OnGUI()
OnApplicationQuit()
OnDisable()
OnDestroy()

Note: You might be tempted to disagree with the placement of OnApplicationQuit() in the above list, but it is correct which can be verified by logging the order in which call occurs when your application closes.

Question 37

Explain the issue with the code below and provide an alternative implementation that would correct the problem.

using UnityEngine;
using System.Collections;

public class TEST : MonoBehaviour {
    void Start () {
        transform.position.x = 10;
    }
}

Answer 37

The issue is that you can’t modify the position from a transform directly. This is because the position is actually a property (not a field). Therefore, when a getter is called, it invokes a method which returns a Vector3 copy which it places into the stack.

So basically what you are doing in the code above is assigning a member of the struct a value that is in the stack and that is later removed.

Instead, the proper solution is to replace the whole property; e.g.:

using UnityEngine;
using System.Collections;

public class TEST : MonoBehaviour {
   void Start () {
        Vector3 newPos = new Vector3(10, transform.position.y, transform.position.z);
        transform.position = newPos;
    }
}

Question 38

What are the benefits of having a visualization mode for rendering optimization, as shown on the picture bellow?

https://uploads.toptal.io/blog/image/91361/toptal-blog-image-1436440710160-c46b314c032ac1ddba5ad073a54adf88.png

Answer 38

The “overdrawn” mode helps the user to profile the number of pixels being rendered in the same “area”. Yellow to white areas are “hot” areas where too many pixels are being rendered.

Developers can use this information to adjust their materials and make better use of the Z-Test and optimize the rendering.

Question 39

What is a gameobject?

Answer 39

Base class for all entities in Unity Scenes.

Note: Many variables in the GameObject class have been removed. To access, for example GameObject.renderer in csharp use GetComponent() instead.

Question 40

What is a component?

Answer 40

Base class for everything attached to GameObjects.

Note that your code will never directly create a Component. Instead, you write script code, and attach the script to a GameObject. See Also: ScriptableObject as a way to create scripts that do not attach to any GameObject.

Question 41

What is the difference between a gameobject and an object in c#?

Answer 41

Object, in C#, is an instance of a class that is created dynamically. Object is also a keyword that is an alias for the predefined type System. Object in the . NET framework. The unified type system of C# allows objects to be defined. Object is the base class for all objects Unity can reference.

GameObject, besides being a subclass of Object, is the base class for all entities within scenes. It has a Transform component by default, and can have other components attached.

Question 42

What value can I access faster, a boolean from a list, or a list from a dictionary and why?

Answer 42

A dictionary is a hash table, so it is really fast to find the keys. So between dictionary vs list speed, the dictionary would be faster.

Note: If you don’t have a value to associate, it is even better to use a set. It is a hash table, without the “table” part.

Question 43

C# has a unified type system, which means that all types inherit, directly or indirectly, from object (________). This includes both reference and value types. It also includes all primitive types, like int and bool, as well as every type provided in the .NET Framework and every custom type that you define.

Because every type inherits from object, you can call any of the _______ methods (e.g. Equals and ToString) on an instance of any type.

Answer 43

System.Object

Question 44

Write a class and use a constructor?

class name person
string for first and last name
constructor setting variables

Answer 44

public class Person
{
private string last;
private string first;

   public Person(string lastName, string firstName)
   {
      last = lastName;
      first = firstName;
   }

   // Remaining implementation of Person class.
}

Question 45

Whenever a class or struct is created, its ________ is called. A class or struct may have multiple ________ that take different arguments. ________ enable the programmer to set default values, limit instantiation, and write code that is flexible and easy to read.

Answer 45

Constructors

Question 46

The Canvas is the basic component of Unity UI. It generates meshes that represent the UI Elements placed on it, regenerates the meshes when UI Elements change, and issues draw calls to the GPU so that the UI is actually displayed.

Generating these meshes can be expensive. UI Elements need to be collected into batches so that they’re drawn in as few draw calls as possible. Because batch generation is expensive, we only want to regenerate them when necessary. The issue is that, when one or more elements change on a Canvas, the whole Canvas has to be analyzed once again, to figure out how to optimally draw its elements.

Many users build their entire game’s UI on a single Canvas with thousands of elements. When they change one element, they can experience a CPU spike costing multiple milliseconds. To learn more about why rebuilding is so expensive, go to the 24:55 mark in this Unite session.

Answer 46

Solution: Split up your Canvases.

Each Canvas is an island that isolates its elements from those of other Canvases. Take advantage of UGUI’s ability to support multiple Canvases by slicing up your Canvases to solve the batching problems with Unity UI.

You can also nest Canvases, which allows designers to create large hierarchical UIs, without having to think about where different elements are onscreen across Canvases. Child Canvases also isolate content from both their parent and sibling Canvases. They maintain their own geometry and perform their own batching. One way to decide how to split them up is based on how frequently they need to be refreshed. Keep static UI Elements on a separate Canvas, and dynamic Elements that update at the same time on smaller sub-Canvases. Also, ensure that all UI Elements on each Canvas have the same Z value, materials, and textures.

Question 47

What is something you can save on UI performance that involves raycasting?

Answer 47

Solution: Remove Graphic Raycasters from non-interactive UI Canvases and turn off the Raycast Target for static or non-interactive elements.

In particular, text on a button turning off the Raycast Target will directly reduce the number of intersection checks that the Graphic Raycaster must perform on each frame.

Problem: Sometimes the Graphic Raycaster does act as a raycaster.

If you set the Render mode on your Canvas to Worldspace Camera or Screen Space Camera, you can add a blocking mask. The blocking mask determines whether the Raycaster will cast rays via 2D or 3D physics, to determine if some physics object is blocking the user’s ability to interact with the UI.

Solution: Casting rays via 2D or 3D physics can be expensive, so use this feature sparingly.

Minimize the number of Graphic Raycasters by excluding them from non-interactive UI Canvases, since – in this case – there is no reason to check for interaction events.

Question 48

Coroutine Misconceptions?

Answer 48

Coroutines are not threads. The code you put in a coroutine is executed entirely in serial by the main thread. There is a scheduled time in the script execution order where coroutines are executed, please see this page: http://docs.unity3d.com/Manual/ExecutionOrder.html

Because coroutines are not threads, they are not designed to perform work in parallel. Their primary purpose is to spread work out over multiple frames so it either animates nicely if it’s a visual effect, or prevents stalling the engine and causing a hiccup if it’s a concentrated amount of heavy workload, like multiple object instantiations of heavy meshes.

A coroutine is an object that implements IEnumerator. This object is added to a list of currently active coroutines inside MonoBehaviour when StartCoroutine is called. This list is then traversed once per Update, and the IEnumerator’s MoveNext method is called, which triggers the execution of the next cycle in the coroutine. Therefore, if you kill the MonoBehaviour you used to start a coroutine, the coroutine dies, too. They are not totally fire-and-forget.

Always carefully define a coroutine’s exit-condition(s). They are often used to animate something from A to B because they exit and terminate themselves so beautifully when written right. But if the loop’s exit conditions is ill-defined, it might run forever, and you won’t find out until something starts acting weird.

Beware of starting more coroutines of the same type based on some user-interaction. You could end up having multiple coroutines try to effect changes to the same program state, and thus, they will end up fighting over who gets to do the work. As an example, suppose you have a coroutine open and close a door. Clicking once opens, clicking again closes. If I click twice really fast, two coroutines open and start fighting over opening/closing the door. The result is a door that either twitches, or is frozen in mid-animation.

Question 49

What is a prefab?

Answer 49

Unity’s Prefab system allows you to create, configure, and store a GameObject complete with all its components, property values, and child GameObjects as a reusable Asset. The Prefab Asset acts as a template from which you can create new Prefab instances in the Scene.

Any edits that you make to a Prefab Asset are automatically reflected in the instances of that Prefab, allowing you to easily make broad changes across your whole Project without having to repeatedly make the same edit to every copy of the Asset.

You can nest Prefabs inside other Prefabs to create complex hierarchies of objects that are easy to edit at multiple levels.