Havent looked at the code yet, but looks nice! Much like what I want to implement. Thanks a lot.

In response to Looking for help

In response to Looking for help

Havent looked at the code yet, but looks nice! Much like what I want to implement. Thanks a lot.

In response to I love asm...

@davepermen

i’m just starting to let asm get a revieval (spelling?) for my engine, all gets written now in sse simd.. hehe:D its fun

:)

In response to I love asm...

In response to Best method for passing multi dimentional arrays

i never use multidimensional arrays.. i always access them manually as such..

good thing: if you don’t care about width/height/depth of them, you can simply iterate linearly through them, performing your task.. best to optimize later.. :D

In response to Best method for passing multi dimentional arrays

In response to Best method for passing multi dimentional arrays

In response to I love asm...

In response to I love asm...

In response to Looking for help

Here’s something I have lying around. I made it on Linux, hence the funny end of lines and the makefile. But, it’s SDL + OpenGL so you should be able to compile it ok.

It opens up hut.3DS and displays it in iso (although I’m not using orthgonic projection, as I hate not having some perseptive), it’s iso angle anyway :)

Download my zip here:

http://www.koyote.dk/other_files/iso_max.zip

This isn’t the best code, it’s just my first attempt, but it works and is quite well contained to separate files. I have one recursive function that does all the parsing, but I only grab the face and vertex data, nothing else! But the following links show you how to grab the rest.

I’ll be changing hosts soon, so download it :)

Here’s sources of info so you can learn these things:

http://www.xbdev.net/3dformats/3ds/3ds.php - very good

http://www.the-labs.com/Blender/3DS-details.html - basic format

http://gametutorials.com/Tutorials/OpenGL/…/OpenGL_Pg4.htm - Many brilliant loaders source code

http://www.cevis.uni-bremen.de/\~uwe/opengl…gl/glOrtho.html - ISO ala orthogranic projection

So, enjoy and learn :)

In response to I love asm...

In response to very simple question

In response to Lines

In response to Lines

In response to Lines

I found the following page useful:

http://mathworld.wolfram.com/Line-LineInte…tersection.html

Let me know if that helps :)

In response to Normals

imagine it like this :

you find per-polygon normals for each polygon in your model. obviously this will result in surfaces that will look very flat when lit as apex said. the easiest way around this is to average the normals of faces that share a vertex. you then assign this new averaged normal to the shared vertex and thus get a different normal for each vertex instead of one for each face.

result == smoother shading.

In response to Normals

per vertex normals are teh w1n!!!!

Render a sphere with per face normals, then

Render a sphere with per vertex normals

the difference is amazing.

That reminds me how many of the neighbour face value normals should I use to calculate the per vertex value?

In response to Ray/Cube Intersection

Hi, thanks :) I’m currently trying to learn a good bit of colision detection math, so I thought I may as well reguritate it in a way I would have liked it. Once I get some demos done using this stuff, I’ll make a short (or maybe not so by then) article on collision, and post it on this nice central resource.

Anyway, I’m off to think how reaction forces will fit into my scheme of things.

In response to Ray/Cube Intersection

Hey Ed Mack!

Very nice detailed post. I’m sure that was very helpful for cdgray. That could be made into a small article, btw.

In response to Ray/Cube Intersection

In response to Ray/Cube Intersection

Basically, it goes like this (I’m bound to make a mistake):

Take the 8 vertexes that make up the cube’s corners. We will work in quads for the working of it out.

The first task is to work out all 6 face normals, and store them in an array somewhere. To work out the normal you must use the cross product of two of the vectors parralel to the face. From that normal you can use the plane equation to make sure that the end point of the ray is outside (result > 0) all of the planes.

Ok, some math:

The four vertexes (x, y, z) that make up a face ABCD are used to make
two vectors.

To get these two vectors, it’s a simple matter of B-A and C-A (that
means B.x - A.x, B.y - A.y ect..)

We have our two parallel vectors, A and B I’ll call them for clarity

Now, take these two vectors and work out the normal (the order of this whole thing is important, which means I probably got it the wrong way around :) If so, the normal points inside instead, not life threatening) using the cross product as follows:

c.x = a.y*b.z - a.z*b.y;

c.y = a.z*b.x - a.x*b.z;

c.z = a.x*b.y - a.y*b.x;

C is our normal. This can be used for lighting and so on. All these values can be stored if you’re keeping the plane the same.

The next thing is to find out the plane’s distance from the origin, which we will put back into the plane equation later on.

The plane equation is

result = Ax + By + Cz + D

Now I’ll explain the bits of it. result is the distance the point x, y, z, is from the plane. It is 0 if the point is on it, a negitive number if it is behind the plane and positive if infront.

A, B and C are the x, y and z of the plane’s normal, as it would be far too confusing to use x, y and z :) As I said x,y and z is a point. D is the distance our plane is from the origin (as the normal vector doesn’t show this). Note, a plane is infinite in size and has no bounderies. Just a flat plane surface.

Anyway, we need to know D so we can test points. So, rearrange the formula like so:

-D = Ax + By + Cz - result

D = -(Ax + By + Cz) + result

We know the normal, so that’s sorted. D is what we will try to find. But, how do we know the result? We know a point on the plane gives a result of 0, so once of the vertexes we used to get the normal will do fine for a point on the plane, and then result no longer matters as it is 0.

So, do this:

vertex is some one that we used earlier. Normal, well I hope you have that :)

D = -(Normal.x * vertex.x + Normal.y * vertex.y + Normal.z * vertex.z)

Keep D too now.

This is a the useful bit now, finding out if our ray has went into the plane. Now, this is a simplier version of testing a whole line. This is only testing a point, so you may want to test both points or something dependinh upon your engine. Note that your ray, if moving very fast could “skip” the cube.

Anyway, here’s our test for our arbitary point:

result = (Normal.x * Ray.x + Normal.y * Ray.y + Normal.z * Ray.z + D)

Do this for all 6 faces of the cube, and if **ALL** of the planes return
that the point is beneth them (a negitive result), then the point is
definately inside the cube, thus at least part of the ray is inside. You
could try the start point of the ray aswell, and make sure it is outside
of the cube (at least one plane returns > 0) and if so the ray
definately intersects the cube).

If the cube doesn’t move around, you should pre-calculate the Normal and D. If it moves but doesn’t rotate, then you could precalculate the normal and work out D at run time.

I hope this is useful, near correct and not a stupid approach :)

In response to Ray/Cube Intersection

In response to Normals

In response to Shell writing

You probably already know this, but that isn’t a simple task, put it this way: explorer is the largest component of Win98, it’s almost the whole system ;)

Anyway, I think that you may run into a heck of a lot of undocumented problems, so if you don’t know how to start then this is maybe not the project for you. As far as my knowledge of the shell, well… Make a dos gui and use it :)

In response to very simple question

You’re welcome, but beleive me the links are a million times more valuable. It’s imperitive that you learn to do it yourself :)