Prototype where polished art are getting integrated with bounding boxes for main player package :

• iteratively tune animation play back for both player and bounding box transforms to feel "good"
• tuning input controller to feel responsive
• background, and boss assets are roughly instantiated and animated to give artist context to tune asset production

Complete gallery can be found at : https://photos.app.goo.gl/o5yDQZDeArgBmhxD8

There was a lot of back and forth with the art team, and generally turn around time was about 2-3 days between deliveries and getting a new build ready for us to progressively iterate towards the next step

This iteration was happening remotely, after work from our actual day job : but the speed and progression gave us momentum to positively move forward 

Gallery of rapid prototype development with white box bounding volumes :

• Unity 3D
• Entity Component System

IMHO the bread and butter of prototyping is :

• visually acknowledging runtime events and physics state
• structuring it so that's it easy to remix and explore possibilities
• including polish for animation curves and transitions

Bonus if the with simple bounding volumes already look good prior to actual art polish

Full gallery available here : https://goo.gl/photos/9jAdyFbYVnNUkhr86

This was a fun scratch pad for mapping and logging function and events to UI, and each gif represented about a bus ride's worth of progress ~ 25 minutes

Junya C Motomura's gave an amazing GDC presentation of how Guilty Gear Xrd achieved it's incredible 2D look.  And I was inspired to write a variant of what Junya presented as a Maya Cgfx Shader.  Check it out, it's available on Github:

https://github.com/miketon/Maya_Tools/tree/master/Shaders/Toon_xrd

Notable differences :

  * Team Red appears to be straight up using a dot product.  This shader uses a dot product to do a uv lookup on a 1D ramp texture.  Affords more flexibility with changing light-to-shadow palette via texture edit.  Tradeoff is lower perf

  * Team Red actually altered the normals, I'm using vertex color (red channel) to alter the uv lookup.

Future improvements could include other 2D effects such as ziptone and crosshatch shading.

Digging through my old archive, I found this old documentation for a matcap shader I wrote for Halo 4 a few years back.  Our pipeline was entirely proprietary, and didn't feature any kind of node based editor such as Unity's ShaderForge or UDK's shader editor.  

Luckily my previous experience working on the hardware side at Nintendo Technology Development and interfacing with OpenGL at a low level helped me find my way around our engine.  

Much of my work nowadays doesn't require the level of linear algebra as it used to, but I still find concepts derived from that foundation useful for debugging collision and raycasting logic in my character/camera controllers.  Like anatomy knowledge, linear algebra has a very low decay, and I'm very glad to have invested in adding that to the tool belt.

I'm a strong believer that all problems crumble under relentless efforts.  All problems.  

Here are the best new additions to my toolbox:

c# - I didn't realize how much I would come to love this language.  Lisp and Javascript were a great entry for me into code, but c# let's me get things done on a practical day to day basis.  Now comfortable with interfaces, class extension, function overrides and overloads as structures to reduce repeated code over medium to larger projects.  Model View Controllers as an intelligent code organization, and Rx as a way to track events in motion.  

Grids - There is something about procedurally building out a level that is exciting.  I'm currently lost in exploration here, but will continue to invest in this space.

Github check ins and daily pomodoros have helped massively expanded my toolbox and skills over the last few years.

IMHO games that effectively allow a compelling conflict to play out on screen rule the day.  There's been an ongoing debate between Narrative/Story vs. Gameplay/Gamerules in game development that has been just as rich.

I stumbled across this interesting article by hitbox team, that I read as framing the debate as developer story vs. player story:

http://hitboxteam.com/designing-game-narrative

A really outstanding read, and interesting angle.

Posted above is an animated gif of most of the ease-out tween types that I organized into an array for reference and a/b comparison using HoTween : https://www.assetstore.unity3d.com/en/#!/content/3311.  Here's hoping this is helpful to folks out there.

HoTween Version 2.0: DoTween is relatively new, but is already my go to tool for any kind of value curve changes.  The support and response that Daniele Giardini (Demigiant) has been offering has been amazing : DOTween (HOTween v2), a Unity tween engine: alpha now open .  

And I especially enjoyed following how lambdas are implemented in C#, and applying them in my own code.  I was more than happy to support and sponsor his effort.  Check it out.  The future is looking amazing for Unity Tweening.

As far as I understand, much of the math is based on Robert Penner's Easing Functions : 

http://www.robertpenner.com/easing/

Which was a tremendous resource when I was building UI prototypes during my Research and Development days at Nintendo Technology.

Learning to filter and chart tables, csv files, xml/JSON docs has been one of the more interesting problems I encountered working on Halo 4.  It's pure data shepherding.  And when I was doing manually it would take nearly half a day; so I wrote scripts to automate that :

https://docs.google.com/spreadsheet/ccc?key=0Ak0Zu3w86Ux5dEtYZkpuV1Y5dWpfRG1KTTNKSEZ1RXc&usp=drive_web#gid=4

