Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon

23. December 2015

 

Unity just released the first patch for Unity 5.3.

From the release notes:

Improvements
  • (706098) - Compute: Improved compute shader import times, particularly on Windows (since 5.1 we were always compiling them for GL4.3+GLES3.1 too, while most people only need DX11).
  • (754898) - GI: Light probes and ambient (everything with SH calculations) match ground truth more closely now.
  • IL2CPP: Optimize method prologues for code size and incremental builds.
  • SceneManagement: Add Scene.GetRootGameObjects() to return the root game objects of the scene.
  • SceneManagement: Add SceneManager.CreateScene() API to allow creating new empty scene at runtime
  • tvOS: Enable Dynamic GI
Changes
  • iOS: Enable bitcode support by default.
Fixes
  • (687655) - Core: Fixed: Not ignoring '~' folders in projects
  • (none) - Android: Fixed NullReferenceException on x86 devices running Android 5.0 or newer.
  • (750362) - Android: Fixed Cloth::SetUpSkinnedBuffers() crash.
  • (none) - DX11/XB1: Fixed FP16 static batched mesh vertex compression to actually work there, was always decompressing to FP32 before.
  • (none) - DX11: Fixed wrong VRAM detection on some Intel GPUs, resulting in shadows not being rendered.
  • (none) - Editor: Fixed MissingMethodException when using some of the API from UnityEngine.WSA namespace.
  • (754898) - GI: Fixed light probes / skybox ambient being wrong in some cases, 5.3 regression.
  • (740808), (747666) - Global Illumination: Enlighten – Fixed an issue where Unity crashed if scene was unloaded before it got a chance to fully load.
  • (752879) - Graphics: Fixed - Realtime reflection probes in some cases did not have trilinear filtering properly set on them.
  • (691038) - IL2CPP: Ensure thread id is valid for all threads.
  • (752737), (751428) - IL2CPP: Fixed an issue that caused a crash in Class::IsSubclassOf.
  • (737529) IL2CPP: Fixed ExecutionEngineException being thrown on System.Reflection.MonoProperty::GetterAdapterFrame.
  • (752153) - IL2CPP: Implemented out marshaling for arrays correctly.
  • (746822) - IL2CPP: Implemented the Thread::Abort and Thread::ResetAbort methods. This should allow a Socket to be closed properly while another thread is waiting in a call to Accept or Connect on that socket.
  • (749988), (733609) - IL2CPP: Properly cleanup when a native thread is cancelled rather than exiting normally.
  • (750153) - IL2CPP: Provide a proper argument for instance methods on value types invoked via a delegate.
  • (none) - iOS/IL2CPP: Fire all GC profiler events. Fixed GC data in internal profiler.
  • (755365) - iOS/tvOS: Build all object files with correct SDK.
  • (752178) - iOS: Added bitcode support.
  • (750311) - iOS: Added Xcode 7.2 to iOS plugin compatibility list.
  • (749289) - iOS: Duplicate another image layer when not all are defined.
  • (none) - Linux: Fixed a corner case where tearing would occur on some WMs even with vsync enabled.
  • (753595) - Mecanim: Fixed a bug where lights would not be animated in Legacy.
  • (752847) - Mecanim: Fixed a bug where RectTransform couldn't be animated in Legacy.
  • (none) - Metal: Wrongly claimed to support DXT1/DXT5 texture formats on iOS, and ETC on Mac.
  • (691466) - Mono: Preserve non-volatile XMM registers across calls on 64-bit Windows during JIT compilation.
  • (none) - OpenGL core: Fixed shaders with multiple const arrays.
  • (755423) - Particles: Fixed error message spam on particle systems that have no particles (5.3.1 regression).
  • (none) - SamsungTV: Fixed wrong jpg library access problem.
  • (748904) - SceneManagement: Fixed the issue that script association was lost when another scene was loaded.
  • (none) - SceneManagement: Fixed the issue that the unloaded scenes would be removed from the hierarchy when entering playmode, if they were first in the hierarchy
  • (none) - Shaders: Fixed a bug in Standard shader GGX specular term, introduced in 5.3.
  • (none) - Shaders: More proper environment reflection in Standard shader for very rough surfaces.
  • (753925) - tvOS: Fixed rendering path selector in player settings.
  • (756044) - tvOS: Fixed missing symbols for simulator builds.
  • (none) - tvOS: Fixed UnityEngine.Apple.TV.Remote API access in editor.
  • (740782) - UI: Fixed crash in some cases after deleting world space Canvas.
  • (751207) - Windows Store Apps: Populate autorotation settings to screen manager.
  • (752546) - Windows Store Apps: Fixed Directory.CreateDirectory() for forward slashes.

