Google Summer of Code 2008

From K-3D

Jump to: navigation, search

Overview

K-3D has been accepted as a mentoring organization for the Google Summer of Code 2008, a program providing $4500 summer stipends to students contributing to Free and Open Source Software.

You can see the Google Summer of Code 2007 Report for the results of K-3D's participation in 2007.

Students

If you're a student interested in contributing to K-3D:

Currently, we are accepting project ideas for Summer of Code 2008. Note that students are free to develop their own ideas for submission, the following projects are just suggestions - we're open to your own original ideas, and your odds of success are better if you propose solving a problem you're passionate about. Please don't flood the mentors and administrators with applications. Decide on one project for which you think you can do a great job, and concentrate on writing one great proposal, with lots of detail about what you plan to accomplish and by when.

Writing Proposals that will be Accepted

Small Deliverables: Based on last year's experience, we will be pushing hard for projects that generate multiple plugin components as their deliverables. We want to maximize your chances of success by encouraging you to make multiple small deliveries over the course of the project, instead of one large "all-or-nothing" delivery at the end. That way, even if your project goals aren't entirely completed, K-3D will still benefit from usable code.

Pipeline Architecture: You need to read-and-understand the material in Visualization Pipeline very carefully, and incorporate it into your proposal. The discipline of decomposing your project into many small pipeline components will be beneficial to you for project planning, and will make the project more enjoyable, allowing you to celebrate many small successes as you progress.

As an example, we would likely reject a proposal to create an all-in-one FractalBrownianMotionLandscape plugin. Instead, we want to see a project that breaks this task down into many individual plugins, e.g: a TriangleGridMeshSource to create the landscape geometry, a FractalBrownianMotion plugin that assigns a vector field to the points in a mesh, a DisplaceField plugin that displaces mesh points based on a vector field, a ColorRamp plugin that assigns per-vertex colors based on a linear transformation, etc.

Use the Wiki: Anyone is welcome to use this wiki to work on their proposal. Sign yourself up for a wiki account, post a proposal on your user page along with supporting references, then ping the list for feedback. We're happy to help, but you have to take the first step.

What we want from a proposal: More than anything, we want to see a concrete list of small, specific, simple plugin deliverables in your proposal. I can't emphasize this strongly enough: you have to show us that you understand how your project fits-in with the rest of the pipeline architecture, and you have to commit to specifics.

Test-driven development: You will have to provide regression tests for your plugins, and they will have to pass on the three architectures that K-3D supports: Linux, OSX, and Win32. You can develop on whichever architecture suits you, our nightly dashboard will provide feedback on how things are working on the other two. For one example, see http://www.k-3d.org/cdash/index.php?project=K-3D&date=20080323

Hit the ground running: Plan on committing your first plugin & tests within a week-or-less of program start. If that seems like an impossible task, you either haven't decomposed your problem into sufficiently simple components, or you've bitten-off more than you can chew: consider revising the scope of your project or working on something else. If you really want to impress us, include a plugin that builds with your proposal.

References:

Project Starter Ideas

File Import / Export Plugins

Mentor: Timothy M. Shead, tshead@k-3d.com

Problem: The K-3D pipeline lends itself well to a variety of data import & export capabilities, but there are few current examples.

Goal: Create a set of data import & export plugins for K-3D.

Deliverables: A successful project will utilize K-3D's plugin architecture to deliver a set of import and export plugins. The specific set of plugins will be negotiated with your mentor, but you should expect to deliver 20-30 different plugins, providing coverage for reading and writing several popular file formats. Deliverables will include links to the references used to implement each format, plus sample files and working regression tests.

Requirements: Good C++ experience.

References:

See Import and Export and Managing External Files for important background on working with external files in K-3D.

NURBS Modeling Tools

Mentor: Bart Janssens, bart.janssens@lid.kviv.be

Problem: K-3D currently includes a complete set of data structures for representing trimmed NURBS patches and NURBS curves, but includes few tools for creating or editing NURBS.

Goal: Create a set of basic NURBS modeling tools for K-3D.

Deliverables: While the list of NURBS modeling tools is open-ended, the successful project will utilize K-3D's plugin architecture to deliver a set of NURBS tools (the set will be negotiated with your mentor). Possible plugins would include: Attach, Detach, Concatenate, Cut, Trim, Project, Union, Subtract, Difference, Intersect, Sculpt, Revolve, Loft, InsertKnot, Extrude, Bevel, Birail, Fillet, Cap, Boundary, Arc, etc.

Requirements: Good C++ experience, knowledge of spline math, familiarity with 3D modeling tools is a plus.

References:

Game Engine Integration

Mentor: Bart Janssens, bart.janssens@lid.kviv.be

Problem: Many open-source game / render engines lack robust content-creation support.

Goal: Provide content-creation support for an existing open-source game engine using K-3D. K-3D's modular structure lends itself perfectly to integration with an external realtime rendering engine, such as CrystalSpace or OGRE 3D.

