I'm looking to work with OpenGl and C++ to generate a procedural real-time metaball animation.
Can anyone suggest a good resource/tutorial for generating metaballs, and/or implementing the marching cube algorithm.
I've spent a fair amount of time googling but having never done anything more complicated than basic GLSL shaders/basic procedural terrain generation/simple particle generation with OpenGL, I'm finding it hard to sort the wheat from the chaff.
Thanks for any help!
The NVIDIA CG Isosurface demo might help you out. It includes a metaball implementation.
Related
I'm currently reading the "official" opengl guide book and their explanations and example codes are way too complex for me. I think I got the idea of procedural texturing, but I can't find any fine tutorial about them. Does anyone know a good guide on that subject? Or maybe explain it a little bit?
This book is the best on the subject:
Texturing and Modeling: A Procedural Approach
It is not API specific so you won't find any OpenGL examples but it does go in depth about techniques for procedural texturing.
Another great resource for examples of procedural graphics is this:
Shadertoy
(note that it works best with Google Chrome)
It is a fantastic collection of WebGL fragment shaders (WebGL is based on OpenGL).
DirectX 11 supports tessellation. What is the real purpose of this feature?
And how to determine whether it's working or not on applications built with DX11 or OpenGL?
There are many fields where tessellation could be applied.
for example, Level of detail on a face, this could make you have 2-3 milion triangles without any super load on the gpu when you are up close to the face. that way you achive über graphics.
another way of using it could be the terrain, DICE uses it on their terrain system to enhance the overall look of the terrain to get it more relaistic.
http://publications.dice.se/publications.asp?show_category=yes&which_category=Rendering
So basicly it´s one of the dx11 best feautres, giving you realy realy good controll of adding extra polygons to meshes. (Higher detail, more good looking graphics)
Suppose there is a lot of vector shapes (Bezier curves which determine the boundary of a shape). For example a page full of tiny letters.
What is the fastest way to create a bitmap out of it?
I once saw a demo several years ago (can't find it now) where some guys used GPU to rasterize the vector art - they were able to zoom in/out of the page in real-time. What is the current state of GPU rendering of Bezier shapes? Is it really fast? Faster than CPU? What are the common and not-so-common algorithms? Is there any open source library for such things? What language does it use? What about OpenGL?
NVIDIA has now an extension for OpenGL that can do this stuff. I guess it's based on the Microsoft RAVG paper.
http://developer.nvidia.com/nv-path-rendering
Perhaps you mean one of these papers:
Random-access rendering of general vector graphics (2008) (PDF)
Resolution independent curve rendering using programmable graphics hardware (2005) (PDF)
I think these are pretty much the state of the art.
I once saw a demo several years ago (can't find it now) where some guys used GPU to rasterize the vector art - they were able to zoom in/out of the page in real-time.
Could it have been this one?
http://alice.loria.fr/index.php/publications.html?Paper=VTM#2005
What is the current state of GPU rendering of Bezier shapes?
About the same like some years ago. Tesselation shaders do help, but when it comes down to rasterizing curves without a intermediary tesselation stage, it's grunt work in the fragment shader.
I'm wondering if anyone could point me to any resources that would deal in rotating one or several 2D textured planes in 3D space. Something like this but with openGL (preferably C++):
I'm attempting to do pretty much the exact same thing but no matter how I order my operations I'm getting right-screwy results. So I figure asking for some resources on the subject is better than posting tons of code and asking for people to fix my problems for me. :)
If you havent already, do a search for 'NeHe tutorials'. An excellent set of OpenGL tutorials.
Here is a link to the rotation tutorial, includes all the source code in downloadable format and the tutorial walks you through each relevant line.
http://nehe.gamedev.net/tutorial/rotation/14001/
I believe this is working in a 2D space, the step up to 3D probably involves a bit more matrix math but...doable
The NeHe tutorials are a very popular place to learn the basics of OpenGL. In particular, the tutorial about texture mapping should help you:
http://nehe.gamedev.net/tutorial/texture_mapping/12038/
Mind you though that these tutorials are written for older OpenGL versions which are more beginner friendly IMHO.
You should look into scene graphs. Basically it is a way to define a bunch of objects (2D textured planes) and their transforms in 3D space. This allows you to define transforms that work on multiple nodes (objects) as well as single nodes. You can make a pretty simple one in C++ with little effort, or use one such as OpenSG or OSG (slight learning curve needed).
Wikipedia - http://en.wikipedia.org/wiki/Scene_graph
I've been reading a lot about deferred shading and want to try and get into it. Problem is I can't find a sample which demonstrates how deferred shading can support so many lights simultaneously - I found one demo which was very simple with a single light in Code Sampler and an nVidia HDR sample butnothing beyond that.
Would anyone know where I should go for a good introductory tutorial (with code) on how to have deffered shading with lighting? I can make it work with one light but one light is a bit too simple (rather obviously :P). Also I only know how to make directional lights in deferred shading code and it's nice an dall but somewhat different to regular ways of rendering lights so I was wondering if there wree tutorials or anything I could find or just reading material that would help me figure out how writing shaders and special fx in deferred rendering works?
Thanks fo rany help!
NVIDIA stuff is usually good: http://developer.nvidia.com/object/6800_leagues_deferred_shading.html
Here's a reasonable XNA tutorial as well: http://www.ziggyware.com/readarticle.php?article_id=155
In terms of blogs: Wolfgang Engel's is a good start, and Christer Ericson recently posted a bunch of links (in the Graphics section of his "Catching Up Part 2" post).
Oh, and the G-Buffer paper is required reading too. Less practical, but a good review of the process and rationale.