PlayUp - Making it Easy to Make Games - www.PlayUpTools.com

Support Added for Master Material Files in CE3

2012-02-11T21:36:00.001-05:00

PlayUp Alpha ver 0.9.8.5 supports master material files in CryEngine 3 and is now available for download. You must enable this feature from the CryEngine 3 tab in the PlayUp Preferences window as shown below:

If you export again with the same master material filename, it will overwrite your original master material file. If you don't want it to overwrite the file, rename it in PlayUp Preferences.

There is, however, a quirk with using this feature. Since there does not appear to be a way to specify a material file name for a given mesh to RC.EXE, your entities will appear in CryEngine with "Replace Me" textures. For example, when exporting these entities from SketchUp:

You will notice that they will come into CryEngine 3 like this:

You will need to select all of the objects, open your Material Browser, select the master MTL file, and click on button to apply the material set to the selected objects.

And that's it. It's an extra step, but it's pretty painless.

Not much testing went into this build, so please leave feedback on the PlayUp Tools Facebook page if you run into issues.

Major Exporter Improvements

2011-10-23T03:46:00.001-04:00

PlayUp Alpha ver 0.9.8.4 is now available with some especially nice fixes to the Unity3D and CryENGINE exporters. Unity users are required to install the new PlayUp package for Unity for this update to function properly. Some of these fixes include:

Meshes are now coming in at the correct scale in Unity
(1 meter in SketchUp = 1 unit in the engine)
Meshes that are not imported as a level are no longer coming into Unity at a 90 degree rotation when you pull them from the Project window
Mirrored and rotated meshes, whether nested or not, are now coming in at the correct rotations and scales when exported as a level to Unity or CryENGINE

Both CryENGINE and Unity3D exporters now have a new global merge option available in the preferences that allows you to choose between exporting every component/group as it's own mesh, or collapsing all nested meshes into the top level component or group.

For example, if you have a component of a dining room table but you would like the chairs and table to be separate entities in your game engine, you could select "All nested meshes export as individual meshes" in the preferences window and export as a level.

And finally, there is now a way to check from within SketchUp to see if you have the latest version of PlayUp. Simple go to Plugins > PlayUp > Check for Updates.

Exciting UI Changes and Dynamic Entities

2011-09-07T10:59:00.006-04:00

This build (PlayUp Alpha ver 0.9.8.3) comes with a number of improvements and changes. To begin, the UI now takes advantage of Silverlight 4 to open up new possibilities for improving and expanding PlayUp. There is a new Geometry Properties window so that you can easily select between components and groups to view the PlayUp properties (as well as the name that will be used on export). Icons have been added to the toolbar to access this window as well as quickly export a level. The buttons on the bottom of the PlayUp Preferences window have also had a minor tweak.

Of course this build also makes a second pass at the level export functionality for CryENGINE 3, providing major improvements to top-level entities that have been scaled, mirrored and rotated. It's not perfectly getting every rotation right yet, but it's almost there.

Another exciting development is that you can now set entities as "dynamic" for CryENGINE 2 and CryENGINE 3 so that they can have basic rigidbody properties. And finally, the three extra collision flags that CE3 provides are available, but have not been thoroughly tested. So please, give feedback. :)

And to preemptively answer some additional questions that might be on your mind...

Why use Silverlight when wxSU can do the job?

wxSU definitely has its benefits. For one, it is quicker to implement. You only have to work in Ruby to do it, whereas Silverlight requires you to make XAML, C#, Javascript and Ruby play nicely with each other to get it to work. That said, the possibilities with Silverlight are far greater. It can support just about every crazy feature idea that's come up, and make it look great to boot. And unlike wxSU, it's a heavily supported product backed by Microsoft.

Ok, so why are you still using wxSU for the PlayUp Preferences then?

A major stumbling block with many of these UI packages that are meant for Internet use is that they limit developers from being able to do certain things that may put a computer at risk. One of those things is being able to send a full filepath name (which PlayUp needs in order to know where your models and levels need to go). You would not want a web browser application to have access to your directories, so like many other UI packages, Silverlight blocks developers from accessing it.

These packages obviously weren't designed with SketchUp plugin development in mind like wxSU was, so I am keeping wxSU around for this particular function.

What are these new icons?

The middle one is to bring up the Geometry Properties window and the right one is to export the level.

Why are the Geometry Properties fields grayed out?

Currently you can only modify one component or group at a time, so it will only allow you to change those fields when you have one (and one only) selected.

Why are there icons on the dropdown boxes?

It shows which engines current support which choices. If you choose something that is not supported and export, the default setting will be chosen.

The Unity 3D icon is not on the default setting for collision. In fact, their really are no choices for Unity 3D in the Geometry Properties window. Why?

Unity 3D is not like other engines. There is no default "sandbox" where you can throw in some terrain, hit a key, and run around shooting at stuff. It's a very broad engine that doesn't gear itself towards an FPS style (both its strength and its weakness).

That said, I do have some ideas brewing for Unity 3D... but I'm waiting for version 3.5 as I understand they are going to open up the engine a bit more.

First Pass at CryENGINE 3 Level Export Process

2011-08-23T11:31:00.003-04:00

PlayUp Alpha ver 0.9.8.2 is now available in the Downloads section. This build contains a first pass at level export functionality for CryENGINE 3 users. Now you can export a level file as a layer and import it into CryENGINE 3 by going to the Layers tab and clicking on the Import Layer icon. That said, rotations & mirroring for the top level components/groups are not yet working correctly in the level export process, and they may export a bit strangely if you rotate/mirror them. Nested components/groups are not affected by this issue.

Also worth noting:

- Collisions are now enabled by default.
- If you forget to name a group before exporting, PlayUp will name it for you.
- The material path problems that I missed in the last build are fixed.
- Warnings should appear if you try to export a single model over the vertices limit. (This is not yet working properly for the level exporter.)

New PlayUp Version Available with CryENGINE Fixes

2011-08-20T11:30:00.008-04:00

PlayUp Alpha ver. 0.9.8.1 is now available in the Download section. Don't be fooled by the small increment in the version number. This new version is important for CryENGINE users. Essentially it fixes a lot of the problems people have been having with the materials showing up. Now, whether you're in SB2, SB3 or the CE3 Standalone SDK, your material paths in the MTL files will be pointing to the right place. You should no longer have to reassign materials in the Material Editor. Also, if you apply SketchUp colors instead of textures, it will no longer look so washed out in CE3.

A couple of additional notes:

1. Re-arranging Materials: It's come to my attention that if you have the Material Editor in CE3 open while you are exporting from SketchUp, the materials may end up mapping to the wrong parts of the entity. I will work on fixing this, but in the meantime, please do not look at the materials in the Material Editor that are related to the materials of the object you exporting while you are exporting them.

2. Dwindling Sandbox 2 Support: I upgraded to a new machine recently, and had to dig around for the old Mod SDK for SB2 that works with PlayUp. All I found were broken links and dead ends. Additionally, the last Mod SDK for Crysis that they had posted was riddled with texturing issues. So today I had to step back and ask myself whether it was worth continuing to support an engine that is obviously getting phased out. If you have an opinion, please visit the PlayUp Facebook page and answer the poll question or leave a note.

EDIT: Since someone asked to clarify what was going on with the colors in CE3, here is the explanation...

The RGB value 255, 128, 128 would normally map to 1, 0.5, 0.5. In CE3 however, it was mapping to 1, 0.21951973, 0.21951973 which was causing the diffuse colors to come in looking desaturated and washed out. They are mapping the RGB values to a curve instead of a line, so in the new version, PlayUp is now passing those RGB values through a new function so that the diffuse values show up correctly in the Material Editor. I'm not entirely sure why they did this, but there it is. :)

PART VII: Must Have SketchUp Plugins

2011-08-15T23:54:00.002-04:00

7. Must Have SketchUp Plugins

Author: bac9-flcl

While SketchUp tools are pretty much sufficient for work, there are several plugins that can greatly help you.

First, install LibFredo6 - important shared Ruby library required for lots of plugins mentioned below. It is available there, detailed instructions on installation provided: http://forums.sketchucation.com/viewtop ... 47#p144178

Now let's get see the plugins.

7.1. RoundCorner

Author: Fredo6
Thread: http://forums.sketchucation.com/viewtop ... 23&t=20485

Excellently executed plugin, allowing you to round, sharpen and bevel edges of any configuration and complexity. Detailed documentation and intuitive interface. Greatly helps in modeling workflow, both when working on optimization (e.g. chamfering edges to reduce smoothing groups count) or on complex props (e.g. various machinery with complicated metal parts).

7.2. Joint Push/Pull

Author: Fredo6
Thread: http://forums.sketchucation.com/viewtop ... 180&t=6708

Another great tool. The .gif is self-explanatory - it is extending the well-know Push/Pull tool functionality, so that the same operation can be performed with multiple surfaces at once, and, practically, with a surface of almost any configuration. Very useful for architecture, e.g. for creating volumetric solids curved in multiple axes or building elements extruded along the walls.

7.3. FredoScale

Author: Fredo6
Thread: http://forums.sketchucation.com/viewtop ... 180&t=6708

A set of purely awesome tools from the same all-mighty Fredo6:

