Google Code-In Tasks
This page is currently a scratchpad for proposed Google Code-In 2011 tasks. Remember this is a wiki, so the tasks listed here may not appear or be modified before being offered for the contest.
New Student? head on over to GettingStarted
Our mentors are on IRC and generally available to answer questions and help get setup with Mercurial, compiling the engine, setting up a development environment, or anything else you need to get started.
For more information about Google Code-In see the Google Code-In site.
If you are interested in these tasks, join the #PySoy IRC Channel on freenode.
Tasks related to writing or refactoring code (Keep in mind the young age and likely inexperience of the student: the more independent thought and breadth of technical knowledge the task requires, the harder you should consider it. Try to break a task into multiple smaller tasks: if you can't - that's a hard task.)
- Billboard Refactoring
- Refactor pysoy/src/models/Billboard.pym (Pyrex) to libsoy/src/bodies/Billboard.gs (Genie), updating its rendering method to work with the newer code such that billboards are always rendered facing the camera. This task will require working with matrix math and learning how PySoy renders bodies in a scene.
- Port soy.fields to experimental
- soy.fields are generic objects in 3d space that apply forces and other changes to other bodies. They were originally written by Eric Stein in Pyrex and later rewritten in Genie by Juhani Åhman (fzzbt) for libsoy during Google summer of code 2011. However, the latest version of soy.fields (and only decently working one) is still in the default branch of libsoy, not in the experimental branch that is currently focused. This task requires that you port the changes in soy.fields and relating classes (mainly soy.scenes.Scene, soy.bodies.Body) from the default branch to the experimental branch. Knowledge of physics and relating mathematics might be helpful. Ask fzzbt in #pysoy@freenode for details.
- Fields Bindings
- Write Python bindings for soy.fields. This is largely a C refactoring task from most any other directory in the PySoy source tree to src/fields exposing the properties of the respective libsoy classes.
- Joints Bindings
- Write Python bindings for soy.joints. This is largely a C refactoring task from most any other directory in the PySoy source tree to src/joints exposing the properties of the respective libsoy classes.
- Scroll Bindings
- Write Python bindings for soy.widgets.HScroll and soy.widgets.VScroll. This is largely a C refactoring task from another Widget class binding exposing the properties of the respective libsoy classes.
- Improve soy.bodies.Box rendering
- soy.bodies.Box.render() currently uses a vertex array of 8 vertices and 6 faces, broken normals, and no texcoords. Update the rendering code (with copious comments) to use a VBO (vertex buffer object) which is only updated as needed, support subdividing faces for better lighting, correct normals, and automatically texcoords which supports a cubemap texture. Update the Python bindings (PySoy) and pysoy/examples/TwoCubes.py to demonstrate this. If "Bumpmap Refactoring" is already finished then additionally update tangents and TSLV calculations for VBO and subdivision, these two tasks cannot be worked on concurrently by different students.
- Improve soy.bodies.Sphere rendering
- soy.bodies.Sphere.render() currently uses a vertex array and no texcoords. Update the rendering code (with many more comments as present) to use a VBO which is only regenerated as needed. Additionally generate texcoords and tangents for a cubemap texture. If "Bumpmap Refactoring" is already finished then additionally generate TSLVs for bumpmapped materials.
- Bumpmap Refactoring
- Refactor Pyrex code for calculating TSLV (tangent-space light vectors) in the pysoy source tree to Genie in the libsoy source tree. Add the TSLV conversion cubemap to libsoy and demonstrate working bumpmapping with an example soy.bodies.Box. The original code for this was written by a GHOP student from Poland who won a grand prize that year, this code has remained largely unchanged from then and needs this update to work again.
- Steering Behaviors
- Implement one of the Steering Behavior algorithms. Code should be implemented in soy.behaviors? Before claiming the task, consult with the IRC channel regarding which algorithm you plan to implement and other considerations.
Tasks related to creating/editing documents (consider length of file)
- Camera Docs
- Write PyDoc for soy.bodies.Camera describing how it can be used with soy.widgets.Projector and what makes the Camera different from other bodies.
- Container Docs
- Write PyDoc for soy.widgets.Container describing how Container widgets can be used and what the Container base type can be used by itself.
- Light Docs
- Write PyDoc for soy.bodies.Light describing how the three light components (ambient, diffuse, and specular) interact with material colors and what each of these properties are for.
- Texture Docs
- Write PyDoc for soy.textures.Texture describing how a Texture can be created and used, especially how atomic Colors are used. Read ColorCanvas?.py for the most advanced example using a texture.
- Scene Docs
- Write PyDoc for the soy.scenes module and the soy.scenes.Scene class to describe what scenes are in the context of the PySoy engine. Proper module documentation should put the soy.scenes.* classes in context without overly duplicating the soy.scenes.Scene class documentation.
- Materials Docs
- Write PyDoc for soy.materials, soy.materials.Material, soy.materials.Colored, and soy.materials.Textured. Documentation should specify what these classes do and how they're used, as well as maintain a narrative form from the module to each of the classes.
- Windows Install Instructions
- Write a section in our INSTALL files for libsoy and PySoy with step-by-step instructions for building on Microsoft Windows 7 starting with cloning our Mercurial source tree. Include URLs for free software tools needed including Python 3.2, Mercurial, MingW, and all dependencies (as binary builds). Its expected that this task will involve working with our Windows packagers for help and documenting the steps you needed to take to compile and run on a fresh Windows 7 install. Copy these instructions to http://www.pysoy.org/wiki/Install/Windows
Tasks related to community management and outreach/marketing (Videos = easy, talk for an audience = medium, written promo or web page = easy)
- Getting Started Screencast
- 10 minute screencast with voice walking through using PySoy for the first time, starting with installing as a package, running a basic example script, editing and expanding that example, and how to learn more about the classes.
- Install from Mercurial Screencast
- 5 minute screencast showing how to clone our Mercurial repository, read INSTALL file for instructions for how to build on a Linux distribution, and running an example to test that it worked.
- What is PySoy Animated Video
- 5 minute "elevator speech" for website with animation and voice talent explaining cloud gaming and and rapid game development targeting amateurs and avoiding technical terms.
- Copyleft Gaming Promo Animated Video
- 5 minute video explaining the AGPL in respect to PySoy games, how to comply, and how it promotes a game's evolution. Animation with voice talent.
- User Group Talk
- Present PySoy at a local user group showing some examples and explaining the concept of "cloud gaming".
Tasks related to testing and ensuring code is of high quality (varies by task)
- Atomic Tests
- Write unit tests for soy.atoms classes covering every math, comparison, and conversion function provided by them. Ensure each atomic type behaves atomically (see examples/ColorCanvas.py).
- Texture Tests
- Write unit tests for soy.textures.Texture ensuring the Color atomics are behaving appropriately, resizing works correctly (length, assignment), change of channels is performed correctly, and math functions work as planned. These tests should report several errors where existing code is incorrect or missing.
- Physics Tests
- Write unit tests for soy.scenes, soy.bodies, soy.fields, and soy.joints ensuring that rigid body physics behave predictably within acceptable limits (there will be minor rounding and timing errors). Every joint and field should be tested by this in a variety ways.
- Collision Tests
- Write unit tests for soy.scenes and soy.shapes to ensure collisions are happening under a variety of cases. Every shape should be tested against every shape to ensure the results are predictable within acceptable limits.
- Widget Tests
- Write unit tests for soy.widgets (without rendering) which ensures container widgets handle space distribution and resizing as expected under a variety of conditions. These tests should discover which existing widgets are not performing correctly.
Tasks related to studying a problem and recommending solutions
- Android Porting
- Research what steps are needed to write a PySoy client for Android (Native), determine where we may hit performance issues and how Android input devices (touch screen, accelerometers, etc) can fit into the current API model. Break the steps into GCI-ready tasks for our ticket system.
- Raspberry Pi Porting
- Research what steps are needed to write a PySoy client for the Raspberry Pi, including which dependencies still need to be ported to ARM, performance issues we may have to overcome, and what issues we're likely to hit with the Broadcom GPU. Break the steps into GCI-ready tasks for our ticket system.
- XO Porting
- Research the hardware capabilities of the XO 1.75 and the steps required to write a PySoy client which will run on the Marvell chipset. Recommend how we can provide access to the XO 1.75's proposed hardware from the API and solve performance issues. Break steps into tasks for our ticket system.
- Wii Porting
- Research what steps are needed to write a PySoy client for Wii Homebrew. Cover topics such as GX/GLES compatibility, user interface, and networking. Write tasks for our ticket system.
- Wiimote kernel driver interfacing
- Create a wiki page on how to use the https://github.com/dvdhrm/xwiimote (kernel driver module for wiimotes).
- PS3 sixaxis controller interfacing
- Research on how to use sixaxis in conjunction with pysoy. Create a wiki page detailing the steps.
- Thread Blocking
- Find where locks frequently block critical thread processing (physics, audio, etc) and recommend ways to solve these problems to optimize the engine. Create a report of the most frequent cases where critical threads are blocked.
- Memory Use
- Find where memory is being used (and wasted or leaked) using valgrind, filing tickets for memory leaks and creating a report showing how much memory is used for different objects and how memory use scales.
Tasks related to helping others learn more (online training page for single feature or command = easy, online training page for a section/group of tools or commands 1-10 = medium, more or complete set = hard)
- Basic Setup Tutorial
- Write a step-by-step tutorial on our wiki for setting up a basic PySoy window, 3d scene, and objects which collide with each other. Describe each step of the process with pointers for learning more via dir() and help().
- Lighting Tutorial
- Write a tutorial on how OpenGL lighting works with examples written for PySoy for our wiki. There are many examples on the web which describe OpenGL lighting in detail, this tutorial should avoid technical terms and complicated math as we're targeting beginners without existing OpenGL knowledge.
- Fields Tutorial
- Write an overview on fields, what they do, which ones are available, and what features they offer. Include an interactive example which allows a user to "play" with bodies and fields in realtime.
- Joints Tutorial
- Write an overview on joints, what they do, which ones are available, and what features they offer. Include an interactive example which allows a user to "play" with these joints in realtime.
- Shapes Tutorial
- Write an overview of shapes, what they do, which ones are available, and their properties. Include an interactive example which allows a user to "play" with every available shape in realtime.
Tasks related to localization (Marketing pages (any) = easy, code documentation by feature/ command = med to hard based on length /# of pages/going from a language that uses Roman characters to a different character set or vice versa) (Note to orgs: Be sure to have someone that can check the efficacy of the translation before approving it).
- French Website
- Translate the PySoy frontpage, Requirements, Download, Licensing, and FAQ pages for French.
- French Promotional Audio
- Translate and record audio for 3 videos (above) in French.
- Spanish Website
- Translate the PySoy frontpage, Requirements, Download, Licensing, and FAQ pages for Spanish.
- Spanish Promotional Audio
- Translate and record audio for 3 videos (above) in Spanish.
Tasks related to user experience research or user interface design and interaction (time- based measurement)
- Container Borders
- Add an option to container widgets to put simple borders between children, useful for debugging UI design.
- Joint Models
- Design simple 3d models for joints, convert to OpenGL ES 1.1 calls with wireframe/solid mode for debugging. Demonstrate with an example which switches between invisible, wireframe, and solid joints.
- Number methods for textures
- Add support for addition, subtraction, multiplication (burn), and division (dodge) to Texture such that two textures can be applied against each other using Python math operations. These functions should be usable to composite different textures for numerous 2d and 3d quser interfaces.
- Texture scaling and shifting
- Automatically scale and average/split channels as per ticket #985. Remember to update weak references to atomic Colors in the process, demonstrate that this works correctly by expanding pysoy/examples/ColorCanvas.py to support changing number of channels and scaling at random.
- Widget Research
- Research current soy.widgets capabilities and suggest features which would make them better, such as proportional scaling or maximum/minimum sizes, and how these would be calculated by container widgets.
- Scrollbar Design
- Design a default scrollbar. All rendering must be done with OpenGL ES 1.1.
- Theme Research
- Research how soy.widgets could be better themed and propose an API model for implementing this which would allow a game designer to implement widgets which appear throughout their game. Propose a specific API to accomplish this with pseudocode mockups.
- Pointer Raytracing
- Map pointer clicks on Window objects to the widget clicked on, and when on a Projector widget also raytrace to the 3d object or point in 3d space clicked on, then pass event to associated object. Write a small example which demonstrates this working.