You can contact either the individual running GSoC for us this year (Tom M. aka LetterRip - LetterRip AT GMAIL DOT COM ) Or via our developers mailing list
Or via IRC
GSoC Project Ideas 2012
The following list provides some ideas for projects that
1) a student coder can complete in the time frame given (hopefully not too easy, and not too hard); and
2) either 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 .
Applicants are also welcome to choose a project of their own design that implements a feature they wish Blender had
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 or python, 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. Skilled C++ developers seem to make the transition to working with pure C fairly readily.
(don't add to this list unless you are a developer who could potentially mentor the project)
General Developer todo list
Based on feedback and bug reporting, the active team of developers maintains a large section in wiki with open issues in Blender. A great collection to browse for people to get ideas for projects we'd really need, including mention of orphaned sections in the code.
- Add or improve some of the following mesh tools using the new BMesh core, picking enough tasks to fill up the GSoC time
- Bevel selected edges, producing clean topology with variable number of divisions. The general case, where any number of edges can come into a vertex, at any angle, and any subset of edges is selected for beveling, is quite hard, so this one tool could take quite some time to design and implement.
- Booleans improved to take advantage of BMesh: have it produce Ngons instead of a complete triangulation of faces, and interpolate UVs etc properly.
- Bridge that intelligently figures out how to join two faces or closed loops.
- Pen for creating polygons.
- More snapping options during operations like move and extrude - this could include snapping to implied planes, intersection points, and directions from pre-existing faces, edges, and normals.
- Make a new tesselator (triangulator) to replace the old scanfill one. It should be as fast or faster than the current one, handle degeneracies, handle non-planer polygons, deal with the general case of polygons containing other polygons (representing holes), etc. A follow-on, if that doesn't take the whole GSoC time, would be to optionally post-process the triangulation to make "nice" triangles or quads or convex ngons, say, and use it as the basis for an improved Beautify tool.
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.)
- Implement mesh quilting, the wrapping of a 3D mesh pattern repeatedly over the surface of a model. This research paper presents an algorithm for "stitching" together duplicated 3D texture patches into one continuous mesh, while correcting for deformation introduced by the curvature extremes of the object being wrapped. Representing textures as independent 3D surfaces (as opposed to 2D pixmaps wrapped onto 3D objects) allows for greater levels of detail and a more straightforward animation process. Quilting functionality could potentially be used to model chain mail, weaving or bark; the patching algorithm could also be guided to produce strands of ivy, for instance.
- Improve the Retopology Tools. Retopology tools allow an artist to start with a 'messy mesh' perhaps from sculpting, or from a model that was created without thought about topology; or perhaps from scanned data - and create a new mesh over the top of the original mesh with the same form, but with a new structure that is better suited for animation and other purposes.
Ideas include for improving retopology tools include (pick one or more to provide enough things to occupy your entire time for gsoc)-
pen tool to quickly draw polygons without the need to fill faces manually.
Paint Stroke tool for adding faces based on intersecting strokes:
quad from nearest points - which creates a quad based on the four nearest vertices or vertex and edge combination to the cursor in screen space;
improve visualization so that with xray on the backfacing faces are culled; similarly backface culling for wireframe see videos for clarification of the problem - video1
stroke sweep tool - which creates a sweep (a rotation of a profile around a center point - i.e. a line rotated around a center point creates a cylinder) around a piece of geometry based on a pen stroke along the geometry.
- Sculpting layers - sculpting layers is an idea that is conceptually similar to layers in image painting programs, where layers can be hidden/revealed, overlayed and combined with eacy other, but instead of mixing image data it mixes geometric data.
- Resymmetrization - when sculpting often times you want a perfectly symmetrical mesh, but sometimes something happens that results in slight assymetry - resymmetrize would copy one side so that it exactly matches the other either from left to right or right to left.
- apply lower for multires modifier - make it so so that all levels below the current display level of a multires modifier can be applied to a mesh while maintaining the higher levels of the modifer as a modifier still.
- UV Unwrap Polishing - there are a large number of small tool and workflow improvements that could be made to the uv unwrapping tools.
Some ideas include (pick one or more to provide enough things to occupy your entire time for gsoc)
symmetrical seam marking - when a seam is marked for unwrapping on one side of a model the mirror seam could be marked on the mirror image of the model. Note that blender already has algorithms for finding topological and geometric symmetrical geometry so it should be fairly simple to hook up the algorithms to do this.
symmetrical layout/constraining of symmetrical geometry - often you wish to peform operations on generated UVs in a symmetric manner. This would port the topological/geometric mirroring algorithms from the mesh tools to the uv tools.
symmetrical selection in the UV editor basically the same as the above but for selection tools.
select vertex path for uvs this would be porting the select vertex path algorith from the mesh tools to the uv tools.
stacking of symmetrical geometry - often times geometry that is exactly the same we will want to use the same image/texture data to save memory however, aligning the uv islands so they exactly overlap can be tedious. This would allow automatic alignment of UV islands for mirrored/symmetrical geometry.0
improved stitching and ripping operations scaling along a custom axis often times a UV island you might want to scale it along dimensions other than the standard x/y directions. It would be desireable to be able to scale the UV island based on a direction defined by the mouse angle to the center of the UV island when scaling begins.
- Improve texture painting - there are a large variety of improvements that can be made to texture painting tools in terms of selection, masking, and brushes. For inspiration see mypaint, gimp, and krita.
- Skinning/Weight painting polishing - while the automatic skinning is amazing, the tools for tweaking and adjusting final weights are still clunky, and a number of small niceties are missing.
Some ideas are
- blend between two geometric selections - interpolate weights between the selection of two loops.
See additional videos for inspiration of other tools that might be useful such as ideas from
- Assorted weight paint tools/
- vgroup limiter (game engines need this, easy utility - many engines for example only allow 3-4 weights per vertex).
- good interactive gradient tool.
- tool for blending between 2 groups.
- cleanup tool, remove isolated weights, smooth sharp changes which can happen by accident when painting.
- option to use weights for Proportional editing? (just a thought)
- Improve blender for dealing with motion capture data (for example imported from BVH files).
Goals for this project could include...
- Rig Re-targeting one rigs animation onto another rig.
- Animation curve simplification
- Turn repetitive motion capture animations into loops.
The new Cycles rendering engine has a huge number of opportunities for GSoC projects. Generally speaking a student interested in working on our rendering engine will want to have experience with rendering algorithms and generally a strong math background. OpenCL and/or CUDA is a bonus but for most projects is not necessary. Pick enough tasks to fill up the GSoC time.
- Smooth anisotropic BSDF tangent (implemented, Patch awaiting in cycles mailing list)
- Color ramp node (DONE, rev 45173)
- Phong ramp BSDF
- Spot Lamp
- Per BSDF bump mapping
- Indirect light influence control
- BVH build multithreading
- Full Sample rendering
- Image cache for CPU
- Samples controls for AA/Glossy/Diffuse/Lamps
- SIMD for BVH/triangle intersection
- Multi/All light sampling
- Path splitting
- Performance test script
- Tile rendering to EXR
- Compositing Render Layer
- Displacement (incomplete)
- Hair Curves, Shaders, Scattering
- Lazy Loading / Cache
- Light Groups
- Motion Blur
- OpenCL device (incomplete)
- Open Shading Language scripting
- Subdivision (incomplete)
- Subsurface Scattering
- Vector Displacement
- Volume Rendering (some interesting tests)
- Point density texture
- Voxel data texture
- Pause rendering when 3d view gets hidden
- Preview rendering support
- Progressive Animation Rendering (details)
- Render pause button
- Node editor support for new active texture workflow
- Add basic color modifications for texture nodes
- Command line option to switch on/off GPU rendering
Video Editing and Compositing
- Compositing Improvements Improve a collection of nodes and tools that currently lack in quality like:
Blender has a number of systems for simulation. Fluid Dynamics, Hair Dynamics, Cloth, Softbodies, etc. And all of them could use better quality and faster speed :)
- Extend elbeem fluid sim with thin fluid features
See: http://www.youtube.com/watch?v=GyfB_vQHMAo and: http://www.youtube.com/watch?v=7Who8EpbvCY also see the papers by the author of Elbeem - note that this would likely require prior fluid dynamics experience to have a successful result. http://www.ntoken.com/pubs.html
- Nodify game logic - there is a proposal for a node interface for blenders game logic
- Improve Collada Import and Export - There are numerous improvements that could be made to our collada I/O especially in handling of animation data. (C/C++)
- FBX import - We don't have FBX import yet, export is working OK now. This would use the FBX text format which is undocumented but there is parser for it in the open source code for field http://www.openendedgroup.com/ and some information in documentation from autodesk http://images.autodesk.com/adsk/files/fbxassets.pdf (python)
- Get the ZLIB licensed Bullet .blend read/write library, bring it back to 100% Blender compliancy, and implement a basic (Mesh + UV + objects) import/export via a commercial SDK (for example maya, 3ds, zbrush). This library then can be offered on blender.org for researches, simulation coders, game engines, or studios for pipeline integration.
- Increase Viewport Performance and Eliminate OpenGL immediate mode - right now we use opengl 'Immediate Mode' stuff that is slow on modern hardware. (Suggestion: more compliancy to OpenGL ES for future tablet ports). While VBO's are supported in some drawing modes, there are enough places that still use deprecated drawing methods.
- Complete Vector Texture Support - The idea is to load SVG files as standard textures, rendered on demand to match the resolution needed by each textured pixel, and cached in a set of tiles. A basic proof of concept exists (as an old plugin at http://code.google.com/p/vectex/, its extended version that implements most of the SVG 1.1 standard - at http://airplanes3d.net/downloads-svgtex_e.xml, and also as some unreleased test patches against 2.5), however much work needs to be done for SVG drawings to function like standard images. The rendering itself can be done by an add-on library (AGG), but most of the work is to implement a good caching mechanism (which could use the tile cache recently added to Blender), a decent integration with the image filtering support already in place and maybe some enhancement to the SVG features supported. See discussion for more details.
Google Summer of Code, application page
Blender project page
A guide for new developers
Google Summer of Code FAQ's
An example of a successful proposal from 2005
Previous summer of code projects
http://wiki.blender.org/index.php/BlenderDev/SummerOfCode2005 http://wiki.blender.org/index.php/BlenderDev/SummerOfCode2006 http://wiki.blender.org/index.php/BlenderDev/SummerOfCode2007 http://wiki.blender.org/index.php/BlenderDev/SummerOfCode2008 http://wiki.blender.org/index.php/Dev:Ref/GoogleSummerOfCode/2009 http://wiki.blender.org/index.php/Dev:Ref/GoogleSummerOfCode/2010/Proposals http://wiki.blender.org/index.php/Dev:Ref/GoogleSummerOfCode/2011 http://wiki.blender.org/index.php/Dev:Ref/GoogleSummerOfCode/2013