Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon
15. November 2016

 

Welcome to the getting started tutorial in the ongoing BabylonJS Tutorial Series.  Today we are going to look at creating our first simple Babylon application setup and running.  As always there is a HD video version of this tutorial available here or embedded down below. 

 

To get started with BabylonJS, we need a web page containing a <CANVAS> tag to host our application.

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Title</title>

    <style>
        #canvas {
            width:100%;
            height:100%;
        }
    </style>
</head>
<body>
<canvas id="canvas"></canvas>
</body>
</html>

 

Nothing special here.  We simply create a canvas tag named canvas, style it so it takes up the entire page and that’s about it.  Now we need to link to the BabylonJs library.  You’ve got a few options here, you can download it locally or host it from a content delivery network (CDN).  I’ll take this approach, as it’s generally the fastest option for end users.  You can even create a stripped down version with only the required features here.

 

The options for using BabylonJS include:

 

Babylon.max.js is the most human readable of the versions, making it the easiest to debug but the slowest to load.  During development, this is the version I am going to use.  Simply link to this library somewhere within the <HEAD> tag of our HTML.

<script src="http://cdn.babylonjs.com/2-4/babylon.max.js"></script>

 

We have our host webpage setup and Babylon linked, time to finally get down to some code.  Below our canvas, add the following code:

    <script>
        window.addEventListener('DOMContentLoaded', function(){
            var canvas = document.getElementById('canvas');

            var engine = new BABYLON.Engine(canvas, true);
            var createScene = function(){
                var scene = new BABYLON.Scene(engine);
                
                scene.clearColor = new BABYLON.Color3.White();
                var camera = new BABYLON.FreeCamera('camera1', new BABYLON.
                Vector3(0, 0,-10), scene);
                camera.setTarget(BABYLON.Vector3.Zero());

                var box = BABYLON.Mesh.CreateBox("Box",4.0,scene);
                
                return scene;
            }

            var scene = createScene();
            engine.runRenderLoop(function(){
                scene.render();
            });

        });
    </script>

 

When we run this code we should see:

image

 

Humble beginnings certainly, but our first running app is complete.  So what are we seeing here?  It’s an unlit cube viewed by a camera looking at the origin from –10 units down the z-axis.  Let’s take a quicker look at the code that got us here.  First we create a function that we call on DOMContentLoaded event fired, so basically when our page is loaded, this function is called.  Let’s walk through the function.

var canvas = document.getElementById('canvas');
var engine = new BABYLON.Engine(canvas, true);

This code gets a reference to the canvas tag we created in our HTML file.  We then use this canvas to create an instance of our Babylon game engine.

var createScene = function(){
    var scene = new BABYLON.Scene(engine);
    scene.clearColor = new BABYLON.Color3.White();
    var camera = new BABYLON.FreeCamera('camera1', new BABYLON.Vector3(0, 0,-10),
    scene);
    camera.setTarget(BABYLON.Vector3.Zero());
    var box = BABYLON.Mesh.CreateBox("Box",4.0,scene);
    return scene;
}

Here we are creating a function that will setup our scene.  First we create a new Scene using our newly created engine.  We then set the clear color to white.  The clear color is the color that each frame is cleared with between calls, essentially setting the background color to white.  Next we create a FreeCamera named “camera1”, located at –10 along the Z axis in our scene.  Next we set the target to the origin (0,0,0).  We will go into more detail on cameras shortly, so let’s skip over this for now. Then we create a cube at the origin named “Box” that is 4x4x4 in dimensions.  Notice in both when we create the Camera and Box we pass the scene in.  This causes these entities to be created in that particular scene.  Finally we return our newly created scene from our function.

var scene = createScene();
engine.runRenderLoop(function(){
    scene.render();
});

 

Next we create our scene by calling our just defined createScene() function.  We then start our game loop calling engine.runRenderLoop().  The game loop can be thought of as the heart of our game.  This is a loop that will be called over and over as fast as possible.  If for example your game is drawing at 60FPS, this function is called 60 times in a second.  For now all we do is call scene’s render() method, which causes the contents of that scene to be drawn.

 

Here now is the code in it’s entirety.  ( A WebStorm project is available in the GFS Patreon Dropbox directory Tutorial Series –> Babylon for backers )

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="http://cdn.babylonjs.com/2-4/babylon.max.js"></script>

    <style>
        #canvas {
            width: 100%;
            height: 100%;
        }
    </style>
