Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon

10. September 2015

 

Ok, I’ll admit, I’m a day and a half late on this tidbit of news, which by internet standards might as well be years!  Regardless, it’s important enough to report late…

 

Unity announced the released of version 5.2 available immediately.  The release included:

Boost your revenue with Unity Ads

Unity Ads is growing at an incredible rate to the point where it’s rapidly becoming one of the world’s most widely used mobile game advertising networks. To find out why more and more studios are turning to Unity Ads, check out how Seriously boosted ad revenue 250% in Best Fiends without any drop off in retention.

Seriously_2

Automatically build, install, and test your apps

Unity Cloud Build optimizes your game development pipeline by automatically creating builds for multiple platforms at once, and making them easy to download and share. It’s streamlined so you can focus on the fun part: making games.

Synapse Games says Unity Cloud Build “has sped up the build process from 45 minutes of engineering time per build to essentially…. zero minutes.”  Set up is easy; try it now!   

Improve your game’s performance

If you’ve launched a game and you’re not using Unity Analytics, the chances are that it could be performing way better than it is. You’ll never know unless you try, and when Ultrateam used Unity Analytics to inform their design decisions they got a surprise: “The result was stunning. I didn’t think a simple change like this would have such a huge effect.”

header_playStore

Get multiplatform multiplayer networking

Use Unity Multiplayer to take the pain out of making networked games. The underlying engineering framework is the same whether you’re looking to deploy to mobile, desktop, Web or console. Try out the Unity Multiplayer Relay and Matchmaker Server Services free of charge today.

Even more VR

Picking up where Unity 5.1 left off, the Unity 5.2 release adds further support for VR developers in the form of a Project Morpheus build option. This means Unity comes with a highly-optimized VR/AR pipeline you can use to deploy to Oculus Rift, Gear VR and Project Morpheus out of the box.

Even more multiplatform

Unity 5.2 also brings you Windows 10 and Universal Windows Platform (UWP) build options. A UWP app can run on any Windows-based device, including phones, Xbox, and PCs!

Native Visual Studio Integration

In further Microsoft-related news, Unity 5.2 comes with a much tighter Visual Studio integration for a vastly improved coding and debugging experience on Windows machines.

The Unity installer will offer to install Visual Studio Community 2015 and Visual Studio Tools for Unity (formerly known as UnityVS). Everything just works out of the box!

VS_rgb_Purple_D

 

Unity ads are certainly a big deal if you are monetizing that way, and VR certainly seems to be a bullet point in all major game engine releases these days.  The addition to Windows 10 and Window 10 Universal platforms is timely, especially with the huge adoption rate of Windows 10 ( amazing what being free does, eh? ).  Unity Multiplayer is a big step and glaring hole in Unity’s functionality, but this isn’t new is it?  The tighter integration with Visual Studio is certainly welcome and something I need to check out soon.

 

You can read the full release notes here and Unity 5.2 is available for download now.

8. September 2015

 

Over the past couple months I have been working on a series of posts covering MonoGame with the intention of compiling them into an e-book when finished.  There have been a few preview builds of the book available to Patreon supporters (thanks by the way!).  Now however I consider the series to be complete so I am making the book available to all.  I will eventually be creating a more complete and formal homepage for the title but this one should work in the meantime.

 

Truth of the matter is, I had intended to cover a great deal more on the subject, but the level of traffic simply doesn’t justify the further expenditure of time.  That said, I leave the book at a state I think it should prove useful for anyone getting started in XNA or MonoGame game development, it is as comprehensive as any beginner XNA book currently available.  The book is composed of seven chapters:

 

Chapter One

An Introduction and Brief History


Book Cover

Chapter Two

Getting Started with MonoGame on Windows


Chapter Three

Getting Started with MonoGame on MacOS


Chapter Four

Creating an Application


Chapter Five

2D Graphics


Chapter Six

Audio Programming


Chapter Seven

3D Graphics 

 

 

 

Of course, the tutorials based here on GameFromScratch are still going to be available in addition to this PDF.  There is also a complete video tutorial series to go along with each chapter in the book available here.

 

With today’s release of the book, I also have published a github repository containing all of the source code used in the book.  This is a single Visual Studio solution containing each example as a separate project.  For some reason I don’t quite understand, all of the chapters are mismatched by one.  So for example the code in Chapter 8 on Github actually corresponds with Chapter 7 in the book.  Oops.

 

