Google Summer of Code

 Read everything about this program here:
 http://www.google-melange.com/gsoc/homepage/google/gsoc2014

Contacting Us

You can contact us via our bf-committers developers mailing list

Or via IRC: irc.freenode.net #blendercoders

You can also use our wiki.blender.org, your private page, to write down proposal drafts for discussions.

For matters you prefer to discuss more in private, mail Ton Roosendaal: ton at blender.org.

GSoC Project Ideas 2014

The following list provides some ideas for projects that

a student coder can complete in the time frame given (hopefully not too easy, and not too hard); and

implements topics marked as "to do" by current developers, implements a coveted feature request from our user community, or improves upon existing code.

Each project has multiple potential mentors (we usually have at least 3 individuals as potential mentors for each project). So if you are interested in feedback or discussion of an idea please email our development discussion list bf-committers or visit or irc channel #blendercoders .

We especially invite students to contribute based on their past experience and competencies, or based on their current research, so that they can efficiently bring a new development direction for blender.

Additional project ideas may be added to this list, so you may want to check this page later as the application deadline looms.

Please note that proposals that have been merely cut and paste from this list of project ideas with little value added will be swiftly discarded.

All projects will require a strong working knowledge of C/C++, in addition we use Python for much of our interface code (anyone skilled in C/C++ can trivially learn enough python to make the needed interface code changes). We use C++ in game engine code; and C++ is also present in many of the libraries we use such as the Bullet physics library. However all C++ libraries use a C interface when accessed from within the Blender core code.

Ideas

