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).
Related
Hey i've started learning WebGl and soon discovered that the language was a tad too difficult to understand. So i've looked for a GLSL tutorial to first grasp the basics of this language before passing on to WebGL . I found this course online that explains GLSL 1.10 which is not by far the latest version(which i think is GLSL 4). So i wanted to ask if there is any difference between tthis version and the latest and will it matter which one i learn?
GLSL is the Shading language, not the API used for the rendering itself (which is equivalent to OpenGLES2.0 in the case of WebGL). If the goal is to work on WebGL, I would recommend going from OpenGLES2.0 (the WebGL specification itself is written as a delta document over OpenGLES2.0), then GLSL corresponding to WebGL. This would also help understanding the more advanced desktop OpenGL versions.
The WebGL (and the corresponding GLSL) specification is at,
https://www.khronos.org/registry/webgl/specs/1.0/
I will only give you here a personal opinion, based on a personal experience.
You can ( note that I wasn't far from saying "should" ) start by GLSL 1.10, because since then a lot have changed : the developper has to manage on its own things that he hadn't to do before, in terms of transformations for example.
Those things are really important to understand, but if you want to start slowly you may want to avoid them at first. It's a bit like the end of the matrix stack in your OpenGL codes, you have to face it one day, but maybe not the day you begin using OpenGL.
I was wondering around google and found nothing good for 3D effects such as bump map, parallax mapping, etc. Please help me with this, is there a book which describes different ways to achieve such effects? furthermore if the book has opengl samples for the algorithms it would be much better.
I've enjoyed Real-Time Rendering. When I wrote my 3D engine everything I needed to know was contained in that book.
http://www.realtimerendering.com/book.html
The GPU Gems series of books comes to mind. Also available online at the NVidia developer webside.
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.
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.
I currently rewrite an old Visual Basic application in java, a large part of the work involves replacing Direct3d with jogl.
Since I have no experience in dealing with Direct3d and only minimal experience using Opengl, I am stuck on finding appropriate replacements for the api calls.
Are there any good guides/tutorials or references?
Edit:
Additional information:
Direct3D version 8
I'd also recommend going through the OpenGL Red Book and investing some time in typing in some samples and playing with them. OpenGL Red Book deals with using GL in C, so I recommend you go through it in C or C++ before going to JOGL.
You don't have to play with everything, but making a few examples work in C++ would be great before you go on.
Otherwise, if you don't have the time or interest or will to study GL, just follow NeHe tutorials as mentioned in other answer, but take a peek every now and then into the Red Book for additional explanations.
The NeHe tutorials are a pretty good intro. They start here. Having Direct3D experience, you'll probably buzz through some of them pretty quickly.
I suppose you could try and browse through the code of this D3D -> OpenGL wrapper library:
http://sourceforge.net/projects/dxglwrap (using it as a reference I mean)
You can browse through it here: http://dxglwrap.cvs.sourceforge.net/dxglwrap/
NeHe tutorials will get you up to speed quickly. If you have time and need for something more comprehensive, you should get the OpenGL SuperBible.