Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon

4. January 2016

 

PlayCanvas, a popular 3D HTML5 game engine have added support for Spine the 2D bone based animation software from Esoteric Software.

 

You can get the plugin from Github, details from the announcement:

This is the first version of PlayCanvas plugin for the Spine Animation tool.

Image

Spine allows you to create bone-driven 2D animations so it does away with the need for huge sprite atlases and tedious animation processes.

Using the PlayCanvas Spine plugin you can drag and drop your Spine Animations into the Editor and get them straight into your game.

Read more on the plugin's Github page

GameDev News , ,

1. January 2016

 

A reader wrote in to share this bundle currently running on BundleStars, and I am glad they did.  Somewhat similar to a humble indie bundle from a few months back but containing a great deal more art assets.  I’ve actually used the tilesets from the earlier humble bundle several times here on GFS, so I will be picking up the $16 tier.

 

The ultimate Game Makers bundle:

image

 

For between $3 and $15 you can end up with a heck of a large volume of assets to make games with.

GameDev News, Art ,

1. January 2016

 

When I set up the news monitoring on GameFromScratch.com I noticed that Ogre3D hadn’t had an update since June and was somewhat concerned that the project was dying off.  Thankfully today there were signs of life over at ogre3d.org.  If you have never heard of it, Ogre3D is a C++ based renderer and scene graph and has been used to create several shipped titles.  The major challenge to Ogre3D is that it is currently Windows and Linux only.

 

From the update:

So… what’s new?

1. Added TagPoints to the new Skeleton system! This has been a sort of unfinished business for me. I’m glad it’s finally done!

2.1’s TagPoints are superior to their 1.x counterparts. The TagPoints from v1.x had many issues: they didn’t follow RenderQueue, visibility rules, nor LOD rules correctly (they were subordinated to the settings from the main entity/skeleton they were attached to). The v1 TagPoints also belonged to an Entity. If the Entity was destroyed, it took down its TagPoints with it. Meaning if you wanted to still keep the attachments, you had to iterate through them, detach them from their TagPoints, and add them to a new SceneNode. Ugh!!! Personally, I gave up trying to use those in my projects a long time ago.

In Ogre 2.1; TagPoints are much better: they are exactly like regular SceneNodes, except they occupy a little more RAM (a few more bytes per node), and can be attached to Bones. Other than RAM consumption, there is no performance penalty for replacing SceneNodes with TagPoints (*).

You can make a TagPoint child of a SceneNode, a SceneNode child of a TagPoint, and a TagPoint child of another TagPoint. The only thing you can’t do is make a SceneNode child of a Bone. You must use a TagPoint for that.

If you want, you can use TagPoints throughout your entire codebase and forget about having to deal with whether an Item/Entity was attached to a TagPoint or a SceneNode and get downcasts correctly.

(*)When a SceneNode or TagPoint is attached to a TagPoint that is child of a Bone, the performance is slower because these nodes need to support non-uniform scaling. But if the TagPoint is child of the Root SceneNode (instead of a bone) like all regular SceneNodes, then there’s no performance penalty.


2. Added PSOs (Pipeline State Objects). This brings us one step closer to Vulkan, DX12 and Metal support. We’ve also noticed some minor performance improvements since there are less hoops now when tying shaders with input layouts in the D3D11 RenderSystem. Overall it simplified our workflow. It also fixed a rare culling winding bug in GL3+ as a nice side-effect.

This work is in the branch 2.1-pso. It’s ready. It hasn’t been merged yet back to main 2.1 branch because I am waiting to test it on a big engine (since it was a big change) in case there are edge cases to fix.


3. Added alpha tested shadows and transparency to PBS! These have requested by many. Alpha tested shadows are useful for grids, leaves and other alpha tested objects.

We offer two transparency modes: Transparent and Fade. The former is physically based and still emits some specular light even at alpha = 0; the latter is good old alpha blending; and becomes invisible when alpha = 0.

 


