No More waiting for Godot! Godot Engine reaches 1.0 milestone release

16. December 2014

 

Sorry… absolutely can’t resist that pun, no matter how obvious it is.  Anyways… the Godot Game Engine has been on my radar since they announced they were going open source at the beginning of the year.  Today they finally announced their 1.0 release today.godot

 

 

Never heard of Godot?  It’s a Unity-esque game engine, except powered by C++ and scripted using a Python-like scripting language.  It includes a surprising number of tools and most importantly, a complete game editor (pictured right).

 

Godot works in both 2D and 3D, with 2D being a first class citizen, not just 3D minus a D.  Godot runs on Windows, OSX and Linux.  Godot is able to target iOS, Android, Desktops, Googles’ NaCL, PlayStation3 and Vita, as well as HTML5 and Windows Phone coming soon.

 

You can read the complete feature list here.

 

You can browse available documentation here.

 

Godot is an open source project hosted on GitHub.

 

What do you think… are you interested in Godot, would you be interested in seeing GameFromScratch do some more in-depth coverage now that it’s reached such a milestone release?

News , ,




Modo Indie released and is available on Steam… on sale of course

12. December 2014

 

Modo, a popular 3D modeling application ( learn more about Modo and more in my Introduction to 3D Applications post, or watch the video ) has just been released on Steam.  Actually, Steam being Steam, it’s actually on sale right now for 25% off!

 

image

 

 

Considering the full price of Modo is about $1,600, the Steam Indie version for $250 CDN is quite a bargain!  So, what’s the catch?

 

Yeah, there’s always a catch isn’t there?  So, what’s the difference between Modo and Modo Indie?  Well…

 

  • Project file (.lxf) linked to Steam account / cannot be shared with other users
  • OBJ and FBX export limited to 100k polys
  • Bake and render resolution limited to 4k
  • Command eval options unavailable
  • Command, scripts, and command history panel results unavailable except “undo” and “history”
  • Python editor, third-party scripts, and third-party plugins unavailable
  • OBJ and FBX export only
  • Can import all formats but can only save in .lxf format
  • Image save formats limited to .png, .jpg, .tiff and .exr

 

So they went the Maya LT route and limited the functionality but not the licensing.  This means you can use Modo Indie regardless to how much money you make or how you use it.  This is the deal breaker for many Indie licenses…  As to the stripped out functionality, I think the first restriction is going to be the most difficult one for many to swallow.

 

Simply put you cannot collaborate on a Modo Indie project!  Only one artist will be able to work on the project, ever.  It’s tied to your Steam account id and cannot be shared with others or distributed, although obviously you can export/import in OBJ or FBX format, so for many this wont be much of a limitation in the end.  However for teams with multiple people working on the same resource, or teams where the artist could change at some point in the future, this is going to be a gigantic deal breaker.

 

I haven’t used Modo recently enough to tell if script/plugin support is a big loss or not.  I frankly don’t recall there being any plugins back when I evaluated.  I understand why they do this though, or the very first plugin that would be released would be something to get around the 100K polygon limits.

 

The other limitations seem reasonable.  The 100K export limit precludes you from being able to use Modo as a level editor, but I don’t think many people are doing this anyways.  For game ready assets, 100K polygons and 4K texture limits seem appropriate.  If your needs are much more extreme than that, I can see how you wouldn’t be viewed as an Indie anymore and thus should have funds to purchase the full version.

 

Another affordable 3D option for indie game devs is always welcome, more choice is almost always good.  If you are interested in picking up Modo, the sale ends December 18th/2014.  That said, this is Steam we are talking about, so there will always be another bigger and better sale around the corner!  Oh, they also have a package deal with their MARI Indie texture painting package.  You can purchase both together for $315CDN.

 

Oh yeah, they also released MARI Indie as well… suppose I should mention that.  I have absolutely no experience with Mari, so I figured I would go with their description:

 

MARI indie is the fastest, most artist-friendly way to texture, paint, and detail amazing 3D assets for your game projects. Fine-tuned for individual developers and freelance artists in the game industry, MARI indie is an invaluable toolset that lets you focus on the artistic aspect of 3D game asset painting without getting bogged down by the technical side -- free of any individual commercial restrictions and without breaking your budget!

 

Delivering massive power and flexibility at minimal cost, MARI indie gives you ultimate control over painting and detailing every facet of your 3D models and animations in a way that's quick, intuitive, and highly creative -- all in one complete package that lets you work just the way you want.


Supported by the world’s most advanced layering system, MARI indie is a real workhorse. It gives game artists and content creators all the functionality they need to exactly replicate the look of assets in their games engine.

 

