hello blender users here are the ideas list my favorite so far is UI AND WORKFLOW yiaaaahuuuu
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.)
Boolean modifier could be improved in several ways:
Currently N-Gons are triangulating before sending to Carve library. But this library supports planar N-Gons and supporting them in BSP would really be nice thing.
Improve behavior in cases if non-closed manifolds, co-planar intersecting faces, double geometry and so.
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 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.
Blender’s 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.
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.
Current algorithm used for feature detection is also pretty basic. Could be improved and made more robust for outliers.
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.
Point clouds reconstruction and orientation, using unordered sequence of photos.
Multicamera reconstruction, in terms several cameras are shooting the same scene.
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.
Temperature to RGB color node
Ambient occlusion color node
For specifying custom AO normal and using it as shader color
Point/vector space transformation node (world <=> object <=> camera)
These matrices are available, just need node implementation
Diffuse and Phong ramp BSDF
Gabor noise node
Can generate many interesting patterns, might need good UI for parameters
Better anisotropic BSDF (ashikhmin, D-BRDF?)
Per-object ray offset bias, to deal with terminator problem
Split/Combine XYZ node
Currently is done with RGB, seems a bit hacky
Add native shader combining glossy, diffuse, transparent
The one described in this presentation looks good
Per object multiplier for motion blur shutter time
Option to clamp BSDF reflectivity by e.g. 0.8 (for faster convergence/correctness)
Transparency and refraction might need exceptions?
Use render visibility when selecting render layer preview in viewport
Needs depsgraph fixes
Add Ray Depth to control the number of bounces from a shader
Add Ray Roughness to manually control roughness filtering tricks
Fresnel node should get a Normal input.
Add back worley weights to voronoi node.
Access to object color and other object properties from nodes (support RNA paths?).
Option to include environment lighting in shadow pass.
Node link menu in properties editor has become too big, needs to get submenus
Properties editor UI should be improved, perhaps:
Add outliner like alternating lines
Some better indication of hierarchy that doesn’t take up much horizontal space
Better auto position when adding nodes (with multiple inputs nodes overlap)
Auto sync BSDF color and viewport color
Needs some algorithm to deal with mix shader hierarchies, to find the good diffuse node
Decouple lamp size for hemi/sun lamp and point/spot/area, the units for the former are wrong
Show watts, watts/m^2 units in the UI
Hide color component for node sockets in the UI
Indirect light influence control
Image cache for CPU (OpenImageIO)
SIMD for BVH/triangle intersection
Performance test script
Multiresolution shading cache
Per lamp option for number of samples (progressive integrator)
Fix mixed displace/bump
Fix displace viewport update
Object space displacement
Global strength value
Lazy Loading / Cache
Deformation Motion Blur
BVH build and trace support
Fluid simulation motion vectors
Volume Rendering (some interesting tests)
Point density texture
Voxel data texture
Pause rendering when 3d view gets hidden
Progressive Animation Rendering (details)
Render pause button
Node editor support for new active texture workflow
Command line option to switch on/off GPU rendering
Keep scene in memory and sync between F12 render (avoid image/mesh/… reloading)
Video Editing and Compositing
Compositing Improvements Improve a collection of nodes and tools that currently lack in quality like:
Dilate/Erode node: Quickly turns smooth edges into blocky edges
Vector Blur: See improvements proposed here http://www.sparkde.com/blog/?p=600 and here http://www.sparkde.com/blog/?p=660
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
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:
Discrete Level of Detail
While this has been worked on in the past, Blender trunk currently has no builtin level of detail (LoD) control. A discrete LoD system is one that has preset levels (with pre-made meshes) and swaps out the meshes at some specified level. Adding in mechanisms to smooth out popping issues would also be nice. -Moguri
Getting Blender’s procedural textures working in the BGE could be useful for getting some quick textures on objects. The main hiccup with this is the texture generation code is in the render code, but it could probably be moved to its own library (possibly bf_render_textures), which means the Blenderplayer could link against it. This would also fix bug #31965. This would probably be trivial to get working in the viewport once the textures work in the BGE, which would provide better viewport previews. -Moguri
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
Alembic fileformat support. This goes beyond simple IO though, it needs design work on how to handle multiple animation systems or simulation caches together.