Tutorial: Using Google Blocks* for VR Modeling

Workflows

Typical workflow for VR development

A typical VR project is an iterative combination of code and assets. Usually there’s a period of preproduction to concept interactivity and assets (via sketches). However, once production begins, you often face many starts and stops, because the code-development side must wait for finished assets and vice versa.

This situation is made worse when developing for VR, because VR’s unique visual perspective creates issues of scale, placement, and detail that exist in 3D projects presented on a 2D monitor. So you must deal with more back and forth on asset development to get ideas right. You’re also often left with low-quality visual presentation in the prototyping stages that can hinder attracting funding or interest.

Benefits of use VR to prototype

Creating prototype model assets in VR itself creates a much smoother flow for both code and asset developers. This approach allows code developers to more quickly design and adjust the rough versions of what they need, have playable objects, and provide reference material to asset developers, compared to what sketches alone can provide. Modeling normally requires specialized skills in using many different tools and camera perspectives in order to work on a 3D object using 2D interfaces, lending precision and detail but at the cost of heavy workloads.

On the other hand, modeling in VR lets you work in the natural 3D environment by actually moving and shaping in the real-world, room-scale environment. In this way, 3D modeling is more like working with clay than it is adjusting vertices in a modeling app. This approach is not only much faster when creating low-detail prototype assets, but also much more accessible to people with no modeling skill whatsoever.

Benefits of Google Blocks low poly models

Google Blocks provides a simple “build by creating and modifying primitives” approach for VR and allows quick volumetric “sketching.” This combination of modified shapes and simple colored surfaces also lends itself to an aesthetic style that is clean-looking and low poly. This means much better performance, which is going to be extremely useful during the prototyping stage where performance will not yet be optimized. The clean look can even be used as-is for a fairly good-looking presentation.

Revised workflow for VR development

The new workflow for production shifts from start and stop “waterfall” development to one where the code team can provide prototypes of anything they need during the prototyping stage without waiting on the asset team. This approach allows the asset team to take the prototype models and preproduction sketches and develop finished assets that can be simply swapped into the working prototype that the code team has already put in place.

It’s easy to think you can just use primitives within a development tool like Unity* software to do all the prototype “blocking” you need, but the lack of actual rough models can lead to difficulty in developing proper interactions and testing. You will often find your progress hindered when trying to build things out using cubes, spheres, and cylinders. With the new workflow, you can quickly obtain shapes closer to finished assets and provide additional direction for the development of finalized assets as a result of what you learn during interaction development.

Tools Overview

Let’s lay out the tools we’ll use for development. All of them, except HTC vive*, are free. As mentioned, we’ll use the Google Blocks app to build models in VR using HTC vive. Next we’ll export and share the models using the Google Poly* cloud service. Then we’ll use the models in Unity software for actual development. Finally we’ll work with the models in Blender* for finalized asset development. You can also swap Blender with Maya*, or with whatever your preferred 3D modeling app is, and replace Unity with the Unreal Engine* (also free-ish).

Using Google Blocks

Because we will be using HTC vive for our VR head-mounted display (HMD), first download Steam*, and then install Blocks from here

When you start Blocks for the first time, you’ll get a tutorial for making an ice cream cone with all the fixings:
https://www.youtube.com/watch?v=kTCcM5sRz74&feature=youtu.be

This tutorial is a good introduction to using the basics in Blocks.

• Moving your object
• Creating and scaling shapes
• Painting objects
• Selecting and copying
• Erasing

You have many more tools and options at your disposal through the simple interface provided. Here’s an overview of all of them:
https://youtu.be/41IljbEcGzQ

Tools list

• Shapes: Cone, Sphere, Cube, Cylinder, Torus
• Strokes: Shapes that are three-sided or more
• Paintbrush: Color options on back side of the Palette, Paint Objects, or Faces
• Hand: Select, Grab, Scale, Copy, Flip, Group/Ungroup
• Modify: Reshape, Subdivide, Extrude
• Eraser: Object, Face

Palette controls

• Tutorial, Grid, Save/Publish, New scene, Colors

Extra controls

• Single Grip button to move scene, both buttons  to zoom/rotate
• Left/Right on Left Trackpad to Undo/Redo
• Left Trigger to create symmetrical
• Right Trigger to place things

