Community Blogs

Chase Camera Tutorial for SunBurn

2012-01-02T05:20:36Z

I've written another tutorial in the series of getting started with SunBurn tutorials. This time taking the quite simple concept of the Camera and the view matrix to explore some more 3D maths and walk through how to get a simple Chase Camera with some basic feel for movement up and running.

http://dsebj.evolvingsoftware.com/2012/01/02/show-me-the-player/

Lot's of pictures this time too.

DSebJ

Normal Map Plugin

2011-12-25T14:49:09Z

As you might have noticed I was working on a plugin for the sunburn editor, which uses the diffuse map of a material to generate a normal map.

Today I published the first version of the plugin, you can download it here.

Furthermore here is a video of it's features:

(Please visit the site to view this media)

In the meantime I fixed the restriction with only accepting Color textures. Now you can also use DXT1 compressed textures (which is the default format of sunburn's imported textures). Besides, the normal map gets properly saved and assigned to the material after closing the dialog.

However, there is still an issue with automatically loading the plugin, so you have to load it manually after adding it to the project:

sunBurnCoreSystem.ManuallyLoadPlugin<EditorPlugins.NormalMapGeneratorPlugin>();

That's my christmas present to the Sunburn Community! Merry Christmas :)

//Edit:

Here you can find a short video tutorial:

(Please visit the site to view this media)

IGF v0.9.1.0 released!

2011-12-12T00:06:14Z

Here is another quite heavy IGF release

[Edit: IGF v0.9.1.0 is now available!]

I managed to get SunBurn 2.0.17.6 fully implemented for all platforms and I must thank SynapseGaming for letting some of us getting access to a pre-release version which helped a lot in this move. Next time SunBurn gets updated, I’m planning to release the updated IGF version at the same time as SunBurn engine!

Another cool feature is the new Lidgren Network based Session assembly which will let you create Windows multiplayer games really easily and if you were already using the IGF Logic Live session system, to get it working with Lidgren is just changing the LiveSessionManager to LidgrenSessionManager in your windows projects…
Unfortunatelly, I couldn’t get the Lidgren WAN implementation ready for today as it would require me to add an external Master server so that it replicates the Matchmaking features found on Live. I’ll be working on it for the next release and I could come up with some cool surprises on that area

BEPUPhysics just updated their library to 1.1 and therefore I decided to directly update the IGF Physics assembly with it.

Finally, I’d like to give a big thanks to bamyazi who helped a lot on two additional features (and some other things too):

you can now easily add vibration to your games when players use a GamePad;
and you now have an ArcBallCamera3D class to orbit around your models

I’d also like to thank all other developers using IGF trusting the effort I put in this framework and all the great feedback you provided me with.

You can download the binaries here, the source code there and see below for a quick view on the changelog:

v0.9.1.0

Feature: Added a new BloomPostProcessor to add some glow & bloom effects to your scene without the HDR provided by the SunBurn post processor.
Feature: Added 4 statistics to SunBurn Statistics system: Session_PlayerAgents_Count, Session_NonPlayerAgents_Count, Session_BytesPerSecondReceived, Session_BytesPerSecondSent.
Feature: ParticleSystems can now be created based on ProjectMercury particle system editor.
Feature: BEPUCollisionMove and its inherited classes can now be Enabled or Disabled so that you can control when physics should be applied.
Feature: GUI Controls can now be rotated.
Bug: Fixed an InvalidOperationException that could be randomly thrown when a GameState was getting loaded asynchrnonously
Misc: Agent now inherits from BaseComponentManualSerialization<ISceneEntity> to prepare support on the SunBurn Editor.
Misc: Added the Serializable & EditorObject attributes to PlayerAgent & NonPlayerAgent classes to prepare support on the SunBurn Editor.
Misc Now PlayerAgents and NonPlayerAgents get automatically removed from the Session when their ParentObject get removed from the ObjectManager to avoid them to be processed.
Misc: Added a Queue base system to the Processing of PlayerAgent and NonPlayerAgent Behaviors to avoid a Collection changed exception when they retrieve themselves from the Session (also prepares for Multithreading support).
Misc: Added a check on Session update to avoid processing PlayerAgent and NonPlayerAgent Behaviors if they are not attached to a SceneEntity or SceneObject instance.
Misc: BEPUCollisionMove now automatically adds or removes their associated SpaceObject or Entity to the BEPUPhysics Space instance when their SceneObject is submitted or removed from the ObjectManager.
Bug: Fixed a bug where BEPU Entities wouldn't be properly initialized.
Bug: Fixed a bug where StaticMeshCollisionMove instances would always throw an exception when colliding with another object.

v0.9.0.0

Feature: Implement SunBurn 2.0.17
Feature: Implement new Lidgren network library based Session system for Windows (supports SinglePlayer & LocalAreaNetwork sessions: WideAreaNetwork session currently under heavy development)
Feature: Implement ArcBallCamera3D (courtesy of bamyazi) to orbit your camera around a given target.
Feature: Added Vibration to PlayerInput (courtesy of bamyazi) supporting multiple vibration events.
Misc: Upgraded BEPUPhysics to v1.1
Misc: BEPUPhysicsManager now has a UseInternalTimeStepping property which enable/disable BEPUPhysics optimized internal time stepping for games that have their Game.IsFixedTime property set to false.
Misc: Upgraded all WP7 projects to WP7.1 (Mango)
Misc: Removed obsolete IRenderEntity interface, DeferredRenderer & ForwardRenderer related managers since SunBurn latest release provides Alpha and Additive Blend support as well as custom rendering pipeline.
Misc: Sessions now have different SessionStates: Lobby, Starting, Playing, Ended & Closed and their companion events: Session.Starting, Session.Started, Session.Ended & Session.Closed.
Bug: Corrected a design pattern misconception where BEPUCollisionMove instances weren’t created until the 1st BEPUPhysicsManager.Update() call was performed.
Bug: Fixed an issue where the collision trigger event were never raised.
Bug: Added a generic Scale property to BEPUEntityCollisionMove class to allow precise control on Entity scale matrix when applied to ParentObject.World
Bug: Fixed an issue where Commands were executed at the wrong Frequency.
Bug: Fixed an issue where models in WP7 projects weren’t lit properly (Added LightMapManager instance by default on WP7.1 IGF Application class)
Misc: Now, all IGF Managers are retrievable from the SceneInterface.GetManager method using an interface based type (i.e.: ICameraManager, IInstancingManager, IBEPUPhysicsManager,…) so that you can create your own overriden managers.
Bug: Fixed a small bug in GameState not using the proper ICameraManager interface to grab the related manager
Bug: Fixed an issue with non Power of 2 RenderTargets used within the UI library on WP7.

Introducing Brain Engine

2011-12-01T16:58:49Z

Release Date: 12/01/2011

Brain - Highlights

What is Brain? Brain is a Free(not open-source) Engine focused on making development of games and Windows app quick and easy.

What are this Release Contents?

The above Release comes with:

- Demo: All the 2D and 3D(BasicEffect) Demos of the Engine

- SunBurn Demo: Only some 3D demos running with SunBurn

- DLL: Windows, Xbox 360, Windows Phone 7, content projects and Pipeline.

- Documentation: Documentation of the Engine, of the Demos, and most Engine's Exceptions.

- Extern: Projects for implementing BEPU or SunBurn on your projects(source-included).

- Suite: Includes Binary File Operations, Language Editor and Windows Phone Tools, described below.

P.S.: Use the download link here. The download link on the Website (http://brain.largaming.com ) is only for non-SunBurn users.

* Platforms

- Windows

- Xbox 360

- Windows Phone 7

- Silverlight 5

* Suite

- Language Editor -> Used to make Language files to be used in your games

- Binary File Operations -> Like WinRAR, but it converts folders and stuff to a Binary File, that can be later loaded to your game

- Windows Phone Tools

- Editor -> A 3D Editor(not on the Release, but soon it will be)

* 2D

- Camera system fully integrated on the Engine

- Particle System(simple)

- Sprites -> Easily render text, texture or rectangles

- Video System -> Automatically plays videos

* 3D

- Avatars

- Custom avatar animations

- Avatar rendering integrated in the Engine

- Easily gets the Player's avatar

- Use with default avatar's animations

- Brain Model

- Easily construct models, by code.

- Mesh Builder:

- Automatic Mesh Builder

- Using reflection, you just give it some vertices and normals, give it your VertexType, and it will return a VertexBuffer and an IndexBuffer

- Manual Mesh Builder -> Helps on making models, manually(without reflection)

- Code for making models -> Box and Sphere

- Camera

- Easy to use Camera classes. Comes with FreeCamera, TargetCamera and InputControlledCamera

- Line Drawing

- Picking (by color)

- Basic Effect Rendering integrated(with Skinning)

- Skinned animation(still on it's beginning, but it works)

* Animation

- Animation_Delegate

- Animate stuff using delegate methods

- Animation_FadeSprites

- Easily fade in/fade out sprites

- Animation_Float

- Animation_I2DObject

- Animates Sprites and any I2DObject interfaced object

- Animation_I3DObject

- Any I3DObject can be animated with this, including the WorldObject class.

Almost everything in Brain is animateable. For example, Cameras 3D have a World Object class, and WorldObject is animateable, and so is the Camera.

* Input

- Easy Input Checking on every platform!

- Buttons Assignments -> Assign an action to a button

- Virtual Thumbstick -> thumbstick on-screen used on WP7 devices

* Managers

- Computer Manager -> Helps getting info like what is the clock of the user's processor and how much ram the computer have.

- Console Manager -> Like any Engine Console, but it's on it's very beginning(dont accept commands, only receive to show on-screen).

- Debug Manager -> Helps debugging a game

- Time Manager -> Manages stuff like timing how much time a Method took to be executed, or even to benchmark a game.

- Game Time Manager -> Calculates the GameTime in platforms that don't have it, making smooth animations(Silverlight, obviously).

- Debug Info Classes -> Make a method that returns a string, and assign it to the Debug Manager, and it will be showed on the game, if you press F4

- Event Manager -> Sometimes, events should be answered by multiple classes. Like, for example, when the game is resized. You may want to make some stuff happen, but th Renderer should see that this happenned, and answer to the Event too. The Event Manager handles stuff like this.

- Exception Handling -> All exceptions on the Engine are handled by the Exception Manager. You can save a log of a ll exceptions with it.

- IO Manager

- Easy save XML stuff using only Serialize(string filename, object o) and Deserialize(string filename).

- Font Manager -> Automatically loads all fonts on a folder you specify. You can load fonts later too, and only use their names(like, Sprite.FontName = "Kootenay"), instead of having to maintain a reference to the SpriteFont instance on everyplace you want to use it.

- Memory Content Manager -> Helper for storing stuff made in code(like the code-made box object)

- Storage Device -> Easily get a Storage Device on Windows or Xbox 360, making it easy to save/load your game. Also, it handles StorageContainers disposing, so you won't have to be aware of forgetting to dispose.

- Language Manager -> More info about it on the Brain's documentation.

- Picking -> System for picking World Objects(mostly used by the Editor). Comes with a fully-working Color Picker.

- Render Manager

- Draws 3D Lines, 2D Rectnagles, Strings and Textures.

- Partial support for Post-Processors

- Position Manager -> Helps centering stuff on Screen (WIP, but it works)

- Serialization Manager

- Serializes the Engine

* Structures

- Vector2I -> A Vector2 made of Ints, for faster computating where it works.

* Util

- Many Util classes, making it easy to animate stuff, to calculate and to everything.

* And mannnnnyyy more

* Some pictures of the Demos running on Windows:

Sunburn Post-Processing Library Community Resource Preview

2011-10-25T07:50:25Z

I want to preview some new progress on the library which will soon be availible as a Community Resource for Sunburn users.

The library will use a single SceneEntity called VICOGSPostProcessorsEntity. It will serve as the manager of its components which will be the Post-Processors.

All the options will be editable in the editor as shown in preview.

http://youtu.be/-c77DSi64CI

Let me know your thoughts, more to come soon.

Ace on Steroids: Learn IGF & SunBurn as I progress

2011-10-10T22:52:25Z

Now that IGF v0.8.0.0 is released, I can focus part of my spare time onto providing developers with some tutorials on how to use the framework.

Before IGF was hosted on Codeplex.com, I used to develop one sample per IGF feature and bundle them in one huge zip file containing the framework source code and these samples. Still, since they were using SunBurn licensed assets, I couldn’t push them on Codeplex. As a consequence, v0.7.0.0 was delivered without any samples which made it very difficult to get onto.

When I started thinking on the best approach to teach developers how to use IGF, I sat back and tried to remember what were my best learning experiences and I realized that I loved learning by practicing with real examples either at school or on some books.
I decided therefore that the best approach would be to create step by step tutorials that would teach the audience how to build a game from start with the framework.

However, I don’t have that much time to write extensive documentation and there are way too many things to cover (Core appplication framework, asynchronous loading, rendering, AI, networking, etc…) so I had to find another medium and context.

Then I thought:

“Why not just develop a simple yet complete game from scratch and let IGF users accompany me in that process?”

That’s exactly what I’ll be experimenting:

“Ace on Steroids” is an Asteroids clone using 3d rendering but 2d gameplay to avoid introducing 3d math complexity. Still, it’ll use all the features present in the framework.

I started the process this week end and the result can be seen on the documentation tab on the Indiefreaks Game Framework.
The first tutorial shows how to setup your development environment to use IGF, create a new IGF game using the Application class and finally create your first GameState to show the required SunBurn SplashScreen.

You may also have a look here:

(Please visit the site to view this media)

I hope this approach will help developers getting into the framework.

For more detailed questions, feel free to post them on the IGF discussions tab on Codeplex.com.

IGF v0.8.0.0 release

2011-10-06T14:38:04Z

Well, I’ve been very busy lately with many personal stuff and therefore couldn’t move as fast as I would have liked on IGF.
Still, here it is: IGF v0.8.0.0 has just been delivered on Codeplex!

Pick what you want!

The content of the release isn’t that big but it includes a very structural change: IGF is now splitted into multiple assemblies; one per feature.

There are many reasons why I made them separated assemblies but here are the most important ones:

Having multiple assemblies eases the maintenance process as well as improving each feature asynchronously or by multiple developers.
IGF users can now pick the feature they want and simply add a reference to the library implementing it.
SynapseGaming is about to launch a “Resource SDK” for SunBurn Engine contributors that should normally make it easier for community members to plug features in their games: IGF will normally be in this process.

And in order to achieve this, I refactored the entire framework in a set of assemblies which some are actually totally independent which allows you to just pick one or multiple features and plug them in your game without the need, for instance, to use the IGF Application Framework which may not suits you

So, now, instead of a unique Indiefreaks.Game.Framework.dll, you’ll have:

Indiefreaks.Game.Framework.dll: Core Application Framework
Indiefreaks.Game.Logic.dll: Logic & Network abstraction system (Requires Indiefreaks.Game.Framework.dll)
Indiefreaks.Game.AI.dll: 2D & 3D Steering Behaviors, Finite State Machines & Goal Driven AI (Requires Indiefreaks.Game.Logic.dll & Indiefreaks.Game.Framework.dll)
Indiefreaks.Game.Instancing.dll: Easy instancing feature (No dependencies)
Indiefreaks.Game.Live.dll Xbox Live networking implementation of the Logic & Network system (Requires Indiefreaks.Game.Logic.dll & Indiefreaks.Game.Framework.dll)
Indiefreaks.Game.Particles.dll: Project Mercury particle system (No dependencies)
Indiefreaks.Game.Physics.dll: BEPUPhysics integration (No dependencies)
Indiefreaks.Game.PostProcess.dll: Post processing effects (No dependencies) [requires SunBurn Pro Edition]
Indiefreaks.Game.Sprites.dll: Sprite system replacement (No dependencies)
Indiefreaks.Game.UI.dll: Graphical User Interface (requires Indiefreaks.Game.Framework.dll)

New features

And as you can read, you now have 2 assemblies which features weren’t part of IGF before

IGF v0.8.0.0 now includes a framework to replace SunBurn default CollisionManager with a BEPUPhysics v1.0.0.0 compatible BEPUPhysicsManager to get the benefits of the wonderful BEPUPhysics library with really low efforts. (Got easier to do thanks to the CJBailey's SunBurn BEPUPhysicsManager example which clarified how things could match with the ICollisionMove system. Thanks budy! :P)
Nontheless, I’m also adding a new Post Processing feature starting in v0.8.0.0 with a Depth Of Field post processor that you can plug & play within your game (courtesy of bamyazi. Thanks you man!)

Documentation

Yet it is still missing something important for IGF users to really get started having fun with it: documentation!

I know and this is something that will get in my primary focus in the coming weeks as I’ll release as fast as I can a set of step by step tutorials to get you on the train.

I wanted to wait for this release to be out before getting into it as the structural change brought by it would make any “getting started” tutorial useless as soon as it would have been released. Now that it’s done, I can spend the required time to get these tutorials published.

How do I get it?

As usual, go to the Downloads tab in Codeplex.com and download the runtime binaries.
If you’re looking for the source code, it can be grabbed on the Source code tab.

And the usual release notes:

Feature: Splitted IGF in multiple assemblies. You can now choose which feature(s)you want in your game.
Feature: BEPUPhysics v1.0.0.0 integration as a SunBurn CollisionManager replacement (You still can use both if you want)
Feature: Depth Of Field Post Processor (courtesy of bamyazi, Thanks )
Feature: Added new ChaseCamera3D class (courtesy of rc183, Thanks! )
Misc: Changed GuiManager.ManagerProcessOrder value to 15 so it gets rendered after PostProcessManager by default.
Bug: Fixed an issue with GuiManager and Xna 4 effect bug with SampleStates.
Misc: Added ContentLoadingException to provide clearer explanation to the developer when an error occur during the asynchronous content Loading process
Bug: Fixed bug on Xbox PlayerInput not being updated correctly introduced in v0.7.0.0 when adding support for WP7

Building a BEPU Physics Manager for SunBurn

2011-08-20T13:11:12Z

Building a BEPU Physics Manager for SunBurn

Source Code

[Updated on 15/10/2011 for BEPU Physics v1.0 and addition of "IsDynamic" checkbox which toggles the physics entity between being dynamic and kinematic]

(Please visit the site to view this media)

Hi guys. This post is in response to a request from Philippe regarding integrating BEPU physics into his excellent Indiefreaks Game Framework. I hadn't got around to sharing this yet because it was a bit of a rush job to see if I could get it to work, and it was too integrated into my game to separate it out.

However, I've done a quick rework to separate it into its own assembly now. There are a couple of quirky workarounds in order to get it playing nicely with the SunBurn editor (at least until we have more virtual methods accessible to us).

The attached zip file contains all the code to save you a bunch of work, so you should just need to load it up in Visual Studio and recompile.

I've tried to make it as plug-and-play as possible but because of the workarounds I had to implement it's turned out to be more complex than I'd like behind the scenes, and will also require a little extra work to get it working nicely with the SunBurn editor. I'll explain more as we go.

The BEPU Physics Manager

First up is the custom SunBurn manager which is effectively a wrapper for the BEPU physics "Space" (see the BEPU documentation). This is called:

BEPUPhysicsManager

Simple enough so far. So all you need to do is create and add this manager at the beginning of your game (removing the default collision manager if necessary):

// Remove the default collision manager and replace with BEPU physics manager.

_sceneManager.RemoveManager(_sceneManager.CollisionManager);

_sceneManager.AddManager(new BEPUPhysicsManager(_graphics));

BEPUCollisionMove

The custom ICollisionMove implementation is unfinished but does enough to get things working.

There are several methods and properties I don't implement properly, such as Distance, Normal, WorldBoundingBox, ApplyWorldForce etc. I'm sure these could be implemented in some way but I didn't really feel it necessary.

The Physics Components

Any scene object can be given physics functionality (except terrain) just by attaching one of the physics components to it (either via code or via the editor). There are currently three components:

PhysicsBox
PhysicsSphere
PhysicsStaticMesh

Each one is derived from the abstract class BasePhysicsComponent, so if you create your own be sure to derive from this class also.

I came across a problem when removing physics components via the editor because the OnComponentListChanged() method doesn't get called on the component that is being removed. This meant that when I remove a physics component the actual physics entity would remain (I needed some way of telling the BEPU "Space" to remove the entity)...

GCManagerComponent

To do this I created another component called GCManagerComponent which could be attached to every scene entity by default. This would then be able to monitor when another component is added or removed and perform any necessary initialisation or clean up code.

I've included this component in the assembly but you will need to add in your own code to automatically add it to your scene entities. I did this by creating an editor extension manager which can monitor when the editor is opened and closed (again... we need more virtual methods on the editor class!) so it can add and remove the GCManagerComponents (since they're only needed by the editor).

Hopefully, all of this will become unnecessary in the next release of SunBurn. ;-)

The Object Manager (SunBurnBEPUObjectManager)

I needed to extend the default object manager in order to initialise the physics entity properties (mass and affected by gravity) upon loading a scene. If anyone can find a better way of doing this please let me know.

Firstly I override the Submit(SceneEntity obj) and Remove(SceneEntity obj) methods to automatically submit and remove scene objects to and from the physics manager.

Secondly I override the Submit(IScene scene) method to call a custom virtual method (OnSubmitScene) for any components that implement the IComponentExtension interface.

IComponentExtension

This is implemented by the BasePhysicsComponent class. The OnSubmitScene method basically sets the Mass and IsAffectedByGravity properties on the physics entity after the scene has been loaded.

You can also override the method in your own physics components if you like.

The Debug Drawer

This is basically a slight modification of Dean Wadsworths debug drawer. You can turn it on and off while running your game using the key combination of CTRL + F3 (don't know why I chose that... feel free to change it).

In your main Game() class create an instance of the BEPUDebugDrawer class during LoadContent() like so:

_BEPUDebugDrawer = new BEPUDebugDrawer(_GraphicsDevice, _physicsManager);

Where "_physicsManager" obviously refers to the BEPU physics manager we created in the previous step.

Then, before the call to SceneInterface.EndFrameRendering() call the BEPUDebugDrawer.Render() method:

_BEPUDebugDrawer.Render(View, Projection);

Ready To Run!

Ok, so now we're ready to roll. Execute your game and fire up the editor. You should now see the physics components when adding a component to a scene object.

If you add a physics component to a scene object you will notice that you can no longer drag the object around within the editor. That's because the scene object world transform follows the physics entity world transform. To work around this, I set the BEPUPhysicsManager.SuspendPhysics property to True whenever the editor is attached.

You'll notice in the BasePhysicsComponent there is code for handling the world transform differently depending on the setting of the SuspendPhysics property.

You will also notice that when you remove a component the physics entity remains (try it with the debug drawer on). As previously mentioned you will need to assign the GCManagerComponent to each scene entity that uses the physics components (or just attach it to ALL scene entities regardless).

I'm sure I've probably missed something out.

[EDIT] Yep... I have missed something...

Before adding a physics component, be sure to set the scene object/entity to receive updates (UpdateType = Automatic) and the CollisionType to Solid object or Trigger.

Oh and also... the PhysicsStaticMesh is a bit buggy. It doesn't seem to generate the mesh with the correct world mesh and I can't figure out why.

Think I fixed the bug in the PhysicsStaticMesh now.

Indiefreaks Game Framework v0.7.0.0 released on Codeplex.com

2011-08-19T19:43:48Z

[Cross posting from http://indiefreaks.com]

Wow! Another huge release for me and the Indiefreaks Game Framework

First, because of its content: IGF v0.7.0.0 comes with 3 new features that on their own generated a bunch of work.

Mercury Particle Engine support: I introduced the ParticleSystemManager class that handles ParticleSystem instances which are triggered through code or directly inside the SunBurn Editor using ParticleTrigger instances.
A new LocalSession system which is another option than the LiveSession system which allows you to use the Logic namespace and its inner AI features for a single player game without the need for Xbox Live.
Windows Phone 7 support: v0.7.0.0 comes now with a WP7 build for SunBurn Indie and Pro. I still consider it an alpha feature since I didn’t yet manage to fully integrate WP7 input with the current InputManager but it still works. Ideal to get some feedback from WP7 developers.

But that isn’t all, since we should see some contributors working on IGF from now on, I setup a project in Codeplex to host the team source code & releases. As a direct consequence, I removed the feature requests, forums and downloads from the current website and push them all on Codeplex.
I still preserved a page describing the project which will see several changes on its presentation to better describe its features. It’ll also be the host of several tutorials to teach developers how to use it.

Another consequence on releasing the source code through Codeplex.com is that I’m not anymore allowed to distribute some of the previously released samples as they’d break SunBurn license. But no worries, we’ll be releasing a unique sample and a set of tutorials soon taking you through a step by step process to build your game with Microsoft Xna, SynapseGaming SunBurn, Mercury Particle Engine all centralized through the Indiefreaks Game Framework.

I’ll keep maintaining blog entries on the work performed in the framework here.

You can download the source code here and the binary files here.

And the usual Release Notes:

v0.7.0.0: 19 August 2011

Feature: Windows Phone 7 support: v0.7.0.0 now supports WP7. Note that this is to be considered an alpha support as I couldn’t fully tested it.
Feature: Added Local Session system for Single Player games while working with the Logic namespace
Feature: Added Project Mercury Particle Engine support as placeable entities in code or in SunBurn Editor.
Misc: Application now exposes the current running Application instance statically.
Misc: Application now exposes its ContentManager statically.
Misc: Agent Add & Remove Behavior methods have been made virtual to override how they are added & registered with the current session.
Misc: Behaviors and Commands now support an ExecutionFrequency property which tells the Session how many times per second they should process. This gives developers a much better control on optimizing their AI & networking code.
Fix: v0.6.0.0 introduces a bug where Server Commands would also execute on the client side.
Fix: Refactored Goal Driven AI due to a defect causing wrong Goals being processed on clients.
Misc: Added ForceVelocity to AutonomousAgent class allowing developers to force the current velocity of a given entity if required.
Fix: Set SmoothRotation property in AutonomousAgent class public so that developers can modify the steering forces when applied to their entities velocity
Fix: Added a simple Enable check on steering behaviors to avoid them being called when not used.
Fix: Fixed a bug where when using ContextualSteeringBehaviors, the considered & ignored entities wouldn’t be correctly processed in some cases.
Misc: Added an AllowPenetration property to ObstacleAvoidance steering behavior (defaults to 0).
Fix: Fixed a bug in ObstacleAvoidance steering force computation which was staying in Local system thus uncorrectly pushing back the resultant force.
Misc: Changed OffSetPursuit.Leader name to Target.
Misc: Removed NetworkIndexPlayer from IdentifiedPlayer as it wasn’t used anyway.

A Child Component

2011-08-19T13:51:33Z

The next blog post in the series introduces the concept of calculating offsets in world space and converting those to an objects local space; using an example of building a child component.

http://dsebj.evolvingsoftware.com/?p=228

Feedback welcome as always.

~DSebJ

A Few Post-Processing Effects for SunBurn

2011-08-02T16:18:22Z

I have been hard at work on my new game, a few weeks ago I started work on some Post-Processing effects.

The Effects I have worked on are: Radial Blur, Camera Motion Blur (used in Crysis), Depth of Field (I made two kinds, a cinematic type and a gameplay type), HDRLighting with Glare (also used in Crysis and Dirt 3) and SSAO with one indirect bounce.

The first three effects are complete and were designed for the Xbox 360. Obviously their performance highly depends on the resolution used. I'm using a res of 960x540x2 in my game which looks very close to 1280x720, therefor the effects are around 2ms each give or take.

I want to ask your oppinions on how you want the effects posted in community resources, a simple copy-paste, a link to an example proj, or ...

I also would like to post a donate link so that those who like my work can help support my game as well as more things for the community.

Please post what you think about this.

A few videos showing the effects:

Radial Blur

(Please visit the site to view this media)

Camera Motion Blur

(Please visit the site to view this media)

Depth of Field; Rough version

(Please visit the site to view this media)

Depth of Field; Cinematic version

(Please visit the site to view this media)

3DS Max Connection -> Improved!

2011-07-30T19:21:36Z

I guess some people may remember my last article, about the 3DS Max Connection. Now, it got better!

Here's a video:

(Please visit the site to view this media)

Basically, I discovered that 3DS Max 2012 supports .NET 4.0. Voi'la! DotNet4.0 is the one that XNA uses, soooo, I can fully integrate XNA and SunBurn with 3DS Max!
I just finished it, so there's nothing much to do, but it works =)

Soon I will make a simpler version, that works without my Engine(so I can give the component to you guys, because currently my Engine can't go out(sent it to John, waiting for clearance etc)).

Thanks by reading =)

ps.: If anyone is interested, we could move this project forward, and make a full integration with 3DS Max, as an OpenSource project =)

IGF v0.6.0.0: Give a Brain to your games!

2011-07-18T20:02:41Z

Finally, I’m pleased to announce the official availability of the Indiefreaks Game Framework v0.6.0.0. It asked me a bit more time to complete because I had to make a high number of tests so that the new features would fit properly with the Logic & Networking system.

For those who may have not followed the framework development, this version is primarly focused on Artificial Intelligence and I’m therefore introducing 3 new features for this unique huge topic:

Steering Behaviors

Steering Behaviors are a set of behaviors (inheriting from the Behavior class and therefore totally compatible with the IGF network abstracted Logic system) and an Autonomous Agent (implemented as a SunBurn Component) that you can configure and add to any SceneEntity or SceneObject instance in your game providing therefore natural movement behaviors to your game entities without the hassle of implementing a lot of game logic to handle all possible cases.

Finite State Machines

Finite State Machines are the first AI system I added to IGF that allow you to define a set of states for your game entities and change them following some unique game logic rules you’ll implement in your code.

Goal Driven AI

Goal Driven AI is the second AI system I implemented in IGF which is slightly more complex but very practical and powerful when you need some advanced AI behaviors. To sum it up, it allows you to define general goals (i.e.: attack ennemy) and add sub goals that will be more explicit and define the tasks that need to be made to achieve the goal higher in the hierarchy (i.e.: find nearest enemy, find most threatning enemy, turn game entity to aim enemy, fire at enemy, …).

For the first time, I’m not including a dedicated sample because, as I explained earlier, each sample is really time consuming and since they’ll be replaced for v1.0 by a unique sample and a set of tutorials to teach developers how to use IGF, I decided to move as fast as possible towards v1.0 release and work on this final sample at the real end.
I’ll still be available in the forums if you need any help using these AI features in your game correctly.

You can download the latest source code & samples as usual here.

And the v0.6.0.0 Release Notes:

Feature: Implements SunBurn engine 2.0.16.15
Feature: Added Steering Behaviors for Aunotomous Agents that work on both 2D & 3D worlds: Alignment, Arrive, Cohesion, Evade, Flee, Hide, Interpose, Obstacle Avoidance, Offset Pursuit, , Pursuit, Seek, Separation, Wander.
Feature: Added Finite State Machine AI structure for you to easily add intelligence to your game entities
Feature: Added Goal Driven AI structure for you to add complex AI behaviors to your game entities
Misc: Added new signatures to Application.FadeIn and Application.FadeOut static methods to let you define how long it should wait before actually fading in or fading out. Useful when you need to fade in or out when the loading gamestate ends loading.
Misc: Changed IRenderEntity.Visible property to IRenderEntity.Show to avoid confusion with SceneEntity.Visible property
Fix: v0.5.0.0 introduced a structural bug on the Agent class with the static CreateBehavior method: replaced it back with the Add static method.
Misc: moved Microsoft.Xna.Framework.Game.Draw() base call inside Application.Draw() at the end of the method for better control on rendering.
Misc: moved all collections to dedicated namespace: Indiefreaks.Xna.Collections.
Misc: Network Session now automatically registers and synchronize SceneEntity and SceneObject instances over the network so that Commands and Behaviors get processed correclty
Misc: Moved PlayerAgent and NonPlayerAgent networking processing code from Session class to these classes directly since they are network independent.
Misc: Added a default OnInitialize() implementation to Behavior class so that each behavior registers automatically its ParentObject (SceneEntity) on the current network Session if not registered.
Misc: Behavior class now implements IDisposable to ensure they get disposed properly.
Misc: Command class now implements IDisposable to ensure they get disposed properly.
Misc: Replaced all Func<> and Action<> generic delegates in Command class to specialized Condition, ClientCommand, ServerCommand and ApplyServerCommand delegates to ease understanding
Misc: Added an abstract Clone method to Gui Control class as well as all inherited classes to create controls from an existing one.
Misc: Added a RemoveAll method to Screen class to allow direct removal of all Controls added to it.
Misc: Changed InstancingFactory to support new SunBurn 2.0.16.15 RenderableMesh.Build() method
Misc: Changed all samples to reflect corrections

The future of IGF...

2011-06-09T14:50:10Z

Yesterday, I decided to make a pause in my development tasks on IGF v0.6 (I needed to change my mind a little bit) and I sat back to have a look where I arrived and where I was going with the framework.

This came after learning that the first game using IGF was published on the Xblig Marketplace: Avatar Word Wave by GloudComputing.

Avatar Word Wave Gameplay - Xbox 360

(Please visit the site to view this media)

The game is available now and I wish them good luck as it’s their entry for DBP 2011.

IGF Road Map to v1.0

This made me realized I made quite a good move forward since I started working on this framework back in January 2011. After 5 major releases, we have a stable framework that eases Windows & Xblig games development thanks to a set of very standard features:

An Application Framework to structure your games code.
A synchronous and asynchronous content loading system so that you can load your game’s content easily with low impact on your players’ experience
A robust and configurable input management system wrapping the usual player input device identification
Obviously the whole framework is tightly integrated with the SunBurn Engine and its wonderful Scene management design to enlighten your game
A sprite system extension to SunBurn’s 2D rendering which brings back 2D positions, rotations, scaling and collisions
A simple yet extendable GUI and Menu system with built in support for rendering your entire GUI or Menu to texture to apply it to any 3D surface
A Logic/Behavior/Command system to create your game entities and apply your AI rules or player controls
And an abstracted network design allowing your game to use whatever networking library you may want as well as making your Logic code similar either you’re creating a solo, multi player game or both

With the incoming v0.6 release which will add Autonomous Agents through Steering Behaviors, Finite State Machines and Goal Driven AI, we are close to get a very robust framework and totally open source

But this is not yet enough, otherwise I’d call it v1.0! There are still a few features and tasks that need to be done to get there. I therefore decided to put them on a list and share them with you in a road map to v1.0:

v0.6 (June 2011): Finalize AI systems with Autonomous Agents, Steering Behaviors, Finite State Machines and Goal Driven AI;
v0.7 (July 2011): Particle System integration (probably Mercury)
v0.8 (August 2011): Lidgren/UDP&TCP network implementation for Windows and potentially WP7.1 Mango networking (depending on feasibility) resulting on IGF supporting Windows, Xbox 360 and WP7
v0.9 (September 2011): Better SunBurn Engine Editor support: Cameras, Sprites, Particle Systems & Emitters, AI Agents… All the framework will be directly usable from within the Editor
v1.0 (November 2011): Performances & Memory optimizations, Totally revised samples, Full API Documentation & Tutorials

I believe with such road map, v1.0 could become a very efficient framework and being open source, very instructive for those who may want to learn a bit more how things can be done. Hopefully, the dates can be met.

Give me a break(through)!

After making such plan, I got pretty interested on the first tasks for v1.0: Performances & Memory optimizations.

I already played a bit with CLR Profiler and other tools to diagnose where my game or IGF was leaking memory or being CPU expensive. However, when I used to work at Monte Cristo on Cities XL, I saw the developers profiling the game directly in the game and I always felt that it should be quite useful to have the game and profiling information at the same place. The Cities XL profiling tool was pretty smart: it could go through each instance method and return the time spent on each of them using some sort of tree view.

I decided then to have a look how I could do that and integrate it with IGF and I found a way using Aspect Oriented Programming and Compite Time Emit code.

The main idea is to create a Profiler attribute that you’d place wherever you want in your game (Assembly, Class or Method) that would intercept Methods before they get called and when the exited so that we can have a set of performance timers and counters around them. When placing the attribute, at compile time, MSBuild would inject the BeforeMethodCall and AfterMethodCall method inside every method that is targeted by the attribute.

I’ll then store the performance counters in another class that would handle their display on screen. This class would also handle some input from the developer so that it can decide to expand or contract nodes in the tree displaying the method performances.

Moreover, this shouldn’t affect much performances since I’d solely make 2 variables assignments. The only consequence would be that the game assembly build would become slightly bigger (a few kiloBytes) due to the code being injected at compile time.

I already have the method injection and performance counting working on my laptop and I still need to work on the presentation layer but that shouldn’t be too hard. Here is a screenshot of my Visual Studio Output where I place the method performances for now (imagine it displayed on your game and being able to dynamically select to move in the hierarchy :

Profiler View in the Output Window

That’s all for now, hopefully, I’ll get back to you soon with more information in my progress on IGF, the Profiler and Cosmos Conflict Commander (I need to find some time to work on it :p)

Cheers and your feedback is very welcomed.

IGF v0.5.0.0 just released!

2011-05-18T21:15:20Z

And here it is! The Indiefreaks Game Framework reaches its v0.5.0.0 which is mentally an important milestone: halfway to v1.0

As promised, you’ll get access to the work I’ve done on the GUI and Menu systems. A new sample to illustrate how to use the new set of classes is also available for both SunBurn Indie & Pro editions. I can’t wait to see what you’ll get done with it

I made a quick video so that you can have a look at what the sample looks like and what the verbose comments both in the framework and the sample itself should teach you to do.

(Please visit the site to view this media)

One simple line to let you know that I’ve received great responses from developers to help me out putting together this open source framework and I should hopefully let you know more on this topic in the coming weeks. Thank you all for the kind words and support for this framework.

Another point to tell you that we should see coming quite quickly a bunch of games made using SunBurn and IGF. I already know about 4 of them and I’m expecting more to come
If you’re developing a game using IGF, I created a specific forum category for it here: let us know what you’re doing!

And finally, the usual release notes and download link:

v0.5.0.0:

Feature: Added GUI System (Label, Image and Button controls)
Feature: Added Menu System (based on GUI System)
Feature: Render both GUI and Menu either directly to screen or to texture (to use in 3d models for instance)
Samples: Added new Menu Sample to demonstrate GUI and Menu system
Misc: Added GameState property to Layer classes to enable easy access (breaking change: all Layer classes require now a valid GameState on their constructor)
Misc: Changed static Application.GraphicsDeviceManager property to Application.Graphics to differentiate with local property access
Misc: Added static GameState property to Application pointing to the current active GameState to ease its access from anywhere in the code
Misc: Now, each GameState has an individual ContentManager instance. It is now the default ContentManager used to load content instead of Application.Content (you can still use it for content that should be available across the game’s life but you’ll have to manually call it).
Misc: Agent Behaviors can now be accessed through a ReadOnlyCollection
Misc: Improved Behavior Commands memory through a set of small optimizations
Misc: Added specific PlayerBehavior<T> and NonPlayerBehavior<T> Behavior inherited classes to avoid usual casting. You can now access your specific PlayerAgent or NonPlayerAgent inherited class and its members without having to cast from Agent.
Misc: Changed AddBehavior(Behavior behavior) to CreateBehavior() using the Factory design pattern (Breaking change)
Misc: Added a virtual Initialize() method to Behavior to initialize inherited classes outside of the constructor
Misc: Added specialized CreatePlayerAgent<T>() and CreateNonPlayerAgent<T>() methods to Session to create and register your own PlayerAgent and NonPlayerAgent specific classes
Misc: Added Visible property to IRenderEntity used to cull your custom SceneEntity and SceneObject instances
Fix: Fixed a bug where Application FadeIn/FadeOut rendering code was always executed when not required
Fix: Fixed default VirtualKeyboardMouseMapping where Mouse Left and Right clicks weren’t mapped to the good KeyMaps
Fix: Fixed a bug throwing an exception when an IGF game used the LiveSessionManager and SunBurn Editor.
Samples: Modified all samples to support v0.5.0.0 API changes