4. Added Metallic and Specular workflow options. We’ve been working hard and closely with other teams and artists, tuning the BRDF settings. We now have 3 workflows: specular_ogre, specular_as_fresnel (what most popular engines do when they say “specular” workflow) and metallic.

For the tech-curious, specular_ogre maps the specular texture to the coefficient “kS”, whereas specular_as_fresnel maps the specular texture to the fresnel, colouring it. And metallic uses the slot reserved for the specular texture to control the metallness.

John Hable has an interesting discussion about the topic. Long story short specular_ogre allows more variety in the amount of materials that can be represented; but the specular_as_fresnel is more intuitive and is what most artists are used to.


5. Optimized vertex buffers for shadow mapping! If you’ve got VRAM to spare, you may want to enable this option to generate vertex buffers optimized specifically for shadow mapping.

Normally, GPUs require us to split a vertex when two triangles can’t share it (i.e. it has a different normal, it has got an UV seam, etc). But shadow mapping only requires position, and these cloned vertices (alongside fatter vertices) reduce performance unnecessarily. This new feature creates a vertex buffer with position data exclusively, thus reducing bandwidth requirements, fitting the cache better; and reducing the vertex count by avoiding duplicates.

Performance improvements vary wildly depending on scene and model complexity.

To enable it, set the global variables:

Mesh::msOptimizeForShadowMapping = true;
v1::Mesh::msOptimizeForShadowMapping = true;

Note that this will increase loading times. For large meshes (i.e. 300k vertices), it is better to do it offline and save it to disk using the OgreMeshTool. If you do this, then there is no need to set msOptimizeForShadowMapping to true.

Also bare in mind this optimization will not be used for meshes using materials with alpha testing, as we require UV data for alpha testing; and not just position data.

For more information, visit the forum thread.


6. Updated and merged OgreMeshUpgrader and OgreXMLConverter into one tool: OgreMeshTool. This new tool supports many similar options and most of the same functionality the other two provided; with the addition of new v2.1 features like exporting to v2 formats, optimizing vertex formats to use half floating point and QTangents, generate optimized vertex buffers for shadow mapping.


7. Compositor improvements. Finished UAV (texture) support, finished resource transition/barriers project (needed by OpenGL, Vulkan and D3D12) see what are barriers and why they are needed, Compositor now allows for rendering to 3D and texture 2D arrays, also declaring cubemaps.

Automatic generation of mipmaps was added for RTTs (useful for cubemap probes). See section 4.1.3.2 generate_mipmaps from the porting manual for more information.

With proper UAV support, compute shaders are around the corner!


8. Added JSON materials. The previous script syntax was not scaling well. JSON rocks! Drop on the forum thread for more details. It was our latest addition so there may still be things to polish. The old hlms material script system will continue to work while we iron out the issues and finish DERGO as a material editor.

GameDev News , ,

30. December 2015

 

GarageGames have just released Torque2D version 3.2.  Torque2D is 2D game engine built over the Torque 3D engine, which is now open source and MIT licensed.

From the release:

While you were singing carols door to door and sipping eggnog by the fireplace, the T2D Steering Committee was hard at work wrapping up one last present! Presenting Torque2D 3.2! This latest incarnation of everybody's favorite 2D engine sports several shiny new features! But before we get into that, let's take a moment of silence to remember the many bugs that lost their lives to make this release possible.


Now then, our first new feature is the FadeTo function. This works like MoveTo except that it changes the blend color over time instead of the position. If you ever wanted to fade a bad guy out when it died or fade a slightly transparent object in, then this function was written for you! It could be used to make your hero flash red when his life is low or slowly change the color of the sky as the sunsets. FadeTo comes with all the support functions of MoveTo including a cancel function and callback when it's finished.


We also added GrowTo which changes the size of an object over time. With GrowTo you can change the x and y at different rates and create all kinds of neat effects. But, there's a catch! Collision shapes don't grow with the sprite. So if your object has collision shapes attached you'll want to use it sparingly. Slight changes can do a lot. Like FadeTo, GrowTo is supported by functions to test and cancel. When an object reaches its target size it will fire a callback.
We also have support now for one way collisions. This is most commonly seen in platformer games when a character jumps up through the platform and magically lands on top of it, but in theory there's many other uses for it. This only works for edge and chain collision shapes.
And finally, last but not least, we have revived ogg! That's right! The open source, compact audio format is back by popular demand. You can start using ogg files again on Windows and Mac OSX.