Files (left controller menu button)

• Yours, Featured, Liked, Environments

You also need to initiate an option using your mouse, in order to import a reference image (or images) that you can place in the scene. This is a great way to go from preproduction sketches to prototyping without having to rely on memory. To import an image, click the Add reference image button in the top center of the screen on your desktop.

Google Poly

Before we go any further into modeling in Blocks, let’s take a look at Poly, Google’s online “warehouse” of published models: https://youtu.be/qnY4foiOEgc

Poly incorporates published works from both Tilt Brush and Blocks, but you can browse specifically for either by selecting Blocks from the sidebar. Take a moment to browse and search to see the kinds of things you can make using shapes and colors without any textures needed. As you browse, be sure to click Like to make it easy to find them inside Blocks.

Also be sure to note which models are under a sharing or editing license. You can only modify and publish changes to a model if it is marked remixable. Currently any models marked remixable require you to also credit the author, so be sure to do so if you use any remixable models as a base for something in an actual project.

Now let’s take a look at the specific Blocks model you’ll be using as a base to build content for: https://poly.google.com/view/bvLXsDt9mww

After you’ve Liked it, to load it easily from inside Blocks, click the menu button on the left controller, and then click the heart option to see your Liked models. Then select the house and press Insert.

Starting out, the house will be scaled like a diorama. To make it bigger, grab it with the grab tool (the hand) and then press and hold Up on the right Trackpad (the +) to scale up. Once the size is what you want, you can use the controller grips to move and rotate it.

Rendering performance may suffer depending on your computer due to the complexity of the model, but this shows you an example of how such a complex scene is composed and lets you even modify it for your own purposes. Once we start using Unity software we will be using a prefab version I’ve modified to reduce complexity and add collision boxes, saving time. Now let’s set up the Unity software with VR implemented so we have a place to put what we make.

Unity* Software Project Setup

Importing plug-ins

First we’ll create a new project (save it wherever you like). Next we’ll need to import the SteamVR* plug-in to support vive: https://assetstore.unity.com/search?q=steamvr

You may have to tweak your project settings to meet its recommendations. Click Accept all to do this the first time. It may ask you again after this, unless you’ve modified your project settings. Just close the dialog in the future.

Next we’ll grab a great toolkit called VRTK, which makes movement and object interactions easier: https://assetstore.unity.com/search/?q=vrtk

We won’t cover the details of how to use the VRTK plug-in for this tutorial, but we will be using a sample scene to handle some things like touchpad walking. The VRTK plug-in is fantastic for making quick interactions available to the things you make in Blocks. To find out more about using VRTK, watch this video:

We’ll use the sample scene “017_CameraRig_TouchpadWalking” as a quick starting scene, so load that scene up and delete everything except the following:

• Directional Light
• Floor
• [VRTK_SDKManager]
• [VRTK_Scripts]

Next, scale the X/Z of the Floor larger to give you more space to walk around and place things.

Importing the prefab

Grab the prefab of the house model we looked at earlier to import into your scene: https://www.dropbox.com/s/87l8k23pc3h4a40/house.unitypackage?dl=0

Be sure to move the house to be pretty flush with the ground:

Then you should be able to run the project, put on your HMD and walk around in the scene using the touchpad to move. You could alternatively have imported this into a different example scene that used a different form of locomotion (all the example scenes are labeled) such as teleporting if touchpad movement is uncomfortable to you.

If you want to skip these set-up steps and go directly to importing the house, you can download a copy of the fully set-up Unity software project here: https://www.dropbox.com/s/cehr2wxhi6nmh6c/blocks.zip?dl=0

Outside of colliding, right now you can’t interact with anything when you move through the scene. To see the original FBX that came from Poly, in the Test Objects folder, open model 1. Now you have a nice little VR scene to start adding things to.

Building Objects

Now that the scene is set up, we have to decide what to prototype to add to it. Depending on what we want to add, there are two approaches: build something from scratch or remix something from Poly. For demonstration purposes, we’ll do both.

Let’s say we want to turn the house into a kind of cooking and training simulator, and we need more interactive props with shapes that are a little more complex than primitives can offer. We’ll start with a simple remix of two components to create a frying pan with a lid.