GameDev News

22. December 2015

 

Welcome to the next section in the ongoing Closer Look at series, a series of guides aimed at helping you decide which game engine is right for you.  Each closer look at entry is a cross between a review and a getting started tutorial that should help you decide if a game engine is right for you.  Today we are looking at the Atomic Game Engine with the extensive editor support forked from the Urho3D game engine that I covered earlier.  The engine itself is written in C++ while the primary programming language is JavaScript, however .NET and TypeScript bindings are available as is a community created Haxe binding.

 

Wait you say?  A commercial game engine forked from an open source project??? Don’t worry, put down your pitchforks, this is an example of commercialization done mostly right.  First off, it’s a noticeable improvement over the original in many ways.  Second, much of the derived source code is still available freely and open source.  Finally the Atomic team are making pro licenses available to contributors of dependencies such as Urho3D, Box2D, TypeScript, Tiled, etc.  This is a nice approach and one I would like to see more closed software layered over open source software adopt.  There is also a free version available with limitations that we will discuss shortly.

As always, there is an HD video version available here.

 

Pricing Structure

 

** Important EDIT ***********

The following details are no longer accurate.  Since this was published, the Atomic Game Engine transitioned to an MIT open source license and is now free to use.

**************************

 

As mentioned earlier, there exists a free option and a number of other tiers.  As of writing Atomic Game Engine is currently in Early Access which includes a lower price (and increased instability…).  The pro licenses include a lifetime of upgrades.  Here is the full pricing structure:

image

 

As you can see the free version you have to choose between 3D, Android or iOS support and must have less than $100,000 annual revenue and includes a splash screen.  The indie license revenue is capped at $500,000 and there is no splash screen requirement.  In my opinion at least, this price tier is fair.  One major caveat however, to build completely from source you will need a Pro license otherwise you have to wait for new binary releases.

 

The Editor

The editing environment is probably the biggest feature of Atomic, so lets start there.  This is the welcome screen when you first load Atomic Editor:

image

 

As you can see there are several sample projects to start from.  Create a new project using File->New Project menu, which will show the following dialog:

image

 

You can work in 2D or 3D mode within Atomic.  For this example I will choose 2D.  Next define your project settings:

image

 

You will notice that TypeScript and JavaScript are the default languages available.  You can work in .NET, Haxe or even using C++ but at this point in time you will be mostly on your own.  The tooling and documentation is mostly oriented for JavaScript development for now.  As it is layered over Urho3D, if you are comfortable in using Urho3D with C++ you should be able to adapt to C++ in Atomic fairly simply, plus the majority of documentation is still applicable with minor changes.  C++, .NET and Haxe targets are beyond the scope of this review however.

 

Now that we have a project loaded, the left hand side of the editor changes slightly.  The top portion represents that assets of the current project, the mid portion contains the contents of the currently selected folder, while the bottom portion represents the scene graph of the currently selected scene.

image

 

With Scene.scene selected you can see that a default scene contains a Camera and a Node entity.  Like most modern game engines Atomic uses the composition approach, although instead of Entities and Components, you have Nodes and Components, but the end result is very similar.  Now that we have a scene selected, it should be visible in the middle portion of the UI:

image

 

This is where you select and arrange the entities within your scene.  You can instance new entities… er, nodes by dragging them in from the left side of the screen.  With a node selected, the right hand side shows the property inspector giving us access to the properties of the node as well as the components it contains:

image

 

Adding new items to the scene is trivial, simply click the Create button in the hierarchy area.  The options are limited to Node or for some reason in 3D there is an option for Light.  You can also create a prefab instance that we will discuss later.

However for adding components there are a ton more options available.  Adding a component is simple a matter of clicking Add Component in the inspector with the appropriate Node selected.

image

 

Each component type has it’s own corresponding editor.  The following for example is the Rigid Body components editor:

image

 

Game assets can be imported via drag and drop.  This process automatically triggers the appropriate importer:

GIF

 

The Programming Experience in Atomic Game Engine