With FredoScale you can orientate the selection box around a set of objects and interactively apply a number of geometric transformations, such as Scaling, Tapering, Stretching, Plane Shear, Twisting, Bending and Rotation. By extension, some transformation can be done without a selection box.

The .gif is self-explanatory. The plugin can be very helpful for working with deformed/destructed objects and complicated surfaces.

7.4. TriangulateFaces

Author: CPhillips; TIG; ThomThom
Thread: http://forums.sketchucation.com/viewtop ... es#p288957

A simple but really handy tool that triangulates the selected area of the mesh. As you know, you're working with non-triangulated geometry in SketchUp, but sometimes it's needed to look at the triangulation structure to check it, or even to manually set the proper triangulation in some problematic areas prior to the export process. Also, even though it is not actual for PlayUp users (errors are fixed in it's own pipeline), 3ds Max users can find it helpful: fully triangulating your model with this plugin prior to export is fixing all invalid faces your model may contain.

7.5. Tools On Surface

Author: Fredo6
Thread: http://forums.sketchucation.com/viewtop ... 80&t=11212

Tools on Surface is a Suite of Tools drawing on curved surfaces, with lines, various shapes, offset and Freehand / Polyline. It provides an inference mechanism, a Contour Editor and a dedicated Eraser.

7.6. BezierSpline

Author: Fredo6
Thread: http://forums.sketchucation.com/viewtopic.php?t=13563

BezierSpline draws a variety of Polylines, Bezier and Spline curves, all in 3D. All curves are based on a sequence of control points, which is entered by the user in interactive mode. Handy when you need something more complex than default SketchUp circular curves.

7.7. Cleanup

Author: thomthom
Thread: http://forums.sketchucation.com/viewtop ... 23&t=22920

This plugin does it best at optimize and clean up a model. Features include fixing of duplicate component definition names, purging of unused items, erasing of hidden geometry, duplicate faces, lonely edges, removal of edge materials, repair of split edges, relocating geometry to Layer0 and merging of identical materials & connected co-planar faces.

7.8. SketchyFFD

Author: CPhillips
Thread: http://forums.sketchucation.com/viewtop ... 180&t=6029

Powerful transformation tool that can be used with FredoScale.

7.9. Sculpt Tools

Author: BTM
Thread: http://forums.sketchucation.com/viewtop ... 23&t=20781

Set of sculpting tools that can be used where the usual Sandbox toolset isn't powerful enough. Includes Bulge, Push, Smooth and Smudge, along with Planar Lock. Stability of work on latest SU versions is not confirmed.

7.10. Shape Bender

Author: Chris Fullmer
Thread: http://forums.sketchucation.com/viewtop ... 23&t=18210

This script will bend an existing group to match a curved line or series of connected lines. Can be useful for modeling of some geometry, e.g. serpentine roads.

7.11. Follow Me and keep

Author: wikii
Thread: http://forums.sketchucation.com/viewtop ... 23&t=16465

Enhancement for Follow Me tool that is preserving the orientation of profile on 3d paths. Useful for some cases of spline-based modeling.

7.12. Extrude Tools

Author: TIG
Thread: http://forums.sketchucation.com/viewtop ... 23&t=25362

A powerful set of Extrude tools with various output. Useful for work with curved surfaces.

7.13. UVTools/UV Bridge

Author: Whaat
Thread: http://forums.sketchucation.com/viewtop ... 23&t=23725

Beta version of a very promising plugin with basic UV mapping functionality, and, most importantly, UV Bridge feature that's allowing you to export certain geometry to external software (e.g. 3ds Max or UVLayout), create complicated mapping layout there, and then import it back into your SU model.

7.14. Perpendicular Face Tools

Author: Chris Fullmer
Thread: http://forums.sketchucation.com/viewtop ... 23&t=17396

Helps to create faces perpendicular to the end of lines, can come in handy when working with complex irregularly oriented surfaces that require reference plane; or in cases when complicated rotation orientation is required.

7.15. Curviloft

Author: Fredo6
Thread: http://forums.sketchucation.com/viewtop ... 23&t=28586

Curviloft is a script dedicated to Loft and Skinning, that is, generation of surfaces from contours.
Loft by Spline joins separate contours, open or closed, by smooth splines; Loft along Path joins contours, along a given rail curve; and Skinning create surfaces bounded by 4 or 3 contiguous contours. Very powerful tool, the best for closing any hole in any model or for spline skinning.

7.16. PlayUp

And, of course, PlayUp Tools.
Be sure to use the latest version that you can get here: http://www.playuptools.com/downloads/

***

I should say that installation and usage of aforementioned plugins is not mandatory nor critical in most cases, they are mostly for enhancing your workflow in some specific cases. Don't rush with installing them if you're not sure if you really need them. Enjoy! )

The list does not pretend to be complete, so feel free to check this forum for other interesting plugins that can be out there:
http://forums.sketchucation.com/viewtop ... 23&t=16909

I'd recommend to register on that forum and keep an eye for the Plugins section, as something new and awesome appears there literally every day, so who knows, maybe you'll find a UVW plugin or something that awesome there tomorrow. )

PART VI: Asset Creation Guidelines

2011-08-15T23:49:00.003-04:00

6. Asset Creation Guidelines
engine requirements and model optimization
Author: bac9-flcl

This tutorial is partially relevant only to the current Crysis 2 CryENGINE 3 build, and will be updated with standalone SDK release. It will also be updated with the development of new SketchUp & PlayUp features.

6.1. Basic requirements

The first things you should know are, of course, modeling guidelines and asset performance guidelines by Crytek, available on the official SDK documentation wiki:

Read these carefully.

Now a bit of disappointing facts: you should know that some of the optimization techniques mentioned in these documents are not available for use in SketchUp and PlayUp, at least in the current versions:

Physics Proxy
Occlusion Proxy
Level of Detail Objects (LODs)

Also some of the important art techniques are not available too:

Vertex colors & Blend Layer (vertex alpha)
UVW Mapping

But don't be frustrated, there are no obstacles around for the future implementation of LoD and Proxy geometry support; and UVW Mapping is not required for most architectural objects so all you should really envy 3ds Max users for is that awesome texture blending/coloring available to them.

6.2. Why bother?

Why we need to optimize the models at all? There are two reasons, and measures to conform these can be different:

To export your model at all (exporter requirements)
To improve ingame performance with your models

While the second one is optional depending on how close your PC configuration is resembling some NASA supercomputer, the compliance with exporter requirements is mandatory. Let's cover them first.

6.3. Exporter requirements

To make it clear: we're speaking about the current build of CryENGINE 3, some changes in limits and requirements can occur in the future releases.

The are two major requirements. The first one: the vertex count of a single .cgf object should not exceed 64000. Total vertex count is one of the most important parameters of your model, watch it.

Problem is, it is nowhere to be found in standard SketchUp stats, so, until some external plugin arrives (shouldn't be hard to make one) we can't keep an eye on this parameter. Fortunately, compliance with other requirements and common sense in model detail in 99,9% cases gives you a model that's suiting in that limit. )

The second one: you can't use more than 32 materials in your model. This one is simple both to keep an eye on, and to comply (usually you'll never need so many).

Now let's talk about ingame performance.

6.4. Performance guidelines and advises

There are two most important aspects you should keep an eye on to ensure your model is working fast in the engine:

Drawcall count: how many times the engine needs to send geometry and texture information to the GPU.
Vertex count: self-explanatory term.

Again, I recommend to check the aforementioned guidelines written by Crytek: there are lots of helpful advises on how to optimize both parameters. If you aren't sure you understand what they mean and how they appear, I have another article to help you out.

I've intended to write a long wall of text with detailed illustrated explanations there, but it turns out there is the excellent article written by Guillaume Provost for Game Developer magazine in 2003. Here's the part one, and here's the part two. I strongly encourage to read it to understand many topics from the basic concepts of optimized level design to the reasons behind vertex count increase in the engine comparing to the source model. Nothing really changed much in this since 2003.

OK, I may have escaped the duty to write a massive tutorial, but I still should provide some examples on how I save drawcalls and reduce vertex count. First, let's look again at this great illustration from Guillaume's tutorial:

Actual vertex count you have in the engine is sometimes 2-3 times bigger than the vertex count a model originally had, because there your model is being additionally split by a lot of criteria. The illustration gives you a basic idea how.

For example, this kind of seemingly simple surface:

Is in fact no less than six separate surfaces for the engine:

Because every face there is situated at right angles to the others, i.e. is in different smoothing group. The engine will work faster with your model if your faces will be attributed to the same smoothing group.

You may already know about selecting faces and using the context menu action Soften/Smooth Edges. While it's handy for situations like mass smoothing of curved surfaces, it's not that easy to achieve desired result with it sometimes. There is a lot faster way to smooth edges: with the Eraser tool. Hold the Ctrl hotkey while using Eraser on the edges, and they will be smoothed instead of being deleted. You can also hold Ctrl+Shift to harden the desired edges back. By the way, you can select the Eraser tool itself by pressing the E on your keyboard. It's worth to remember hotkeys for all commonly used tools as it will tremendously speed up your workflow.

OK, so having less smoothing groups is good, but if we'll try to smooth the edges:

The lighting will just look plain ugly. How to avoid that? Easy, - just spend additional faces to chamfer the edges like that:

Or like that:

This way the shading gradient will be distributed on the middle surface only, and won't affect the proper lighting of the main surfaces. And don't worry about the increased polycount - the new geometry is still easier for the engine to work with than the old one, because if you'll look closely, you'll see that the vertex count there is the same as with separated right angled adjacent faces, while you get a nice, more detailed look and faster calculations.

If you're interested how I've produced these chamfered edges, check the next part of the tutorial for the RoundCorner plugin.

But here we are entering the dangerous area of conflicting requirements from different optimization aspects. Do you remember the FP16 limitations on vertex position precision?

Let's repeat again what we have there: there are vertex and drawcall counts which should be as low as possible, and there are several ways to optimize your geometry:

Chamfered edges + combined smoothing groups: better performance, but all the produced vertices are in dangerous proximity (depends on object size). Vertex count is the same.
Separating your object into several files: smaller volume -> smaller vertex coordinate range -> better vertex coordinates precision, less risk of lost or incorrectly positioned vertices appearing, but thedrawcalls count is multiplied, so performance is worse. Vertex count is increased too, comparing to the solid model.

Here is an illustration of these relations:

Basically, it can be narrowed down to the following principle:

The smaller details you need, the smaller your model should be. Vertex welding and position artifacts should be avoided at all costs, even if it means that your object will use more drawcalls or slightly more vertices.

As an example, I recommend to take a look at Crytek's skyscrapers models. These are consisting of several files: multiple lower-level parts that are excessively detailed and usually closely observed by a player, and the top part with low-frequency details.

If the next SDK version will be using FP32 vertex format, it'll be great news, but you should know that even with it, you will always have to use small details in large-scale objects very carefully, and preferably separate them.

If you're interested in performance priorities, drawcalls count optimization is the first one to worry about. It's not bad if you miss thousand or two of vertices in possible optimizations, but every drawcall matters. The only thing that can justify sacrificing drawcalls is, as stated above, keeping your models properly converted. If you are sure that, in some case, the geometry separation is not needed to preserve the precision of vertex positions, - don't do it.

6.5. Side notes

I should also specify that:

By "model separation" above, I meant separate .cgf files, NOT your entire component hierarchy. Don't worry, everything you export with PlayUp is a solid mesh without any preserved substructure. You aren't multiplying drawcalls amount by using components or groups in SketchUp.
You should use the "Enable Collision" PlayUp option carefully. The collision is not meant to be calculated with the fully detailed main mesh, every Crytek asset is using a special separate geometry called physics proxy which is as low-detailed as possible ensure that there won't be any massive performance drop. But, as for the moment PlayUp is not supporting the proxy geometry, i.e. exporting several separate meshes inside one file.

You can still create the simplified geometry for collision calculations in SketchUp as a separate component, and store it for the future use. Or you can try to export it in the separate file, apply the invisible collision proxy material to it and place it to the same position where the main, non-physicalized mesh stands.
LoD and occlusion proxy export are not available at the moment too, but it's still worth to create and keep them for future use. They drastically affect the performance, and are important parts of almost every model. So don't worry if your current assets are working quite slow at the moment, I can be fixed later.

Keep in mind that examples of optimizations above only scratched a surface of the subject. There are hundreds of ways to reduce your polycount, vertex optimizations, examples of good model separation etc. You'll eventually know them all with practice.

Just try to keep every count you have in your model (from materials to vertices) as low as possible. )

>> PART VII: Must Have SketchUp Plugins <<

PART V: Export to CryENGINE 3

2011-08-07T00:01:00.004-04:00

5. Export to CryENGINE 3
introduction and PlayUp usage

Author: bac9-flcl

For this tutorial, I am going to assume you are already familiar with CryENGINE 3 Sandbox editor, particularly with Material Editor and Brush utilization. I am also going to assume you've seen the previous tutorials on SketchUp, and followed proper modeling/texturing guidelines.

5.1. Basics

So, we are ready to export a model into the engine. It is properly assembled and optimized, neatly textured and even lacking the backfaces. Great, let's get to work.

I won't duplicate the already existing tutorial on installation and initial configuration of PlayUp plugin, it's available on the official site. Read it if you haven't already.

This particular tutorial is covering the export to CryENGINE 3, but I suppose that with several reservations it applies to CryENGINE 2 too.

Here are the things you will need in order to work.

Google SketchUp 8
PlayUp Tools
Crysis 2 1.9
Crysis 2 Mod SDK

You should also decide on where your objects should be exported and where you will store the other resources.

Models; e.g.: D:\...\Crysis 2\Mods\Project\GameCrysis2\objects
Texture library; e.g.: D:\...\Crysis 2\Mods\Project\GameCrysis2\textures

Note that these requirements and file paths are actual only for current SDK which requires Crysis 2 to work and is tied to the game in a number of ways. The tutorial will be updated after the standalone SDK release (somewhere in the August).

To avoid confusion and loss of your own files in the wilds of Crysis 2 resources, I recommend setting up the Mod and utilizing the corresponding folders from it: this way you won't need to remember paths to your models and textures in all that mess of several thousand files. Just like I did for example paths above.

I also recommend to keep an organized file structure and separate different kinds of objects, e.g. group the objects per type, utilize folder hierarchy etc. But the PlayUp exporter is saving all your objects in one folder you've specified in the export preferences:

So use this folder as temporary: objects will arrive there and then you'll relocate them anywhere you like. Name it "temp" or "import", doesn't really matter.

Ok, enough with these advices, let's export something.

5.2. Export process

We'll start with a simple object. Create a cube.

Here is the first requirement: everything you intend to export should be stored in a group or a component. Free geometry can't be exported.

So select our cube and make a component from it.

Note that the name you've specified for component will be the name of produced file. That could have been an optional subject if there wasn't one issue: as it will be used as the file name, you should avoid any symbols that are not supported by Windows file system there.

Now, when the component is created, we can export the model. There are two ways you can start the process. The first one is via the Plugins -> PlayUp menu:

The second one is via the context menu. Right-click while selecting a single component and you'll see this:

The difference between them is obvious and stated in the names: use Export All Components and Groups if you're intending to export the whole model and use the Export Selected Geometry when you want to export only a certain part. For objects of significant size and detail we'll usually use only the second option, - as they are to be exported in parts for a number of reasons we'll cover later.

Hit the "Export Selected Geometry". If everything went smooth, you'll see the following message:

Check the export folder, you should see the following new files there:

Now open the Sandbox editor. The easiest way to check if you're object is there is to open the Brush scroll on the first RollupBar tab and look for it. Here, we've got our cube:

Drag it into the viewport to see it in all beauty.

OK, we've got several problems. First, even if you haven't applied any materials and textures on the model, PlayUp should have used the placeholder texture playup_nomaterial.dds (some 32x32 light grey fill), and it's not displayed for some reason (I'll explain why a bit later, let's deal with more important issue first). Second, the standard CryEngine "Replace Me" placeholder texture which we're seeing here is for some reason extremely small scaled. Take a closer look:

But why is it so small? Let's examine the default (empty) SketchUp material window:

Here's important thing: if you don't have any materials applied on your model, it's filled with "default" SketchUp material instead. As you remember, every SketchUp material has a size. Take a closer look, even this locked empty template has one:

The material size is basically the tile size in UV space. While it may seem not important for an empty material, or for a material with only a diffuse color...

... It actually is important. Let me explain why.

For example, many level designers like to create a non-textured prototype geometry, import it and play with applying different materials later, right in the editor. Problem is, with default 10cm sized SketchUp mapping scale, you'll end up with something like this instead of relatively proper-scaled materials.

So, basically, that's how our model should look after the export, in the worst case scenario.

How can we set up the proper tile size? Well, I suppose the default one is hardcoded somewhere, so here's the rule that will allow you to avoid the problem:

PLAYUP TOOLS DEVELOPER NOTE: Regarding the note below, I wouldn't say "never". If you use a diffuse color instead of a texture, PlayUp exports a texture called "playup_nomaterial.tif" and changes the diffuse values of the color to match what is in SketchUp (the path is current bugged for exports to the Mods/ directory but still works for exports in the Levels/ directory). Some people may want to just make models with colors instead of textures, so in this scenario it is not necessary to bother with making textures for it. If you plan on going back and adding a texture later, then yes, you should do what is suggested below.

~~Never use the default material or any other non-textured material in your model.~~ If you don't need any textures, create a material anyway, assign some placeholder texture to it and set up the proper size in properties (the size configuration fields are locked until you enable the texture).

I also suppose that having hundreds of tiles on screen instead of one is not good performance-wise, so it's a healthy thing to do anyway. So let's fix that.

By the way, you can rename the component via the context menu option "Entity Info", - it can be useful if you want to re-export some component (e.g. after editing it to be an alternative prop type) without overwriting the previous model.

So, after these edits and exporting we should finally get a properly looking model. Here's how it looks in the engine now:

Okay, the scale is perfect now. Now let me explain why we don't see the textures. Relax now, your model is perfectly fine, we don't need to fix anything else in SketchUp.

As you remember, we've configured a path in the PlayUp preferences where the models should be saved. And they are saved propely, as you've seen a bit earlier:

As you remember from the previous tutorial on materials & textures, your textures are embed in SketchUp file, so there is no way to determine their initial location. That's why PlayUp plugin is always exporting your textures to the \textures subfolder located in the same place as your objects. It is a good solution since it is actually normal for unique props to keep textures near the objects.