Deliverables: Use K-3D's plugin system to provide integration with a game engine. Example plugins would include:

  • A viewport displaying its contents using the external engine.
  • Painters rendering different kinds of K-3D geometry in the new viewport.
  • Elements specific to the engine used, i.e. light sources, particle sources, materials, etc.
  • Conversion between game-engine file formats and K-3D data structures.

Requirements: Good C++ experience recommended. Experience with the engine being integrated is a plus.

References:

Multi-Core / Parallel Processing

Mentor: Timothy M. Shead, tshead@k-3d.com

Problem: As physical limits make it increasingly difficult to improve CPU speeds, hardware manufacturers are turning to "multi-processor" machines and "multi-core" processors to meet demands for greater computing power. The change from traditional single-CPU, single-core systems to ubiquitous multi-core, multi-processing machines requires significant changes in the way software is written. Some initial parallel experiments have been performed in K-3D, but much work remains.

Goal: K-3D's pipeline architecture is uniquely suited to parallel programming. Exploit multi-core, multi-processing hardware using K-3D's pipeline architecture, and develop empirical data on which techniques are best under different circumstances.

Deliverables: A successful project will deliver a set of plugins that perform computation in parallel on multi-core / multi-processor architectures, plus corresponding capabilities for instrumentation and testing. Your mentor will work with you to develop a set of plugins to be created / converted. The list will include computations of varying complexity from "embarassingly-parallel" on.

Requirements: Access to multi-core/multi-processor for development is required. Strong C++ experience recommended. Knowledge of parallel programming techniques is a plus.

References:

GPU-Based Processing

Mentor: Timothy M. Shead, tshead@k-3d.com

Problem: Many modern graphics cards include powerful programmable pipeline functionality. Because K-3D is used mainly for offline rendering using dedicated render engines such as RenderMan, much of this GPU functionality goes to waste. Even when using the GPU's programmable functionality for online rendering, rendering normally cannot begin until K-3D's pipeline processing is complete.

Goal: Explore using GPU processing in the implementation of K-3D filters.

Deliverables: A successful project will deliver multiple K-3D plugins that use the GPU to perform offline processing. You will work with your mentor to develop the list of plugins, which will explore a variety of techniques, from using the GPU to perform efficient image processing (easy) to using the GPU for geometric computations (difficult).

Requirements: Access to high-end GPU hardware is required. Strong C++ programming skills are recommended. Familiarity with writing GPU programs is a plus. Use of GLSL is preferred for portability, but not required.

References:

  • http://www.gpgpu.org/ - General-purpose computation on GPUs website.
  • http://libsh.org/ - A high-level, open-source library for programming GPUs in C++.
  • "Metaprogramming GPUs with Sh"
  • "GPU Gems"
  • "GPU Gems 2"
  • "OpenGL Shading Language".

Pipeline Visualization

Mentor: Timothy M. Shead, tshead@k-3d.com

Problem: K-3D is designed around a flexible Visualization Pipeline architecture, where data sources, filters, and sinks are interconnected by users to create a document. Currently, there is only rudimentary support for providing users with a graphical view of a subset of the pipeline.

Goal: Expand the current pipeline visualization support. Any solution will have to scale both in the number of nodes, properties, and connections, as well as providing users with a useful (not overwhelming) display of their document. We leave the nature of the display deliberately vague, to encourage out-of-the-box thinking. See Visualization Pipeline Display for ideas.

Requirements: A successful project will require good C++ programming skills and familiarity with graphical user interface programming. Experience with / interest in infoviz topics such as graph layout and visualization will be of great help.

References:

Verse Protocol Implementation

Mentor: Joaquin Duo, joaduo@gmail.com (more ideas from this mentor)

Problem: Interacting quickly with other graphics applications.

Goal: As a first goal, implementing a client for the verse protocol supporting basic meshes. Later more complicated objects and features. (bitmaps from gimp for example)

Deliverables: Once implemented the protocol Blender could be used as an importer/exporter for various 3D data formats. Automating this task would be helpful.

Requirements: Good C++/C experience recommended. Knowledge of 3D data types, 2D textures and 3D textures projections. Familiarity with verse is a plus.

References:

Physics engine integration

Mentor: Bart Janssens, bart.janssens@lid.kviv.be

Problem: K-3D currently does not provide any tools to automate animation involving the dynamics of rigid bodies.

Goal: Integrate an existig physics engine, such as ODE

Deliverables: A set of plugins to interface with the chosen dynamics engine, to allow the animator to set forces such as gravity and to simulate collisions between K-3D meshes. Other possibilities include joints and constraints. The exact set of plugins can be negotiated with the mentor.

Requirements: Good C++ experience, knowledge of mechanics and/or the engine to be integrated is a plus.

References:

Retrieved from "http://wiki.k-3d.org/Google_Summer_of_Code_2008"