</head>
<body>
    <canvas id="canvas"></canvas>
    <script>
        window.addEventListener('DOMContentLoaded', function () {
            var canvas = document.getElementById('canvas');
            var engine = new BABYLON.Engine(canvas, true);
            var createScene = function () {
                var scene = new BABYLON.Scene(engine);
                scene.clearColor = new BABYLON.Color3.White();
                var camera = new BABYLON.FreeCamera('camera1', new BABYLON.
                Vector3(0, 0, -10), scene);
                camera.setTarget(BABYLON.Vector3.Zero());
                var box = BABYLON.Mesh.CreateBox("Box", 4.0, scene);
                return scene;
            }
    
            var scene = createScene();
            engine.runRenderLoop(function () {
                scene.render();
            });
        });
    </script>
</body>
</html>

 

That’s it for now.  In the next part we will explore cameras in more detail.

 

The Video

GameDev News


9. November 2016

BabylonBannerSplattered_thumb[3]

Welcome to the GameFromScratch.com tutorial series covering the BabylonJS HTML5 game engine.  The home page of the series is available here.  For each tutorial in the series there is both a text and video version available.  In this post we are simply going to introduce the BabylonJS engine, the scope of this tutorial series and discuss why you might want to use the Babylon engine and also some of the alternatives available should you decide not to.  If you’ve already decided on using the BabylonJS game engine, jump forward to the next tutorial.

 

BabylonJS Overview

I’m not going to go into a great deal of detail on the functionality included in BabylonJS as I have already featured this game engine in the Closer Look game engine series.  Instead we are going to take a quick top level look at the engine features.

 

Why Choose BabylonJS

So, why is the BabylonJS game engine a good choice for you?

  • Open source (Apache 2 license) and free to use
  • Full featured 3D game library (scene graph, physics, particles, models, sprites, etc)
  • Compatible with most modern WebGL browsers
  • Excellent tooling, including level editor, Unity exporter, model converters
  • Good documentation, samples and other learning materials

You can read the full feature set here.

 

Why Not Choose BabylonJS?

So we mentioned a number of Babylon’s strengths, but why would you *not* choose to use BabylonJS?  Well, beyond the fact you may not like how they implement things the biggest reason all comes down to your priorities.  WebGL performance isn’t on par with desktop OpenGL or even OpenGL ES, so there is a bit of a performance penalty at work here.  While HTML5 applications can be wrapped to run as applications on various mobile devices, again there is a price to be paid, in both performance and labor.

At the end of the day, personally, I think a lot of it comes down to your primary target.  If you are creating a browser game first and foremost, I recommend working in a browser native library such as BabylonJS.  This has the most direct workflow, is easiest to debug, etc.  If on the other hand the browser is just another target for you you are probably better off working in a game engine that also targets HTML5, such as Unreal or Unity.

 

Alternatives to BabylonJS

Shockingly there aren’t actually a ton of HTML5 3D game engines or frameworks like BabylonJS.  The most direct alternatives are:

 

By no means is that an exclusive list, but it does represent some of the most common 3D engines with WebGL as their primary target.

In addition to these engines several 3D engines offer HTML5 as a target including Unreal, Unity, Godot and many more.  The primary challenge with these options is the generated code is often illegible, acting almost identically to a compiled binary.  So if things don’t work right you are dependent on the engine developer to fix things.  Or if you wish to use a native browser feature, you are again dependent on the engine developers to support it in some form.

 

Enough overview, lets jump into the technical details.  I am aiming to keep each tutorial somewhat short and concise, both text and video versions.  Stay tuned for the first tutorial covering getting BabylonJS up and running.

 

The Video

Programming


6. June 2016

 

V8 is a popular embeddable JavaScript engine, perhaps most famously used to power the popular Node development framework or as the JavaScript engine used by Chrome.  They just announced the release of version 5.2.  From the release notes V8 gained the following features:

ES6 & ES7 support

V8 5.2 contains support for ECMAScript 6 (aka ES2015) and ECMAScript 7 (aka ES2016).
Exponentiation operator
This release contains support for the ES7 exponentiation operator, an infix notation to replace Math.pow.
let n = 3**3; // n == 27
n **= 2; // n == 729
Evolving spec
For more information on the complexities behind support for evolving specifications and continued standards discussion around web compatibility bugs and tail calls, see the V8 blog post ES6, ES7, and beyond.