Once again, MARI Indie has no limitations on commerical usage, all limitations are technical:

 

  • Project file (.mra) linked to Steam account / cannot be shared with other users
  • Allowed export formats: .psd, .png, .tga, .jpg
  • Output formats no longer available .exr, .tif, .tiff, .hdr, .dds, and .ptx
  • The patch count is limited to 2 patches
  • The object count is limited to 3 objects
  • The output texture resolution size has been limited to 4k
  • Python scripting disabled

 

With zero experience with MARI I have no opinion on these limitations either way.

 

But WAIT, there’s more!

 

image

 

Yep, there is also a subscription plan available.  And at as low as $11 CDN a month it’s pretty freaking reasonable too.  For example, Maya LT is $30 a month, although they only offer monthly rates.

Art, News ,




Phaser 2.2.0 ( then 2.2.1 ) JavaScript Game Dev library released

4. December 2014

 

The Phaser HTML5 game development library has been churning out the releases as of late, and just yesterday 2.2.1 was released.  Perhaps most impressively, much of the releases content came from members within the community, always a good sign with open source projects. 

 

The biggest new feature is the Scale Manager, which you can read about here or from this newly released e-book.  The ScaleManager is to help enable your code to run on devices with multiple different resolutions.  The biggest change is Phaser moved to a proper fixed-step game loop, fully decoupling logic and rendering.

 

The full (and massive) change log below:

 