The primary or lead programming language when working with Atomic Game Engine is JavaScript, while .NET, Haxe and Typescript language bindings exist (but aren’t documented).  The source code is primarily written in C++, while the editor is created using the Typescript language.  You could of course code your entire game using C++ if you preferred, but again, the process is currently undocumented.  The programming model is pretty intuitive and quick to come to terms with.  For the following code examples, I will be looking at the Platformer2D example.

 

Taking a quick look at the generated source code, you can find your project’s entry point in the Scripts folder:

image

 

Here are the contents of main.js:

// This script is the main entry point of the game

// create the start ui programmatically, we could also
// use a ui template
//create  main view
var view = new Atomic.UIView();
//create a window
var window = new Atomic.UIWindow();
//disable tile bard and make it non resizeable
window.settings = Atomic.UI_WINDOW_SETTINGS_TITLEBAR;
window.text = "Physics Platformer";

// Create a layout, otherwise child widgets won't know how to size themselves
// and would manually need to be sized
var layout = new Atomic.UILayout();
layout.rect = view.rect;
// give ourselves a little more spacing
layout.spacing = 18;
//axis to y
layout.axis = Atomic.UI_AXIS_Y;
//add ours layout to window
window.addChild(layout);

//create a text field
var text = new Atomic.UITextField();
text.text = "Please select the time of day:";
layout.addChild(text);

// Buttons layout
var buttonLayout = new Atomic.UILayout();
buttonLayout.axis = Atomic.UI_AXIS_X;
layout.addChild(buttonLayout);
var buttonDaytime = new Atomic.UIButton();
buttonDaytime.text = "Play Daytime";
buttonDaytime.onClick = function () {
  run(true);
  //we need to return value here, otherwise we will be GC'ed
  return true;
}
buttonLayout.addChild(buttonDaytime);

var buttonNightTime = new Atomic.UIButton();
buttonNightTime.text = "Play Nighttime";
buttonNightTime.onClick = function () {
  run(false);
  //we need to return value here, otherwise we will be GC'ed
  return true;
}
buttonLayout.addChild(buttonNightTime);

window.resizeToFitContent();

// add to the root view and center
view.addChild(window);
window.center();
var dayTime;
function run(daytime) {
  //ok, then remove ours window
  view.removeChild(window);
  //require GlobalVariables module, and set its dayTime value to the current daytime
  require("GlobalVariables").dayTime = daytime;
  //load main scene!
  var scene = Atomic.player.loadScene("Scenes/Scene.scene");
  //if we are running ours game on android
  if(Atomic.platform == "Android" || Atomic.platform == "iOS") {
    //requiring a dpad module
    var DPad = require("DPad");
    //create a new view
    var uiView = new Atomic.UIView();
    //creating a new DPad
    var dpad = new DPad();
    //adding horizontal and vertical buttons
    dpad.addAll();
    //ok, then we could init ours dpad
    dpad.init(uiView);
    //create a jump button
    var jumpButton = new Atomic.UIButton();
    //unset its skin, because we will use UIImageWidget
    jumpButton.skinBg = "";
    //create ours jump button image
    var jumpButtonImage = new Atomic.UIImageWidget();
    //load image
    jumpButtonImage.setImage("UI/jumpButton.png");
    //resize ours image by 2.2x
    var jumpButtonWidth = jumpButtonImage.imageWidth*2.2;
    var jumpButtonHeight = jumpButtonImage.imageHeight*2.2;
    //calculate position
    var posX = Atomic.graphics.width - Atomic.graphics.width/8-jumpButtonWidth/2;
    var posY = Atomic.graphics.height - Atomic.graphics.height/4-jumpButtonHeight/2;

    //sets jumpButton rect, specify position and end position
    jumpButton.rect = [posX, posY, posX+jumpButtonWidth, posY+jumpButtonHeight];
    //sets jumpButtonImage rect, we specify there only end position
    jumpButtonImage.rect = [0, 0, jumpButtonWidth, jumpButtonHeight];
    //adds image to jumpButton
    jumpButton.addChild(jumpButtonImage);
    //adds jumpButton to the dpad view
    dpad.view.addChild(jumpButton);
    //sets jumpButton capturing to false, because we wanna make it multitouchable
    jumpButton.setCapturing(false);
    //binds jumpButton to KEY_SPACE
    Atomic.input.bindButton(jumpButton, Atomic.KEY_SPACE);
  }
}

