8. April 2015

 

The first tutorial in the Unreal Engine vs Unity tutorial series is now live.  In this tutorial we look at using Unreal Engine.  It’s an introduction to Unreal Engine, a guided tour around the editor, then we create a simple Hello World application using Blueprints.

 

I will be creating a companion text tutorial to go along with this video shortly.

 

You can see the video in full 1080p here.

 

The Video

 

Programming , , ,

7. April 2015

 

In this video tutorial we continue to look at 3D programming in LibGDX.  First we look at how to convert a 3D model to work with LibGDX using fbx-conv.  We then write the code to display that model and look at displaying animations.  The fbx-conv application can be downloaded here.

 

The data file used in this example can be downloaded here (zip format).  If you are interested in learning more about the process of creating the model click here.

 

The video is available in HD here.

 

The source code, and an embedded copy of the video, are available below.

 

 

Source Code

 

package com.gamefromscratch;

import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Files;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.PerspectiveCamera;
import com.badlogic.gdx.graphics.g3d.Environment;
import com.badlogic.gdx.graphics.g3d.Model;
import com.badlogic.gdx.graphics.g3d.ModelBatch;
import com.badlogic.gdx.graphics.g3d.ModelInstance;
import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute;
import com.badlogic.gdx.graphics.g3d.loader.G3dModelLoader;
import com.badlogic.gdx.graphics.g3d.utils.AnimationController;
import com.badlogic.gdx.utils.UBJsonReader;

public class ModelTest extends ApplicationAdapter {
    private PerspectiveCamera camera;
    private ModelBatch modelBatch;
    private Model model;
    private ModelInstance modelInstance;
    private Environment environment;
    private AnimationController controller;

    @Override
    public void create() {
        camera = new PerspectiveCamera(75,Gdx.graphics.getWidth(),Gdx.graphics.getHeight());

        camera.position.set(0f,100f,100f);
        camera.lookAt(0f,100f,0f);

        camera.near = 0.1f;
        camera.far = 300.0f;

        modelBatch = new ModelBatch();

        UBJsonReader jsonReader = new UBJsonReader();

        G3dModelLoader modelLoader = new G3dModelLoader(jsonReader);
        model = modelLoader.loadModel(Gdx.files.getFileHandle("model.g3db", Files.FileType.Internal));
        modelInstance = new ModelInstance(model);

        environment = new Environment();
        environment.set(new ColorAttribute(ColorAttribute.AmbientLight,0.8f,0.8f,0.8f,1.0f));

        controller = new AnimationController(modelInstance);
        controller.setAnimation("Mixamo.com", -1, new AnimationController.AnimationListener() {
            @Override
            public void onEnd(AnimationController.AnimationDesc animation) {
            }

            @Override
            public void onLoop(AnimationController.AnimationDesc animation) {
                Gdx.app.log("INFO","Animation Ended");
            }
        });
    }

    @Override
    public void dispose() {
        modelBatch.dispose();
        model.dispose();
    }

    @Override
    public void render() {
        Gdx.gl.glViewport(0,0,Gdx.graphics.getWidth(),Gdx.graphics.getHeight());
        Gdx.gl.glClearColor(1,1,1,1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT|GL20.GL_DEPTH_BUFFER_BIT);

        camera.update();
        controller.update(Gdx.graphics.getDeltaTime());

        modelBatch.begin(camera);
        modelBatch.render(modelInstance);
        modelBatch.end();
    }
}

 

Video

 

Programming , , ,

3. April 2015

 

The open source, C++ based, cross platform game engine and editor Godot have just released version 1.1 beta.  GameFromScratch.com has a fair bit of contentNewImage about the Godot engine, including this ongoing tutorial series, if you wish to learn more.

 

 

So, what’s new in 1.1 Beta?

 

 

Well, I’ll use their own words:

 

 

Godot 1.1 Beta is Out!

Time to get serious again!

After three months of hard work, our first new release is out! This beta prepares the road for the 1.1 release, expected sometime in late April.