(don't add to this list unless you are a developer who could potentially mentor the project)

Getting the big picture

A good illustration of projects we do for Blender you can find on many places at blender.org and our wiki. For example check on:

Modeling

Improve Mesh Modeling Tools

There are various modeling tools which can be added/improved. A collection of improvements like this could make a GSOC project.

Possible tools aren't limited to the ones listed below.

Edge loop slide (slide edge loops on either side of an edge).
Edge loop re-distribute (with smoothing options).
Make existing tools modal, eg:
- Draw a stroke to rotate edges to match the stroke.
- Select shortest path could draw a preview line from the active element to the mouse before executing.
- Mark seams/sharp/crease could use a similar path preview.
Loop cut could work better with modifiers applied (preview could follow subsurf)

Modifiers

Modifiers are probably one of the best introductions to coding new modeling tools. Modifiers have a well-defined API (DerivedMesh comes in, new DerivedMesh goes out), so the student need learn only a small part of Blender's internals before becoming productive.

Ideas for modifiers can come from academic papers, but be sure to check details of the paper for full understanding (e.g. if interpreting the paper requires knowledge of some mathematical field, be sure you have that knowledge before taking it on as a project.)

Solidify currently uses a simple duplicate and extrude method however this gives self intersections for more complex geometery, a method of solidify which is able to avoid overlapping geometry would be good to have, but is a fairly involved task too.

Decimate: possible improvements to the existing decimate modifier.
- NGON support.
- edge-loop aware decimate which doesn't triangulate the mesh.
- Mirror aware decimate which keeps the mesh topology symmetrical.

Quad Dominant remeshing modifier Note, this was a previous GSOC project which didn't end up being usable, but still an important modifier, this is an advanced project

Weight Painting

Blenders weight painting has been successfully improved from a previous GSOC but there are still areas for further work.

Note that this is just a list of tools that would be good to improve but others may be included too.

Improved Blur brush.
- Better method of smoothing weights.
- Optionally also smooth multiple groups at once (Multi-paint option)
Improve weight Blend tool (currently uses simplistic methods of smoothing weights).
Take depth into account when painting to avoid accidental splashing onto other areas of the mesh (other limbs for example).
Tool to evenly distribute weights across edge-loops.
Refactor Weight painting to use PBVH similar to sculpting

Texture Painting

Add support for layer type images, similar to gimp/photoshop
Add better masking tools and support (lasso/box masking, path masks, adaptive selection, cavity based)
Add deformable stencil (through control points)

Sculpting

Add better quad based remeshing (For instance http://www.graphics.rwth-aachen.de/media/papers/IGM_preprint.pdf or http://sites.fas.harvard.edu/~cs277/papers/quadrangulation.pdf).
Add operator for multires level recalculation based on subdivided mesh. (For instance http://wscg.zcu.cz/WSCG2006/Papers_2006/Full/B89-full.pdf)
Add support for holes and mesh unions in dyntopo.

Vertex Painting

Refactor Vertex painting to use PBVH similar to sculpting

UI and Workflow

Make a custom and customizable "manipulator handle" system in Blender, which can be used for purposes such as rigging (handles to transform bones), tools (Spin, Screw), or editing properties (Lamp spot size).

Blender's "snap" feature for transform has many open issues. todo list, and could get more common features for precise modeling. Needs proposal from someone experienced with CAD or architecture modeling.

Animation

Muscle system for character rigging. Can have several aspects:

Under skin volume simulation:
- New muscle primitive (maybe a bone type) that repels the mesh with a spheroidal algorithm. You should also be able to move this object and it should make the skin slide over it. A Simple jiggling effect could be added to the bone.
- Refactor Shrinkwrap modifier to work with geometry based muscles in a smooth and fast way
- Refactor Warp modifier to be able to produce non spherical forms

High resolution muscle tension or skin wrinkle animation:
- multires sculpt keyframing (follow mesh shapekeys)

References: http://cg.skeelogy.com/research/simplified-muscle-dynamics.php

Video Editing

The sequencer is carrying over a lot of code from the past. The core for its "strip" definition and handling could be recoded entirely, including better visualization. This is not a typical beginner project though.

The sequencer internal 'rendering' code could get a similar recode, bringing it back to more clean APIS, and especially look at (optional) GPU support for color operations.

Motion Tracking

Generally, this is a complicated area (requires lots of knowledge in mathematics and computer vision), but there're also some simpler projects:

Tools improvement. For example scene orientation operators could be improved in a way, so after every structure solution it's not needed to re-orient scene again and again and again. Will also need some nice user interface for this. Stabilization tools are also pretty much basic at this moment.
Lens estimation, will require some mathematics involved. But also algorithms from other open-source libraries could be adopted here. Same goes to grid calibration.
Reconstruction from non-calibrated camera.
Single frame reconstruction using manual survey data.
Variable focal length, so motion reconstruction could happen in cases focal length is changing across the footage.
Dense reconstruction using unordered sequence of photos.
Outlier filtering (roughly speaking removing tracks which doesn't correspond to the same feature point across the whole footage).

Rendering

Rendering engines such as LuxRender or YafaRay could be better integrated into Blender if an improved API was available. In particular faster data exchange with a C/C++ API rather than a Python API is important.

Make a C/C++ API available for renderes to integrate with Blender. Cycles already uses a C/C++ API that is automatically generated from the same "RNA" data system used to expose Blender data for the Python API. The project would involve finishing this API, documenting it and generally getting it in a state where it is ready to be released and used on all platforms supported by Blender.

The new Cycles rendering engine has various opportunities for GSoC projects, however they all require some experience with computer graphics and C++.

BVH / raytracing optimizations: add support for SIMD triangle intersection, add multithreaded BVH building when the spatial splits option is enabled, more efficient BVHs for hair rendering, and other optimizations to improve rendering performance. Some experience working on a ray tracer is required.

Network rendering: Cycles has some initial code for network rendering, however it is unfinished. This project would turn this into a feature usable for users, improving the code architecture to be more efficient and extending it to offer control over which servers.

Open Shading Language: support for OSL metadata, support for requesting attributes / texture coordinates to be loaded, work on improving performance of the OSL integration to match non-OSL rendering.

Pick two of these features:
- Better anisotropic BSDF (ashikhmin, D-BRDF?)
- Light Groups
- Access to object color and other object properties from nodes (support generic RNA paths?).
- Indirect and environment lighting in shadow passes
- Light portals
- Point density texture

Compositing

Improve vector blur node to give better quality results (Pixmotor, ideas here and here)

Visual handles on the backdrop of compositing result to control the transform node, possibly also nodes like render layer, movie, image and texture.

Improve Full-Sample-Antialiasing workflow in the compositor (FSA), enable the compositor to work on combined samples instead of running on each individual sample image (T39143)

See here for more compositing ideas

Physics

Polygonizer to create meshes surfaces from particle points, for particle based fluid simulation. This could be implemented as a mesh modifier that takes a particle system as input. A good quality polygonizer offers control over thickness, smoothness, etc., and gives a smooth and temporally coherent result avoiding artifacts when particles make sudden moves or disappear.

Improve the hair physics simulator. It currently lacks support for good hair-hair interaction and is not sufficiently reliable for production use with collision and fast motion. This is currently based on the cloth simulation code, but a new integrator or one based on the Bullet physics library may be needed for better results.

Fluid simulator support for thin fluid features (video examples, papers). This requires some experience working with physics simulation code.

Game Engine

Compositing Nodes: This requires compiling the compositing nodes down to a GLSL shader and running them through the BGE's 2D filter system. This would be similar to how material nodes are already done (compiled to GLSL code). It would be nice to also have the compositing nodes work in the viewport for better previews. Getting the BGE's 2D filter system working in the viewport would also be nice and would go hand-in-hand with this project. -Moguri

Collection of smaller projects

A couple of times in the past the BGE has had GSoC projects that would fix/implement a set of smaller features. These have been somewhat weak in the past since they usually have vague goals, but having the smaller projects well defined in advance would probably help. Some possible smaller projects include:

Group properties: At the moment working with group instances can be rather bothersome if a user wants to have per instance properties. In other words, it would be nice to define a set of properties for a group object that each instance could change. At the moment, this type of behavior can be emulated with a Python script, but it gets rather clunky. Having a clean way to do this via the logic/property UI would be much nicer. -Moguri
Cleanup Blenderplayer Command Line Argument Parsing: The Blenderplayer's parsing of command line arguments is currently very picky and prone to breaking, and adding more command line options can be a bit painful. Instead, we should take advantage of a library such as one listed on this Stack Overflow page, or BLI_args, which is used by Blender. The BGE already has Boost as a dependency, so Boost.Program_options is an option. This project would also involve adding some more command line arguments for controlling audio options, anisotropic filtering, and possibly others. -Moguri

Using blender as game engine/level editor: The target of this project is to utilize blender as a game development tool for external engines. To get an idea what blender should be used for, have a look at other game engine tools like the UDK or CryEngine toolset. The outcome of this project should be either a usable editor for a specific engine or a very good document on how to use blender like this, focusing on the actual implementation and showing samples for some imaginary non-existent game engine. Examples of features and important things to think about: adding a RenderSettings.engine (next to Blender Internal, Cycles and Blender Game) to select the game engine and change the UI elements to what is used for the engine; level editing tools, for example setting entities and their properties; necessary exporters for levels, game engine models, etc; baking of light-/shadowmaps and similar for the asset pipeline of the game engine; and many more! -neXyon

Audio

Contact: neXyon

Playback manager - A class/interface that can handle multiple sounds being played back with different categories assigned (e.g. voice, music, background noise, notifications, etc.) where each category can be controlled. Useful for the game engine for example to easily pause/stop all sounds and adjust volume levels of different categories.
Binaural audio: 3D audio with headphones, using HRTFs (head-related transfer functions)
Environmental audio: different sound modifications (filters, reverb, etc.) which are spatially dependant on sound source and listener position. For example a gunshot in a tiled bathroom sounds different than in a room with sound absorbing walls.
Dynamic music: a music playback interface which can change the music based on some user-defined flags. For example: a game has some random background music while the player runs around and then he starts fighting against a bunch of enemies and the music gets more exciting. This interface should then use predefined loopable music samples and transition nicely between them changing the mood of the background music according to the action that is currently going on.
Random sounds: repeating sounds all over again sounds boring and is easily noticed by the player (for example footsteps) so this functionality should add a list of sounds to the sound actuator instead of a single one, with the ability to choose sounds randomly or sequential when it is triggered.
Reverberation
Back- and front-ends (libogg, libvorbis, alsa, pulse, Windows and OSX backends)
Plugins (including plugin architecture)
Filters
Lipsync: see the not-implemented project idea

Python API

A project on the Python API would likely cover many smaller tasks. It may also involve completing small tasks which make use of API improvements (to be used as examples/test cases).

General improvements to the interactive console and text editor for use with Python.
General improvements for writing interactive tools in Python (perhaps custom manipulators).
Expose areas of Blender to Python which are currently not accessible, eg:
- Events - tablet pressure, ndof events.
- Some viewport settings (clipping, access to camera frame.
Add simple Python API for handling 2d and 3d bounding boxes (eg, mathutils.Box), which can be used to access axis aligned rectangles, cubes.
Add a way to cancel long running scripts with a keypress.

Important Links

Application Template

http://wiki.blender.org/index.php/Dev:Ref/GoogleSummerOfCode/2013/Application_Template