This is actually a fairly advanced main.js, some are as simple as:

// This script is the main entry point of the game
//Load scene
Atomic.player.loadScene("Scenes/Scene.scene");

In this particular example the first half of the code demonstrates programmatic generation of a UI.  The later half creates an on screen controller if running on a mobile platform.  As you can see from the second, much shorter main, it can be as simple as calling loadScene() passing in the scene you create using Atomic Editor.

 

The majority of code in your project will be organized in components:

image

 

Components are attached to Nodes just like any other component.  Here for example is a script component attached to the Level node in the platformer example:

image

 

And the contents of that script:

"atomic component";
//requiring LevelParser module
var LevelParser = require("LevelParser");

//A Level
var component = function (self) {
  //start function will be excecuted, after connecting our component to the node, after the constructor
  self.start = function() {
    //get TileMap2D component from our current node
    var tileMap = self.node.getComponent("TileMap2D");
    var tmxFile = tileMap.tmxFile;
    
    //looping main game song
    var music = Atomic.cache.getResource("Sound", "Sounds/JumpingBat.ogg");
    music.looped = true;

    //create LevelParser object
    var levelParser = new LevelParser(tileMap);
    levelParser.createPhysics(tileMap, tmxFile);

    var position = levelParser.getSpawnpoint();
    position[1] += 1.5;

    //create a child prefab
    var node = self.scene.createChildPrefab("Player", "Prefabs/Hero.prefab");
    //set it position to the current node position
    node.position2D = position;

    //get all entities from our map which names MovingPlatform
    var platforms = levelParser.getEntities("MovingPlatform");
    for (var i = 0; i < platforms.length; i++) {

        var p = platforms[i];
        var node = self.scene.createChildPrefab("MovingPlatform", "Prefabs/MovingPlatform.prefab");

        node.position2D = p.start;
        node.startPos = p.start;
        node.stopPos = p.stop;
    }

    //get all entities from our map which names Coin
    var coins = levelParser.getEntities("Coin");
    for (var i = 0; i < coins.length; i++) {
        var node = self.scene.createChildPrefab("Coin", "Prefabs/Coin.prefab");
        node.position2D = coins[i].position;
    }

    //get all entities from our map which names BatWaypoint
    var waypoints = [];
    var batWaypoints = levelParser.getEntities("BatWaypoint");
    for (var i = 0; i < batWaypoints.length; i++) {
        waypoints.push(batWaypoints[i].position);
    }

    //get all entities from our map which names Bat
    var bats = levelParser.getEntities("Bat");
    for (var i = 0; i < bats.length; i++) {
        var node = self.scene.createChildPrefab("Bat", "Prefabs/Bat.prefab");
        node.position2D = bats[i].position;
        node.scale2D = [.5, .5];
        node.waypoints = waypoints;
    }

    //get all entities from our map which names Vine
    var vines = levelParser.getEntities("Vine");
    for (var i = 0; i < vines.length; i++) {
        var vnode  = self.scene.createChild("Vine");
        vnode.createJSComponent("Components/Vine.js", {startPosition : vines[i].position});
    }
    
    //reduce num rays on mobile/web platforms for better performance
    if(Atomic.platform == "Android" || Atomic.platform == "iOS" || Atomic.platform == "WebGL") {
      self.scene.getChild("TheSun").getComponent("DirectionalLight2D").numRays = 512;
    }

  }

}

exports.component = component;

You may notice the exports statement at the bottom of the example and the require statement at the top.  Atomic uses CommonJS for module support.  This particular example implements the start() method, which will be called automatically on the component during creation.  There is a method update() that will be called each pass through the primary game loop and is where the majority of your game logic will most likely be performed.  You can also create and subscribed to arbitrary events, enabling easy component to component component communication.

 

This example also illustrates another powerful feature of AGE, prefabs.  In the line:

var node = self.scene.createChildPrefab("Player", "Prefabs/Hero.prefab");

This is programmatically creating a prefab named Player from the file Prefabs/Hero.prefab.  Prefabs are simply pre-configured Nodes that can be re-used and instanced easily.  To create a prefab you simply create a node, add it’s various components, then drag that node up into your project resources, generally into a folder called prefab. 

 

One other thing you may notice is that double clicking a script brings up an integrated code editor:

image

 