As for assets based on generic textures from organized libraries, like buildings, which aren't requiring unique textures and a separate folder, - you can manually set the proper texture paths in the material editor later.

Here is our \textures subfolder with aforementioned playup_nomaterial.dds:

Everything is fine there, the texture is perfectly converted, nothing to fix. The sole reason behind missing textures is simple - it's just an incorrect path generated for the material. Open the Material Editor in Sandbox and find our material there:

Take a closer look at the Texture Maps section:

For my case, it looks like that:

Code:

D/Games/Crytek/Crysis/2/Mods/Project/GameCrysis2/objects/test/textures/playup_nomaterial.tif

But the proper path should look like that:

Code:

Mods/Project/GameCrysis2/objects/test/textures/playup_nomaterial.tif

Just remove anything before the root subfolder, or manually select the texture with Browse. Now, the first cube should look like that:

And the second, textured cube, should look like that:

Awesome! Now let's explore more complex examples.

Don't worry - If the issue with incorrect texture paths will be fixed in the next PlayUp release, I will update this part. )

5.3. Advanced object export
surprisingly short chapter

I apologize for that trial-and-error approach to writing this tutorial, but I believe practically everyone will encounter aforementioned situations and ask about them on the forums, so it's better to cover the reasons behind them right there.

For the next example, we'll use more complex model. Let's try to export some complicated object consisting of multiple component instances nested within multi-level hierarchy.

We'll also use several materials with assigned diffuse textures (for this particular example I've used two textures from Crysis 2 content library):

You can download the model from the following link: http://www.sendspace.com/file/7gam87

So how should we export such a model?

Pretty much in the same way as the aforementioned cube. Just select all the components, choose Make Component from the texture menu, choose a name for it (e.g. test_tower_04), hit OK and choose PlayUp -> Export Selected Geometry.

Reload your object browser in Sandbox for new object to appear in the list, and drag it into the viewport. We'll see this:

After we'll fix diffuse texture paths, or in case they're already proper, the object will look like this:

Good. Now let's cover some additional subjects.

5.3. Physics

What's left? Well, we have only one issue left: you can walk through the object. This unfortunate event happens because our model does not contain the collision data.

In 3ds Max, all you need to do is to hit "Physicalize" button in material properties prior to exporting your model.

With PlayUp, enabling it is easy too: just check "Enable collision" in component context menu:

And enjoy!

>> PART VI: Asset Creation Guidelines <<

PART IV: Materials & Textures

2011-08-04T23:41:00.007-04:00

4. Materials & Textures
introduction and basic advice on texture/material application
Author: bac9-flcl

4.1. Introduction

First, let's cover some basic facts.

All the textures you utilize in your model were actually embed in the file right after you pointed at them.

This leads to several pros and cons, namely you don't need to have the constant access to a heavy texture library to edit some models, but on the other hand there is a significant performance/memory/filesize hit if embed textures are huge. You should also understand that due to that feature, SU models store no paths to the textures, and therefore for export plugins (e.g. PlayUp) it is impossible to determine the proper location of the texture - they usually extract the textures in some new folder, e.g. a subfolder near the exported object itself.
SketchUp supports a dozen of image formats: JPEG, PNG, TGA, TIF, BMP, and eved PSD. The DDS image format is not supported.

The first thing you should note there is .tif texture format support, - which is simply awesome because you don't need to convert your textures to any additional format: just use the CryTif output. Though if you want to reduce memory/performance footprint, it's worth to keep JPEG copies of every texture in the library and use them for SU instead.
The only texture mapping types available in SketchUp are planar and basic perpendicular mapping; no UVW unwrap tools available.

This means that complex organic shapes like character models or complex props like weapons can't be properly textured in SketchUp. However this does not necessarily applies to simple organic objects (e.g. trees) or not too complex props (e.g. bus or computer terminal models with unique textures and simple manual unwrap)

Also, I am going to assume you've already prepared your own nicely organized texture library with .tif/.dds CryTif final output. It's not a problem if you store .psd source files or .jpg copies there too - it's useful to have everything in one place and besides, these last ones can also be used for SU.

4.2. Materials

Material and texture are different terms. Material is an entity, that is what you are applying on your model surfaces, and a texture is the one of it's properties.

However, while the material is usually associated with a kilometer-long substance containing thousands of settings, shader properties and so on, the ones you encounter in SketchUp aren't that complicated. Here it serves only one purpose: contains the texture and a tiny number of texture-related parameters.

Let's create new material. Click on the "Create material" button. The following window will be opened:

The only thing you really need to set up there is the texture file itself, and the default size of the texture. Once you're done with that, click OK and that is done with.

Remember what I've told you earlier: you should not use the built-in material library!

You should also note that if you'll click the "Create material" button while having some already existing material selected, the new material will be the duplicate of it. Of course these will be just default values, you can still change size, texture file or anything else to your liking in this case.

Let's examine several material properties more closely:

1. Name: not really important, default ones should work fine. You might want to change it to have a nicely organized material list, but that's all, at least for the current moment.

2. Use texture image: self-explanatory; in 99% cases this should be turned on.

3. Size: allows you to set the default size of the texture. Now that is an interesting subject to talk about.

Basically, you should know (at least the approximate) real physical size of every texture you've used in your library, especially if we're talking about brick walls or other surfaces with strictly fixed features scale. For example, judging by the brick type and count, this texture is of a 4,34x4,34m size:

While this one is precisely of a 3,38x3,20m:

Keeping eye on that makes your workflow easier (e.g. you can easily determine the building height from a single blurry reference photo) and makes your objects more realistic: good material and element proportions are always a plus in my book.

In some cases, the size determination of the texture proves difficult, - for example, if we're talking about a tiled rust texture where you won't usually find any features to reference real size from:

Then you should refer the modeling guidelines by Crytek. Here's some quotes from these:

The texture size that you should use for an object is related to the amount of space that the object will use on screen. For Crysis, Crytek aimed for a screen resolution of 800 x 600 pixels. Let's assume that the object will fill half the screen's height at all times (600/2 = 300 pixels); therefore, you should use at least a 256 x 256 screen, and 512 x 512 will be even better. The best case scenario will be to have 1 pixel on screen represent one pixel in the texture. Of course, this depends on how big the object is in all the dimensions, as you can't really translate the texture space in 2D directly to the amount of space it will use in 3D.
Try to keep the texel ratios for all objects, constant. This means that every object on screen uses roughly the same amount of texture pixels per meter. By doing this, you will ensure that all the objects have roughly the same sharpness on screen and that the textures don't look muddy.
Objects that are always on screen and at the same distance to the player (for example, weapons) can use a higher texel ratio in areas that are closest to the player (butt-stock, iron-sights, and the like).

The easiest approach would be to just determine the resolution of textures you want to have on your environment. It's like deciding about DPI for image prints: choose some pixel per meter budget and stick to it. For example, I tend to use 512x512 pixels of diffuse texture per square meter (for areas that are closely observed by the player during the gameplay).

For mainstream configurations or projects with high amount of unique content I'd recommend 512x512 per 2 meters, - for example, STALKER utilized that scale. You should also keep in mind that you can always compensate the lack of diffuse resolution with techniques like detail bump or detail subtextures.

All your real-sized textures should also reference the the budget in the first place. For example, the aforementioned brick walls, if encountered closely by the player, should use 1024x1024 texture as this is the resolution for 4 square meters surface and their size is close to that.

Of course there are some exceptions and additional factors, many of them are covered in the aforementioned guidelines. Read that wonderfully useful document. So, why exactly do I care so much about the default texture size in your material settings if you can resize the texture anytime during the modeling workflow?

Because it makes your texturing workflow extremely fast, that's why.

4.3. Texture mapping
get yourself a coffee and a pillow, it'll be the long story

The SketchUp is well-known for the fast modeling process, and texture mapping is not an exception: you can apply the textures to the some generic building in just several minutes, and I'm not talking about some randomly oriented misaligned slapping, - nope, we'll get the perfectly aligned seamless texture mapping.

So how do we achieve that? Let's examine the way texture mapping works in SketchUp first.

Here's the example scene with some geometry of varied complexity. It also includes the fashionable orange placeholder texture, just like the one Valve guys have. Download it, could be a useful scene to start practicing with the texturing: http://www.playuptools.com/downloads/extras/MaterialExample.skp

The first stage of the texturing is applying the material to a surface. Pick the Paint Bucket tool and watch this tutorial first:

Unfortunately, this video covers only the basic material functionality that mostly won't be used for game-targeted models at all. But you should learn how to use the Paint Bucket tool just fine from it.

When you click on the face with the Paint Bucket tool, you apply the material to this face, and then the texture specified for this material instantly appears on the surface.

Somewhat proper texture mapping is already there: you don't need to additionally specify the projection direction or participate in other fun activities e.g. 3ds Max is famous for.

No matter how your face is oriented, by default you'll get the perpendicular mapping, without any distortions.

How the actual position of the texture is determined? Actually, there is no pan or other directional shifts present: the texture is located on the 0;0 position in UV space and you just see the tiling of the texture that got to your face. Let me show you the simple illustration so that you'll understand how projection plane is determined and what affects the default texture position on the face.

Or a slightly more complicated face orientation:

Ok, so now we understand how default texture mapping works and why everything we simply fill with the Paint Bucket tool looks how it looks. Now, why I said we won't use default texture position most of the time? Here are several examples, some of them featuring the desired texture position which is not achievable with default mapping.

SketchUp is not some telepathic magician, so you should excuse him for these cases - it can't predict what position do you actually need. But we're still in a sweet situation, because, remember: we don't even need to setup the projection orientation for any faces, the textures are always applied perfectly straight and proportional. All we need to do is to change their position to a desired one.

In order to edit it, right-click on the face and choose Texture -> Position in the context menu:

The following interface will appear:

It is very intuitive and pretty much self-explanatory. You can pan the texture in the plane of the face by dragging it with the cursor, and you have 4 controller pins that you are usually dragging to transform the texture.

Object position is snapped to the red pin: you can, for example, hold it with your left mouse button and snap the border of the texture to the particular vertex or an edge.
The green pin is controlling the proportional scale of the texture (with the relative distance to the red pin) and the rotation angle of the texture (with red pin being a center of a virtual circle). Sounds complicated, but you better try it yourself, it's very easy and intuitive to use.
The blue pin controls the vertical non-proportional scaling of the texture (move it closer or farther from the red pin on the vertical axis to see the effect) and the texture skewing. This is used relatively rare as the texture size is usually proportional (or, in case of a slightily irregular size, proportions are defined in the material properties). If used, is often combined with the green pin to produce an arbitrary non-uniform scaling. Use with caution to avoid horizontal movement of the pin: the skewing must not be used to avoid problems with UV coordinates convertation in other 3d file types.
The yellow pin controls the perspective distortion of the texture and should not be used in any circumstances, as it is not supported in the common UV coordinate formats.

Take your time and practice these. It normally takes only a few seconds to configure the mapping on a surface.

Also, I remind again: never use the horizontal skewing (controlled with horizontal movement of the blue pin) and the texture distortion (yellow pin), - these types of texture transformation are not supported with the majority of 3d file formats, including CryEngine3 ones. I can't stress this enough.