Data once it's filtered for relevancy and visualized as information becomes highly valuable in understanding trends and detecting spikes. Properties that are highly desirable for tracking and reporting memory usage.

Code is available at : https://github.com/miketon/Maya_Tools/tree/master/toolBox

Code is available at : 

https://github.com/miketon/Photoshop_Scripts/blob/master/source/stripToLayers.jsx

Built this little animation out of three key thumbnails, and good old fashion brute force key tweaking.  I recall how exciting it was to exceed the boundaries of what I could reliably produce animation wise, at that point. 

This was suitable enough to use as one of my animation sequences to profile different compression settings.  Feet sliding was the most obvious artifact in more compressed versions.

This was a production trial as a means to refine my sculpting, skinning and animation skillset.

Over Christmas break, my brothers(one of which is in the industry) and nephew(who just turned 14) wanted to do some off the books game development.  The above video, steps through the features of our ripest prototype.

What's cool is how my nephew got to experience building something hacker style : Through pivoting and ad hoc problem solving. 

  And the highlights on that roadmap were:

• Basic control and movement.  Started out with a ball and worked on getting good horizontal movement with acceleration and deceleration.  Then moved on to add jumps and fall along the y axis.
• To fire bullets, you must first spawn them.  This lead us to discovering this prototypes funnest game element; spawning the satellite weapons.  Realizing this completely changed our mental model: Every object in the game bullets; floor and wall tiles are effectively static bullets that never move.  
• Collision detection.  We've made many false starts with other development environments(HTML5, Game Salad, Unity..etc), and getting stuck in tiles, or completely missing tiles was always an issue with higher speed transform.  Managed to get good results by incorporating acceleration into the collision calculation, and that got us 90% of the way there.

My nephew was familiar with GameMaker, so that became the platform of choice.   And I was surprised at how articulate of a guide he was in getting me up to speed with GameMaker's inner working.  

We managed to complete about a feature per day.  So within a week and some custom code slinging, we had a fun prototype.

My public gallery can be found here: https://picasaweb.google.com/113437345776751967428

Once upon a time, I was exclusively an artist :).  

The game development paths winds through the unknown on a continous basis.  And a core component for effectively handling the unknown requires updating one's mental model and pushing the edge of understanding. 

An old Indian parable describes how 3 blind men, holding each part of an elephant are convinced that they have 3 different animals. 

Mindmaps, in my experience, offer a holisitic and methodical approach for mapping out what's at the edge of one's understanding: They capture what you know, and perhaps more importantly, reveal the empty space of what you yet don't know.  

Below is an index to the current mental maps that guide me about the elephant: 

http://www.mindomo.com/view.htm?m=8b80c850ca4441418aa8f013aea5bd01

I really loved learning things as a collective group.  

And a few years back, during Christmas break, my 10 year old nephew and brothers(software engineer and med student) spent time playing with stop motion animation.  