This is an incredibly handy feature that is sadly somewhat broken right now.  Normally the editor has a great deal more functionality including full code completion but a bug resulted in it’s removal.  As of writing they are in the process of integrating Chromium and improving the integrated editor.  That said, the majority of users make use of an external editor.  One popular choice is the Atom editor, which has a Atomic Game Engine package available:

image

 

This enables you to run Atomic projects directly from the Atom editor, or to open the current project in the Editor.  That said, it didn’t actually work for me, saying atomic-cli NPM package needed to be installed, which it was.  Not sure what the error here was.  On cool thing about using Atom as your editor, is if you also use the Typescript language, you get complete and accurate intellisense in the editor:

image

 

There is a Typescript seed project (among other things) available in this Github repository.  You may have noticed a few moments back that I mentioned a CLI, or command line interface.  Assuming you have Node installed, you can install it using the command

npm install atomic-cli –g

This interface enables you to create, edit and run projects directly from the command line, which also makes it easy to integrate AGE into existing text editors such as Sublime Text or Notepad++.

 

The actual coding process is a bit beyond the space/time we have available here.  Given that Atomic is built on top of Urho3D you can expect a full featured and expansive API including pretty much all the functionality you expect from a modern 2D or 3D game engine.  If you want more of a taste for what coding in AGE is like be sure to check out the examples repository which contains a pretty comprehensive set of examples to learn from.  Of course the existing Urho3D documentation is also a good source of information, although some things will obviously be different as this is a fork.

 

Platform Support

Once you finish developing your game it’s time to deploy and AGE makes this process easier than most.  Depending on version, the following platforms are available:

  • Windows
  • Mac
  • WebGL
  • iOS
  • Android

And building for a platform is as simple as choosing Build->Build Settings and filling in the appropriate values:

GIF

 

Documentation and Community

 

As is often the case with in development engines, documentation is not the strong point of Atomic Game Engine.  There is a complete reference guide available somewhat confusingly under the videos section of the AGE website.  There is also a robust collection of examples available, which truth told is going to be your primary source of information for the foreseeable future.  As this engine is based on a fork of the Urho3D engine, a good chunk of Urho’s existing documentation is still applicable, although it will be a challenge for new developers to figure out when this is and isn’t true.

 

There is a community forum with a  growing community.  It’s not exceedingly active, but almost every single question goes answered, which is a good sign.  Additionally there is a Gitter chat which can be thought of as a version of IRC that  lasts forever and no doubt pulls a bit of traffic away from the forum.  It does seem to be quite active and a fast source for answers.  Bugs and features are tracked using github and are very active making development quite transparent.  Finally there is a Wiki, but it is extremely sparse at the moment.

 

Summary

 

Atomic Game Engine is very much an engine under development and at times it shows.  On the other hand, it is based on a very mature engine, so there is no reason you wouldn’t be able to use it in a production ready environment.  I am not going to answer the question “Is it worth it to use Atomic instead of Urho3D?”, as value is an incredibly subjective concept.  What I will say is the Atomic Game Engine adds a layer of tooling and polish on top of a game engine that required a layer of tooling and polish and did it well.  The developer experience using Atomic is a great deal nicer than the developer experience using Urho3D.

On that point, would I recommend Atomic Game Engine to new users?  No, not yet, but mostly due to the in development nature and the current lack of documentation.  In the future though, I imagine all of that will change and this will be an easy to recommend engine.  Now, what about to more experience developers?  Well if you are willing to work on an engine that is under development, there is certainly a lot here to like.  If you are looking for a Unity-esque editing experience, but with a much cleaner coding experience and access to the source code, certainly give Atomic a shot… especially with early access pricing in effect.

 

The Video

Programming , , ,

22. December 2015

 

There is a preview of the upcoming Leadwerks Game Engine 4 available on Steam today.

From the announcement:

We completely rethought how large-scale scene management should work to bring you a one-of-a-kind vegetation system for handling massive amounts of foliage. Instead of storing each instance in memory, our new system uses a distribution algorithm to dynamically calculate all relevant instances each frame for rendering and physics. This allows enormous densely packed scenes with minimal overhead. The results are blazingly fast, efficient, and easy to use.  In fact, the new system is so advanced it's featured in the upcoming book Game Engine Gems 3.  Other features include autocomplete in the built-in script editor and integration with Steam Leaderboards.


Attached Image