Alright, enough blathering, here is the book in PDF format.  I can make it available in other e-reader formats if requested.

EDIT: Here is an untested epub version of the book.

EDIT2: Now it has been posted on Smashwords as well, which should ultimately make it available from a number of sources.

 

If you enjoyed this free e-book and would like to see more similar free books, or would like access to books in development, please consider supporting GameFromScratch on Patreon.

 

 

Cheers!

Mike

, ,

4. September 2015

 

While on vacation I have been looking at the process of extending the Godot Game engine using C++.  Due to the vacation, this isn’t a proper tutorial, I may do one later on when I have access to video, etc…  There is pretty solid documentation of the process in this post on the Godot wiki beyond that however there is a huge lack of information.  So the following is mostly trial and error.

 

I worked entirely in Visual Studio for this example and am working from the most recent source from Github.  If you have trouble working in Visual Studio with Godot, be sure to check out this post.

 

We are going to have to create several files in the modules folder, but don’t worry many can be copy/pasted from an existing module.  I created a new module called modTest inside the modules folder, and the contents end up looking like:

 

image

 

Many I coped directly from gridmap, but I will show the entire contents below.

 

config.py

def can_build(platform):
  return True
  
  
def configure(env):
  pass
  

 

SCSub

Import('env')

env.add_source_files(env.modules_sources,"*.cpp")


 

register_types.h

void register_modtest_types();
void unregister_modtest_types();

 

register_types.cpp

#include "register_types.h"
#include "object_type_db.h"
#include "modtest.h"
#include "modtest_editor.h"

#define TOOLS_ENABLED 1

void register_modtest_types() {
  ObjectTypeDB::register_type<ModTest>();

#ifdef TOOLS_ENABLED
  EditorPlugins::add_by_type<modtest_editor_plugin>();
#endif
}



void unregister_modtest_types() {


}

 

modtest.h

#ifndef MODTEST_H
#define MODTEST_H

#include "scene/2d/node_2d.h"

class ModTest : public Node2D {
  OBJ_TYPE(ModTest, Node2D);
};

#endif

 

modtest.cpp

#include "modtest.h"

 

modtest_editor.h

#pragma once

#include "tools/editor/editor_plugin.h"
#include "tools/editor/editor_node.h"
#include "tools/editor/pane_drag.h"


class ModtestEditor : public VBoxContainer {
  OBJ_TYPE(ModtestEditor, VBoxContainer);

public:
  ModtestEditor(){}
  ModtestEditor(EditorNode * p_editor);


private:
  VBoxContainer * container;
  Label* label;
  EditorNode* _editor;
};




class modtest_editor_plugin : public EditorPlugin
{
  OBJ_TYPE(modtest_editor_plugin, EditorPlugin);

public:
  modtest_editor_plugin(EditorNode *p_editor);
  ~modtest_editor_plugin();

  virtual void make_visible(bool isVisible);
  virtual void edit(Object *p_node);
  virtual bool handles(Object *p_node) const;

private:
  EditorNode * _editor;
  ModtestEditor* modtestEditor;
};

 

modtest_editor.cpp

#include "modtest_editor.h"
#include "tools/editor/plugins/canvas_item_editor_plugin.h"
#include "tools/editor/editor_settings.h"

#include "scene/main/viewport.h"

#include <iostream>


ModtestEditor::ModtestEditor(EditorNode* p_editor){
  std::cout << "New Modtest Editor" << std::endl;

  this->set_size(Size2(600, 600));
  label = new Label();
  label->set_text("Hello World");
  this->add_child(label);

  //p_editor->add_child(this);
  p_editor->get_scene_root()->add_child(this);
  _editor = p_editor;
  
  this->hide();
}


// **************************** PLUGIN BEGIN ********************************************

modtest_editor_plugin::modtest_editor_plugin(EditorNode * p_editor)
{
  _editor = p_editor;
  modtestEditor = memnew(ModtestEditor(_editor));
  
  std::cout << "Editor" << std::endl;
  
}


modtest_editor_plugin::~modtest_editor_plugin()
{
}


void modtest_editor_plugin::make_visible(bool isVisible){
  std::cout << "Make visible" << std::endl;
  if (isVisible){
    std::cout << "Showing" << std::endl;
    modtestEditor->show();
  }
  else{
    std::cout << "Hiding" << std::endl;
    modtestEditor->hide();
  }
}

