rolandoam / chestergl Goto Github PK

we're already using closure compiler, so it might make sense to use closure library instead of jquery

Run a few tests...
In one of them clicked fullscreen - browser gone fullscreen and didn't go back. Had to use Esc to minimize the window. Fullscreen button no longer works and panels behave rather strange - dock and system panel autohiding when focused on browser. Dunno how to fix that. In all the options fullscreen / autohiding is disabled.

we should have a version of chester that can be used with requireJS

http://requirejs.org/

Visit method doesn't work when this.children changes through the execution. Please change the following lines on Block.js
From 507 to 511
//var children = this.children;
//var len = children.length;
for (var i=0; i < this.children.length; i++) {
this.children[i].visit();
}

right now there's a problem with the y position on canvas fallback

It should wiggle according to the block's orientation instead of changing its rotation value to 0.

we should be able to draw primitives. The shader is there, so probably the right way to do it would be to create a primitive block. It would be helpful for debugging (i.e. drawing the bounding boxes, etc)

we should support touch events

We should replace FPS for average ms between frames. It's basically the same... but makes things clearer. We should not think in terms of FPS

It'd be helpful if it took other action sequences for extra versality.

adding a jsfiddle example (like this http://jsfiddle.net/8A7jx/13/) will mean easier way to test chesterGL and more people might play with it.
This means we also need to have a CORS-enabled server to host chesterGL.js and the shaders, as well as some textures to play and also, set a base path for resources.

time dependent actions are not working (just a stub). My idea for the actions API is the following:

// 1) moves instantly
block.moveTo([x, y, 0]);
// 2) schedules an action to be executed immediately and should take 2.0 seconds
block.moveTo([x, y, 0], 2.0);
// 3) actions should be chain-able (they should return the block object). Here they will be executed immediately
block.moveTo([x, y, 0]).rotateBy(45.0);
// 4) you can chain several actions in a sequence: this will move to x, y and *then* rotate by 90 degrees
block.moveTo([x, y, 0], 2.0).rotateBy(90.0, 2.0);
// 5) or be executed in parallel
block.spawnActions().moveTo([x, y, 0], 2.0).rotateBy(90.0, 2.0).spawnActions();

The only one that doesn't look good to me is number 6. Perhaps passing an of action names and arguments might be a better idea, something like:

// 5b) parallel execution of actions
block.spawnActions([["moveTo", [x, y, 0], 2.0], ["rotateBy", 90.0, 2.0]]);

but that doesn't seems so clean either... Perhaps I should just follow the jquery way to execute actions...

Frames are broken in canvas mode... need to fix this

The BlockGroup should either behave like a regular block in canvas, or be an offscreen buffer for canvas. Either approach should be reliable and work for canvas fallback support.

need to handle context lost and reload texture + shaders (and other needed data)

event handler and propagator - work already being done on my local repo

it should accept a canvas element and not just a canvas id.

I propose we replace the Makefile with something cross-platform.

I wrote my own version using Python. I chose python because if you are going to compile you will already have python installed.

My python script: https://gist.github.com/coolhome/4993248
Example Usuage:

C:/Python27/python.exe compile.py -mode=release -docs -clib ./closure-library -ccompiler ./closure-library -jsdoc ./jsdoc-toolkit -python C:\python27\python.exe

It's not an exact copy of the Makefile but it has most of it.

add the possibility to create particle systems - shouldn't be too hard using block groups

BlockGroup#removeChild is not implemented :)

Fixing this would allow us to have dynamic tiled maps and other interesting things.

use __defineGetter__/__defineSetter__ instead of (set | get)PropertyName in all the objects.

Block group is broken now. Must be fixed

The map generated from TMX files should be a BlockGroup: we don't want to draw the whole map tile by tile, just with a single drawElements call.

should be easy using block groups

Add some documentation/examples on the wiki for the project

The game should be very, very simple and just to showcase ChesterGL, with all features:

• animations
• canvas fallback
• shaders

It should show how to handle input and probably sound (SoundManager? http://www.schillmania.com/projects/soundmanager2/)

we need one

The test files should be public, perhaps in the same gh_pages as the doc

Could you possibly make some samples which demonstrate IO?
Ideally a full suite would be neat, but I feel a simple up/down/left/right would really help.
Thanks,
Dean.

While anyone can recreate the documentation, they need a Java VM + jsdoc to build it. It would be nice to have the docs uploaded to a github page for the project.

This could also include the same examples in the html directory.

BlockFrames.loadFrames is not using the asset loader (it's using a custom jquery ajax call). It should use the default asset handler

Needed for several things, like in-game menus, etc.

First attempt on 14e51c8. At first I thought on implementing bitmap font support, and while we still need that, for labels that will not be updated too frequently, we can take advantage of the canvas font rendering mechanism and use that for the texture of a block. It turned out to be very simple.

Actually, we could use the canvas for more complex "vector"-like rendering and then use that texture in the webgl environment. Might be worth the investigation.

textures loaded from external sites are not supported and they should: it is a very common pattern to put assets in a CDN like google storage (or s3 once they add support for CORS).

the asset loader should also detect if the path is absolute or relative, if it's relative, it should use the basePath (defaults to "") otherwise just the path, but add the CORS headers (origin) to the ajax request