To help you make the most of the new vegetation system, we're also introducing the Nature Model Pack DLC.  This includes trees, plants, grass, and rocks, to make a variety of outdoors settings with.
Leadwerks Game Engine 4 is a free update and allows publishing of games for the PC and Steam Machines.

 

The timing is good as right now Leadwerks is 80% off on Steam.

GameDev News

22. December 2015

 

Unreal have just released a preview version of Unreal Engine 4.11 today. 

The following is a list of items updated within this release:

  • Rendering Updates:
    • New physically based shading model for realistic hair based on the latest research from film. It models 2 specular lobes, transmission, and scattering.
    • New physically based shading model for eyes.
    • New physically based shading model for cloth. This combines the standard shading model with a layer of velvet fibers. This layer simulates fuzz and fabrics.
    • Capsule Shadows - We now have support for very soft indirect shadows cast by a capsule representation of the character
    • Lightmass Portals - Skylight quality indoors can be massively improved by setting up Portal actors over openings. Portals tell Lightmass where to look for incoming lighting, they don’t actually emit light themselves. Portals are best used covering small openings that are important to the final lighting. Placing large Portals all over the level will dramatically increase build times.
    • Per-vertex translucency lighting - There are two new translucency lighting modes available in the material editor which compute lighting per-vertex. PerVertex lighting modes use half as many shader instructions and texture lookups.
    • We now have support for 3 lighting channels. You can set which channels a PrimitiveComponent or a LightComponent is in.
    • We’ve integrated Intel's Embree ray tracing library into Lightmass and we got a huge lighting build speedup from it, as the majority of lighting build time goes toward tracing rays to figure out how light is bouncing.
    • We’ve integrated updates to the D3D12 RHI to allow better CPU utilization while generating rendering commands in parallel.
    • Improved quality and performance of the SubsurfaceScatteringProfile shading model.
    • Circle Depth of Field post process - New Material Functions to render small particles with out of focus.
    • Materials using separate translucency can now be rendered at a lower resolution, which can be useful to improve GPU performance for fillrate and overdraw heavy geometry (for example particle effects).
      The resolution is controlled via a console variable, r.SeparateTranslucencyScreenPercentage, which expresses separate translucency as a percentage of current screen resolution.
    • Static mesh LOD transitions now supporting dithering.
  • Core Updates:
    • CrashReporter Server available
    • Improvements
      • Garbage Collection up to 4x faster
      • Dependency preloading - brings us close to seek free loading (90% of the time seek free), faster package loading
      • UnrealHeaderTool makefiles - iterative UHT runs are 5x faster
  • Platform Updates:
    • Metal on Mac
    • AppleTV support
    • Fast Semantics on XboxOne
    • VS2015 on XboxOne
    • Code plugins for PS4
    • Deterministic cooking "bug-finder" commandlet
    • Background content precaching for most-recently-cooked-platform
  • Editor/Tools Updates:
    • Sequencer improvements
      • New tracks: Shot/director, play rate, slomo, fade, material, particle parameter tracks.
      • Improved movie rendering, exr support
      • Improved/consistent keyframing behaviors, copy/paste keyframes, copy keys from matinee, 3d keyframe path display
      • Master sequence workflow
      • Spawnables workflow
      • UI improvements: track coloring, keyframe shapes/coloring, track filtering
  • Framework Updates:
    • Anim Dynamics Skeletal Control for Animation Blueprints - allows dynamic motion to be procedurally added to skeletal meshes without having to use a full physics solution. This is accomplished using the new “Anim Dynamics” node in the Animation Graph of an Animation Blueprint.
  • Networking Updates:
    • Packet handler system
      • Easy interception of packets for things like encryption, compression, etc
      • Added CryptoPP, and packet handler components that support it out of the box
    • Oodle integration (SDK purchase required)
    • Client-side replays
  • Blueprint Updates:
    • The Blueprint search tool has been updated to support more advanced search functionality (to get more targeted results).
    • Native C++ functions marked BlueprintCallable can now also be optionally marked as DevelopmentOnly. This new metadata allows calls to those functions to be disabled (compiled out) of all Blueprint function graphs in cooked/packaged builds without breaking the execution flow.
  • Mobile Rendering Updates:
    • Support for hardware instancing on iOS and many Android devices, reducing draw calls for Foliage and InstancedStaticMeshComponents.
    • Improved reflections on mobile, optionally interpolating between up to 3 reflection captures and performing parallax correction
  • VR Updates:
    • Instanced Stereo Rendering
    • Head Mounted Display Camera Refactor
    • Stereo Layers
    • SDK Updates: Oculus SDK 1.0, SteamVR 1.0, PlayStationVR SDK3 Updates, and Gear VR LibOVRMobile 1.0 (not yet updated for Preview 1, but will be by final release)
  • Landscape/Foliage Updates:
    • Landscape layer whitelisting, allowing you to control which landscape components should accept which layers in the painting tool
    • Landscape layer usage view mode, to quickly see which landscape components are using which layers
    • Support for baking WorldPositionOffset changes into landscape collision

 

