Babylon JS-like game engine or complete port

Guillaume Piolat via Digitalmars-d digitalmars-d at puremagic.com
Thu Feb 11 02:25:00 PST 2016


On Wednesday, 10 February 2016 at 20:07:24 UTC, karabuta wrote:
> I like the feel when using Babylon 
> JS(http://www.babylonjs.com/) and how the APIs are designed. It 
> has glTF, STL & OBJ importers and many more cool features for 
> game devs (http://www.babylonjs.com/#featuresdemossection).
>
> But, it does give me the power and performance I need since it 
> is based on webGL and JS.
>
> Now, how practical will it be to port this JS game engine to D 
> (OpenGL / Vulkhan/ **)? There seems to be a Haxe Version 
> (http://babylonhx.gamestudiohx.com/) which has something to do 
> with C++ (seems Haxe can target C++).
>
>
> Is anyone doing something like that?
>
> Example;
>
>  // Babylon
>     var engine = new BABYLON.Engine(canvas, true);
>     var scene = new BABYLON.Scene(engine);
>     var camera = new BABYLON.FreeCamera("Camera", new 
> BABYLON.Vector3(-190, 120, -243), scene);
>     camera.setTarget(new BABYLON.Vector3(-189, 120, -243));
>     camera.rotation = new BABYLON.Vector3(0.30, 1.31, 0);
>
>     camera.attachControl(canvas);
>
>
> I can handle brutal honesty so, destroy :)

Javascript world beat us easily in things being easy.
The current D offering is not as integrated but each component is 
pretty much better.

OBJ is not a fantastic mesh format. For loading it requires 
triangularization, spatial hash for vertex values, and generally 
using a subset of it because it's crazy. 3DS, Collada or FBX are 
usually favoured. You can use them thanks to the D bindings to 
ASSIMP.

With Derelict bindings to windowing libraries and OpenGL, it 
doesn't even complicates your build. We have plenty of wrappers 
over these libraries that makes it a bit easier than using the C 
API directly (which is also a good solution).
Here a "modern OpenGL" example: 
https://github.com/d-gamedev-team/gfm/blob/master/examples/simpleshader/simpleshader.d

You can also use bgfx which is an abstraction over 3D graphics 
APIs, at the cost of more complexity.
https://github.com/bkaradzic/bgfx

A camera doesn't need it's own abstraction, it is a regular 4x4 
matrix like any other. I don't know why JS engines insist on 
"camera" being a thing. It only complicates things.

You don't necessarily need scene graphs :) You can go immensely 
far without scene graphs.




More information about the Digitalmars-d mailing list