New features include:

  • Rewritten Auto-Completion in the Code-Editor. Supports a lot of scenarios and perform smart-completion of node types if a scene where the script is being used is open.
  • Visual Shader Editor (Edit shaders connecting nodes)
  • New API in OS for managing the screens and window, with multi-monitor support.
  • Largely rewritten 2D engine, with support for:
    • Shaders (Visual and Code)
    • 2D Materials
    • 2D Independent Z ordering per-node.
    • 2D Lights
    • 2D Shadows with Polygonal Occluders
    • 2D Normal Mapping
    • Back-Buffer compositing for shaders that read from screen (allows all sorts of post-processing effects).
    • Improved Isometric TileMap Support (proper Z ordering of tiles and children nodes).
    • Distance-Field font support.
  • New 2D Navigation Polygon support, for efficient 2D pathfinding. Navigation Polygons can be edited visually and combined, disabled, etc.
  • Improved Usability in 2D Physics API:
    • Area2D and RigidBody2D can receive input events
    • Area2D can detect overlap with another Area2D
  • New Dark Theme
  • Large amount of bug fixes and smaller improvements.

Please remember that this new version is BETA, so this is your time to report everything that doesn’t work to GitHub as Issues, contribute PRs with fixes or annoy Juan and Ariel to fix what is not working for you.

Godot 1.1 Beta1 can be obtained in the Downloads section, or source cloned at GitHub.

Happy Testing!

 

 

Very cool stuff!  

 

There are actually some pretty major changes in this release.  The improved auto completion is certainly nice, but the rewritten 2D engine is probably the biggest change.  One of the major components of this is the Visual Shader Editor.  As someone who hates writing shaders, this is a welcome addition.  Here it is in action:

ShaderEdit

 

 You can build shader networks by connecting nodes together.  Of course the new 2D navigation stuff is an excellent addition.  I’ll be looking in to this new functionality closer in the near future.

 

You can download Godot here.  The complete source code is available on Github.  As mentioned earlier, to get started there is a complete tutorial series on this very site.

Programming

2. April 2015

 

Overlap2D, a 2D Level/UI editor built over LibGDX has recently gone open source.  We hosted a tutorial here on Gamefromscratch on using Overlap2D several months back.

 

From the announcement:

Overlap2D is now open source!

So yeah, after intense re-factoring, we are finally ready to give Overlap2D sources to our fantastic community!

Github URL: https://github.com/UnderwaterApps/overlap2d

From now on, you will be able to fix or add anything and for everyone.

We are going to see tons of new features in near time, starting from bug proof editor with performance improvements and finishing with crazy addons like terrain editor, custom shaders, polygons, advanced asset manager and much more. With so much going on, you may be asking yourself – how can I help?

And seriously, we really need your help. 

So, here are some ideas you can try out if you feel generous:

We hope this will make editor better, and that in turn will enable you to make amazing 2D games!

Head to github, fork us, explore the code and make some pull requests!

 

Nope, this is not a late April fools joke.  You can see Overlap2D in action in the video below:

 

 

Very cool news guys!

Design, News, Programming

31. March 2015

 

Today I suppose, the new tutorial series covering creating a 2D game in both Unreal and Unity officially kicked off.  I just finished publishing this videoUntitled 7 ( embedded below ) to YouTube.

 

In many ways the video covers the same topics as the earlier announcement post.  Additionally it also goes into a bit of the differences between Unity 5 and Unreal Engine 4, especially from a licensing perspective, and area where Unity and Unreal differ a great deal.

 

We also cover some of the similarities and differences between Unity and Unreal Engine, which are probably more alike than you realize.  We go into the languages and platforms supported by each engine.  Of course we also describe the goals of this entire series.  If you are already familiar with Unity and Unreal and read the last posts, there isn’t really anything new here.

 

Once again, your comments and feedback will shape how I continue, so the earlier you can get suggestions in to me, the more likely I am to be able to cover them! Next up I will be doing a learning resources post for each engine, then we will jump in to the technical details, so stay tuned!

 

Unity vs Unreal Engine Tutorial Series –The Series Introduction

 

This space left intentionally vague.

Programming

Month List

DisqusCommentsSummary