Known issues in this release are:

UE-24744 Editor crashes when a Character is selected in Paint Mode.
UE-24721 Hot Reload fails to take effect when compiled from Xcode
UE-24716 Crash occurs selecting to open Session Frontend on Mac
UE-24715 Unplayable GearVR tracking sensitivity in First Person Template
UE-24699 Unable to build Linux editor ConvexHull2D file not found
UE-24650 Materials using separate translucency stop rendering if r.SeparateTranslucency is 0
UE-24590 Crash resetting Bound Bone in Anim Dynamics node
UE-24369 MAC: UI: Top half of the game client is not visible to users when Mac client is launched in fullscreen.
UE-23231 Can't Upload iOS build signed on PC

 

More details of the release are available here.  You can download the preview release using the Epic Game Launcher.

GameDev News

22. December 2015

 

LÖVE, the popular Lua based open source game engine, just released version 0.10.  This is excellent news for me as I can now use the newest release in my upcoming complete beginners series.

 

So, what’s so special about this release?  Well the biggest feature has to be iOS and Android support, which I think you will agree is pretty big. 

 

That said, there are tons of new features in this release:

Changes from 0.9.2

Additions
Changed APIs
Renamed APIs
Removals
Bugfixes
Performance improvements
Other changes

GameDev News ,

Month List

Popular Comments

Project Anarchy Tutorial: Your first 3D model
Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon


11. July 2013

 

Even though Project Anarchy ships with a ton of assets, you are eventually going to want to add your own.  In this tutorial we are going to do exactly that, by creating the Hello World of game modelling… a textured crate.

 

Ain’t she a beauty?

image

 

 

For this tutorial I am using the 30 day trial of 3D Max 2014, which you can download for free right here. Of course you can use any of the supported modelling programs if you already own one.  This tutorial will not be teaching you how to model in any way, besides I suppose how to create a cube, which isn’t really all that exciting is it?  In addition to Max 2014, the prior 4 versions are also supported, as well as multiple revisions of Maya and Softimage.  Oddly, there is a plugin for Softimage, but no documentation… I’m not entirely certain of why.

 

In this tutorial we will cover:

  • installing the Project Anarchy content tools
  • creating and texturing a 3d crate in 3D Studio Max 2014
  • exporting a model from 3D Studio Max to vForge
  • attaching a model to an entity in vForge

 

 

Setup and Configuration

 

 

To continue if you haven’t already, install the 30 day trial of 3D Max 2014.  Then run the Project Anarchy download manager again.  Don’t worry, it will have locally cached all the install files if you ran it earlier.  You want either the 32 or 64bit version of the Havok Content Tools, depending what version your 3D app is.  In my case it’s 64bit I need.  Select the one you need and click Download.  If you’ve already downloaded everything, skip this step and jump ahead.

 

image

 

If you already downloaded everything, you can locate the installer in a sub-directory of your USER directory, in my case it was C:\Users\Mike\AnarchyPackages, like so:

 

image

 

The downloader should run the installer automatically, but otherwise you can run the one you need from this folder, select either the 32 or 64bit version of HavokContentTools and run it.  Make sure that your 3D application and Havok are closed ( just in case ).

 

The installer should automatically determine which versions you have installed:

image

 

 

 

If you don’t already have a vForge project and scene configured, do so now.  If you have no idea how, please refer to this earlier tutorial.  I created a project using these settings:

 

image

 

Strangely, it didn’t make a textures folder.  That’s it for the Havok stuff for now, let’s switch over to 3DS Max and create a simple textured crate.

 

Oh yeah, the texture, I am using this one:

crate

 

