Quote:

A complete formula was once published on an issue of ROM ..

some 3d->2d stuff I use in Blitz+ is:

Function Calc3d(xx#,yy#,zz#,alpha#,beta#,gamma#,depth,k)
	Sa# = Sin(alpha#): Ca# = Cos(alpha#)
	Sb# = Sin(beta#): Cb# = Cos(beta#)
	Sg# = Sin(gamma#): Cg# = Cos(gamma#)
	x# = xx# * Ca# + yy# * Sa#: y# = yy# * Ca# - xx# * Sa#: z# = zz#
	x2# = x * Cb# + z# * Sb#: y2# = y#: z2# = z# * Cb# - x# * Sb#
	x3# = x2#: y3# = y# * Cg# + z2# * Sg#: z3# = z2# * Cg# - y2# * Sg#
	z3#= z3# + depth: Calc3dX = ((x3# / z3#) * k): Calc3dY = ((y3# / z3#) * k)
	Calc3dZ=z3#
End Function

Due to the lack of reference vars in Blitz, Calc3dX,Calc3dY,Calc3dZ are globals here

And Blitz' sin and cos don't work from 0..2pi, but from 0..359

Quote:

on other way, which is the generic 3d to 2d plus Z coordinates formula?

when i does the one that i do, i use only multiplications and AND / OR plus some SIN() nothing more.

but i not get the perfection that i was finding in that time, so, i drop the proyect.

i remember i dividel the formula in two stages. ONE executed one time per frame or each time that the point of view changes. This one calculates 9 raw values, for the usage of the second a little formula.



the other is executed for each point to draw. And is too simply like

// EDITED : i forgot the ZS effect in XS & YS //

ZS= (XP*XZ + YP*YZ + ZP*ZZ)
XS= (XP*XX + YP*YX + ZP*ZX) * ZO * (ZS+ZC) + XC
YS= (XP*XY + YP*YY + ZP*ZY) * ZO * (ZS+ZC) + YC

where ZC is a calibration factor for to do FX



where XC, YC is the offset to aims to the center of the screen while XP,YP,ZP = 0.

XP , YP , ZP is the 3D coordinates of the point to draw.

ZO = zoom (its value is the half of the size of the window use for the drawing), negative value just flips the draw.

XS,YS is the screen coordinate for the point
ZS is the Z position on the screen to use this value for masking purposes.


XX, XY, XZ, YX, YY, YZ, ZX, ZY, ZZ are raw values precalculates. Its means, means

By example:

"XY" = In which amount (or level) the (X position 3D) will affects the Y position on the screen.

where the first leter is the 3D position, and the second leter is the effect on the screen.

Those raw values are precalculated one time per frame or each time that the point of view changes. Zoon or offset screen changes will NOT needs to precalculating again.

And the heavy where SIN() and a lot of * and logical part are, are in the first formula.

Quote:

that's for each point .. there's not much to explain .. this is what it is ..

xx#, yy#, zz# = point
alpha#, beta#, gamma# = rotations (x y and z)
depth is the offset to prevent a division by zero (see previous page)
k is the zoom

naturally you can put all the sin/cos alpha/beta/gamma stuff in a table to save cpu speed..

Quote:

Just use matrices guys !

Multiply a matrix with a vector and ... voila new vector.

Multiply matrices with eachother to create a new matrix that
converts a vector from a ship (object) based system to screen (2D)
directly, doing so skipping the main space system.

ehmmm... or something like that.

Anyway 3D takes a lot of calculations so that number 13 would
be more like 16 times multiplications plus 16 times adding per vector.
Ofcourse you can check for zero's and one's to reduce the number
of calculations to speed up the process.