Indigo Renderer Forum

Hey,

I've kinda gotten interested in programming 3d stuff, unfortunately i have no clue where to start. I have a good math background (i'm about a year away from taking a calculus class), and if there is stuff I dont understand my parents can help me. Does anyone have any links or anything that could get me started?

Thanks,
delta

i like QT ! since it work on windows/linux/osx without sourcecode change

also SDL may be choice

http://trolltech.com/developer/downloads/qt/index

QT provides a VERY good tutorial/ documentation! and many examples (also for opengl)
...

I would try python. take blender for example, it's written in Python and it runs on all OS

It's nice that people start throwing around with links to graphical libraries, user interface toolkits and other libraries, but you won't learn to program if you don't know how to actually use all the good stuff

Start simple, and if you're looking into 3d specifically, there are sites like www.gamedev.net , the now defunct www.flipcode.com (I loved that site, unfortunately it was killed by morons) and www.devmaster.net .

Most of those sites are primarily devoted to game development, but there's a lot of useful stuff for offline 3d in it as well. GameDev.net has a lot of cruft, but you'll be able to find topics about nearly anything related to programming and 3d on their boards.

ps. I really do miss flipCode (and I suspect a few others here do as well... ). RIP.

joegiampaoli wrote:I would try python. take blender for example, it's written in Python and it runs on all OS

False. It's written in C (user interface, internal renderer, etc), parts in C++ (fluid simulator and other external libs) and Python is just added on top of it

(edit, fix0red links)

If it was written in python, it would be years slower

And think about the amount of memory it would take

You can't compare scripting in Python to real programming anyway. There's no way you can feel like you're programming when you don't have to press F7 every few minutes

THANKS oggsnoepje!!! I found a 10 part tutorial on gamedev.net.

I know how to program all ready, i just didnt know how the hell prespective projection worked, and now i know, so when i get home from school today ill prob. write a simple program to read the OBJ format and display it.

Or maybe ill make it read the indigo format right away, cuz im planning to evolve this to an unbiased GPU powered renderer.

You're welcome but...

deltaepsylon wrote:Or maybe ill make it read the indigo format right away, cuz im planning to evolve this to an unbiased GPU powered renderer.

When I say: KD-Tree! What do you say then?

Just wondering if you're not going too fast There's a lot to learn for writing a renderer*
(I've tried a few months ago, but I had to give up because I couldn't find a nice strategy, the renders kept being noisy as hell)


*That's why I really appreciate the work being done by Ono as well. Writing a renderer is easy. Writing a good renderer is hard. Writing a physically correct renderer without too much noise in the resulting images is hell.

Hi deltaepsylon,

you should prepare for a long journey to master mlt on a GPU. That's more involved than just a simple perspective transform. So you will need to learn the basics from good books before you can learn the state of the art from recent papers. There are already people using GPUs for ray tracing but it isn't that simple than hacking some cheap code in CUDA-C or CTM-Asm...

Here some books I know and that I would recomend:

Physically based rendering, M.Pharr/G.Humphries
Fundamentals of Comp.Graphics, P.Shirley
The computer Image or '3D Graphics' by Alan Watt
Geometric Tools for CG, Eberly/Schneider
Realtime Rendering, E.Haines/T.Akenine-Möller
Production Rendering, Stephenson, Pantaleoni, et al.
Realistic Ray Tracing, P. Shirley

More about GI:
Advanced Global Illumination, Bala/Dutre/Bekaert
Realistic Image Synthesis using Photon Mapping, H.W.Jensen

Some older stuff, but still good:

CG - Principles and Practice, Van Dam, Foley, et al.
Adv. Animation & Rendering Techniques, A.Watt/M.Watt
Texturing and Modeling - A Procedural Approach,
Ebert, Perlin, Musgrave, Worley, Peachy
Introduction to Raytracing, Glassner et al.
Principles of digit. Image Synthesis, Glassner


You don't need all of them or even read all of one, but it is handy
to have them and don't have to guess and re-ivent the wheel....