GameDev News, Programming , ,

24. December 2015

 

Care of /r/gamedev, Ultraviolet released version 1.3.  In their own words, Ultraviolet is:

Ultraviolet is a cross-platform, .NET game development framework written in C# and released under the MIT License. It is heavily inspired by Microsoft's XNA Framework, and is intended to be easy for XNA developers to quickly pick up and start using. However, unlike MonoGame and similar projects, Ultraviolet is not intended to be a drop-in replacement for XNA. Its current implementation is written on top of SDL2 and OpenGL, but its modular design makes it (relatively) easy to re-implement using other technologies if it becomes necessary to do so in the future.

At present, Ultraviolet officially supports Windows, Linux, Mac OS X, and Android. Support for additional platforms will be forthcoming in future releases.

 

From the release 1.3:

 

Core

  • Ultraviolet Framework now supports Mac OS X.

Installer

  • Installer will now install project templates for Visual Studio 2015.
  • Installer will no longer install project templates for Visual Studio 2010.
  • Installer will no longer install project templates for Visual Studio 2012.

Graphics

  • Completely rewrote the text layout engine.
    • Text layout engine now does a better job of inserting line breaks.
    • Text layout engine now supports non-breaking spaces.
  • Implemented glyph shaders.
    • Glyph shaders allow custom logic to be applied to each glyph at the time it is rendered, allowing for complex visual effects.
    • Added support for the |shader| formatting command.
    • Added methods to TextRenderer for specifying glyph shaders.

Presentation

  • Lots of miscellaneous fixes, refactorings, cleanup, and general improvements.
  • UVML binding expressions been significantly improved.
    • Binding expressions can now contain arbitrary C# 4.0 code, i.e. {{2 + 2}} or{{DateTime.Now}}
    • Binding expressions must be compiled into an assembly using the new binding expressions compiler. This can be done ahead-of-time or at runtime on platforms which support it (Windows, Linux, OS X).
    • Added arrow syntax for directly referencing elements in the same view, i.e. {{foo->Value}}
  • UVSS has been improved and has gained some new operators.
    • UVSS parser now understands the inheritance relations between styled types.
    • Added "navigation expression" operator (|) and "type conversion" operator (as)
      • As foo | bar as Baz meaning "property bar on foo, which has type Baz."
    • Added "logical child" operator (>?)
      • As x >? y meaning "y is the logical child of x."
    • Added "templated child" operator (>>)
      • As x >> y meaning "y is the templated child of x."
    • Added "exact type" operator (!)
      • Referencing TypeName will apply the style to elements of type TypeName and any of its descendants. Qualifying this with the exact type operator, i.e. TypeName! will cause the style to only apply to elements of that exact type.
  • Added support for touch devices.
  • Implemented visual effects for elements.
    • Implemented BlurEffect built-in effect.
    • Implemented DropShadowEffect built-in effect.
    • Implemented ShaderEffect built-in effect.
  • Implemented element transforms (render and layout).
    • Implemented TransformGroup transform.
    • Implemented IdentityTransform transform.
    • Implemented MatrixTransform transform.
    • Implemented RotateTransform transform.
    • Implemented ScaleTransform transform.
    • Implemented SkewTransform transform.
    • Implemented TranslateTransform transform.
  • Implemented element adorners.
  • Implemented keyboard and game pad navigation.
  • Implemented tool tips.
  • Implemented modal dialog boxes.
  • Implemented cursor queries.
  • Implemented TabControl.
  • Implemented PasswordBox.
  • Completely rewrote the TextBox control.
    • TextBox can now edit multiple lines of text.
    • TextBox should now generate significantly less collection pressure while typing.

Ultraviolet is available on Github.

GameDev News ,

Month List

Popular Comments