Link

1. Overview

Shark 3D tools are designed for as much productivity and convenience as possible.

The integration and interaction between Shark 3D and other tools provides optimal workflow for designers, artists and programmers. Using Live editing the running console and PC game, the designer can live manipulate the running console or PC game comfortably.

Shark 3D tools are a flexible and open environment for configurating and manipulating Shark 3D components and properties.

Link

2. Authoring Editor

Game designers use game editor to implement and test their game.

Put together your game

• Create 3d objects, sensors, triggers and scripts all in one place.
• Unlimited undo of all changes.
• When clicking a node, the context help will automatically show you an explanation of that node.
• When typing Perch scripting, the auto-completion function will provide you all available commands you can send to a node.
• In the script editor, the context help will automatically provide you information about built-in script functions and node commands at the position of the cursor.
• You can also use Python as scripting language.

Link

3. Multiply your options: Live nested prefabs and templates

Live prefabs

You can create a prefab once, and instantiate it multiple times within our level or game.

For example, define an enemy type, and then place that enemy multiple times in your level.

Prefabs are live. This means that you can change each template or prefab afterwards, and all instances in the scene will use that change.

Live nested prefabs and templates

The prefab and template mechanism is generic and powerful. For example you can create nested prefabs and templates by creating new prefabs and templates which contain other prefabs and templates.

For example, you may create a template defining the basics of all enemies in your game. Then you can use that template to create multiple nested prefabs for different enemies, for example having different scripts. You can instantiate these enemies at multiple places in your levels.

All this can be done graphically without any scripting or programming.

Also nested prefabs and templates are live. You can change each prefab or template afterwards, and all derived prefabs, templates and instances in the scene will use that change.

Passing parameters to templates

Templates and be also customized by parameters, called slots. For example, a template defining the common aspects of different monster types can define a slot for custom sensors. When using this template you can choose which sensor is placed at that location. Slots can be used for any kind of nodes, including geometry, scripts, sensors and more.

Also slots can be used graphically without any scripting or programming. And of course also slots are live and can be changed afterwards.

Link

4. Shader editor

Artists use the node-based graphical shader editor to create advanced materials and rendering effects. This includes for example sophisticated per-pixel lighting, hard and soft shadowing using area lighting, reflections and refractions, shader animations and much more.

Any change in the shader editor can be seen live in the game editor and on all target consoles. For example, as soon as the artist connects two nodes, the resulting surfaces change immediately in the game running on the consoles.

Link

5. Live editing the running console and PC game

All changes in the editor can be automatically updated into the running Shark 3D based application. See Workflow and Live editing the running console and PC game for details.

Link

6. Stand-alone or integrated

First, some tools exist as stand-alone tool. For example, the game editor can be used to edit and test the game live. The resource editor has a tree view of all resources of the project, and allows to manipulate them.

Furthermore, tool functionality can be also integrated into other tools. For example, a standard plugin for 3D Studio Max™ integrates the editing functionality for shaders into 3D Studio Max™.

Using the modular structure of the editor architecture and the component architecture, it is easy to integrate functionality of the tools into other tools, including proprietary tools.

Link

7. Consistency checks and efficient error handling

Compile time error checks

If your resources include errors that can be detected at resource compilation time, you simply double-click the error message, and your resource editor jumps to the corresponding location. For example, a script file may contain a syntax error. Then you easily can jump to the corresponding location.

Runtime error checks

Many errors cannot be detected at compile time. Runtime binding, polymorphism, complex object relationships and complex dynamic interactions unavoidably cause runtime errors. Even the most sophisticated tools cannot avoid this. Therefore, comfortably handling runtime errors is very important for an efficient workflow.

In Shark 3D, runtime errors can be interactively managed similarly easily as compile time errors. Internally, runtime error handling is performed by a sophisticated online communication between the resource editor and the running Shark 3D based application. Changes are updated into Shark 3D by Live editing the running console and PC game, and Shark 3D gives direct feedback about runtime errors to the resource editor.

This means in practice: You change some complex object configuration. The editor shows the runtime errors caused by this new configuration. You click on a runtime error to jump to the component configuration causing this runtime error. You fix the error. And the error will vanish from the list of active runtime errors.

This provides a new level of productivity also for managing complex object relations including runtime binding, polymorphism and dynamic object relations.

For example, you may dispatch a command in a wrong way, causing problems only at runtime because of runtime binding and polymorphism. Shark 3D automatically gives feedback to the editor as soon as the error has occurred. When clicking this error you jump directly to the dialog where you configured the dispatcher component in the wrong way. After having fixed the erroneous dispatching configuration, the error will automatically vanish in the list of active runtime errors.

Link

8. Tools customization and configuration

The most important strength of the tools are their flexibility. Most tools are no hard-wired applications. Instead, they are very modular, configurable systems.

If a programmer has implemented or assembled a new component, he easily can provide a customized user interface (UI) to the designer in the tools. This includes a detailed specification which parameters can be modified by the designer. A designer having insight into the component provided by the developer also easily can configure the tools for his particular needs.

Link

9. Live-live editing the tools themself

Scripters and programmers can live-live edit the tools. This means that scripters can change the Python code of a tool, and the tool can use the changed implementation immediately without restarting the tool.

For example, a scripter can add a new GUI control for a game play item and connect it to a run-time feature via some sophisticated Python code. By pressing one button, both the editor and the run-time use that change.

Another sample is that a graphics scripter edits the Python code of a Shader Editor node which generates the pixel shader code for that node. By pressing one button, the shader editor immediately uses that modified implementation, and updates the new pixel shader to the run-time on PC or consoles.