Then you may read the recent papers and some older PhD thesis,
that are nearly all on the net. Look what people like
Peter Shirley (Utah), the Stanford people (Hanrahan, Levoy), the
Cornell (Greenberg/Bala) are doing and don't miss the german
RTRT gurus: Ingo Wald, Alexander Keller, Phillip Slussalek....

Than there are some interesting discussions at omph.org

a lot of interesting open source ray tracers to study and learn from: Sunflow, yaCort, Lucille maybe Radium in some weeks....

So this is my advice where you can get started. It's nearly all in the books. The newest stuff with QMC, CPU/GPU-RTRT, FPGAs is more in the papers and PhDs....

Hope this helps. I'm waiting for real time MLT on cheap GPUs

With best regards
Knax

BTW to Ono: sorry about BIH, I didn't know at that time I adviced it to you, that there was a patent pending...
But I think Wächter/Keller and Mental Images won't do anything, as long as it's no commercial implementation...

well it depends what your interested in. if you want to program a modeler, then you need lots of knowledge on topology and linear algebra, and a very strong algorithm sense. if you want to program a renderer, you realy dont need to understand topology that well, but linear algebra helps alot and knowing how to do algorithms is fairly necessary. if you want to program a renderer you should also brush up on physics and learn at least a little calculus.

either way you should probably do an intro to working with linear algebra. i recomend MIT opencoursware into to linear algebra which you can download on itunes. it also helps alot if you have a text book for it. you should also learn how to work with vectors and rays.

as for starting your programing, the four essential classes that anything in 3d should have are the point3d, vector3d, ray3d, and orthonormal classes.

the point3d should be able to go back and forth from a vector but not have the same functionality as a vector. it should also be able to be multiplied by matricies.

the vector3d class should have all the functionality that a vector can have, including but not limited to, dot product, cross product, addition, subtraction, negation, normalization, length, and matrix multiplication.

the ray class should contain a vector and a point and you should be able to get the length of the ray, scale the ray and get a point at t along the ray.



before writing an unbiased renderer, i recommend you make an attempt at writing a biased renderer that can render with simple lights, and simple shadows and maybe simple reflections/refractions.

Knaxknarke: Thanks for the books & etc, at the library where my dad works all but one of these books are readily available
I know that an unbiased renderer is more than a matrix transform, but i gotta start somewhere and im not the kind of person to make vaporware or come up with fantastic ideas without ever implementing them. I hope i might be done by Feb. 2008, specially cuz now starting in school i'll be doing guided research 3d graphics class.

Hi, there was a mistake in my last post:

it's the ompf.org forum.

There is a section about "must reads" papers and PhDs:

http://ompf.org/forum/viewtopic.php?t=9

The TU Wien guys are great, but not so involved in GPU raytracing.

The most recent papers about GPU raytracing:

Stanford guy with Brooks+ HLSL+ DX9+ ATI/CTM (with oss code)
http://graphics.stanford.edu/papers/i3dkdtree/

Saarbruecken guys with G80/CUDA:
http://graphics.cs.uni-sb.de/Publications/#Papers2007



There is an older oss GPU raytracer on NV40/GLSL:
gpurt.sourceforge.net/DA07_0405_Ray_Tra ... -1.0.5.pdf

And this is about acceleration structures for GPU ray tracing:
http://www.larsole.com/files/GPU_BVHthesis.pdf

im not the kind of person to make vaporware or come up with fantastic ideas without ever implementing them. I hope i might be done by Feb. 2008

How about starting with an open source pathtracing + MLT renderer on the CPU ? GPUs are powerful if you need lot's of ALU-FLOPS per LD/ST.
They are great with coherent/coalesced LD/ST. But they have no useful caching for more complex memory traversal. So instead of the advertised 80GB/s on G80 you get 6-10 GB/s and you have no useful L1/L2.

The SIMD style of the onchip multiprocessors don't make it easier to ray trace. Then there is register pressure, no useful stack, etc....

If you get a really useful and fast GI ray tracer going on the G80 until 2/2008, I will call you a genius!

Start reading, thinking, coding! And good luck.[/url][/b]

there already is a fast GPU GI raytracer, called parthenon, google it I got around 7000 mutations in 10 minutes on cornell box.

BTW man, thanks for those links, REALLY helpful!