It’s a 512x512 texture I downloaded from the web… I did not create it, nor do I have any rights to it, so do not use in a commercial project!  Now download this file and save in the root of your newly created project.  ( C:\temp\MyFirstObject in my case ) as crate.jpg.

 

Creating a textured crate in 3DS Max 2014

 

 

If you’ve ever used 3D Max, just skip this part completely, its 101 stuff. 

Once the installer finishes, the required plugins should now be installed.  Fire up 3D Max 2014 ( or whatever app you are using ).  In the Create Panel, left click Box icon.  Now left click and drag to draw the rectangle you want in any viewport, then release the button.  Now the next mouse movement will represent the depth of the object you are creating.  Click when done and you should now have a 3D cube.

 

image

 

Press ‘Q’ to switch to selection mode and make sure that the cube is selected.

 

Now we want to texture it… first we need to turn texture display on so we can tell if our texture is working or not.

In the Perspective window, left click the word “Realistic” and set Materials to Shaded Materials with Maps.

image

 

Now the cube in this display will display your texture once assigned.

 

Now lets assign a texture.  Press ‘M’ to bring up the Slate Material Editor.  From the left hand panel, drag over a Standard material and a Bitmap map.

image

 

For the bitmap, you will be prompted for the texture to use.  Select the crate.jpg at the root of your project.

image

 

Now drag the connector on the right of the Bitmap to the Diffuse Color on the material.

image

 

This assigns the bitmap texture to the diffuse channel of the material.  Now drag the connector from the right side of the material to the cube in your scene.

 

image

 

You should now have a fully textured cube for exporting.  If it doesn’t appear to be textured, make sure the the viewport is set to show texture maps.

image

 

Now save your scene.  For the sake of ease, I am going to save to C:\temp\MyFirstObject\Crate.max.

 

Exporting to vForge

 

Assuming you have installed the Content Tools properly, you should have a menu in 3DS Max, Havok Content Tools

image

 

Select Havok Content Tools->Export:

image

 

The following dialog will appear:

image

 

You may notice some error text about unloadable DLLs, this has no effect on the export process, you can read more about it here.

 

In the left hand side, highlight Process Vision Data, then on the right hand side, click Add >>

image

 

---------------------------------!!Now make sure you have your project open in vForge before continuing!! --------------------------------------------------

 

With your project open in vForge, click Run Configuration.

image

 

If everything goes according to plan, your model will appear in vModelViewer:

image

 

Now if you take a look at your project directory, you will see your newly exported .model ( and .anim ) files:

image

 

Congratulations!  You just exported your first 3D model from 3D Studios Max to Project Anarchy!

 

Using the crate model in game

 

Now let’s make sure it worked.

 

In vForge, drag an Entity from the Shape Creators panel to the Engine View:

image

 

With your newly created entity selected, in the Properties panel locate Model File:

image

 

When you click the … button, you should now be able to select your crate model.

image

 

Select it and click OK.

 

And voila!  Your crate model in the game engine!

 

image

 

We will be making heavy use of our newly created um… crate in upcoming tutorials, so stay tuned.

Programming ,

blog comments powered by Disqus

Month List

Popular Comments

Refreshing Javascript JS file caching in Chrome during development
Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon


21. December 2012

I am not sure if a recent release has made it worse or it's always been this annoying, but Chrome does a lousy job of refreshing changes to JavaScript files.  It used to be you simply hit CTRL+F5, or CMD+F5 on MacOS to for the browser to reload with changes, but this simply doesn't work with Chrome, which is really really irritating when developing in HTML.

 

One option is to use a cache breaker, but this is an irritating process.  Basically you just add a random number to the end of your script inclusion script.

 

So instead of:

<script src="MyScript.js">

You do

<script src="MyScript.js?Num=21421423asdfsdf2">

 

Then you basically change the magic number every time you update the script, which WILL result in the new script being reloaded regardless to the browser settings.  In development, this is still a gigantic pain in the arse.

 

Fortunately there is a solution.  On a PC hit CTRL+SHIFT+i or on a Mac hit CMD+Option+i, to bring up the developer tools.  This will bring up the developer tools, now locate the gear icon in the bottom right corner:

Google Chrome Developer Settings Icon

 

Then under the General Tab, select Disable cache:

DisableCacheChrome

 

 

Voila, much more sane JavaScript development under Chrome.

 

 

General

blog comments powered by Disqus

Month List

Popular Comments