In my scene, the image looks a little squished compared to the original. My original photo is 2576 x 1932 pixels or a 0.75 aspect ratio. But our quad is square. Let's fix that up:

1. Select the Photo quad in the scene.
2. Set its transform Scale Y to 7.5.
3. Set its transform Position Y to 3.75 (this is its new center offset, 7.5 / 2; in fact, you can type 7.5/2 into the Y value slot and Unity will evaluate the calculation).

Why 3.75? The height started at 10, so we scaled it to 7.5. The scaling of objects is relative to their origin. So now, half of the height is 3.75. We want to position the center of the backdrop 3.5 unit above the ground plane.

We have the size and position set up, but the photo looks washed out. That's because the ambient lighting in the scene is affecting it. You might want to keep it that way, especially as you build more sophisticated lighting models and materials in your scenes. But for now, we'll disallow lighting effects on the photo using the Unlit shader. With Photo selected, change it to Unlit by going through the following steps:

1. Select the Photo object.
2. In Inspector, note that the photo's GrandCanyon Material component in the Inspector window has its default Shader set as Universal Render Pipeline/Lit.
3. Change the Material's Shader to Universal Render Pipeline/Unlit using the dropdown selection list.

One more thing: let's adjust the GroundPlane color to better match the photo ground:

1. Create a new material in the Materials folder and name it Ground Material.
2. Drag it onto the GroundPlane object.
3. Then, change itsBase Mapcolor. I suggest using the dropper (icon) to pick a sandy tone from the image in your photo plane.

Here's what mine looks like; yours should be similar:

There! That looks pretty good. Save your scene.

We have created a 3D diorama scene consisting of a few geometry primitives, including a Plane, Cube, Sphere, and Quad, and applied some simple Materials. Obviously, Unity is capable of using more complex and interesting graphics. Next, we'll look at using Unity prefabs for managing reusable GameObjects.

Unity prefabs (short for prefabricated object) allow you to create, store, and modify GameObjects as reusable assets together with all its components, property values, and child GameObjects. Prefabs are easily created by dragging an object from the scene Hierarchy window into the Project window, or they may be imported as part of a Unity asset package. You can read more about prefabs in the Unity Manual at https://docs.unity3d.com/Manual/Prefabs.html.

Let's see how this works by creating a simple reusable model built from simple geometric elements.

Creating and instantiating a prefab

We're going to create a reusable character prefab named BobHead. First, let's build the little guy from a few primitive 3D objects, as follows:

1. In the Hierarchy, create an empty GameObject named BobHead (by clicking on +| Create Empty; name it BobHead).
2. Set its position to something like Position (3, 0.75, 1.25).
3. Create a child Sphere for its head (right-click the BobHead and click 3D Object | Sphere). Name it Head.
4. In the ProjectMaterials/ folder, create a new Material, named BobHead Material, and make it a dark blue (for example, #191963).
5. Drag the BobHead Material onto the Head.

Now, add the eyes:

1. Create a child white-colored eye (right-click the BobHead, then click 3D Object | Sphere) and name it Eye.
2. Set its Transform Position (0.15, 0.2, -0.35) and Scale (0.15, 0.25, 0.25).

3. Drag the White Material that we created earlier from the ProjectMaterials/ folder onto the Eye.
4. Duplicate the eye (select the Eye and press Ctrl + D).
5. Change its Transform Position X to -0.15.

The resulting model, including the scene Hierarchy, is shown in the following screenshot:

Now to create a prefab of the object. We'll save it in a project folder named Assets/Prefabs/ by going through the following steps:

1. In the Project window, create a new folder named Prefabs (at the root Assets/, right-click, then click Create | Folder and name it Prefabs).
2. In the Hierarchy window, click and drag the BobHead GameObject into the Project window's Prefabs/ folder we just created.

Note that a few things have changed in the editor, as shown in the following screenshot:

• The ProjectAssets/Prefabs/ folder contains the BobHead.prefab file, with a preview image.
• Because the asset is presently selected, the Inspector shows its component values and a button to Open Prefab for editing. We'll get to that in a moment.
• The BobHead object name in the Hierarchy is now blue, indicating that it's now a prefab instance.
• There's also a > icon on the BobHead that you can click to edit the prefab asset (the same as the Open Prefab button).

The BobHead prefab is now available as a template for other BobHead GameObjects; you may want to add one or more to your scenes. All instances of the prefab will inherit the properties of the prefab. To add a new instance, just drag it from the Project window into the scene. Let's do that now:

1. In the Project window, click the BobHead prefab and drag it into the scene (either the Scene view window or the Hierarchy).
2. Once positioned as you like, drop it into the scene.
3. Add a few more too.

The following screenshot shows the scene with multiple BobHead instances. In the Hierarchy, the BobHead objects are blue because they reference prefab assets:

You can now modify the instance as you like, such as adjusting its position and scale.

In summary, we have learned the following definitions:

• GameObject: Generally refers to game objects in the Scene and Hierarchy, containing a geometric mesh, material, and other components that define its behavior.
• Asset: Refers to files in the ProjectAssets/ folder that can be added to a scene, including prefab GameObjects, materials, audio clips, and more.
• Prefab asset: A GameObject saved as an asset.
• Prefab instance: A prefab that's been added to a scene is said to be instantiated.

Now that we have a prefab, let's see how to edit it.

Editing and overriding a prefab

Suppose that you now decide that the BobHead needs adjustment; perhaps you want to add a hat. You can modify the prefab and all of the instances will be updated. You could select the BobHead prefab in the ProjectPrefabs/ folder and select Open Prefab to edit it (or just double-click it). Right now, we'll edit it first in the scene Hierarchy, then apply the overrides:

1. To add a hat, select one of the BobHead objects in the hierarchy, right-click,and select Create Empty, then rename it Hat.
2. Set its Position to (0, 0.5, 0).
3. Right-click the Hat and select 3D Object | Cylinderto add a cylinder as a child of Hat— name it HatTop.

4. Set itsTransform Scale to (0.5, 0.1, 0.5).
5. Drag the Red Material from the Project's Materials/ folder (created earlier in this chapter) onto the HatTop.
6. Right-click the Hat again and select 3D Object | Cylinderto add a cylinder as a child—name it Brim.
7. Set itsTransformScale to (0.75, 0.01, 0.75) and Position to (0, -0.075, 0).
8. Drag the Red Material from the Project's Materials/ folder onto the Brim.
9. Adjust the Hat transform to Rotation (0, -15, 25) and Position (-0.2, 0.5, 0).

That looks cool! Presently, only one of the BobHead instances has a hat. Suppose we want each of them to have one too. Select the BobHead object in Hierarchy; note the Overrides dropdown in the Inspector. Click it to show the modifications that you have made relative to the original prefab, as shown in the following screenshot: that'd be the Hat:

Do the following steps to actually apply the overrides:

1. Click the Overrides in Inspector.
2. Press Apply All.

Voila! Now all the BobHeads in the scene have been updated, as shown in the following screenshot:

Because prefabs may include child objects, it is possible for a child to be another prefab. That's perfectly fine. This is called a nested prefab, and will behave as you expect—for example, we could have made the Hat object its own separate prefab and then inserted it into the BobHead prefab. If you change the original child prefab, then that change will be reflected in the parent prefab.

In addition, modified instances of a prefab can be saved as a separate prefab variant. In that case, the new prefab still references the original prefab so that if the original prefab is changed and said properties have not been overridden by the variant, then the variant (and all its instances) will inherit those changes.

One more thing to point out. When you edit a prefab instance in Unity, you have the option to view it in the Scene window in the context of its position within the scene (Normal), to gray out the surrounding scene (Gray), or hide the context altogether (Hidden). The following image shows a BobHead being editing with a Gray context:

There you have it! Prefabs are a very powerful feature of Unity that we will use throughout this book. Next, we'll look at how to import content from outside of Unity.

So far, we have shown you how to use Unity and be productive in creating a scene, but with pretty simple content. Normally, Unity is not a 3D-modeling or asset-creation tool. Rather (as the name Unity suggests), it's a unified platform for pulling together content from a variety of sources to assemble and program a game or experience involving animation, physics, rendering effects, and so on. If you are a 3D artist, then you may know how to create content in other programs, or you can find a plethora of models on the web.

Creating 3D content for VR

Unity offers some basic geometric shapes, but when it comes to more complex models, you'll need to go beyond Unity. The Unity Asset Store and many other sites have tons of amazing models. Where do they come from? Will you run into problems while importing them into Unity?

For example, Blender is a free and open source 3D animation suite (http://www.blender.org/) that you can use to make a model and then import it into Unity. Other popular software, for both hobbyists and professionals, includes ZBrush, 3DS Max, Maya, and Cinema4D. A detailed list of 3D modeling software can be found at https://en.wikipedia.org/wiki/List_of_3D_modeling_software.

Actually, there are content creation tools that run right inside the Unity editor. Polybrush and ProBuilder are two examples, bought by Unity Technologies in 2019 and provided free with Unity itself (we will be using both these packages in later chapters in this book). Many other in-editor tools can be found on the Unity Asset Store, for example, by searching modeling or painting tools (https://assetstore.unity.com/tools?category=tools%2Fmodeling%5Ctools%2Fpainting&orderBy=1).

In addition to traditional 3D-modeling software, there is a new generation of 3D design apps that let you directly create inside VR. Let's be honest: it's pretty awkward trying to use an inherently 2D desktop screen with a 2D mouse to form, sculpt, and manipulate 3D models. If only it could be more like real-life pottery, sculpture, and construction. Well, why not just do it directly in VR? Some of the growing number of VR 3D content creation tools include the following:

• Google Tiltbrush (https://www.tiltbrush.com/): 3D painting and sculpture; import directly into Unity with Unity SDK (https://github.com/googlevr/tilt-brush-toolkit).
• Google Blocks (https://arvr.google.com/blocks/): 3D modeling and painting.
• Tiltbrush and Blocks models can also be uploaded to Google Poly (https://poly.google.com/) and imported into Unity with the Poly Toolkit on the Asset Store (https://assetstore.unity.com/packages/templates/systems/poly-toolkit-104464).
• Microsoft Marquette (https://www.maquette.ms/): Import with the Unity Addon (https://www.maquette.ms/unity-addon).
• Adobe Medium (originally by Oculus) (https://www.oculus.com/medium): Digital clay tool.
• Adobe Substance Painter (originally by Allegorithmic) (https://www.substance3d.com/products/substance-painter/): Design PBR (physically based rendering) textures and materials.
• Oculus Quill (https://www.oculus.com/experiences/rift/1118609381580656/): Illustration and animation tool.
• VR Gravity Sketch (https://www.gravitysketch.com/): Sculpting tool for 3D models.
• Unity Editor XR (https://github.com/Unity-Technologies/EditorXR): An experimental extension of the Unity editor that operates in VR, with 3D gizmos for scene editing and access to all the Unity windows, including Inspector and Project assets.

Let's see how to import assets from the store in the next section.

Importing from the Unity Asset Store

One terrific source is the Unity Asset Store (https://www.assetstore.unity3d.com/en/). Many asset packs are free, especially starter ones, with possible paid upgrades if you want more. These can be very useful, for instance, if you are looking for a few things to get your learning and experimental projects going.

As of Unity 2020.1, you are expected to browse and purchase assets from the Unity Asset Store website using your web browser. You can then find and import packages that you already own using the Package Manager (by going to Window | Package Manager). The Package Manager window with the My Assets filter selected is shown in the following screenshot:

Unfortunately (or fortunately), Unity keeps evolving, and some asset packages can get left behind. The Asset Store is filled with popular packages that were built for older versions of Unity and may have problems importing into the current version, possibly including the following:

• Unsupported shaders
• Obsolete C# script APIs

In this book, we created our Unity project using the Universal Render Pipeline, derived from the new Scriptable Render Pipeline (SRP) system that replaces the built-in render pipeline (https://docs.unity3d.com/Manual/ScriptableRenderPipeline.html). As we'll see, Unity provides tools to help upgrade materials for your Render Pipeline (RP). Sometimes that works, but sometimes it needs manual adjustment, as we'll show you next.

The Unity Scripting API (programmer interface) also evolves. When importing old scripts, Unity will try to automatically update them to work with the current version. Sometimes it cannot. Usually, if an API function has changed, Unity will give a warning that it is deprecated, and then eventually it will become unsupported after a number of Unity updates. You may find assets on the Asset Store that have not been updated and will throw errors when you try to import. Sometimes, this incompatibility makes the package unusable and obsolete. But sometimes a minor script edit can take care of the problem without having to chase down the developer and request a fix.

Let's run through a couple of these scenarios now, while at the same time learning more about Unity.

A skybox is a panoramic texture drawn behind all objects in the scene to represent the sky or another vista at a far distance. You can find many skyboxes to use in your projects; one of my favorites is the free Wispy Skybox from MUNDUS. Let's add it to our project now:

1. In your browser, go to the Asset Store (https://assetstore.unity.com/) and search for Wispy Skybox, or go directly to https://assetstore.unity.com/packages/2d/textures-materials/sky/wispy-skybox-21737.
2. Click Open in Unity.
3. In Unity, the Import Unity Package dialog box will pop up, with all the contents selected. Click Download (if present), and then click Import.
4. Check your console window for errors (by going to Window | General | Console). I see none, so that's good.
5. Open the scene's Lighting window (by going to Window | Rendering | Lighting).
6. Select the Environment tab at the top of thewindow.
7. At the top is a slot for Skybox Material. Click the doughnut icon, which opens the Select Material dialog.
8. Search using the string wispy.
9. Select one of the skyboxes to use in the scene.

Voila! That's good.

Next, let's import a model with a relatively high-quality PBR material. For fun, let's add the FREE Snowman from Angry Mesh:

1. In your browser, go to the Asset Store (https://assetstore.unity.com/) and search for free snowman, or go directly to https://assetstore.unity.com/packages/3d/props/free-snowman-105123.
2. Click Open in Unity.
3. In Unity, Import the package.
4. In the Project window, go to the Assets/ANGRY MESH/Snowman/Prefabs/ folder.
5. Drag the Snowman_01 prefab into the scene.

Oh no! It looks all magenta. That's Unity telling you that the object's materials are missing or not compatible with the current render pipeline:

To fix it, we'll try converting the imported materials to our RP:

1. Select Edit | Render Pipeline | Universal Render Pipeline | Upgrade Project Materials to UniversalRP Materials, then click Proceed:

There we go. Now he looks happier:

If you were to open the Demo_Snowman demo scene that comes with the package, you will see three snowmen in a terrain of pink snow! The upgrade tool didn't work on the terrain. Let's see why:

1. Save your current work by going to File | Save.
2. Go to File | Open Scene and select the scene Assets/ANGRY MESH/Snowman/Scene/Demo_Snowman.
3. Select the Terrain GameObject.
4. In Inspector, click the gear icon to open its Terrain Settings (you may need to first click Active to enable this object if the gear icon is disabled). Note that its Material property is called Default-Terrain-Standard.

As we've seen, Unity has a number of built-in default materials—for example, when you create a new object, its default material is Lit with the URP/Lit shader, because that's compatible with our current render pipeline. The default material with the imported terrain is not compatible with our render pipeline. We can create new material instead by going through the following steps:

1. In the Terrain's Inspector, next to the Material slot, click the Create... button.
2. Name it Snow Terrain Material.
3. Set its Shader to Lit (Universal Render Pipeline/Terrain/Lit).

There, that works! Although we're not using this terrain in our scene, it was worthwhile seeing how to drill down into the game object properties to fix the unsupported shader that it was using.

Next, let's look at some assets that we will definitely be using in the projects in this book.

Using Unity Legacy Standard Assets

Several of the chapters in this book use a variety of assets that Unity has provided as a Standard Assets package for a long time; however, while still useful and fun, the package as a whole has grown stale and unsupported. Since Unity 2018, it was removed from the standard Unity install and became available on the Asset Store instead. We're still going to use this package, but we'll need to make some adjustments for compatibility with Unity 2019.3 or later and the Universal RP.

You can import the entire package or a subset as described in the following steps:

1. In your browser, go to the Asset Store (https://assetstore.unity.com/) and search for Unity Standard Assets, or go directly to https://assetstore.unity.com/packages/essentials/asset-packs/standard-assets-for-unity-2017-3-32351.
2. ClickOpen in Unity, click Download, and then click Import.
3. In Unity, theImport Unity Packagedialog box pops up, with all the contents selected.
4. Uncheck the SampleScenes folder.
5. Uncheck the Standard Assets/2D folder.
6. Uncheck the Standard Assets/Cameras folder.
7. Uncheck the Standard Assets/Characters/FirstPersonCharacter folder.
8. Uncheck the Standard Assets/Characters/RollerBall folder.
9. Uncheck theStandard Assets/Vehiclesfolder.

The import box with items that we don't need for this book is shown in the following image:

Import the assets, then correct any import errors as follows:

1. ClickImport.
2. Check your Console window for errors by going to Window | General | Console.
3. There may be numerous import errors, but most of them will have been corrected by Unity. Click the Clear button (in the top-left of the Console window).
4. The remaining errors need to be resolved manually. I see two script files with obsolete references. We could update the scripts rather easily, but since we will not need time at all, they can just be deleted.

5. Clicking an error message will take you to the offending file in the Project window. Locate the file, right-click it, and select Delete. At the time of writing, the broken files will be as follows:
   • Assets\Standard Assets\Utility\ForcedReset.cs
   • Assets\Standard Assets\Utility\SimpleActivatorMenu.cs
6. The import can now continue. More errors may be found and fixed by Unity. Click Clear again.

That should complete the import. Next, let's attempt to convert materials to the current render pipeline:

1. SelectEdit | Render Pipeline | Universal Render Pipeline | Upgrade Project Materials to UniversalRP Materials and then clickProceed.

You can browse the warning messages, but don't worry about them; we'll find incompatible materials soon enough.

One of the models that we plan to use soon is the Ethan humanoid model. Let's add him to the scene:

1. In the Project window, drill down to the Assets/Standard Assets/Characters/ThirdPersonCharacter/Prefabs/ folder.
2. Drag the ThirdPersonController into the Scene.
3. You may want to turn him around so that he's facing the camera by going to Transform | Rotation | Y: 180.

Say hi to Ethan!

Ethan has a third-person control script that lets you control his animation with user input. We will work on VR input devices in later chapters, so for now, let's try it out with just the keyboard:

1. Click on the Play icon at the top of the Unity window in the center to start your game.
2. Use the W, A, S, and D keys to move him around. Run, Ethan! Run!
3. Be careful not to let him fall over the edge of our playground, or he'll fall down forever.
4. Click on the Play icon again to stop the game and return to edit mode.

Other than creating geometry inside Unity and getting asset packages from the Asset Store, content is otherwise imported from other graphics software.

Importing models in supported formats

Unity has built-in support for reading and importing models in a few generic file formats, including .fbx and .obj. Most 3D-modelling software can export these files. No extra software or licenses are required to use these files. In general, you should try to obtain 3D models in .fbx or .obj file format.

Unity also supports importing models in a number of proprietary formats, provided that you have the corresponding applications that edit these files on your development machine. These include Autodesk 3ds Max (.max) and Blender (.blend). This can be an advantage if you or your team is actively working on 3D models with one of these applications, and you have the software licenses to install it on your system (if needed). But you must have a copy of the application on your own system for Unity to know how to import the files. Not having to export files to .fbx, for example, before using them in Unity saves a step, especially if the models are still being developed and modified. Unity can import proprietary files from the following 3D-modelling software (from the Unity Manual, https://docs.unity3d.com/Manual/3D-formats.html):

• Autodesk® 3ds Max®
• Autodesk® Maya®
• Blender (a free and open source 3D application)
• Cinema4D
• Modo
• LightWave
• Cheetah3D

For models that have been imported in Unity, you can modify their Import Settings and reimport as needed. The following is a screenshot of the import settings for the snowman FBX file we used earlier—for example, you can change the Scale Factor and Units if the source file was built at a scale other than Unity's 1-unit equals 1-meter scale. There are settings to select what to import from the file's scene, the mesh, and geometry.

Depending on the capabilities of the model, the Rig, Animation, and Materials tabs provide additional import parameters. If you change settings, click Apply to reimport the object with the new settings:

When the source model has materials, you can instruct Unity to use those Materials automatically, or you have the option to extract the Materials into separate Unity Material files that can be modified and adjusted like any other Material in Unity.

While Unity provides a lot of import parameters, if you have access to the original modeling software, you can also gain control of the file that is using that software's export settings—for example, in Blender, its default coordinate system has the z-axis up, while Unity's is y. This can be compensated by rotating it once inside Unity, or you can adjust Blender's FBX export settings as shown in the following screenshot:

Next, we'll consider the workflows related to creating and importing 3D assets.

Round-trip geometry workflows

All this said, Unity is increasingly more capable of creating and modifying geometry within the Unity Editor itself—for example, the ProBuilder package that is integrated into Unity (which we'll use in Chapter 10, Exploring Interactive Spaces) is useful for white-boxing (prototyping) level designs and creating simple buildings with walls, passageways, and windows. There are many other third-party tools to be found on the Asset Store.

Unity is supporting advanced workflows with the FBX Exporter package, available in Package Manager, which provides round-trip workflows between Unity and other 3D software. With this package, GameObject hierarchies, animations, lights, and cameras can now be exported from Unity and shared with other applications.

The tool also allows you to preconfigure an integration with a specific 3D-modeling software. Presently, only Autodesk Maya and 3ds Max are supported, but more may be available by the time you read this. For details and instructions on using the FBX Exporter, see https://docs.unity3d.com/Manual/HOWTO-exportFBX.html. The package is presently still in preview, but is very promising.

As you can see, building a VR project requires you to not just understand how to use the many features of Unity itself, but how to import artwork and other assets from other sources into your project.

In this chapter, you built a simple diorama, became more acquainted with the Unity editor, and learned about importing content into your project. We started by installing Unity via Unity Hub, creating a new VR project with the Universal Render Pipeline, and installing additional packages using Package Manager.

Then you learned some basics of the Unity editor, such as how to navigate between its many windows and how to use the Scene editing gizmos, including grid and snap. We built a simple diorama scene with a ground plane, a crate (cube), a red ball, and a photo backdrop. You then created a BobHead prefab and learned about prefab editing, overrides, variants, and nesting, which we'll be seeing more of in upcoming chapters.

You also looked at the value of, and potential problems with, importing assets and Unity asset packages, including ones from the Asset Store. We learned about the issues with importing legacy assets that are not necessarily compatible with the version of Unity and render pipeline that you are using and how to fix it. Lastly, you learned how Unity is growing support for round-trip geometry workflows with the FBX Exporter package.

When developing for VR, you need to set up Unity for the specific platform and device that you plan to target, as well as the SDK external to Unity that is used to build the executable project. In the next chapter, we'll set up your development system and Unity settings to build and run the project to play on your VR headset.