void modtest_editor_plugin::edit(Object *p_object) {
  std::cout << "Edit" << std::endl;
}

bool modtest_editor_plugin::handles(Object *p_object) const {

  return p_object->is_type("ModTest");
}


So that was a mountain of examples, but nothing particularly complicated.

 

The SCSub and config.py files simply tell the Scons build system how to build your module, both of them can be copied in unchanged from the gridmap module.  It’s only if your module doesn’t build for every platform or you need to do something other than compile all the included cpp files that you need to alter either of these files.

 

Next up are the register_types cpp and h files, which registers your type with Godot.  ModTest is a simple Node2D extension type, it can be registered using ObjectTypeDB::register_type().  Additionally we have an editor we want to show when editing our new type, that is registered using EditorPlugins::add_by_type() .  The TOOLS_ENABLED means that you are building Godot with full tooling support, as opposed to building just a game (without the editor in the generated binary).

 

Our extension is completely pointless.  It’s inherited from Node2D and well, that’s about it.  Obviously you would add functionality as you go.  The simple fact it inherits from Node2D makes it available in Godot as a Node:

image

 

Next we register an editor and a plugin for our ModTest type.  The ModtestEditor class is going to be the editor displayed within Godot.  It’s a simple VBoxContainer.  In this case all we do is add a label with the text Hello World then add it to the editor using the passed in pointer to the EditorNode.  This is generally where the majority of logic will go.

 

Next up is the modtest_editor_plugin which inherits EditorPlugin.  This class is loaded with Godot by the call EditorPlugins::add_by_type<modtest_editor_plugin>().  The important call is modtest_editor_plugin::handles(), which attaches the editor to the type it edits.  In the constructor, we create an instance of our editor.  The make_visible() method is called each time the editor is needed, or no longer needed and toggles the visibility of our editor.

 

As you add or select a node of ModTest type, the editor will automatically be shown:

image

 

Obviously this is a barebones example.  As I implement a more detailed example I will share the results.

Programming ,

31. August 2015

 

Today Unreal announced the release of version 4.9 of the popular Unreal Engine.

 

Unreal always have fairly massive release notes, so here is the short hand version:

  • Enhanced Support for Mobile Devices
  • Dynamic Character Shadows for Mobile
  • Dynamic Point Lights for Mobile
  • Decals on Mobile
  • Major VR Updates
  • New VR Motion Controller Support
  • Experimental Direct X 12 Support
  • Full Scene Particle Collision with Mesh Distance Fields
  • Hierachical LOD Fast Preview and Clustering
  • Arch VIS Character Controls
  • Widget Depth ordering
  • Area Shadows (For Stationary Lights)
  • Ambient Occlusion Material Mask
  • Mesh Distance Field Materials
  • Improved Distance Field Ambient Occlusion
  • Content Browser Advanced Search
  • Collection Improvements
  • Plugin Creation Wizard
  • Enhanced Curve Editor
  • Multiple Return Nodes in Blueprints
  • Construct Custom Objects in Blueprints
  • Blueprint Class Defaults
  • Blueprint Communication
  • Optimized Math Expression
  • Blueprint Asset IDS
  • Montage Element Timing Interface
  • Non-Linear Animations Blending
  • Bone Driven Animation Controllers
  • Animation Transition Rules
  • Animation Curve Evaluation Change
  • Animation Asset Metadata Support
  • Sound Quality Levels
  • Custom Audio Attenuation Curves
  • Actor Tick Intervals
  • Actor Encroachment Detection
  • Post Process Blending
  • Runtime Asset Cache
  • Volume Decals (Experimental Only)
  • UE4 Documentation Tags, Version and Skill Level
  • Updated UE4 Documentation
  • Async Real-Time Audio Decompression
  • Shared Resources for Feature Packs and Templates
  • Improved HTML5 (Easy Setup, Amazon S3 Support, Networking)

 

This only represents the highlighted features too, be sure to check the full release notes for more details.

News

31. August 2015

 

In this Closer Look At we look at take a look at the jMonkeyEngine.  The Closer Look At game engine series is a cross between an overview, a review and a getting started tutorial to help you decide if a game engine is the right fit for you.  The jMonkeyEngine engine is a Java based, open sourced, cross platform 3djMonkeyCloserLook_450px game engine that runs on most Java supported platforms and can target Windows, Linux, Mac and Android, with iOS and Oculus VR support currently being tested.  jMonkeyEngine is available as both a game library, or as a set of tools built on top of the NetBeans IDE.  For this closer look, we will focus on the full SDK experience.

 

 

