I’m going to actually sit down and finish typing out the rest of my notes from Tuesday. The rest of the days are much lighter on the notes.

Anyway, on with the show!

Tuesday (Tech Artist Bootcamp) (continued):

Seth Gibson – 343 Studios (Microsoft) – How to Train your Technical Animator – leveraging personality types – slides here

  • Team Fit
    • the myth – it’s about who you’d want to have a beer with
    • It’s not about generic ‘strengths’ and ‘weaknesses’
    • it is about leveraging personality
  • Personality assessment overview (I’m an Integrator, with a strong hint of Focuser)
    • The Focuser
      • “Management Material”
      • Question they ask: What?
        • “what is the job right now?” — not big picture
      • Generally self-reliant
      • Authoritative
      • Practical
      • Clear
      • Predictable outcomes
      • Areas to improve:
        • People skills
        • Breadth of knowledge
        • Time management skills
    • The Relater
      • “Who?”
        • “Who is involved?”; “Who is affected?”
      • People person
      • enthusiast
      • Better at scheduling than the focuser
      • Big picture/teamwork focused
      • Interpersonal
      • Effective communicator/presenter
      • Also a great tools/tech/etc. evangelist
      • Areas to improve:
        • Focus
        • Breadth of Knowledge
        • Depth of Knowledge
        • Time management skills
    • The Integrator
      • “Why?”
        • or, “What is the significance?”
      • Self directed, self-reliant
      • Finisher
      • strong team member, considers all the input
      • Asks (and often answers) the hard questions
        • Is there a better way to do this?
        • Is this the most productive use of time?
        • etc.
      • Areas to improve:
        • Leadership skills
        • People skills
        • Depth of Knowledge
    • The Operator
      • “How?”
      • Detailer, systemic
      • No stone unturned
      • Attentive to “little things”
      • Iterates and improves
      • Analyzes, monitors, documents
      • Knows systems, procedures, boundaries
      • Areas to improve:
        • Leadership skills
        • people skills
        • Breadth of knowledge
        • Time management
  • Personality training now means personal success later
    • Assess early, leverage often
  • Redefine “team fit”
  • Re-think development paradigms

Steve Theodore – Undead Labs, Epic Fail – slides here

  • Dealing with problems is a huge part of the job
  • Defensive Design – take inspiration from real defense
    • Compartmentalize
      • like battleships!
      • Encapsulation
        • Small functions with clear jobs
        • well defined inputs and outputs
        • each piece is a black box
        • bigger jobs = a collection of small jobs
        • “Single responsibility pattern”
          • Each small chunk of code has a single responsibility
        • Why encapsulate?
          • localize problems
          • Simpler maintenance
          • Easier debugging
        • Extra benefits:
          • Reusability
            • Bug fixes happen in one place
          • Teamwork
            • It’s easier to divide tasks when you have a bunch  of small pieces with clearly-defined functions
          • Testability
            • It’s easier to figure out whats wrong when the function that is throwing the error has limited length
            • testing for individual black boxes is relatively easy
        • Different flavors of black boxes
          • Library code
            • intended to be used anywhere
            • should be the bulk of the code  we write
          • Tool code
            • complex jobs
            • very specific
            • should make use of library code
          • UI code
            • buttons, menus, etc.
          • Model View Controller
          • Black Box Code
            • What is inside a black box can change
            • inputs and outputs can not
            • wrap existing functions to add data or functionality
        • Document!
          • Memory is fallable
          • teammates need help
          • write your code for strangers to read
          • automatic documentation generation software:
            • Doxygen (many languages)
            • Epydoc (Python)
    • Debugging
      • Code stacks up
        • returns go down
        • debugging = inspecting the stack, and backtracking to the bug
        • 90% of the time, errors are from carelessness in how code talks to code
      • Debugging is the art of finding responsibility
      • Print Debugging
        • simple
        • cheap
        • limited
        • messy
        • fundamentally the wrong tool for the problem
          • you must know where the problem is to find the error
      • Logging
        • Print debugging plus
          • global on/off
          • write to text file
          • email
        • Python
          • use the standard logging module
      • PDB (Debugger)
        • step through code
        • inpsect variables
        • execute statements
        • move up/down the stack
      • IDE
        • Eclipse + pydev
        • wing
    • Exception Handling
      • Exceptions retrace the stack
      • catch only expected errors
      • Catch Fails
        • blatant catches
          • Hiding errors you should be fixing
        • Empty catches
          • (don’t lie to yourself, the error is still there)
        • Catching too high
          • your catch needs the right context
      • Catch Win:
        • tight scopes
          • expected errors
            • empty returns, etc.
          • External Errors, etc.
            • network, disk issues
      • Exceptions are friends
        • Valuable for debugging
        • flexible, because you can write your own
        • save all exceptions
          • text file
          • email
          • database
      • Good error reports
        • save whole stack
        • file, location, local vars
        • Python Stack Capture
        • throw exceptions high on the stack to be handled lower