Combining objects

We’ll use the following two remixable models to mix into one, so be sure to Like them:

• Frying pan: https://poly.google.com/view/bYF5rVRy_kp
• Saucepan with lid: https://poly.google.com/view/2iOIFA7Sgtg

Let’s combine them: https://youtu.be/SbjSs_rcFbk

You might be wondering why we couldn’t just bring both objects into Unity software and do the mixing of objects there. This highlights the importance of the two download options you can get from Poly: OBJ and FBX. When you download an OBJ, the entire model is a single mesh, but with an FBX the model is a group of all the individual shape pieces.

This makes a difference in how you can use the model within the Unity software. Having an entire mesh as a single object can be useful when putting on mesh colliders and setting up objects to be interactive via VRTK. The two models we are remixing are available only as OBJ files, so we can’t modify the individual parts within the Unity software. However our new model will be available as both (sometimes it takes time for the OBJ option to show up under download).

Now let’s download the FBX and import it into the Unity software using drag and drop, as we would with any other file, and then we’ll drop the object into the scene.

Testing the scene

Once you’ve got the object placed, click play to hop into the scene and check the scale. If the scale doesn’t look right, select the whole model group to adjust it. Now you have a simple object to use for interactive prototyping with VRTK that will be much more effective than using a couple of unmodified primitives. You also have a great starting point for refining the model or adding extra details like textures.

What’s really cool is that you could also have inserted the house object into Blocks first and modeled the pan (or any other accessory) while having the full house for reference, and then deleted the single house object before saving and publishing, without even having to go into the Unity software.

Creating a model

Now let’s look at making a quick, simple model—a cheese grater—from scratch. This model is more than a simple primitive, but not overly complex. We’ll also make a block of cheese with the kind of crumbly edge you get when you slice it. You’ll notice that I used the menu button on the right wand to group and ungroup objects for easier manipulation, and I also used the modify tool for both edges and faces. See Video:

Because you can import this model as an FBX into the Unity software, you can easily separate the cheese from the grater for different interactions but do it as a single import.

If you prefer using Unreal Engine over the Unity software, first read about FBX workflows with that engine: https://docs.unrealengine.com/latest/INT/Engine/Content/FBX/index.html

Working with a Modeler

Importing into blender

Once you have the FBX or OBJ files you or a modeler want to work with in a full modeling package, you can import them into a free program such as Blender.

From there you can edit the model, animate it, or perform other operations.

Exporting for Poly

If you want to be able to share the model using Poly again, you can export it as an OBJ (with an MTL materials file).

Next, click the upload OBJ button on the Poly site.

Finally, drag and drop the .obj and .mtl files onto the page, and then click Publish to publish the model.

The disadvantage, however, is that the model is a single mesh OBJ, and you also can’t use it in Blocks to remix or view, so it’s useful mostly as a way to quickly share a full model. But this can also be a great way for a modeler to show you the work in progress (as well as allow you to download the OBJ for testing in the Unity software). Keep in mind that files uploaded this way won’t show up in Blocks even if you Like them. So pay attention to objects you Like to see if they say “Uploaded OBJ File,” because that won’t be usable in Blocks.

Review

Let’s review what we covered in this article.

• Take preproduction reference images into Blocks when you have them.
• Quickly “sketch” usable models in Blocks.
  • Use remixable models as starting points when it makes sense.
  • You can bring in other models to use for reference or scaling purposes.
• Publish your models to Poly (you can choose to make them unlisted).
• Download the OBJ or FBX, depending on your needs.
• Import the model into Unity software for prototyping.
• Share the Poly page with a modeler so they can modify the OBJ and FBX or simply use it as a reference along with the preproduction sketch and even screenshots (or a playable version) of the Unity software scene to begin developing a finalized asset in a tool like Blender.
• The modeler can also use Poly as a way to provide you with quick previews that you can download and insert in your scene.
• Rinse and repeat to quickly build your commercial or gaming project!

Click here to Join the Intel® Game Dev program for free tools, resources, and opportunities to help you bring the best game experience to the biggest worldwide audience

Source: https://software.intel.com/en-us/articles/using-google-blocks-for-prototyping-assets-in-vr