This closer look is also available in HD video format here.

 

 

Although we are going to focus on the complete set of tools including in the jMonkeyEngine SDK, keep in mind it can be used in library form if you prefer working in Eclipse or IntelliJ.  You will however lose access to some very convenient tools.

 

 

Meet jMonkeyEngine

 

As I mentioned earlier, jMonkeyEngine ships in two forms, as a set of libraries, or as a complete SDK build on top of the Netbeans IDE.  You can download load the SDK for Windows, Mac or Linux right here.  As of writing, 3.0 is the current released version, while 3.1 is available in development on Github.  This version marks the first public release using the Github platform.  jMonkeyEngine has a few prerequisites before installing, but they basically boil down to having an OpenGL 2 compatible video card and JDK 6 or higher installed.

 

Once downloaded and installed simply run the jMonkeyEngine SDK application.   This is jMonkeyEngine:

image

 

As mentioned earlier, this is actually a preconfigured version of the Netbeans IDE with a set of plugins and extensions to support jMonkeyEngine development.  This means in addition to the various jME tools you get a complete modern Java development environment, meaning code completion, project management, refactoring tools, debugging and more.  I won’t be specifically covering Netbeans functionality in this guide.  If you’ve got prior experience in Eclipse or IntelliJ, you should feel right at home.  Personally I rate the Netbeans experience somewhere between the two, with IntelliJ being quite a bit better, while Eclipse is many many many times worse.  That all said, that is purely opinion, each platform has it’s strength and weakness, it’s fans and haters.  If you prefer to use Eclipse or IntelliJ you can.

 

Hello jMonkeyEngine

 

It is often easiest to start with a simple project, so let’s do exactly that.  Select File->New Project

image

 

A New Project wizard will appear.  All of the standard project types supported by Netbeans are available, but also the new jMonkeyEngine templates are available too.  Select BasicGame and click Next.

image

 

Pick a name and location and click Finish.

image

 

Your project will now be created.  You can have several projects open in the IDE at the same time, just be sure to select the right one in the Projects panel:

image

 

The wizard will have automatically created a project hierarchy for you:

image

 

It’s optional to use this layout, but you are making life more difficult for yourself if you do not.  File paths for textures in imported models are absolute, forcing your hand somewhat in how you import your data.  Again, you can code around this design, but you are making your life more complicated.  For the most part I found the layout fairly logical, but the suggestion to import your models into the Textures folder then relocating them to Models ( well discuss this more later ), well that simply a gross kludge.

 

The New Project wizard also generated a default source file for us, Main.java, with the following contents:

 

package mygame;

import com.jme3.app.SimpleApplication;
import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Vector3f;
import com.jme3.renderer.RenderManager;
import com.jme3.scene.Geometry;
import com.jme3.scene.shape.Box;

/**
 * test
 * @author normenhansen
 */
public class Main extends SimpleApplication {

    public static void main(String[] args) {
        Main app = new Main();
        app.start();
    }

    @Override
    public void simpleInitApp() {
        Box b = new Box(1, 1, 1);
        Geometry geom = new Geometry("Box", b);

        Material mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
        mat.setColor("Color", ColorRGBA.Blue);
        geom.setMaterial(mat);

        rootNode.attachChild(geom);
    }

    @Override
    public void simpleUpdate(float tpf) {
        //TODO: add update code
    }

    @Override
    public void simpleRender(RenderManager rm) {
        //TODO: add render code
    }
}

The code is all pretty straight forward.  You game code extends the class SimpleApplication, which in turn implements Application plus implements some “out of the box” behaviour like key mappings for exiting the application and implementing a camera.  These default behaviours can easily be overridden as we will see shortly.  SimpleApplication exposes three critical methods as part of your games life cycle, simpleInitApp(), called when your app is created, then simpleUpdate() and simpleRender() called over and over by the game event loop.  Basically stick your setup code in the init() method, your update code in the update() method and drawing code in the render() method.  If these methods start getting overly complex, you can refactor your design to use States, something we will cover later on.

 

You can run or debug your project using the toolbar:

image

 

Or via the Run menu:

image

 

Once launched you will see a configuration Window.

image

 