New Features
  • Updated to Pixi v2.2.0 - see separate change log entry below.
  • Cache.getRenderTexture will retrieve a RenderTexture that is stored in the Phaser Cache. This method replaces Cache.getTexture which is now deprecated.
  • Cache.autoResolveURL is a new boolean (default false) that automatically builds a cached map of all loaded assets vs. their absolute URLs, for use with Cache.getURL and Cache.checkURL. Note that in 2.1.3 and earlier this was enabled by default, but has since been moved behind this property which needs to be set to true before you load any assets to enable.
  • You can now call Tween.to again on a Tween that has already completed. This will re-use the same tween, on the original object, without having to recreate the Tween again. This allows a single tween instance to be re-used multiple times, providing they are linked to the same object (thanks InsaneHero)
  • Phaser.Color.valueToColor converts a value: a "hex" string, a "CSS 'web' string", or a number - into red, green, blue, and alpha components (thanks @pnstickne #1264)
  • Stage.backgroundColor now supports CSS 'rgba' values, as well as hex strings and hex numbers (thanks @pnstickne #1234)
  • Pointer.addClickTrampoline now adds in support for click trampolines. These raise pointer events into click events, which are required internally for a few edge cases like IE11 full screen mode support, but are also useful if you know you specifically need a DOM click event from a pointer (thanks @pnstickne #1282)
  • Point.floor will Math.floor both the x and y values of the Point.
  • Point.ceil will Math.ceil both the x and y values of the Point.
  • ScaleManager.scaleSprite takes a Sprite or Image object and scales it to fit the given dimensions. Scaling happens proportionally without distortion to the sprites texture. The letterBox parameter controls if scaling will produce a letter-box effect or zoom the sprite until it fills the given values.
  • Phaser.DOM.getBounds is a cross-browser element.getBoundingClientRect method with optional cushion.
  • Phaser.DOM.calibrate is a private method that calibrates element coordinates for viewport checks.
  • Phaser.DOM.aspect gets the viewport aspect ratio (or the aspect ratio of an object or element)
  • Phaser.DOM.inViewport tests if the given DOM element is within the viewport, with an optional cushion parameter that allows you to specify a distance.
  • Phaser.DOM.viewportWidth returns the viewport width in pixels.
  • Phaser.DOM.viewportHeight returns the viewport height in pixels.
  • Phaser.DOM.documentWidth returns the document width in pixels.
  • Phaser.DOM.documentHeight returns the document height in pixels.
  • TilemapLayers have been given a decent performance boost on canvas with map shifting edge-redraw (thanks @pnstickne #1250)
  • A large refactor to how the internal game timers and physics calculations has been made. We've now swapped to using a fixed time step internally across Phaser, instead of the variable one we had before that caused glitchse on low-fps systems. Thanks to pjbaron for his help with all of these related changes.
  • We have separated the logic and render updates to permit slow motion and time slicing effects. We've fixed time calling to fix physics problems caused by variable time updates (i.e. collisions sometimes missing, objects tunneling, etc)
  • Once per frame calling for rendering and tweening to keep things as smooth as possible
  • Calculates a suggestedFps value (in multiples of 5 fps) based on a 2 second average of actual elapsed time values in the Time.update method. This is recalculated every 2 seconds so it could be used on a level-by-level basis if a game varies dramatically. I.e. if the fps rate consistently drops, you can adjust your game effects accordingly.
  • Game loop now tries to "catch up" frames if it is falling behind by iterating the logic update. This will help if the logic is occasionally causing things to run too slow, or if the renderer occasionally pushes the combined frame time over the FPS time. It's not a band-aid for a game that floods a low powered device however, so you still need to code accordingly. But it should help capture issues such as gc spikes or temporarily overloaded CPUs.
  • It now detects 'spiraling' which happens if a lot of frames are pushed out in succession meaning the CPU can never "catch up". It skips frames instead of trying to catch them up in this case. Note: the time value passed to the logic update functions is always constant regardless of these shenanigans.
  • Signals to the game program if there is a problem which might be fixed by lowering the desiredFps
  • Time.desiredFps is the new desired frame rate for your game.
  • Time.suggestedFps is the suggested frame rate for the game based on system load.
  • Time.slowMotion allows you to push the game into a slow motion mode. The default value is 1.0. 2.0 would be half speed, and so on.
  • Time.timeCap is no longer used and now deprecated. All timing is now handled by the fixed time-step code we've introduced.
  • Time.now can no longer be relied upon to contain a timestamp value. If the browser supports requestAnimationFrame then Time.now will contain the high resolution timer value that rAf generates. Otherwise it will contain the value of Date.now. If you require the actual time value (in milliseconds) then please use Time.timeinstead. Note that all Phaser sub-systems that used to rely on Time.now have been updated, so if you have any code that extends these please be sure to check it.
  • Game.forceSingleUpdate will force just a single logic update, regardless of the delta timer values. You can use this in extremely heavy CPU situations where you know you're about to flood the CPU but don't want Phaser to get stuck in a spiral.
  • Tilemap.createFromTiles will convert all tiles matching the given tile index (or an array of indexes) into Sprites. You can optionally then replace these tiles if you wish. This is perfect for games when you want to turn specific tiles into Sprites for extra control. The Sprites have an optional properties object which they can be populated with.
  • Added support for the Wheel Event, which is the DOM3 spec (thanks @pnstickne #1318)
  • Wheel Scroll Event (old non-FF) and DOM Mouse Wheel (old FF) are supported via a non-exported reused wrapper object; WheelEventProxy. The proxy methods are generated one-time dynamically but only when needed.
  • Key.justDown allows you to test if a Key has just been pressed down or not. You can only call justDown once per key press. It will only return true once, until the Key is released and pressed down again. This allows you to use it in situations where you want to check if this key is down without using a Signal, such as in a core game loop (thanks @pjbaron #1321)
  • Key.justUp allows you to test if a Key has just been released or not. You can only call justUp once per key press. It will only return true once, until the Key is pressed down and released again. This allows you to use it in situations where you want to check if this key is up without using a Signal, such as in a core game loop (thanks @pjbaron #1321)
  • Device.whenReady is a new signal that you can use to tell when the device is initialized.
  • Device.onInitialized is dispatched after device initialization occurs but before any of the ready callbacks have been invoked. Local "patching" for a particular device can/should be done in this event.
  • TweenManager.removeFrom method allows you to remove a tween from a game object such as a Sprite (thanks @lewster32 #1279)
  • Tweens have been completely rewritten. They're now much more flexible and efficient than before:
  • When specifying the ease in Tween.to or Tween.from you can now use a string instead of the Function. This makes your code less verbose. For example instead of Phaser.Easing.Sinusoidal.Out and you can now just use the string "Sine".The string names match those used by TweenMax and includes: "Linear", "Quad", "Cubic", "Quart", "Quint", "Sine", "Expo", "Circ", "Elastic", "Back", "Bounce", "Power0", "Power1", "Power2", "Power3" and "Power4". You can append ".easeIn", ".easeOut" and "easeInOut" variants. All are supported for each ease types.
  • Tweens now create a TweenData object. The Tween object itself acts like more of a timeline, managing multiple TweenData objects. You can now call Tween.to and each call will create a new child tween that is added to the timeline, which are played through in sequence.
  • Tweens are now bound to the new Time.desiredFps value and update based on the new Game core loop, rather than being bound to time calculations. This means that tweens are now running with the same update logic as physics and the core loop.
  • Tween.timeScale allows you to scale the duration of a tween (and any child tweens it may have). A value of 1.0 means it should play at the desiredFps rate. A value of 0.5 will run at half the frame rate, 2 at double and so on. You can even tween the timeScale value for interesting effects!
  • Tween.reverse allows you to instantly reverse an active tween. If the Tween has children then it will smoothly reverse through all child tweens as well.
  • Tween.repeatAll allows you to control how many times all child tweens will repeat before firing the Tween.onComplete event. You can set the value to -1 to repeat forever.
  • Tween.loop now controls the looping of all child tweens.
  • Tween.onRepeat is a new signal that is dispatched whenever a Tween repeats. If a Tween has many child tweens its dispatched once the sequence has repeated.
  • Tween.onChildComplete is a new signal that is dispatched whenever any child tweens have completed. If a Tween consists of 4 sections you will get 3 onChildComplete events followed by 1 onComplete event as the final tween finishes.
  • Chained tweens are now more intelligently handled. Because you can easily create child tweens (by simply calling Tween.to multiple times) chained tweens are now used to kick-off longer sequences. You can pass as many Tween objects to Tween.chain as you like as they'll all be played in sequence. As one Tween completes it passes on to the next until the entire chain is finished.
  • Tween.stop has a new complete parameter that if set will still fire the onComplete event and start the next chained tween, if there is one.
  • Tween.delay, Tween.repeat, Tween.yoyo, Tween.easing and Tween.interpolation all have a new index parameter. This allows you to target specific child tweens, or if set to -1 it will update all children at once.
  • Tween.totalDuration reports the total duration of all child tweens in ms.
  • There are new easing aliases:
  • * Phaser.Easing.Power0 = Phaser.Easing.Linear.None
  • * Phaser.Easing.Power1 = Phaser.Easing.Quadratic.Out
  • * Phaser.Easing.Power2 = Phaser.Easing.Cubic.Out
  • * Phaser.Easing.Power3 = Phaser.Easing.Quartic.Out
  • * Phaser.Easing.Power4 = Phaser.Easing.Quintic.Out
  • ScaleManager.windowContraints now allows specifying 'visual' or 'layout' as the constraint. Using the 'layout' constraint should prevent a mobile device from trying to resize the game when zooming.

    Including the the new changes the defaults have been changed to

    windowContraints = { right: 'layout', bottom: '' }

    This changes the current scaling behavior as seen in "Game Scaling" (as it will only scale for the right edge) but also prevents such scaling from going bonkers in some mobile environments like the newer Android browser. (Automatic scroll-to-top, albeit configurable, enabled for non-desktop by default is not a fun situation here.)

    To obtain the current semantics on a desktop the bottom should be changed to 'layout'; although this will result in different behavior depending on mobile device. To make the sizing also follow mobile zooming they should be changed to 'visual'.

    Also added temp Rectangle re-used for various internal calculations.

  • Phaser.DOM now also special-cases desktops to align the layout bounds correctly (this may disagree with CSS breakpoints but it aligns the with actual CSS width), without applying a window height/width expansion as required on mobile browsers.

  • Signals have been heavily restructured to cut down on the number that are generated in-game. New signal proxies manage the setting and creation as required, cutting down on the volume of run-time object creation significantly. No user code needs to change, however if you did override Phaser.Signal or Sprite.Events then please be aware of the changes by inspecting the source (and commit #1389 by @pnstickne).
  • Game.lockRender is a new property. If false Phaser will automatically render the display list every update. If truethe render loop will be skipped. You can toggle this value at run-time to gain exact control over when Phaser renders. This can be useful in certain types of game or application. Please note that if you don't render the display list then none of the game object transforms will be updated, so use this value carefully.
Updates
  • TypeScript definitions fixes and updates (thanks @clark-stevenson @draconisNoctis)
  • The TypeScript definitions have moved to the typescript folder in the root of the repository.
  • Cache._resolveUrl has been renamed to Cache._resolveURL internally and gained a new parameter. This method is a private internal one.
  • Cache.getUrl is deprecated. The same method is now available as Cache.getURL.
  • Loader.useXDomainRequest used to be enabled automatically for IE9 but is now always set to false. Please enable it only if you know your server set-up / CDN requires it, as some most certainly do, but we're finding them to be less and less used these days, so we feel it's safe to now disable this by default (#1248)
  • Game.destroy now destroys either the WebGLRenderer or CanvasRenderer, whichever Pixi was using.
  • Particle.Emitter will now automatically set particle.body.skipQuadTree to true to help with collision speeds within Arcade Physics.
  • Particle.Emitter.explode (or Emitter.start with the explode parameter set to true) will immediately emit the required quantity of particles and not delay until the next frame to do so. This means you can re-use a single emitter across multiple places in your game that require explode-style emissions, just by adjusting the emitter.x andemitter.y properties before calling explode (thanks Insanehero)
  • Phaser.Polygon has been refactored to address some Pixi v2 migration issues (thanks @pnstickne for the original implementation #1267)
  • Polygon.area is now only calculated when the Polygon points list is modified, rather than on every call.
  • Phaser.Polygon can now accept the points list in a variety of formats: Arrays of Points, numbers, objects with public x/y properties or any combination of, or as a parameter list (thanks @pnstickne for the original implementation #1267)
  • All of the Input classes now use the more consistent enabled property instead of disabled. I.e. you can now checkif (input.mouse.enabled) rather than if (!input.mouse.disabled). The disabled property has been moved to a getter for backwards compatibility but is deprecated and will be removed in a future version (thanks @pnstickne #1257)
  • The Input class has been given a minor refactor to tidy things up. Specifically:
    • pointerN are aliases to backed pointers[N-1] array. This simplifies (and increases the efficiency of) looping through all the pointers when applicable; also eliminates pointer-existence checks Removes various hard-coded limits (added MAX_POINTERS); changed maxPointers default
    • Removed some special-casing from cases where it did not matter
    • Removed === false/true, == usage for consistency, changed missing value check to typeof, etc.
    • Updated documentation for specificity; added @public\@protected
    • @deprecated currentPointers due to odd set pattern; totalCurrentPointers is more appropriate. (thanks @pnstickne #1283)
  • Various ScaleManager fixes and updates (thanks @pnstickne):
    • Scale modes can now be set independently
    • Switching between fullscreen and normal correctly restores modes
    • Alignment does not incorrectly offset in fullscreen mode (#1255)
    • Changing scale/alignment promptly refreshes layout
    • isFullScreen returns a boolean, as it should
    • Faster parent checks (if required)
    • NO_SCALE should not not scale (vs previous behavior of having no behavior)
    • Correct usage of scaleMode depending on mode
    • Fullscreen Mode always scaling to fill screen in Firefox (#1256)
  • AudioSprite - removed an unnecessary if-statement (thanks @DaanHaaz #1312)
  • ArcadePhysics.skipQuadTree is now set to true by default. A QuadTree is a wonderful thing if the objects in your game are well spaced out. But in tightly packed games, especially those with tilemaps or single-screen games, they are a considerable performance drain and eat up CPU. We've taken the decision to disable the Arcade Physics QuadTree by default. It's all still in there and can be re-enabled via game.physics.arcade.skipQuadTree = false, but please only do so if you're sure your game benefits from this.
  • Phaser.DOM now houses new DOM functions. Some have been moved over from ScaleManager as appropriate.
  • Key.justPressed has bee renamed to Key.downDuration which is a much clearer name for what the method actually does. See Key.justDown for a nice clean alternative.
  • Key.justReleased has bee renamed to Key.upDuration which is a much clearer name for what the method actually does. See Key.justUp for a nice clean alternative.
  • Keyboard.justPressed has bee renamed to Keyboard.downDuration which is a much clearer name for what the method actually does.
  • Keyboard.justReleased has bee renamed to Keyboard.upDuration which is a much clearer name for what the method actually does.
  • Keyboard.downDuration, Keyboard.upDuration and Keyboard.isDown now all return null if the Key wasn't found in the local keys array.
  • The Phaser.Device class has been made into a singleton and removed it's dependency on Phaser.Game (thanks @pnstickne #1328)
  • ArrayList has been renamed to ArraySet (as it's actually a data set implementation) and moved from the corefolder to the utils folder (thanks @pnstickne)
  • If you are reloading a Phaser Game on a page that never properly refreshes (such as in an AngularJS project) then you will quickly run out of AudioContext nodes. If this is the case create a global var called PhaserGlobal on the window object before creating the game. The active AudioContext will then be saved towindow.PhaserGlobal.audioContext when the Phaser game is destroyed, and re-used when it starts again (#1233)
  • Camera.screenView is now deprecated. All Camera culling checks are made against Camera.view now instead.
  • Various CocoonJS related hacks removed thanks to fixes from Ludei directly in CocoonJS! Woohoo :)
  • Phaser.HEADLESS check removed from the core game loop. If you need to disable rendering you can now override the Phaser.Game.updateRender method instead with your own.
  • Group.forEach fixed against browser de-optimization (thanks @pnstickne #1357)
  • Phaser.Signals have been taken on a diet. They have been updated such that there is significantly less penalty for having many unused signals. The changes include:
  • * Changing it so there is no dispatch closure created. This is a potentially breaking change for third party code.
  • * In the rare case that code needs to obtain a dispatch-closure, the boundDispatch property can be used to trivially obtain a cached closure.
  • * The properties and default values are moved into the prototype; and the _bindings array creation is deferred. This change, coupled with the removal of the automatic closure, results in a very lightweight ~24bytes/object (in Chrome) for unbound signals.
  • With this change in place Signals now consume less than 50KB / 50KB (shallow / retained memory) for 200 sprites, where-as before they used 300KB / 600KB (thanks @pnstickne #1359)
  • Time.elapsedMS holds the number of milliseconds since the last Game loop, regardless of raF or setTimout being used.
  • Incorrectly prepared tilemap images (with dimensions not evenly divisible by the tile dimensions) would render incorrectly when compared to the display seen in Tiled. The Phaser tilemap code has been adjusted to match the way Tiled deals with this, which should help if you're using tileset images that contain extra padding/margin pixels. Additional console warnings have been added. However the fact remains that you should carefully prepare your tilesets before using them. Crop off extra padding, make sure they are the right dimensions (thanks @SoulBeaver for the report and @pnstickne for the fix #1371)
  • Text.setShadow has had the default color value changed from rgba(0,0,0,0) to rgba(0,0,0,1) so it appears as a black shadow by default - before the alpha channel made it invisible.
  • Math.getRandom will now return null if random selection is missing, or array has no entries (thanks @pnstickne #1395)
  • Array.transposeArray has had a small off-by-one error fixed. It didn't effect the results but meant returned arrays were 1 element bigger than needed (thanks @nextht #1394)
  • State.preRender is now sent two parameters: a reference to the Phaser.Game instance and a new parameter:elapsedTime which is the time elapsed since the last update.
Bug Fixes
  • Tilemaps in WebGL wouldn't update after the first frame due to a subtle change in how Pixi uploads new textures to the GPU.
  • XML files weren't being added to the URL map.
  • Cache._resolveURL was causing a Sound double-load in Firefox and causing errors (thanks @domonyiv #1253)
  • Loader.json was using the wrong context in IE9 with XDomainRequest calls (thanks @pnstickne #1258)
  • Text.updateText was incorrectly increasing the size of the texture each time it was called (thanks @spayton #1261)
  • Polygon.contains now correctly calculates the result (thanks @pnstickne @BurnedToast #1267)
  • Setting Key.enabled = false while it is down did not reset the isDown state (thanks @pnstickne #1190 #1271)
  • The Gamepad.addCallbacks context parameter was never actually remembered, causing the callbacks to run in the wrong context (thanks @englercj #1285)
  • Animation.setFrame used the wrong frames array if useLocalFrameIndex was false and a numeric frame ID was given (thanks @Skeptron #1284)
  • Fullscreen mode in IE11 now works (thanks @pnstickne)
  • Cache.addBitmapData now auto-creates a FrameData (thanks @pnstickne #1294 #1300)
  • P2.BodyDebug circles were drawing at half widths (thanks @enriqueto #1288)
  • FrameData.clone fixed when cloning data using frame names rather than indexes (thanks pjbaron)
  • Lots of the Cache getters (such as Cache.getbitmapData) would return undefined if the asset couldn't be found. They now all consistently return null for missing entries (thanks @Matoking #1305)
  • Phaser games should now work again from the CocoonJS Launcher.
  • Only one of the mouse wheel events is listened to, newest standard first. This fixes a bug in FF where it would use the default DOMMouseWheel (thanks @pnstickne #1313)
  • Stage.smoothed needed to modify the value of PIXI.scaleMode.DEFAULT instead of PIXI.scaleMode.LINEAR (thanks @pixelpicosean #1322)
  • Newly created Groups always had zero z index (thanks @spayton #1291)
  • Sprite.autoCull now properly works if the camera moves around the world.
  • Sprite.inCamera uses a much faster check if auto culling or world bounds checks are enabled and properly adjusts for camera position.
  • Camera.totalInView is a new property that contains the total number of Sprites rendered that have autoCull set to true and are within the Cameras view.
  • Emitter.setScale fixed minX minY order precedence (thanks spayton)
  • Group.iterate can now accept undefined/null as the arguments (thanks @pnstickne #1353 @tasos-ch #1352)
  • When you change State the P2 Physics world is no longer fully cleared. All of the bodies, springs, fixtures, materials and constraints are removed - but config settings such as gravity, restitution, the contact solver, etc are all retained. The P2.World object is only created the very first time you call Physics.startSystem. Every subsequent call hits P2.World.reset instead. This fixes "P2.World gravity broken after switching states" (and other related issues) (#1292 #1289 #1176)
  • Text.lineSpacing works correctly again. Before no space was added between the lines (thanks @intimidate #1367 and @brejep #1366)
  • P2.BodyDebug always lagged behind the position of the Body it was tracking by one frame, which became visible at high speeds. It now syncs its position in the Body.postUpdate which prevents this from happening (thanks @valueerror)
  • A State.preRender callback wasn't removed correctly when switching States.

 

Phaser is available here.

 

Of course, GameFromScratch has a comprehensive Phaser with TypeScript series available here.

News ,




MelonJS 2.0.0 released

20. November 2014

 

The JavaScript game library MelonJS reached the milestone 2.0.0 release yesterday.

Melonlogo

 

The key features of this release are:

 

  • Shape-based collision layer has replaced the tile-based collision layer.
  • WebGL support has landed! (Currently alpha-quality)
  • Many fixes and improvements with collision detection in isometric maps.
  • Physics bodies now support multiple shapes.
  • Automatic collision response handling is enabled by default, and fully customizable.
  • Support for most of the new features in Tiled 0.10, like :
  • Shape scaling and rotation (especially in TMX maps,)
  • TMX Tileset animations

 

You can read more about the release here.

 

You can read the change log here.

 

You can download MelonJS here.

 

You can view the source here.

 

You can see a rabbit with a waffle on it’s head here.

 

WebGL support is a nice add, as with it’s recent adoption in both Safari and Internet Explorer, it is certainly the future of HTML5 gaming.  While it’s popular I have never actually taken more than a cursory look at MelonJS, I really should jump in a bit deeper one of those days.

News




Visual Studio 2013 is now.... free?

12. November 2014

 

This one falls under the category of “extremely awesome news”, Microsoft just announced Visual Studio Community 2013 and it’s completely free.
 
You may think to yourself… big deal, there is already Express and it’s free too.  Unlike Express however, Visual Studio 2013 Community is actually the complete version of Visual Studio, nothing has been stripped out.
 
Here is the announcement from the Visual Studio blog:
 

Visual Studio Community 2013 is a new edition that enables you to unleash the full power of Visual Studio to develop cross-platform solutions. Create apps in one unified IDE. Get Visual Studio extensions that incorporate new languages, features, and development tools into this IDE. (These extensions are available from the Visual Studio Gallery.) Find out more details about Visual Studio Community 2013  here.

Download Visual Studio Community 2013.

What's in Visual Studio Community 2013 

  • Professional-grade editing, code analysis, and debugging support 
  • Support for open-source workflows (Git)
  • Compilers for managed languages, C++ and more
  • Cross-platform mobile development for your preferred device and platform, including the web, Android, iOS, and Windows Phone with the free Visual Studio Tools for Apache Cordova extension
  • Take advantage of cloud services with simplified Azure SDK integration, and incorporate modern app analytics and telemetry with Application Insights
  • Access to all the Visual Studio 2013 extensions on the  Visual Studio Gallery
  • Visual Studio Community 2013 includes Update 4, which is a cumulative update of all previous Visual Studio 2013 updates

Watch the  Visual Studio Community 2013 video to learn all about what you can do with this release:

Introducing Visual Studio Community 2013 

Several other Visual Studio 2013 products are available for download with Update 4, including the following:

  • Visual Studio 2013 Update 4 
  • Azure SDK for .NET 2.5 
  • Visual Studio Tools for Unity (VSTU) 2.0 Preview 
  • Kinect for Windows 2.0 SDK RTW 
  • Visual Studio Tools for Apache Cordova CTP3 
  • TypeScript 1.3 

To get more details on these releases, go to the  release notes for Visual Studio 2013 Update 4.

 

So, what's the catch? There's always a catch, right?

 

Yes, there is a catch, but it’s a pretty generous one.  From the Community page:

 

Q: Who can use Visual Studio Community? 
A: Here’s how individual developers can use Visual Studio Community:
  • Any individual developer can use Visual Studio Community to create their own free or paid apps.
Here’s how Visual Studio Community can be used in organizations:
  • An unlimited number of users within an organization can use Visual Studio Community for the following scenarios: in a classroom learning environment, for academic research, or for contributing to open source projects.
  • For all other usage scenarios: In non-enterprise organizations, up to 5 users can use Visual Studio Community. In enterprise organizations (meaning those with >250 PCs or > $1MM in annual revenue), no use is permitted beyond the open source, academic research, and classroom learning environment scenarios described above.

Q: How does Visual Studio Community 2013 compare to other Visual Studio editions? 
A: Visual Studio Community 2013 includes all the great functionality of Visual Studio Professional 2013, designed and optimized for individual developers, students, open source contributors, and small teams. 

So, basically if you are part of a team with 5 or fewer members, and made less than a Million dollars last year… Visual Studio is now completely free.

 

Merry XMas!

News




Daz3D Hexagon 2.5 Mini-Review
Home > Art

Daz3D Hexagon 2.5 Mini-Review

6. February 2012

 

 

As I recently mentioned Daz3D have made Hexagon, Bryce and Daz Studio all available for free for a limited time.  As a Blender user, until they finally ship BMesh, I am always in the market for a good modeler with effective COLLADA support.  So at a price of 0$ I figured I would try out Hexagon 2.5.  This is not a complete review, not even close, think of this more as a “These are the things I ran into that made me decide to not waste any more time on Hexagon” review.  Obviously, it doesn’t have a happy ending, which is a shame.

 

 

First off, it is a remarkably capable modeler, almost every feature you could want is in there… somewhere.  Feature-wise, it actually spanks Blender handily, with support for n-gons, good boolean supports, surfacing, etc.

 

First a look at the interface:

 

image

 

At first glance it’s pretty clean.  Properties and scene graph on the right, a tool shelf ALA Maya across the top and a mish mash of visibility buttons across the bottom across the bottom.  Then this is where things start to show the sloppiness as well.  Consider this expanded icon:

 

image

As you can see from the tool tip, this control “Activates actual lighting” and when you click it, that toolbar folds out.

 

 

Any guesses what any of these icons means?  Cause, I’ll tell you, I don’t have a bloody clue either!  None of them have mouse over tool tips, so you are stuck trying to figure it out from the icons…  good luck with that.

 

Don’t worry, there is always the help files to sort things out…   or wait, is there?

 

 

Here comes big and I mean BIG strike number two.  The help, yeah, there is none!



Of course, there is a Help menu, and as you can see, the options look pretty encouraging imageover all but they do nothing!


You click Help->Documentation or Help->Tutorial and you are brought to Daz3D’s website.  At first it appears that it is going to bring you to a documentation page, but then you are redirected back to the Front page.  Yay.


Alright, so the help hyperlink is broken, no big deal right, just surf to the help manually in your browser?


Ah good idea, let’s try that!

So you go to Support->Wiki from the front page manual.  Then select Hexagon on the left hand side and click the Hexagon documentation link.

image

 

 

 

Ooooh, this looks encouraging!  Hexagon 2.1 Manual in English, it’s an earlier version but better than nothing, lets click that!

 

image

 

 

Oh my!  Amateur hour continues.  So, no help, I guess you are on your own figuring things out and, well…  good luck with that.  The interface is downright confusing.

 

Take view navigation for example.  Other than Blender, the 3D world has become pretty standardized on how to navigate in 3D, so lets see how it works in Hexagon.  To pan your view, hold down your middle mouse button.  Ok so far.  To zoom in your view, use the scroll wheel.  Ok, pretty standard.  To Dolly/Rotate your view you….

 

Um….

 

You…  well apparently you use the arrow keys.  Yep, by default there is no mouse mode to actually orbit the camera!   Of course, there might be, put to hell if I can find it with a complete lack of documentation!   Of course, a little googling later and I discovered the answer… It’s a preference and it’s by default OFF! Huh?  Why?  Seriously, why?

 

For those following along at home, its pretty easy to resolve. Go to the Edit Menu->Preference Editor.  Under the User Interface tab, click Misc then select Dolly around selection center, like so:

 

image

 

 

Can you seriously tell me a reason why this wouldn’t be enabled by default?  It’s a small thing, but it is infuriating until fixed.  It’s a problem that exists for no reason, and those are always the worst kinds of problems.

 

 

There are a few thousand examples like this, all around, it’s like death from a thousand paper cuts.  Like features are added or removed with no thought to being a cohesive tool.  Lets take a look at the tools panel for an example:

 

image

 

Second Life???  HUH?  Why exactly is Second Life getting such important placement, or even placement at all?  Now *this* is the type of thing you make optional in the Preference Editor!  Now take another look back at the shelf and answer me this… where you do think you would go to say… split an edge?  If you said anything except Vertex modeling, you are wrong.  Now lets take a look at that process…  How do you split an edge?  Using a tool named Tessellate, that expands down with various options, lets take a look at that next!

 

image

Lovely eh?

 

So, not only do you not have documentation, you also do not have tooltips so its basically anyone’s guess which icon you actually want to press.

 

But wait, there is a description of each icon below the shelf!  Oh wait… the expanded toolbar obscures the description text!

 

 

 

 

Again, a small niggling thing, but 5 minutes in QA should have caught this.  Again, it’s like people keep adding features with no thought to how they fit or should work.  Even worse, you have items that simply don’t exist in the panel, but only via menu.  For example, there is a utilities panel, and a tools->Utilities menu, but WELD can only be accessed via the menu! Or how about the “Lines” menu that has 5! items called arc!  I’m not kidding… look:

 

image 

 

 

Then there is the lack of polish that if you switch to a different part of the tools panel with a menu expanded, it doesn’t close.  You have to switch back to Vertex modeling, click Free Tessellate again to get rid of the menu, otherwise it’s stuck there forever. There are tons of little things like that with the UI, that make the UI toolkit they used just feel… sloppy and frankly, slow.

 

 

Speaking of slow, I am running Hexagon on a 12GB i7 machine purchased 3 weeks ago and it can be downright sluggish.  This is especially true when it comes to sub-division surfaces.  The finally

 

 

 

It’s all such a shame, as reality is, there is a great program underneath the surface here.  I didn’t give this program a lot of time; I didn’t have to.  The glaring problems are exactly that, glaring.  I encountered a good dozen “WTFs?” in less than half an hour and within three or four hours with this program I realized it had nothing to offer me that Blender/Wings didn’t already do better.

 

 

If there was documentation available ( a big huge mistake, especially when they new they were going to have a giant influx of new users with the promotion ), it might be worth fighting through the stupidity, but there isn’t and it’s not really worth it in the end.

 

 

Product Link: Hexagon 2.5

 

It’s free for the remainder of February, so there is no need to take my word for it, check it out yourself.  Be aware though, once you sign up, Daz is a little spam happy.  Since signing up this weekend, I believe I have received 5 emails, in addition to the receipt and serial number emails you get initially.  A word of advice to Daz, first off, it’s really cool you have made your applications available freely and I hope you see an uptick in your market sales as a result; but dial it back on the volume of emails or you are going to be blocked as SPAM and ignored by the users you are trying to attract!

Art







blog comments powered by Disqus