New OpenGL adapter on Windows

In WaveEngine 2.3.1 we have added a new adapter on Windows for OpenGL, this allows WaveEngine developers to run their games using DirectX and OpenGL on Windows. This will be really handy to adapt their assets (like shaders or textures) faster to our OpenGL platforms (Linux, MacOS, iOS and Android).

Continue reading New OpenGL adapter on Windows

New serializer using Protobuf-NET

In Wave Engine 2.3.1 we have started to use Protobuf-NET as the default serializer in all game description files (scenes, prefabs, materials, etc…).

Protobuf-NET is a contract based serializer for .NET code, that happens to write data in the “protocol buffers” serialization format engineered by Google.

The inclusion of Protobuf-NET gives us the following advantages:

  • Performance Boost: Reduce app startup time and other serialization related actions up to 5X  (scene navigations, prefab instantiations …)
  • Reduce app package size
  • Binary files: Avoid to deploy plain xml files in app packages
  • Support DataContract attributes: You don’t need to change your components code

Continue reading New serializer using Protobuf-NET

What’s new in Wave Engine 2.3.1

Wave Engine 2.3.1 has been released today.  This version adds some important features that we think our community will enjoy, like binary scene serialization and OpenGL support in Windows. Let’s have a look in detail.

Bokeh lens sample

Continue reading What’s new in Wave Engine 2.3.1

Appear and disappear effect in WaveEngine

In this article, I’m going to show how to create a cool effect to make the NPCs in your game appear or disappear. One of the issues that you need to resolve when you kill an enemy in your game is how to hide it from your scene. Unless, of course, you want to pile up enemy bodies.

We are going to create a custom shader in WaveEngine for our aim. If you do not already know it, we recommend reading this article before you start.

Follow the steps to create the project effect.

Continue reading Appear and disappear effect in WaveEngine

Facing navigation flow with Wave Engine

The navigation flow in games is a very important part that can be difficult to deal with. In this article we will introduce a possible strategy to solve this.

Wave Engine provides generic services and tools to manage scene transitions and basic navigation. However, distributing the navigation logic between different scenes and behaviors can be tricky at times and difficult to scale.

To solve this, an interesting approach is to use a service that contains all the navigation logic, managing transitions and deferred loading between scenes. Later, a simple and generic component can be used to link navigation events to buttons in the scene and hardware buttons. Continue reading Facing navigation flow with Wave Engine

How components resolve their dependencies

In this article we will learn how components resolve their dependencies with other components and how the custom attribute [RequiredComponent] works.

Entity and Components

As you know, an Entity represents a logic element of our game and it is an empty box where you can put component insides which define what the entity can do.

The logic hierarchy is handle by the EntityManager which stores the struct of all the entities in our scene. For example:

Continue reading How components resolve their dependencies

[Working on] Relative entity paths

In the next Wave Engine version, we are introducing a new feature that can help improving your productivity.

We have decided to add relative entity path in our engine, allowing to obtain an entity just knowing its path from another entity.

This will be really helpful when you’re creating components that reference other entities and:

  • You don’t know the target entity’s absolute path.
  • Your component is used several times in your scene.
  • You want to make your component / entity reusable.

Continue reading [Working on] Relative entity paths

Nine Patch in WaveEngine

What is Nine-Patch?

A Nine-Patch is an image format that adds extra information on an image file, defining what parts of it should be scaled (and which are not) when the image is rendered in a larger or smaller size. This technique was introduced in the Android SDK and is very useful for creating UI components like buttons, panels, containers, etc.

Using this technique, you can define the background of multiples UI components like panels or buttons with the same image asset. You can also create large panels with a reduced image asset so is very useful for optimizing your project resources.

Continue reading Nine Patch in WaveEngine