Ok, so now we know how to properly position any texture, and have a good predefided default texture size (so that in most cases we don't even need the scaling functionality, only panning and rotation). But manually configuring every surface, even when so few actions are left, is still way too slow. How to speed up the workflow?

In the next example I will utilize this relatively complex object and the upgraded version of our fashionable placeholder texture, which will help us to clearly visualize the texture mapping features.

So, we need to cover all there surfaces with properly rotated and positioned textures. We start with the first face:

We edit the rotation (green pin) and position snap point (red pin):

Then we hit the Enter key and it's done with. But we don't wan't to repeat the same operation all over again for every face. So that's when we should use the Sample tool.

Press and hold the Alt key to change from the Paint Bucket tool to a Sample tool for sampling materials within your model. The cursor will change to an eye dropper.

Click on the face whose material you want to sample. Then release the Alt key to return to the Paint Bucket tool and paint the sampled material on a face.

What's so awesome about this tool is that not only does it sample the material type, but also the texture mapping itself. Let's see that on the example: we'll sample the material from our face and then will apply the material on the parallel faces around.

If we examine the mapping with the edit mode, as you can see, it is perfectly aligned:

Another example:

Well, we can still say it's not a big deal - these examples only applied on parallel surfaces, so we'll need to manually set up the position and rotation again for any new face orientation.

Wrong! The most awesome thing about the texture mapping sampling is that it even translates the mapping onto the adjacent surfaces. Here is an example:

It's like you're covering the object with wallpaper: the mapping is perfectly aligned, continuous and solid. You should also note that you can sample the previous face every time you paint the next one (over time the pressing Alt hotkey during the texture mapping would become an unnoticeable instant action), making the long sequences of faces with awesome seamless mapping:

It applies to more complicated cases too, e.g. the sampling perfectly continues rotated texture mapping on the new face without any seams:

Important note: You should know that the texture mapping sampling only works for the faces with attached texture position. Here's what I'm talking about: as you remember, there is a default texture mapping that applies your texture with projecting it prom the 0;0 point of corresponding plane. That means that the texture is not attached to the face position. You can try it yourself: move a face like that:

Having a default texture mapping basically means having no specific texture position information in your face. And as no specific information is available, sampling the material from such faces will have no effect: the same default mapping will be applied on the next areas you'll click at.

But permanently attaching the texture position to the face is very easy: just open the Texture -> Position edit mode and close it with hitting the Enter key. You don't even need to edit the position or touch the pins if you don't want to. Then it's done with, now the texture is placed relatively to your face and can be sampled alright.

You can easily determine what faces store the position information and what aren't by moving them: as you've seen above, the faces without any are exhibiting displacement of the texture even when the surface itself is selected. Faces with the position information are keeping the texture in place no matter how you move them: the only way to reproduce the displacement is to deselect the face itself and move it with the border edges.

Okay, I hope you aren't asleep yet. Sorry for long explanations, these things are utterly basic and should have been covered. Please be patient, there not too much stuff left thanks to the wisdom of SketchUp design team. )

Here's the tip on the texture sampling: actually, you don't need to press the Alt hotkey and sample every subsequent face in order to produce seamlessly painted sequence of faces: sample the texture mapping only once and then just click on the next faces, one by one, following the sequence. If there's no distractions for SketchUp texture mapping algorithm (e.g. some faces with the same material and different coordinates that are adjacent to the sequence somewhere), it'll automatically apply the proper texture positions for every face:

This also applies to more complicated cases like arcs with several adjacent face sequences. All that matters is the proper order of faces you click on:

Let's see what's left to explain yet. You should know about this useful context menu (right-click on the texture in the position edit mode):

And all that's left is one complicated case. At the moment you know how to apply textures to surfaces like this:

And like this:

But what should we do with that kind of surface?

The faces there are twisted along several axes, and simple sequential mapping translation won't do, - we'll get unattractive seams. Well, there is a solution: Projected texture mapping mode (with which you're probably already familiar with from 3ds Max/Maya, where it goes under the name of "planar mapping").

I works very simple: you can fix the projection orientation for a certain face and then translate it to other faces. Looks like a projector.

Let's cover our surface with seamless texture utilizing the projected mode (by the way, as you've probably already noticed, practically every object I used to illustrate this tutorial is included in the model I've shared in the beginning, so you can repeat and practice all the examples).

Create the new simple rectangular surface over the existing one and set the desired texture mapping on it:

Try to sample it down:

As you can see, it's pointless to sample that mapping: all the faces below have different orientation and different projection plane. The correction of sampled mapping to new projection plane leads to different results on every face, so all we get is a mess with seams on every edge. Let's fix that. Right-click the face above and activate the Texture -> Projected mode from the context menu:

Now try to sample the mapping to the faces below:

I've applied smoothing and hidden the edges for the sake of clearness of the illustration.

As you can see, individual projection direction is not utilized there: every face has uniform projection and texture parameters. By the way, of course you can do it without the additional face, just adjust the projection mode to some suiting face on the surface and sample the mapping from it. I've just used the additional face to make everything clean and accurate: to ensure that the projection plane is horizontally oriented and to get the texture properly positioned.

This technique is particularly useful for geometry of certain types, like terrain, mud/garbage/leave piles props, and basically in every other case of surfaces which are curved in multiple directions. For example, there it was used for the dust and for hertical/horizontal slice texture projections:

I suppose that's all for now on materials and textures. With all these rules and techniques in mind, you'll be able to cover the object of any complexity with a wonderfully accurate texture mapping. Have fun.

>> PART V: Export to CryENGINE 3 <<

PART III: General Advice on Modeling

2011-08-03T21:26:00.007-04:00

3. General Advice on Modeling
basic principles and guidelines
Author: bac9-flcl

The next thing I'd like to cover is the modeling process itself. I am going to assume you have already studied all the tutorials in the "New to Google SketchUp" tutorial section of official site. If you are not yet confident with the way how tools work, open up the Instructor window:

It is displaying the information about the currently selected tool along with an awesome animated examples, and is quite helpful.

I also recommend to keep all the modifier key combinations and hotkeys in mind, as they are greatly speeding up your workflow and are often helping you to create cleaner geometry.

3.1. Mesh structure
edges, faces, face directions

All SketchUp models are consisting of edges and faces. You should keep in mind that under the hood there is a traditional simple 3D model based on vertex coordinates, and that all your faces are in fact already triangulated, but right during the modeling process you will work only with the edges and seemingly non-triangulated faces with unconditioned side count.

Creating faces in SU is a very frequent activity, and it's very simple: all you need is a coplanar closed loop of edges, once you have it (side by side with the Line tool or straight away with something like Rectangular/Circle tools), the face is automatically created.

Hovewer, for some reason, a lot of SU modelers forget about one thing: the direction in which the created surface is facing. And there we get to the very important issue.

Quote:

sketchup makes realy bad meshes

Quote:

sketchup engine itself creates a lot of problems for any 3D software (doble-sided planes, wrong backfacing and so on)

It is a common belief that the SketchUp itself is faulty in terms of surface orientation, and no matter how you work with it, it'll always produce inverted faces and other errors. That is not true, and, as aforementioned, the modeler himself should keep an eye on that, just like in any other DCC package.

The face direction is very easy to determine, as SketchUp is using color indication to display face direction:

In this example, the white face is facing upwards, while the blue one is facing downwards. Remember: the white is a color of the front side, and all your model surface should be covered with it. There are only a few exceptions like transparent textures which will be covered separately.

To reverse the face orientation, right click on it and choose Reverse Faces context menu action. Like that:

Here are some examples of proper and improper geometry:

Remember: when creating a face in a closed edge loop, SketchUp has no idea what face direction is right for you. And you shouldn't blame it for that

Unless... you already have some adjacent face(s) around. In that case, SketchUp knows exactly what direction are you looking for. Here's the example:

Remember: in the most cases, the back faces won't be there in other 3d formats, so make sure they are on the inside of the surface and are not used in any way. This applies to texturing too: never use backfaces to apply textures. Here's the example on how the model will look if you'll use the back surface.

To sum it up:

Always check your model for faces with incorrect orientation. I should also mention that if your model is already textuted, you can switch to the monochrome mode where only face direction is displayed. Just choose View -> Face Style -> Monochrome, instead of Shaded With Textures. Of course, you'll need to apply the texture again in case you'll reverse certain face direction.

3.2. Mesh combination
handling of adjacent surfaces, welding

During the modeling process, we constantly encounter adjacent surfaces, contacting parts and so on, basically every structure has these. It's good to know how SketchUp handles such cases and what should be avoided.

The main difference between e.g. adjacent parts in 3ds Max and adjacent parts in SketchUp is that SketchUp geometry is always solid and welded. Here are several examples.

Let's draw two colinear surfaces with a parallel edge, then match them in SU.

You will get a single mesh which can be moved and modified as a whole. You can even erase the old edge now:

It can be called "sticky geometry". Quite self-explanatory term.

Sound useful? Yes, if is, in many cases. But not always. Let's take a look on the other example (I've triangulated all the surfaces to visually demonstrate the mesh structure changes and differences).

Let's create a cube and a vertical plane, and then superpose one of the cube's sides on that "wall".

^ here's what we'll get in 3ds Max, the mesh stayed the same, the cube and the wall are still separate objects

^ and there's what we get in SketchUp: once free parallel surfaces adjoin, the mesh is welded

If you are not sure why the welding is not good in this particular case, take a look at the following, not so abstract examples. Let's use some kind of a wall lamp instead of a cube:

Or a simple clock:

Or a stair (my eyes are bleeding on this one, polycount became 100 times bigger then it was).

I guess you already know how we should sum this up: NEVER DO THAT.

Ok, sure, we won't ever match the geometry that we do not want to weld. But then how are we supposed to assemble complex objects? The answer is simple: with separating the model into components.

3.3. Making of the optimized model
utilizing groups and components

The components are nice little things you'll use about a several thousand times, so I'd recommend to watch this tutorial video by Google very thoroughly. (Though, to be honest, I hope you've already watched it as was asked in the beginning of the tutorial.)

To clear this from the start: you'll never need to use Groups, there are no downsides for using instanced Components all the time. Even if some part like room is used only once in your model, make it a Component. Just because this way you can, for example, make a copy of it away from an assembled building and make all the necessary changes without obstructions from the surrounding building geometry.

Basically, every single part (that you want to be free) you use in your building should be a separate component. Some modular source objects can contain up to several thousands of them. Here's the example with the stair.

But you should use them logically, where it makes sense. It's not really needed to separate each and every part in the individual component: just make sure that every pair of contacting parts is situated in the different component. For example, look at this detailed broken wall:

In fact, it is composed from only two components:

So let's examine the cases where you should and should not utilize the model separation.

For the first one, let's take a look at some indoor corridor. Should we separate a floor and a wall into the different components, or it better to use solid geometry there? It depends.

As you see in this example, the decision depends on whether these parts share the same amount of subdivisions and positions of vertices on the border. If they align perfectly, then you can combine the geometry without producing new edges.

Let's take a look at more complex, practical examples:

Obviously, we won't combine the walls and floor in the first example as it'll produce unwanted additional geometry, - but the second example looks normal, and welding it is a good idea (you'll get reduced vertex count at no additional cost).

By the way, all of this applies to wall/ceiling separation, but I'd recommend not to include the ceiling in the wall geometry nor to make it share the component with the floor. The reason is simple: with ceiling being

The most obvious case to discuss there is how the whole generic building should be separated. No problem.

Here you can download the .skp model of the building depicted above, consisting of 15 components: http://www.playuptools.com/downloads/extras/ExampleBuilding.skp

I hope it'll serve as a useful reference.

When the model is done and by no chance you'll need any modular flexibility to edit it again, you can simplify the component structure and hierarchy. It's not mandatory (well, it is only in case your hierarchy is too complex (e.g. 4+ levels) for some applications (e.g. PlayUp exporter) or for some other reasons), so if you aren't forced to simplify the object structure - don't do that. It's always awesome to have the possibility to, for example, extract some neatly organized window components from the building you've made a year ago and utilize them in the new model.

If you're simplifying the component structure, rules are simple:

1. Everything that's not contacting can be combined.
2. It's better to combine only closely situated (e.g. parallel window separators) or functionally similar elements (e.g. a row of columns on the facade).
3. Analyze the object and split it with functional approach even if you're not going to edit it again, - it never hurts to have a neatly organized hierarchy where e.g. windows are combined with windows and small brick parts are combined with small brick parts.

Example of finalized component structure:

>> PART IV: Materials & Textures <<

PART II: Golden Rules of SketchUp

2011-08-03T21:12:00.007-04:00

2. Golden Rules Of SketchUp

ladies and gentlemen, attention please

Author: bac9-flcl

1. Google SketchUp learning curve is extremely easy.

2. Lots of SketchUp users started modeling straight away, prior to learning about any optimization techniques, general modeling rules, and so on (which is generally not a bad thing unless it involves someone else trying to use the resulting models). Which brings us to the following:

3. Google 3D Warehouse is not your prop library.

4. Most of Google 3D Warehouse models are not properly optimized, textured and structured, and are literally far beyond rescue to suit any game engine.

5. Default collection is not your material library, never use these low-res JPEG images.

6. If you need something (from a cardboard box prop to a skyscraper), it's always easier and usually faster to create it yourself. Sometimes so fast that you'll get lazy to give a task to 3D modelers from your team, - as you can already create the required object in the time required to formulate the description itself.

7. SketchUp is a modeling package, just like the others, and all the general rules of 3D modeling are still applied there. You must keep an eye on surface orientation, you must optimize your model, keep neatly organized component hierarchy, etc. The program won't magically solve all these issues for you.

8. Always use tool snapping (axis-based, point-based, midpoint-based, parallel/perpendicular-based, and so on), it is extremely well made and is the one of the most important features of SU that is allowing you to work solely in the 3D viewport while producing clean and straight models.

9. Always type values manually while working with the tools to keep your geometry proportional, regular, and clean.

10. Always use components instead of groups.

11. Take your time to study at least the basic concept and tool tutorials here.

>> PART III: General Advice on Modeling <<

PART I: Getting Started with Google SketchUp

2011-08-03T21:12:00.006-04:00

1. Getting Started

basic workspace & viewport setup
Author: bac9-flcl

For this and all the following tutorials I am going to assume you have the latest version of Sketchup 8.0 (not necessarily in Pro edition) in English, and (in case you're intending to use SU for CryEngine-oriented modeling) PlayUp plug-in installed (you can find the installation tutorial on the official PlayUp site).

1.1. Toolbars

The first thing we're going to check is your workspace setup, toolbars in particular. By default your SU interface looks like that:

This is "Getting Started" toolset. Unfortunately, and despite our tutorial title, the tool selection there is insufficient for any serious work. Let's configure the workspace properly. Most importantly, you need to disable the "Getting Started" and enable the "Large Tool Set". I'd also recommend to enable "Views" and "Sandbox" (this one is not anyhow related to CryEngine) panels, these might get handy later. Here's my setup.

Remember that you can drag and place the panels as you like, and also resize them, changing the row count. On a widescreen display, I'd recommend to place all the tools as 2-column side panel.

1.2. Template

The next thing it's good to check is the template. Basically, the template is a model containing the empty scene and all of the precision, dimensional, unit and style parameters. This model is loaded every time you hit the "New" button.

I am going to assume you'll be working with the metric system of measurement, but, of course, it's possible to configure unit setup for feet/inches.

When you launch SketchUp for the first time, you're prompted to select a template. We're usually selecting "Simple" one, which is basically good.

Apart from the fact that it contains several things we'll never need, e.g. these 8 materials and SketchUp developer Susan. I suppose you don't want to waste your time on deleting these materials and component every time you create a new model. And also that color setup which is not easy on eyes if you're going to spend hours there.

Instead of wasting our time with detailed instructions on style configuration and other template aspects, let me give you the template where everything is already configured for work.

http://www.playuptools.com/downloads/extras/CleanTemplate.skp - just copy this file into the Google SketchUp 8\Resources\en-US\Templates directory and select the new template in the following window:

Now that's better.

Still, I'd like you to know how to configure the unit setup for yourself.
The tab you're looking for is situated in the Window -> Model Info window.

The settings above are recommended and already provided with the aforementioned template. These a good for a game-oriented model and ease the workflow a bit.

Please note that the "Precision" parameter is not defining the actual vertex coordinate precision, but rather the display of lengths in the bottom right corner of SU interface. 0.000m or further values will give you unnecessary visual clutter and aren't really useful in 99% cases since you have a 0.01m length snapping, so your tools will never produce irregular fractional values.

The 0.01m length snap itself is good because such value makes it easy to hand-draw the lengths like 1m, and also ensures that you won't use features smaller than 1cm (e.g. too thin metal plates).

Also, don't worry, using meters instead of centimeters as default unit does not affect the scale of the model. It's used to, again, speed your workflow up: meter-based values are utilized more often then centimeter-based ones in architecture modeling. Setting them as default unit means you won't need to type the unit name when working with the tools, e.g. typing "8" while drawing the edge will give you precisely 8m long edge. You can still use centimeters, e.g. type "37cm", but it's not that common value, and it's also faster to input it as "0.37".

That's it.

1.3. Materials

One of the most important aspects of modeling is working with materials. You will use the material window quite often, so let's add it to our workspace.

By default, the material window looks like this. But we'll need a little more complex layout with two windows: one for browsing/selecting materials, one for editing them.

Open the second window with the button.

Now switch the click on the Edit tab above:

Make sure that the lower window is set to display the "In Model" folder, and we're ready to work with materials now. But there we have one more thing to talk about: material collections.

There are lots of categories, surface types, colors and so on. All of these are included in SketchUp setup by default.

Here's one thing about it: you won't ever need these for any game-targeted model. These textures are low-quality JPEG images primarily used for geolocated Google Earth modeling, and are not suiting for use in games. So switch the browser folder back to "In Model" and forget about them.

1.4. Render settings

Just a couple of handy settings to enhance your viewport look and ease your workflow. First, open up the Rendering tab in the Model Info window and enable anti-aliasing of textures.

Second, open up the OpenGL tab in the Preferences window and configure it as shown below:

That's all we need to know about the workspace setup.

>> PART II: Golden Rules of SketchUp <<

Mini-Fix for CryENGINE 3

2011-07-29T02:44:00.001-04:00

A mini-fix that cleans up degenerate faces is now available in the Downloads section. Essentially, the new build no longer counts 3 vertices on the same line as a triangle (see illustration for an example). It should solve the problem of geometry not getting processed correctly by the Resource Compiler for CryENGINE 3. Please leave feedback on Facebook if you are still having issues getting geometry into the engine.

Exporting Entire Levels to CryENGINE 2

2011-07-05T05:17:00.001-04:00

The latest version of PlayUp allows you to export entire levels to CryENGINE 2. When you export, a .GRP file is created and placed into your level folder. This file contains information on the placement of the TOP LEVEL components/groups in your SketchUp file. Any nested components/groups will be merged into the the same mesh as the top level component/group.

You'll notice a new field in your PlayUp Preferences window under the CryENGINE 2 tab for "Starting Coordinates". Here, you can specify the coordinate in CryENGINE that you would like to line up with SketchUp's 0,0,0 coordinates. Since CryENGINE places the 0,0,0 coordinate in the corner of the world, this setting allows you to specify a more practical starting location.

In Sandbox 2, go to Modify > Load Objects and select the .GRP file. Please note that CryENGINE has a limit to the size a mesh can be. If a file is missing, try to break it up into separate top level components/groups to reduce the amount of faces/vertices in a single mesh.

PlayUp Tools Now Supporting CryENGINE 3

2011-07-05T04:05:00.002-04:00

This is the first release with support for CryENGINE 3, although I must warn you that it is not without its bugs. Please read the notes in the download section for more information and workaround suggestions. Also included in this build is the CryENGINE 2 level exporter which you can play with until I get the level exporter functioning properly for CryENGINE 3.

Translucent Materials & Mirrored Entities in CE2

2011-06-12T04:26:00.006-04:00

Translucent materials and mirrored components/groups are now supported when exporting to CryEngine2. The scale of the entities are also coming in correctly now. Please note that there is a limit to the amount of geometry one component/group can contain in CE2. If the exporter does not generate a .CGF file or if the models comes in with a few strange faces, try breaking up your component into smaller components. Go to the download section to pick up the latest build (PlayUp Alpha ver. 0.9.6).

Nested Components Now Supported in CryEngine2

2011-06-06T05:11:00.004-04:00

PlayUp Alpha ver. 0.9.5 (now available in the Download section) allows you to export nested groups & components to CryEngine2 with one important caveat: MIRRORED COMPONENTS/GROUPS ARE NOT YET SUPPORTED. CryEngine2 does not allow for negative scale values, which makes PlayUp's job a bit trickier. In the interim while a solution is being worked out, you can fix this by exploding the mirrored components and making them new components.

New Version Available

2011-05-26T07:04:00.004-04:00

UPDATE (5/29): The installer currently available in the Downloads section should now properly install the missing wxSU DLLs if your machine does not already have them installed.

A few people have reported getting DLL errors due to a third party package called wxSU that PlayUp uses to serve up the interfaces. In the rare case that you cannot get wxSU to work, a new version of PlayUp is available that uses JQuery instead. It's not nearly as slick of an interface as wxSU (and more prone to user error since it doesn't allow you to browse for the directory you need to specify), but it solves the compatibility issues.

Please make a post on the PlayUp Facebook page after attempting to use the latest download to notify us that there is still an issue, and we will provide you with a link to the JQuery version.

Nested Components Now Supported in Unity 3D

2010-06-16T00:23:00.002-04:00

PlayUp Alpha ver. 0.9.3 is now available in the Download section. PlayUp Tools now supports nested components and groups for the Unity 3D engine.

The changes are accompanied by a new and improved Unity 3D package that allows you to import levels by right-clicking on the level you wish to import directly from the project panel. Please note that you must install the new Unity 3D package for the new version of PlayUp to import properly to Unity 3D.

If you find a bug, please document it on the discussion forums in Facebook.

Exporting to Unity 3D Now Available

2010-04-16T11:08:00.002-04:00

PlayUp Alpha ver. 0.9.2.621 is now available in the Download section. This version supports the ability to export levels from SketchUp into Unity. Since the scene files in Unity are kept in binary format, exporting to Unity requires the additional installation of the bundled Unity package in this zip file. Please help me convince the developers to make a text version of the scene files by voting in the feedback forums.

Note that if you export groups with the same name, the last one imported will write over the rest. Also exporting models with nested components or groups is not supported in this build.

VIDEO: Simple example of exporting from SketchUp to Unity 3D

CryEngine2 Fixes and More

2009-09-04T13:36:00.002-04:00

PlayUp Alpha ver. 0.9.1.620 is now available for download.

In this build, the CryEngine2 exporter is LIGHTNING fast in comparison to the last update (what would take 2 minutes before now takes 2 seconds), and we have fixed a bug where models missing material data on any of the front faces would not export correctly.

Another nice addition is that PlayUp will no longer be in conflict with other plugins such as LightUp or SketchyPhysics.

Enjoy!

CryEngine Mini-Update

2009-03-30T17:58:00.010-04:00

PlayUp Alpha ver. 0.9.0.564 is now available for download.

This is a mini-update specifically enabling models with textures and colors to be exported to CryEngine2.

Here is a model from Google Warehouse. It was actually pretty difficult to find a model that had a material assigned to every front face, so don't be surprised if you have a little clean-up work to do.

In SketchUp, make sure that the model is completely exploded and use the PlayUp Check Normals tool to ensure the faces are correct. Give the group or component an identifiable name. Set your export directory to your custom map directory off of the /Levels directory in Crysis ( ie. /Levels/Mapname ). On export, the textures used will be converted to TIF format and placed in /Levels/Mapname/textures. Exporting colors will place a file called "playup_nomaterial.tif" into the /textures directory.

In SandBox 2, import and orient the model as desired. Enjoy the view.

Ver 0.9.0.564 Notes:

- Models need to be turned -90 degrees on the X axis in SB2.
- Models missing material data on any of the front faces will not export correctly.
- All textures used in the model will be converted to TIFs and placed in the /textures directory off of your export directory.
- Level export to CryEngine 2 not yet supported.

CryEngine Progress

2009-03-14T16:32:00.005-04:00

One of the problems we found with going from SketchUp to XSI to CryEngine was that there were some irregularities with the textures like in the building shown below:

With PlayUp, we were able to get rid of some of these irregularities. You can see the difference with the same house model shown here:

We have a few more kinks to work out, but hope to have a mini-update for the CryEngine tools soon.

Notes on Previous Alpha Versions

2008-07-24T10:33:00.007-04:00

Screenshot of model exported via PlayUp

Ver 0.9.0.531 Notes:

- Export components / groups with or without collision to Source (Orange Box or Episode 1)
- Export components / groups to CryEngine2 (no materials/textures or collision data, just geometry currently supported)
- Export level for Source with the ability to tag spawns and static/dynamic models-- but not BSPs
- The Source levels will be generated with a basic skybox and player spawn that you can delete or modify in Hammer as you please. This allows you to open the map in Hammer and run it right away.
- Models containing a large number of faces will run into problems when trying to import them into Hammer as there is a size limit. We are working to make this process seamless in later builds.
- Level export to CryEngine 2 not yet supported.

Ver 0.9.0.246 Notes:

- Only exporting models is supported in this build.
- Models must be components before they can be exported.
- Exporting models with nested components or groups is not supported in this build. We are working to have this available for the next build.
- Models containing a large number of faces will run into problems when trying to import them into Hammer as there is a size limit. We are working to make this process seamless in later builds.

Getting Started

2008-07-20T10:10:00.023-04:00

Installation

1. Run PlayUpTools.exe.
2. Install the files to your Google SketchUp directory.
3. Run SketchUp.
4. Go to Window > Preferences > Extensions and check the PlayUp box to enable the plugin.

4. Go to Plugins > PlayUp > Preferences.

5. Select the engine you wish to export to and specify the correct path information for the engine in the corresponding tab.

NOTE: If you run into problems with the exporting process, it's very likely that you did not set up your paths correctly so please make sure you specify the correct locations. If you are exporting to Half-Life 2, you need to select "Half-Life Source: Episode 1". If you are exporting to Team Fortress 2, you need to select "Half-Life Source: Orange Box".

Here is a typical example of the various settings:

SOURCE (ORANGE BOX / TEAM FORTRESS 2)

SDK Path:
C:\Program Files\Steam\steamapps\STEAMNAME\sourcesdk
Mod Path:
C:\Program Files\Steam\steamapps\STEAMNAME\team fortress 2\tf
Mod Name:
tf
StudioMDL Executable:
C:\Program Files\Steam\steamapps\STEAMNAME\sourcesdk\bin\orangebox\bin\studiomdl.exe
StudioMDL Arguments:
-nop4
VTEX Executable:
C:\Program Files\Steam\steamapps\STEAMNAME\sourcesdk\bin\orangebox\bin\vtex.exe
VTEX Arguments:
-nop4

SOURCE (EPISODE ONE / HALF-LIFE 2)

SDK Path:
C:\Program Files\Steam\steamapps\STEAMNAME\sourcesdk
Mod Path:
C:\Program Files\Steam\steamapps\STEAMNAME\half-life 2\hl2
Mod Name:
hl2
StudioMDL Executable:
C:\Program Files\Steam\steamapps\STEAMNAME\sourcesdk\bin\ep1\bin\studiomdl.exe
StudioMDL Arguments:
-nop4
VTEX Executable:
C:\Program Files\Steam\steamapps\STEAMNAME\sourcesdk\bin\ep1\bin\vtex.exe
VTEX Arguments:
-nop4

CRYENGINE 2

Model Export Path:
C:\Program Files\Electronic Arts\Crytek\Crysis\Game\Levels\YOURLEVEL\
RC Path:
C:\Program Files\Electronic Arts\Crytek\Crysis\Bin32\rc\rc.exe

CRYENGINE 3

Model Export Path:
C:\Program Files\Electronic Arts\Crytek\Crysis 2\Game\Levels\YOURLEVEL\
RC Path:
C:\Program Files\Electronic Arts\Crytek\Crysis 2\Bin32\rc\rc.exe

UNITY 3D

Assets Path

C:\UnityProjects\MyProject\Assets

Remember, you need to download the SDKs for your given engine before you can export anything. For Source, you can download the SDK through Steam. For CryENGINE, you can download it from here. For Unity 3D, you can get it from here.

Once you have your SDK installed and the paths correctly specified, you're ready to give it a go.

Make a model and texture it. Select it and make it a component or group. Right click the model and you will see a choice for PlayUp Properties. Note that this option will not appear if you did not make your model a component or group. Only components and groups are exported by PlayUp.

In PlayUp Properties, you can Enable Collision (supported in Source only at this time), Set as a Spawn, Turn Static Off, or Export Selected Geometry. By default the model is "static", but should you want to bring it in as "dynamic" you can turn it off here. You cannot currently make dynamic models in SketchUp, however we have put this flag in place to be able to export it as dynamic if you choose. If you set a component or group as a spawn, it will disregard the dimensions and create a spawn point at the origin of the entity. Exporting selected geometry will just export the currently selected component or group as a singular model.

You can export a single model by right-clicking and going to the PlayUp Properties, or you can export all the visible components by going to Plugins > PlayUp > Export All Components and Groups. Exporting components with nested components and groups will create prefabs.

When the process has completed, a window will appear letting you know.

For Source, you can also export a level by going to Plugin > PlayUp > Export Level. This will generate a VMF file which you can then open in Hammer. Since we do not yet support BSPs, this file will automatically have a generic BSP box (with a skybox texture) and spawn for you to modify or delete. This allows you to quickly launch Hammer and run the map so you can see what your models look like in the engine.

We have also added the following icon to the interface. Clicking this icon will toggle a style that clearly shows you the normals. Dark gray faces indicated the front side of the face, whereas bright green faces show the back side. We encourage you to use this tool to check your models before exporting.

PLEASE NOTE: Level export is also not yet supported in CryENGINE 3. We are currently in the early stages of supporting this engine and plan to have more functionality in future builds.

Resources
www.playuptools.com

Frequently Asked Questions

2008-07-16T11:25:00.009-04:00

What is PlayUp?
PlayUp is a plugin for SketchUp that allows people to create and export content to a 3D game engine.

Are you saying I can build a level in SketchUp and export it to a game?
That is the goal.

What game engine does it support?
The current build supports Valve Source (Orange Box and Episode One), Crytek CryENGINE 2, Crytek CryENGINE 3 and Unity 3D.

Do I need the professional version of SketchUp to make this work?
Nope.

What version of SketchUp do you support?
The latest version of PlayUp was tested in SketchUp 7 and SketchUp 8.

How do I get in touch with you? Where can I go for help?
Go to www.facebook.com/playuptools.

Troubleshooting

2008-07-16T10:35:00.042-04:00

GENERAL:

I'm getting an error that says I am missing a series DLL files.
PlayUp uses wxSU, an interface layer for the menu. When you install PlayUp, it should install wxSU in the Plugins directory as well. If you copied the PlayUp files rather than installed them, it's possible that you may not have grabbed the wxSU files. Using the official PlayUp installer should alleviate this problem, or you can grab the latest release of wxSU from here and install it separately. To date, PlayUp uses wxSU version 0.3 without any issues.

SOURCE:

My models won't export.
There are three likely reasons for this. Either you do not have your paths set right in your preferences, Steam isn't running, or Steam has an updated SDK. Check to make sure that Steam is running and is up-to-date first. If that checks out, take a good look at your preferences. The Getting Started section has examples of typical paths for the preferences fields. Also make sure that you are you are exporting to the right engine. If you are exporting to Half-Life 2, you need to select "Half-Life Source: Episode 1". If you are exporting to Team Fortress 2, you need to select "Half-Life Source: Orange Box".

UPDATE: Another possible reason for the problem is that it may not be finding tier0.dll. As goofy as this sounds, try running the Half-Life Model Viewer (hlmv.exe) and then try exporting your model.

It took a long time for my model to export, and when it finally did I can't seem to open it in Hammer.
Models containing a large number of faces will run into problems when trying to import them into Hammer as there is a size limit. We are working on a solution that should both speed up the export as well as allow large models to be imported.

I can see my models in Hammer, but my textures aren't exporting with them.
You need to check the VTex path in your preferences and verify that it's pointing to the right place. Please note that if you are painting your model with colors from SketchUp rather than importing and applying textures, it will not auto-generate textures for those colors.

Faces from my model are missing!
Did you accidentally texture the wrong side of the face? SketchUp will allow you to texture the backside of the face, but Hammer will not recognize it. Check your normals and make sure that you textured the right side. PlayUp installs a toggle icon in your interface to check the faces for you.

I tagged a building to have collision, but I can't walk into it when I run it in the engine.
It will only create a collision solid for your component or group that is a convex solid. If you want to make a building you can walk into, you need to separate the walls and tag them individually. We do not yet have support in place for tagging nested components and groups with collision.

I tagged a nested component/group to have collision, but it's not working.
Currently only the properties of the parent component/group is being checked.

It seems to export properly from SketchUp, and some of my models are showing up just fine in Hammer, but a few of them are showing the word "ERROR" where the model should be. Why is it that some models won't export when others will?
Hammer is very particular about the name of the component/group. For example, if you try to export a component with the name "post" it won't work. We believe it's because there is already a "post" model in Source. Try changing the name of your components to something unique and see if it fixes the problem.

CRYENGINE:

My models won't export.
Did you install the Crysis SDK? You need to do that before you can use PlayUp's CryENGINE exporter. Also if you did not explode everything inside of the component, it will not export.

My models have no collision data.
Right-click on the component in SketchUp, go to the PlayUp properties, and turn collision on.

Faces from my model are missing!
Did you accidentally texture the wrong side of the face? SketchUp will allow you to texture the backside of the face, but CryENGINE will not recognize it. Check your normals and make sure that you textured the right side. PlayUp installs a toggle icon in your interface to check the faces for you.

The UV coordinates for the textures are messed up.
One of the versions of RC.EXE is causing texture UV coordinates to mess up. You can download Bin32.zip with a version of RC.EXE that works properly from here.

UNITY 3D:

It says it exported, but I can't find the files.
It will place all of the files into the /Assets/PlayUp directory.

All of my assets are there, but I can't figure out how to load the level.
You need to install the Unity package that's accompanying the latest build. This package will install a new PlayUp tool in your toolbar. Go to PlayUp > Import Level. Hit the Browse button and select the level file you want to load. Click the Import button. Your level will load into a GameObject with the same name as the level. Alternatively as a way to do this more quickly, you can right-click on the corresponding level file in the /Assets/PlayUp/Levels directory and select Import Level via PlayUp.