Performance

V8 5.2 contains further optimizations to improve the performance of JavaScript built-ins, including improvements for Array operations like the isArray method, the in operator, andFunction.prototype.bind. This is part of ongoing work to speed up built-ins based on new analysis of runtime call statistics on popular web pages. For more information, see the V8 Google I/O 2016 talk and look for an upcoming blog post on performance optimizations gleaned from real-world websites.

V8 API

Please check out our summary of API changes. This document gets regularly updated a few weeks after each major release.

GameDev News


27. May 2016

 

RPGMaker, the seminal, um... RPG (role playing game) maker, is currently available for free on Steam over the weekend and available for a sale price of 50% off.  image

 

RPGMaker is a complete game engine and toolset geared towards making JRPG style games.  First released in 1992, RPGMaker has been used to make several commercial games such as To The Moon and the Aveyond series.  Up until recently scripting was done using the Ruby language.  However with the move to MV, the language was changed to JavaScript.  Another major feature of the MV release is the ability to target both iOS and Android.  One nice thing about RPGMaker is it ships with a ton of game assets that should ease the getting started process.

 

To go along with the free weekend sale, the RPGMaker folks have put together an introduction:

So you’ve downloaded the program, opened it up, and are seeing the Engine for the first time. RPG Maker is not hard to use, but at first glance, there is so much to do that it can be a bit overwhelming. That is why we’ve prepared this quickstart guide, to get you on your way to making your game, your way.

What makes RPG Maker special, and what drew me to RPG Maker to begin with is that it allows anyone to make a game. You don’t have to know how to code, you don’t have to know how to make art, you don’t have to know how to make music. I don’t know how to do any of those things. But I can make a game, and you can too. All it takes is getting to know the three main parts of the RPG Maker engine. This won’t be a tutorial. It won’t explain how to do everything, but it will give you the basics of where to get started and how things work together.

 

Click here to read the full post.

GameDev News


3. May 2016

 

Cocos Creator is a new game editor built over top of the Cocos2d-x JavaScript port.  I did a hands on video with an earlier version of Cocos Creator if you are interested in learning more.

 

This release brings a number of new changes and features, including:

  1. [Animation] Allow position.x and position.y properties can be added separately in an animation
  2. Windows] Use new installer framework based on Squirrel.Windows. New version of Cocos Creator will be installed to %User/AppData/Local/CocosCreator, different version will be stored in sub folder named as app-x.x.x.
  3. Dashboard] Dashboard stays in memory now. When open a project the Dashboard window will hide, and show up again when the project is closed. Added Systray icon for dashboard. You can open multiple project from Dashboard now.
  4. JSB] Fixed newly created cc.SpriteFrame via url cannot be displayed when assigned to sprite issue.
  5. Engine] We include cocos2d-x prebuilt library in installation so no more manually building for that.
  6. Render] Add SpriteDistortion component for simulating a 3D ball rolling effect
  7. Render] Add Circle mode for Mask component
  8. Render] Fixed rotating a node with Mask will not display correctly issue.
  9. Console] Optimized duplicated message into collapsed messages.
  10. Animation] Fixed switching among multiple animation clip may cause timeline to lock up issue.
  11. Animation] Fixed play animation direction error when wrapMode is set to Reverse
  12. Animation] Fixed root node may jump to other position when updated sample issue.
  13. Component] Fixed help button link on builtin components
  14. Component] Add tooltip for Layout and EditBox components
  15. Prefab] Fixed when reference a node from scene on a component attached to Prefab may cause duplicated node instantiated together with prefab issue.
  16. Tiledmap] Fixed rotated tile in a tax file will not display correctly issue.
  17. Build] emit a editor:build-finished message after a successful build process. So plugins can catch that and do modifications to the built project.
  18. Build] Fixed iOS project templates may cause rejection when submitting to iTunes connect issue.
  19. Editor] Make error message when requiring third party javascript library more clear.
  20. Auto Update] Fixed when text is large in change log, the window will not display all content issue.

The full release announcement and download information is available here.

GameDev News


AppGameKit Studio

See More Tutorials on DevGa.me!

Month List