Select your preferred configuration and click Continue.  You may be asking, can I get rid of this damned window?  The answer is yes you can, but you have to use code to do it.  I can’t really fathom why there isn’t a “Remember my settings” check box.  Once you click Continue, your first app will run.

FirstApp

 

As you move the mouse cursor around, the camera implemented in SimpleApplication is moving the camera position around.  You may also notice the debug details and of course that startup window.  As said earlier, this can all be override, let’s look at how.

First we can get rid of the configuration window ( which I admit, gets old very quickly ) and set a default resolution using the following code:

    public static void main(String[] args) {
        Main app = new Main();
        
        // Dont show window
        app.showSettings = false;
        
        // Create a new app settings loaded with defaults
        AppSettings appSettings = new AppSettings(true);
        
        // Override resolution
        appSettings.put("Width",720);
        appSettings.put("Height",480);
        
        // Add a title, just because
        appSettings.put("Title", "Super Awesome Megagame 9000!");
        
        app.setSettings(appSettings);
        app.start();
    }

 

Next in our init we add the following logic to disable the camera and debug info. These need to be called after app.start(), thus why they are in init.

    @Override
    public void simpleInitApp() {
                
        // Disable fly cam
        this.flyCam.setEnabled(false);
        
        // Turn off debug info and FPS window
        this.setDisplayFps(false);
        this.setDisplayStatView(false);
        
        Box b = new Box(1, 1, 1);
        Geometry geom = new Geometry("Box", b);

        Material mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
        mat.setColor("Color", ColorRGBA.Blue);
        geom.setMaterial(mat);

        rootNode.attachChild(geom);
    }

 

Now when you run your game, you should no longer see the config window, nor display stats when running.  Instead you should see:

image

 

Importing a 3D Model

 

One of the first things I do when testing a new engine is check to see how hard it is to get a 3D model imported.  In jMonkeyEngine you have a couple of options, you can import to their native format, use a Blender plugin, support an OBJ file, or import files converted using the Ogre XML toolchain, which is also available as a Blender plugin as well as several other packages.

 

I will use the native format (j3o) later, for now, let’s look at the process of importing a Blender model, since jMonkeyEngine has solid Blender integration built in.  In fact, jMonkeyEngine actually ships with a copy of Blender as part of the SDK install, currently version 2.69 (as of writing, 2.75 is the most current version).  When you run Blender from within jMonkeyEngine, this included version is the one that is run.  (Note, for performance, you should always prefer using the native binary format unless you have a very good reason not to).

 

You can add a new textured Blender cube (you don’t have to by the way), right click the desired location and select File->New->Other…

image

 

Then select Blender->Box prepared for UV texturing.

image

 

Name it and confirm the location, then click Finish.

image

 

This will run a copy of Blender and set up a cube with textures defined for you.

image

 

What’s extremely odd here is the configured cube isn’t actually ready to go.  You still need to UV unwrap the cube, attach a texture and set the UVmap.   You can see the entire process in the video if you need more details.

 

You can confirm that the blend file works fine, right click the blend and select View Model.

image

 

This will open the Viewer.

image

Be sure to click the light icon (top left) to enable lighting in the viewer.  Now that we know the Blender file works, let’s move over to the code to load a Blender file.  there is a bit of a challenge first, Blender support is actually added as a plugin, we need to add it in first.

 

Right click Libraries and select Add Library…

image

 

Select jme3-libraries-blender then click Add Library.

image

 

We need to add a light to the scene or the model isn’t going to show up.  Simply drag and drop SunLight from to the drop of the simpleInitApp() code and it will drop all the code we need.

image

package mygame;

import com.jme3.app.SimpleApplication;
import com.jme3.light.DirectionalLight;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Vector3f;
import com.jme3.renderer.RenderManager;
import com.jme3.scene.Spatial;

public class Main extends SimpleApplication {

    public static void main(String[] args) {
        Main app = new Main();
        app.start();
    }

    @Override
    public void simpleInitApp() {
        /** A white, directional light source */ 
        DirectionalLight sun = new DirectionalLight();
        sun.setDirection((new Vector3f(-0.5f, -0.5f, -0.5f)).normalizeLocal());
        sun.setColor(ColorRGBA.White);
        rootNode.addLight(sun); 
        Spatial blenderModel = assetManager.loadModel("Models/demoBox.blend");
        rootNode.attachChild(blenderModel);
    }