The best part was how my sister was genuinely stunned by what her little boy could produce(her expectations for the kid's uncles were already high<g>).  

The highs of game development, in my opinion, building more than what you think is possible as part of a collaborative effort.

A timelapse of a sunrise out at Hood Canal.  It was a weekend with a bunch of friends building a potato gun canon.  We manage to complete two variants:

• Aerosol      : http://dangerouslyfun.com/spud-gun
• Pneumatic : http://www.spudgundepot.com/pneumatic-modified-sprinkler-valve.html

Lazily firing potatos into the canal was fun. And I recall one of my buds managed to launch a spud out as far as 50 yards.  He pumped up the psi far beyond what the gun was specced for to manage that<g>.

This can certainly be used as a great artistic effect, but more often than not it's unintentional.  As a result the spatial aspect of play spaces/environment becomes greatly diminished.  Players have to work harder to discern the play space, leading to visual fatigue.

Been checking out WebGL as part of my more recent Saturday Morning Project.  And as far as I can surmise, WebGL seems to be an interface that exposes GPU hardware buffers to the browser. And javascript in this context, is basically utilized to push floating-point values to vertex buffers, and shuttling them through the C(?) foreign-function interface into the GL library.

Here's the current code state of my fiddling  with a simple, bare bones WebGL context:

https://github.com/miketon/webGL

Here's a mindmap of my current understanding OpenGL functions and hardware registers:

http://www.mindomo.com/view.htm?m=fe720acc4ba34b7bb49c8524b427c768

There's a lot to love about the how graphics development on the web is trending.  It feels like a reset/re-invention of the industry ~10 years ago.

Interfaces however, are much more resilient and surprisingly high mileage.  

I've built many one off animations rigs that languish, while the keyframe tool that drives it continues to find usage.  The animation UI pictured for simple commands such as zeroing out, mirroring and keying poses have been adapted to numerous foreign rigs on a number of various contracts and small side projects.

• Initial Standard : The project's character clothing used the standard normal, specular, diffuse uber shader.  There was an interesting tweak to the specular to 'pop' more detail with front facing normals.  And that worked great on surfaces such as leather and velvet.  But not so much on on cloth and materials where specular was minimal.
• Hue Shift Pivot : Adding a complementary hue shift to the tangent facing normals of the material colors on the character's cloth pumped up the palette.  I utilized calculations already being processed to add minimal perf cost to the process.
• Art Direction : The art director liked the expanded palette, but felt my shaders defaults were too heavy handed with color usage.  I worked with him to dial down many of the settings(it's easier to rein a shader artist back to push him for more:).  The Lead Tech Artist also exposed a custom sample of the dominant scene light.  Changing the shader to sample the complementary color from scene lighting as opposed to local material colors.  The final look something more along the lines of the palette brilliantly achieved in Unchartered 2. 

Code is available at :  https://github.com/miketon/Photoshop_Scripts/blob/master/source/layersToStrip.jsx

"A problem well stated is a problem half solved."

                                        -Charles F. Kettering

One of the day to day challenges of tool/workflow development is resolving the needs and wants of diverse disciplines.  That gap can be particularly wide on complex and ambitious projects.  Many times the requests from one department will appear to conflict with what another may be asking for. 

A practical and direct way to address this is with Photoshop wireframes.  Words can be imprecise; pictures and numbers however tend to be concrete.  Photoshop->conversationw/Design->Photoshop->conversationw/Engineers, in my experience has worked as an effective means to iterate.

This process is a great aid in moving the needle forward on plans sidetracked by abstration and ambiguity.  And at times these visualizations will also serve as an ad hoc contract for the tools to implement or workflow to be setup.

It's modal nature is somewhat astonishing at first : Why would a text editor have a mode that does not input text?  The reason becomes a bit more clear when you consider that about half the time of an average text editing session is spent tumbling to and from characters/words.  And by separating those two modes, Vim effectively doubles the available keystroke space.

Originally, I struggled with a number of false starts with picking up Vim.  Persistance paid off.  And the resources that helped me most were:

• The built in vimtutor or the browser based openvim .
• The videos at vimcast.org are a gentle, practical introduction to Vim's day to day use.  These videos got me to the critical point of applying Vim idioms to my real world projects.
• Beautiful wallpaper by Ted Naleid. (My personal variant is attached.)

I also recommend finding a nice .vimrc :

• https://github.com/wgibbs/vim-irblack   (my initial starting point)
• https://github.com/miketon/vimrc         (tuned to my personal workflow) 

(The jj macro to switch modes will be kinder on your fingers than having to reach for the escape key.)

Vim is ~20 years old, yet IMHO manages to feel ahead of the curve.

• Landing page posts can be sorted by tags.  I use Posterous to document some of the experience and tools I've developed over the course of my career.  I also use it to share social posts about personal projects, product reviews...etc.  Using tags I can directly share a url to a landing page sorted for disparate topics:

1. http://miketon.posterous.com/tag/top -   Portfolio and career topics
2. http://miketon.posterous.com/tag/fluff -  Social and personal posts

• (An added note is how remarkable Posterous support was: I received answers to my specific questions, from a person, in only a few hours!)

• Posterous themes utilizes standard CSS formating.  To simplify my page, I removed a number of fields to free up some page real estate. (Theme edited from Contra by Cory Watillo .) 
• Archiving : Posterous blog can be downloaded and locally archived by running a chron task on : http://posterous.com/api/readposts?hostname=miketon&num_posts=50

Posterous is by far the most hassle free and simplest way to blog, and is definitely worth leaning on for my posting needs.

Attached are also a few quick throwaway thumbnails trying to hash out the idea.

I'm a dabbler by nature and generally have about a dozen projects going on at any given time.  It's the things with purpose, that I'll move to the finishing stage. 

And before discovering the advances in Javascript and HTML5, it was my favorite technical sandbox.  Here's a small OpenGL program I wrote while learning matrices to implement ArcBall rotation: 

https://github.com/miketon/Impromptu/blob/master/OpenGL_Basic_ArcBall.scm

Just got an e-mail from YouTube to describing how my channel may be eligible to earn revenue, if I'd agree to have ads on my uploaded videos.  This got me wondering how many views/subscribers does it take to receive an invitation.

Currently my channel has:

• 28,064 views total over 4 years (created in 2007)
• ~1,000 views every two weeks for the past half year
• 32 subscribers
• 29 views

It's pretty gratifying to receive such an offer.  On the one hand I'm really curious to see how the revenue system works.  On the other this channel is being used to host portfolio and family videos: It'd be worth seeing if it's possible to create a 2nd private/personal channel that would be low view count, but ad free.

Anyhows, one of the nicer things that the internet has offered beyond convenient shopping and naughty pictures.  For that I'm very much grateful:).