Adam Pletcher – Volition, Databases and Technical Art – slides here

  • Embrace the database
  • Relational Databases
    • Strengths:
      • Speed
      • Volume
      • Multi-user
      • data relationships
    • Hurdles
      • SQL query complexity
      • centralized service
    • How they work
      • Server -> databases -> tables -> Columns and Rows
        • Each Column has a type
    • Visualization
      • Allows you to quickly and easily show data in a visual format
        • Heatmaps, graphs/charts
      • Tools:
      • When graphing, show the trend line
        • Useful for proving viability to management/producers
      • Heatmap for tool usage/errors
    • Databases and Python
      • SQLite
      • pymssql
      • postgres
      • **SQL Alchemy
        • Pythonic
        • Independent of DB flavor
        • Abstraction layer between the python and the SQL/DB
        • Object relational mapping
          • direct relationship between code object and database data
            • add, update, delete
    • Start small and simple
      • install a server on your workstation to begin
      • start with a dumb datastore
        • good place to learn
      • Set goals for data capture

Bryan Moss – THQ Digital Studios Phoenix -Using Simulation data in real time – slides here

  • Graphics talk, not so much tools
  • Video simulation textures
  • Pipeline
    • Sim cloth with DCC
    • Video node used in shader to add video to the shader
      • Render to texture
      • don’t be subtle
      • Can use compositing on videos
        • “fix in post” mentality
        • allows for a lot of flexibility
    • Bink for video compression
    • Cloth shader
      • Tech artists are invaluable here
      • art knowledge plus technical know how
      • Running the numbers is a must( PIX, Gpad, etc)
        • Tech artists should know exactly how much something costs
      • Downsides:
        • Art setup is cumbersome
        • Artists need to know multiple packages
        • can be tech heavy when designing, coding, maintaining shaders
      • Features
        • Extremely dynamic shader
          • 5 dynamic systems including cloth
          • multiple specular types
          • two sets of UVs
          • 5 textures plus one video texture
        • Bulk of cloth is in normal and parallax
          • swizzle out blue for using on the parallax
        • process helped by efficient, established shader pipeline tools

Bronwen Grimes, Valve Making and using nonstandard textures – slides here

I didn’t take many notes for this one, I was mostly trying to digest the material.  Definitely take a look at the slides for this one

  • Standard textures
    • Diffuse, specular, normal, etc.
    • useful, but by no means the limit to what can be done with a 2-dimensional array of data (map)
  • Non-standard textures
    • Manipulate the UVs through color data
    • Flow Map – representation of a 2-d vector field, plotting the flow of pixels on the surface
      • Water needed to follow the complex contours of the levels in a believable way
        • Flow around things
      • Flow map generated by Houdini & scripts (definitely reference the slides for this one)
        • artists were given a mock-up of the level, with the plane of the water.
        • They could then paint the flow on the surface, which was basically painting the surface normals
        • this information was then baked out to a two channel map
          • This data was not normalized, to allow for different magnitudes of flow
      • Use a noise texture (cloud) as a time input in order to offset the motion in timing
        • cycle the values so that this can also be used to mask off movement
      • Flow maps done by 2 artists, for 30 levels, in 1.5 days
    • Material Emancipation grid
      • had to be non-threatening, convey that it was non-blocking, and also communicate state (show player that it would “emancipate” level meshes
    • Surface-facing normals
      • The “science-y” gels for portal 2
      • Wanted texture to look like it had embedded sprites
      • ended up using a uv texture that reacts to the camera’s angle to the texture.
      • along with a bump offset, made a texture that made the bubbles always look round