    @Override
    public void simpleUpdate(float tpf) {
        //TODO: add update code
    }

    @Override
    public void simpleRender(RenderManager rm) {
        //TODO: add render code
    }
}

And run it:

image

 

So other than Blender configuration, getting a model into a jMonkeyEngine app is fairly straight forward.

 

Tools in jMonkeyEngine

 

Code Palette

We briefly saw the Palette in action in the previous example.

image

This is a selection of code snippets you can drag and drop into the editor.  One major gotcha however, many of these samples depend on a library, jme3-test-data, that isn’t included by default oddly enough.  We saw earlier when we set up the Blender plugin the process of adding a library.

 

3D File Importer

While jMonkeyEngine supports the Ogre XML format and Blend files, working with a game oriented file format is almost always the best performing option.  Fortunately jMonkeyEngine provides just such a format, j3o.  These files can be created easily using the menu File->Import Model menu:

image

 

Then select the model

image

 

Material/Shader Editor

You can easily create shaders right clicking an Asset folder such as Materials, New->Other…

image

 

Then Material->Empty Material file

image

 

You can then define a shader using a UI tool.  You can also set a template that other materials inherit from.

image

 

3D Scene Composer

image

 

The Scene Composer can be use to assemble and create 3D scenes.  There is also a corresponding scene graph:

image

 

A variety of game nodes can be created here:

image

 

Terrain Editor

In addition to the Scene Composer, there is also a 3d terrain tool:

image

You can create terrain visually.  Easily pull and push terrain into shape, paint with multiple textures.  The generated terrain can be used in the scene composer.

terrain

 

Engine Capabilities

 

We only briefly touched upon the code capabilities of the jMonkeyEngine due to time and space restraints.  jMonkeyEngine is a full functioning engine with the following functionality, excerpted from their website.

image

 

Documentation and Community

jMonkeyEngine is well documented, with a comprehensive collection of tutorials and guides available on the wiki.  I encountered a few entries that were out of date or invalid, but for the most part the document was solid and easy to follow.  There is also a good reference in the form of the JavaDoc.  I may not always be the biggest Java fan, but I almost always love JavaDoc generated references!

Until recently the forums for jMonkeyEngine were pretty terrible, but thankfully they’ve recently transitioned to an improved forum.  There is an active community and questions rarely go unanswered.  They have also recently transitioned the source code to Github.

 

Books

 

There are two books available for jMonkeyEngine.

jm1jm2

 

 

The Video

 

Programming , , ,

Month List

Popular Comments

Unity Release Unity 5.4 Beta and 5.3 Stable
Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon


15. March 2016

 

Unity have just released Unity Beta 5.4 today, available for download immediately.  Of course, this is a beta, so all usual warnings apply, there be dragons!

So what’s in this release?  Well...

Enhanced visuals, better performance, tighter Unity IAP integration and a major VR rendering upgrade

There are significant visual quality and in-editor artist workflow improvements in the Unity 5.4 beta. We’ve also worked to further optimize our VR rendering pipeline, making it far easier for you to deploy your build across the major VR platforms.

Our cross-platform in-app purchasing service, which you can use to integrate support for multiple stores through one API, is now more tightly integrated with the Unity Editor to make assessing and boosting the revenue performance of your game a smoother experience.

This latest release also comes with faster WebGL development build times, support for Retina displays, and much, much more…

One of the coolest new features is compatibility with popular PBR based texturing tools such as Substance Painter or DDo.  Now you should be able to drag and drop them in and have them appear exactly as you have designed them.  There are also particle system improvements, better VR support, VR performance improvements, enhanced IAP and performance improvements. 

There have also been some cuts, specifically in platforms supported.  Unity 5.4 loses support for iOS 6, web player and PS3 deployment.  The web player loss is unfortunate, but not unexpected, as basically every single web browser has removed traditional plugin support at this point.  Thus why WebGL became such an important target for Unity.  One of the major focuses of Unity as of late has been improvements in graphical rendering prowess, and they have put together a video illustrating the changes between Unity 5 and 5.4.

 

In addition to the 5.4 beta, they also released the stable version of Unity 5.3.  This can be downloaded using the standard download process.  Another GDC announcement from Unity was the private beta launch of Unity Collaborate, a cloud hosted service for remote teams to collaborate on development, locally or remotely. 

GameDev News

blog comments powered by Disqus

Month List

Popular Comments