OpenGL 3.0+ (min) in C or C++ Runnable on Linux OS

Solar System

(15 marks – 15% of module overall)

GLM toolkit

The GLM toolkit has many useful functions: (you are welcome/encouraged to use this if you want)
http://glm.g-truc.net/code.html (see http://glm.g-truc.net/api-0.9.0/a00162.html for an example)

Sphere and texture links:

As you’ll have noticed (probably), new-style OpenGL doesn’t have a sphere as easily as previously. There are many ways to achieve a sphere, with many links on the web. We are happy with any method that you like – including procedural generation and loading a pre-generated mesh for a sphere.

For generating your own, there are MANY guides on the web. A few (very quick) are:

http://stackoverflow.com/questions/6072308/problem-drawing-a-sphere-in-opengl-es
http://iphonedevelopment.blogspot.com/2009/05/procedural-spheres-in-opengl-es.html
For loading meshes, I would recommend (for this CW, not generally) the OBJ file format.

definition:
http://en.wikipedia.org/wiki/Wavefront_.obj_file

some objloaders:

http://studentpages.scad.edu/~mparro21/cg/objLoad.html
http://www.kixor.net/dev/objloader/
code fragment – http://en.wikibooks.org/wiki/OpenGL_Programming/Modern_OpenGL_Tutorial_Load_OBJ


example obj files that may help:

http://liszt.stanford.edu/meshes/sphere.obj – contains vertices and faces
sphere model (obj) with texture coordinates – from http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Number=309345
some examples sphere (earth) textures

GlTutorials 15 – Many Images

Dates:

Submission to NESS – April 23rd 2012, 4pm
Demo in CSC3204 Monday practical slot – April 23rd 2012, 4pm-6pm - email at least 4 days in advance if you cannot make this time slot.
Specification

Write an OpenGL 3.0 (or higher) compliant program, using only the core profile, that shows various dynamic views of a solar system..

There should be various shader-based perspective-view camera positions/modes for your program:

a overview (can be static) of the whole solar system (which sits [roughly] in a plane) from above/below. (no marks, non implementing will incur penalty marks)
a pre-set fly-through smoothly following a path (sequence of points and view directions) defined in a text file (format of your choice – explain in a very brief document). (1 mark, non implementing will incur penalty marks)
a chase camera providing an over-the-shoulder view of a planet as it moves, with key bindings to move between planets. (1 mark, non implementing will incur penalty marks)
There should also be a mode (activated on key-press) that adds an interesting shader-based effect to your solar system – either vertex or frag shader, or both. You *don’t* need to write this shader – you are, in fact, recommended to find one from the Internet. (2 mark, non implementing will incur penalty marks)

Requirements on your program include:

At least 6 planets and a sun (1 mark)
All planets should rotate around both themselves, and the sun, at differing speeds (1 mark)
At least 1 planet with 1 or more moons that orbit it (1 mark)
At least 1 planet with 1 or more rings (not the moon’ed planet) (1mark)
Planets should have textures (1 mark, non implementing will incur penalty marks)
Planets should have some kind of lighting (shader-based) (1 mark, non implementing will incur penalty marks)
Use C or C++ (REQUIRED for no marks, non implementing will incur penalty marks)
Use at least OpenGL 3.0, and only use the core profile (not the compatibility profile) (REQUIRED for no marks, non implementing will incur penalty marks)
Use a utility toolkit to help with windowing and input. e.g. freeGLUT, GLFW (no marks)
Note: planets do not *need* to follow elliptical paths (but marks in extras)
Implementing all the above without any issues will achieve 10 out of 15 – note that the mark scheme is *not* distributed evenly over the above requirements.

The remaining 5 marks are available for advanced features, particularly shader-based features. This could include features than interact or enhance the “interesting” shader from the requirements. Marks will be awarded for overall demonstration of graphics techniques – you could focus on just one (challenging) feature, or on many. Some examples include:

All camera movement should be smooth – i.e. no big jumps from one position/angle to another.
per-pixel lighting
Appropriate values for size and speed of planets
Managing planets being visually very small when far away.
Minimal CPU usage (i.e. effort off-loaded to GPU)
Very high polygon count – dynamic level of detail extra bonus
Very high framerate
Elliptical paths
Cubemap/Spheremap
Dynamic level of detail for planets
No simulation other than time on the CPU => BIG bonus
Others as you like, confirm with SL or JS