X
xzh2000
Unregistered / Unconfirmed
GUEST, unregistred user!
1、在IDE中，OPENGL程序结束时线程没有完全退出，
跟踪知是由wglDeleteContext函数引的？如何解决？
2、本人有一个用于矢量运算的unit,但在D6上没法
使用，那位能够修改的可以用用D6？本人修改了一
部分，还望高手搞定。
{}内注释部分是我修改前的代码，如果不用修改，是
否需要一些其它的配置？
3、零分贴如何结？
----------------------------------------------
unit CgGeometry;
interface
uses
CgTypes;
procedure cgSetPrecision(eps: Single);
function cgPrecision: Single;
function cgOrigin: TCGVector;
function cgXAxis: TCGVector;
function cgYAxis: TCGVector;
function cgZAxis: TCGVector;
function cgVectorComp(v1, v2: TCGVector): Boolean;
procedure cgTranslate(var v: TCGVector; t: TCGVector);
procedure cgMirror(var v: TCGVector; mx, my, mz: Boolean);
procedure cgScale(var v: TCGVector; sx, sy, sz: Single);
function cgVectorLength(v: TCGVector): Single;
procedure cgNormalize(var v: TCGVector);
procedure cgRotateX(var v: TCGVector; a: Single);
procedure cgRotateY(var v: TCGVector; a: Single);
procedure cgRotateZ(var v: TCGVector; a: Single);
procedure cgRotate(var v: TCGVector; P, Q: TCGVector; a: Single); // Doesn't work.
function cgDotProduct(v1, v2: TCGVector): Single;
function cgCrossProduct(v1, v2: TCGVector): TCGVector;
function cgGetNormal(v1, v2, v3: TCGVector): TCGVector;
function cgVecMult(v1, v2: TCGVector): TCGMatrix;
function cgIdentity: TCGMatrix;
function cgNullMatrix: TCGMatrix;
procedure cgApplyMatrix(var v: TCGVector; m: TCGMatrix);
procedure cgMatrixAdd(var m1: TCGMatrix; m2: TCGMatrix);
procedure cgMatrixSub(var m1: TCGMatrix; m2: TCGMatrix);
procedure cgMatrixMult(var m1: TCGMatrix; m2: TCGMatrix);
procedure cgMScalarMult(var m: TCGMatrix; s: Single);
function cgMRotateX(angle: Single): TCGMatrix;
function cgMRotateY(angle: Single): TCGMatrix;
function cgMRotateZ(angle: Single): TCGMatrix;
function cgMScale(sx, sy, sz: Single): TCGMatrix;
function cgPlaneFromPoints(p1, p2, p3: TCGVector): TCGPlane;
function cgVecSub(v1, v2: TCGVector): TCGVector;
function cgVecAdd(v1, v2: TCGVector): TCGVector;
function cgVecScalarMult(v1 : TCGVector ; scale : Single): TCGVector;
implementation
uses
CgUtils;
type
TAVector = array [0..3] of Single;
var
CG_EPS: Single = 0.0001;
function cgVecSub(v1, v2: TCGVector): TCGVector; //assembler;
Begin
Result.x :=v1.x-v2.x;
Result.y :=v1.y-v2.y;
Result.z :=v1.z-v2.z;
Result.w :=v1.w-v2.w;
end;
{ fld v1.y
fsub v2.y
fstp Result.y
fld v1.z
fsub v2.z
fstp Result.z
fld v1.w
fsub v2.w
fstp Result.w
end;}
function cgVecAdd(v1, v2: TCGVector): TCGVector;// assembler;
//asm
begin
Result.x:=v1.x+v2.x;
Result.y:=v1.y+v2.y;
Result.z:=v1.z+v2.z;
Result.w:=v1.w+v2.w;
end;
{ fld v1.x
fadd v2.x
fstp Result.x
fld v1.y
fadd v2.y
fstp Result.y
fld v1.z
fadd v2.z
fstp Result.z
fld v1.w
fadd v2.w
fstp Result.w
end;
}
function cgVecScalarMult(v1 : TCGVector ; scale : Single): TCGVector;//assembler;
//asm
begin
Result.x:=V1.x*Scale;
Result.y:=V1.y*Scale;
Result.z:=V1.z*Scale;
Result.w:=V1.w*Scale;
end;
{ fld v1.x
fmul scale
fstp Result.x
fld v1.y
fmul scale
fstp Result.y
fld v1.z
fmul scale
fstp Result.z
fld v1.w
fmul scale
fstp Result.w
end;
}
procedure cgSetPrecision(eps: Single);
begin
{ Set precision for vector comparisons. Doesn't really affect floating point
precision, of course... The default of 0.0001 should be adequate in most
cases, but you never know. }
CG_EPS := eps;
end;
function cgPrecision: Single;
begin
{ Return the current vector comparison precision. }
Result := CG_EPS;
end;
function cgOrigin: TCGVector;
const
r: TCGVector = (x: 0; y: 0; z: 0; w: 1);
begin
{ Return the origin. }
Result := r;
end;
function cgXAxis: TCGVector;
const
r: TCGVector = (x: 1; y: 0; z: 0; w: 1);
begin
{ Return a unit vector along the X axis. }
Result := r;
end;
function cgYAxis: TCGVector;
const
r: TCGVector = (x: 0; y: 1; z: 0; w: 1);
begin
{ Return a unit vector along the Y axis. }
Result := r;
end;
function cgZAxis: TCGVector;
const
r: TCGVector = (x: 0; y: 0; z: 1; w: 1);
begin
{ Return a unit vector along the Z axis. }
Result := r;
end;
function cgVectorComp(v1, v2: TCGVector): Boolean;
begin
{ Determine if two vectors are equal. }
Result := (Abs(v1.x - v2.x) < CG_EPS) and (Abs(v1.y - v2.y) < CG_EPS) and
(Abs(v1.z - v2.z) < CG_EPS);
end;
procedure cgTranslate(var v: TCGVector; t: TCGVector); //assembler;
begin
//asm
v.x:=v.x+t.x;
v.y:=v.y+t.y;
v.z:=v.z+t.z;
end;
{ fld v.x
fadd t.x
fstp v.x
fld v.y
fadd t.y
fstp v.y
fld v.z
fadd t.z
fstp v.z
end;
}
procedure cgMirror(var v: TCGVector; mx, my, mz: Boolean);
begin
{label __my , __mz , __exit;
asm
test dl,dl
jz __my
fld v.x
fchs
fstp v.x
__my :
test cl,cl
jz __mz
fld v.y
fchs
fstp v.y
__mz :
cmp mz,$00
jz __exit
fld v.z
fchs
fstp v.z
jb __exit
__exit:}
end;
procedure cgScale(var v: TCGVector; sx, sy, sz: Single); //assembler;
//asm
{ Scale v with the given scale factors for each axis. }
begin
v.x:=v.x*sx;
v.y:=v.y*sy;
v.z:=v.z*sz;
end;
{ fld v.x
fmul sx
fstp v.x
fld v.y
fmul sy
fstp v.y
fld v.z
fmul sz
fstp v.z
end;
}
{
function cgVectorLength(v: TCGVector): Single; assembler;
asm
fld v.x
fmul v.x
fld v.y
fmul v.y
faddp
fld v.z
fmul v.z
faddp
fsqrt
fstp Result
end;
function cgVectorDistance(v1, v2: TCGVector): Single;
begin
// Calculate the distance between two points.
// cgMirror(v1, TRUE, TRUE, TRUE);
asm
fld v1.x
fchs // working faster - no if conditions!
fstp v1.x
fld v1.y
fchs
fstp v1.y
fld v1.z
fchs
fstp v1.z
// cgTranslate(v2, v1);
fld v1.x
fadd v2.x
fstp v2.x
fld v1.y
fadd v2.y
fstp v2.y
fld v1.z
fadd v2.z
fstp v2.z
end;
Result := cgVectorLength(v2);
end;
procedure cgNormalize(var v: TCGVector); assembler;
var
l : Single;
LABEL _EXIT;
asm
fld v.x
fmul v.x
fld v.y
fmul v.y
faddp
fld v.z
fmul v.z
faddp
fsqrt
ftst
jz _EXIT
fstp L
fld v.x
fdiv L
fstp v.x
fld v.y
fdiv L
fstp v.y
fld v.z
fdiv L
fstp v.z
_EXIT:
end;
procedure cgRotateX(var v: TCGVector; a: Single); assembler;
var temp: TCGVector;
sin_ , cos_ : Single;
asm
fld a
fcos
fstp cos_
fld a
fsin
fstp sin_
fld v.y//dword ptr [v.y] // y := (v.y * cos_) + (v.z * -sin_);
fmul cos_
fld v.z//dword ptr [v.z]
fmul sin_
fsubp
fstp temp.y
fld v.y//dword ptr [v.y]
fmul sin_
fld v.z//dword ptr [v.z]
fmul cos_
faddp
fstp v.z//dword ptr [v.z]
fld1
fstp v.w//dword ptr [v.w]
fld temp.y
fstp v.y//dword ptr [v.y]
end;
procedure cgRotateY(var v: TCGVector; a: Single); assembler;
var temp: TCGVector;
sin_ , cos_ : Single;
asm
fld a
fcos
fstp cos_
fld a
fsin
fstp sin_
fld v.x//dword ptr [v.x]
fmul cos_
fld v.z//dword ptr [v.z]
fmul sin_
faddp
fstp temp.x
fld v.z//dword ptr [v.z]
fmul cos_
fld v.x//dword ptr [v.x]
fmul sin_
fsubp
fstp v.z//dword ptr [v.z]
fld1
fstp v.w//dword ptr [v.w]
fld temp.x
fstp v.x//dword ptr [v.x]
end;
procedure cgRotateZ(var v: TCGVector; a: Single);
var temp: TCGVector;
sin_ , cos_ : Single;
asm
fld a
fcos
fstp cos_
fld a
fsin
fstp sin_
fld v.x//dword ptr [v.x]
fmul cos_
fld v.y//dword ptr [v.y]
fmul sin_
fsubp
fstp temp.x
fld v.x//dword ptr [v.x]
fmul sin_
fld v.y//dword ptr [v.y]
fmul cos_
faddp
fstp v.y//dword ptr [v.y]
fld1
fstp v.w//dword ptr [v.w]
fld temp.x
fstp v.x//dword ptr [v.x]
end;
}
procedure cgRotate(var v: TCGVector; P, Q: TCGVector; a: Single);
var
rho, phi, theta: Single; // Spherical coordinates the axis endpoint.
begin
{ Rotate v over a radians around axis PQ. }
// Translate the rotation axis to the origin.
cgMirror(P, TRUE, TRUE, TRUE);
cgTranslate(Q, P);
// Calculate spherical coordinates for Q.
rho := cgVectorLength(v);
phi := cgArcCos(v.z / rho);
// ArcTan is always in [0, 2*pi], which is not good.
if v.x > 0 then theta := ArcTan(v.y / v.x)
else if v.x < 0 then theta := ArcTan(v.y / v.x) + pi
else if v.y >= 0 then theta := pi / 2
else theta := 3*pi / 2;
// Now transform the Z-axis to coincide with Q.
cgRotateZ(v, -theta);
cgRotateY(v, phi);
// Now rotate around the Z/Q-axis.
cgRotateZ(v, a);
// And restore the original coordinate system.
cgRotateY(v, -phi);
cgRotateZ(v, theta);
// Now translate the vector over P (the starting point of the PQ axis).
cgMirror(P, TRUE, TRUE, TRUE);
cgTranslate(v, P);
// The vector v has now been rotated around axis PQ.
end;
{
function cgDotProduct(v1, v2: TCGVector): Single; assembler;
asm
// Return the dot product v1 . v2
// Result := v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
fld v1.x
fmul v2.x
fld v1.y
fmul v2.y
faddp
fld v1.z
fmul v2.z
faddp
fstp Result
end;
function cgCrossProduct(v1, v2: TCGVector): TCGVector; assembler;
asm // Result := cgVector(v1.y * v2.z - v2.y * v1.z,
// v2.x * v1.z - v1.x * v2.z,
// v1.x * v2.y - v2.x * v1.y);
fld v2.y
fmul v1.z
fld v1.y
fmul v2.z
fsubp
fstp Result.x
fld v1.x
fmul v2.z
fld v2.x
fmul v1.z
fsubp
fstp Result.y
fld v2.x
fmul v1.y
fld v1.x
fmul v2.y
fsubp
fstp Result.z
fld1
fstp Result.w
end;
function cgGetNormal(v1, v2, v3: TCGVector): TCGVector;
begin
// Return the normal vector to the plane defined by v1, v2 and v3.
asm
//cgMirror(v2, TRUE, TRUE, TRUE);
fld v2.x
fchs // working faster - no if conditions!
fstp v2.x
fld v2.y
fchs
fstp v2.y
fld v2.z
fchs
fstp v2.z
// cgTranslate(v1, v2);
fld v1.x
fadd v2.x
fstp v1.x
fld v1.y
fadd v2.y
fstp v1.y
fld v1.z
fadd v2.z
fstp v1.z
// cgTranslate(v3, v2);
fld v3.x
fadd v2.x
fstp v3.x
fld v3.y
fadd v2.y
fstp v3.y
fld v3.z
fadd v2.z
fstp v3.z
end;
Result := cgCrossProduct(v1, v3);
cgNormalize(Result);
end;
}
function cgVecMult(v1, v2: TCGVector): TCGMatrix;
var
i, j: Integer;
begin
// Multiply a row and a column vector, resulting in a 4x4 matrix.
for i := 0 to 3 do
begin
for j := 0 to 3 do
begin
Result[i,j] := TAVector(v1) * TAVector(v2)[j];
end;
end;
end;
function cgIdentity: TCGMatrix;
const
i: TCGMatrix = ((1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1));
begin
// Return the identity matrix.
Result := i;
end;
function cgNullMatrix: TCGMatrix;
const
n: TCGMatrix = ((0, 0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0));
begin
// Return the null matrix.
Result := n;
end;
procedure cgApplyMatrix(var v: TCGVector; m: TCGMatrix);
var
t: TCGVector;
r, c: Integer;
begin
// Multiply v with the matrix m.
for c := 0 to 3 do
begin
TAVector(t)[c] := 0;
for r := 0 to 3 do
begin
TAVector(t)[c] := TAVector(t)[c] + TAVector(v)[r] * m[r,c];
end;
end;
v := t;
end;
procedure cgMatrixAdd(var m1: TCGMatrix; m2: TCGMatrix);
var
i, j: Integer;
begin
// Add the second matrix to the first.
for i := 0 to 3 do
begin
for j := 0 to 3 do
begin
m1[i,j] := m1[i,j] + m2[i,j];
end;
end;
end;
procedure cgMatrixSub(var m1: TCGMatrix; m2: TCGMatrix);
var
i, j: Integer;
begin
// Substract the second matrix from the first.
for i := 0 to 3 do
begin
for j := 0 to 3 do
begin
m1[i,j] := m1[i,j] - m2[i,j];
end;
end;
end;
procedure cgMatrixMult(var m1: TCGMatrix; m2: TCGMatrix);
var
r, c, i: Byte;
t: TCGMatrix;
begin
// Multiply two matrices.
t := cgNullMatrix;
for r := 0 to 3 do
begin
for c := 0 to 3 do
begin
for i := 0 to 3 do
begin
t[r,c] := t[r,c] + (m1[r,i] * m2[i,c]);
end;
end;
end;
m1 := t;
end;
procedure cgMScalarMult(var m: TCGMatrix; s: Single);
var
i, j: Integer;
begin
// Multiply a matrix with a scalar.
for i := 0 to 3 do
begin
for j := 0 to 3 do
begin
m[i,j] := m[i,j] * s;
end;
end;
end;
function cgMRotateX(angle: Single): TCGMatrix;
begin
// Return a rotation matrix for the X axis.
Result := cgIdentity;
Result[1,1] := cos(angle);
Result[2,2] := Result[1,1]; // Don't calculate cosine twice.
Result[1,2] := sin(angle);
Result[2,1] := -Result[1,2];
end;
function cgMRotateY(angle: Single): TCGMatrix;
begin
// Return a rotation matrix for the Y axis.
Result := cgIdentity;
Result[0,0] := cos(angle);
Result[2,2] := Result[0,0];
Result[0,2] := -sin(angle);
Result[2,0] := -Result[0,2];
end;
function cgMRotateZ(angle: Single): TCGMatrix;
begin
// Return a rotation matrix for the Z axis.
Result := cgIdentity;
Result[0,0] := cos(angle);
Result[1,1] := Result[0,0];
Result[0,1] := sin(angle);
Result[1,0] := -Result[0,1];
end;
function cgMScale(sx, sy, sz: Single): TCGMatrix;
begin
// Return a transformation matrix for scaling.
Result := cgIdentity;
Result[0,0] := sx;
Result[1,1] := sy;
Result[2,2] := sz;
end;
function cgPlaneFromPoints(p1, p2, p3: TCGVector): TCGPlane;
var
n: TCGVector;
begin
{ Create a TCGPlane from 3 coplanar points. To do this, calculate the normal
to the plane. The x, y and z components of the normal vector correspond to
the A, B and C components of the plane. D can then be very easily calculated
knowing that Ax + By + Cz + D = 0 for any point on the plane, such as p1. }
n := cgGetNormal(p1, p2, p3);
with Result do
begin
A := n.x;
B := n.y;
C := n.z;
D := -(A * p1.x + B * p1.y + c * p1.z);
end;
end;
end.
----------------------------------------------
跟踪知是由wglDeleteContext函数引的？如何解决？
2、本人有一个用于矢量运算的unit,但在D6上没法
使用，那位能够修改的可以用用D6？本人修改了一
部分，还望高手搞定。
{}内注释部分是我修改前的代码，如果不用修改，是
否需要一些其它的配置？
3、零分贴如何结？
----------------------------------------------
unit CgGeometry;
interface
uses
CgTypes;
procedure cgSetPrecision(eps: Single);
function cgPrecision: Single;
function cgOrigin: TCGVector;
function cgXAxis: TCGVector;
function cgYAxis: TCGVector;
function cgZAxis: TCGVector;
function cgVectorComp(v1, v2: TCGVector): Boolean;
procedure cgTranslate(var v: TCGVector; t: TCGVector);
procedure cgMirror(var v: TCGVector; mx, my, mz: Boolean);
procedure cgScale(var v: TCGVector; sx, sy, sz: Single);
function cgVectorLength(v: TCGVector): Single;
procedure cgNormalize(var v: TCGVector);
procedure cgRotateX(var v: TCGVector; a: Single);
procedure cgRotateY(var v: TCGVector; a: Single);
procedure cgRotateZ(var v: TCGVector; a: Single);
procedure cgRotate(var v: TCGVector; P, Q: TCGVector; a: Single); // Doesn't work.
function cgDotProduct(v1, v2: TCGVector): Single;
function cgCrossProduct(v1, v2: TCGVector): TCGVector;
function cgGetNormal(v1, v2, v3: TCGVector): TCGVector;
function cgVecMult(v1, v2: TCGVector): TCGMatrix;
function cgIdentity: TCGMatrix;
function cgNullMatrix: TCGMatrix;
procedure cgApplyMatrix(var v: TCGVector; m: TCGMatrix);
procedure cgMatrixAdd(var m1: TCGMatrix; m2: TCGMatrix);
procedure cgMatrixSub(var m1: TCGMatrix; m2: TCGMatrix);
procedure cgMatrixMult(var m1: TCGMatrix; m2: TCGMatrix);
procedure cgMScalarMult(var m: TCGMatrix; s: Single);
function cgMRotateX(angle: Single): TCGMatrix;
function cgMRotateY(angle: Single): TCGMatrix;
function cgMRotateZ(angle: Single): TCGMatrix;
function cgMScale(sx, sy, sz: Single): TCGMatrix;
function cgPlaneFromPoints(p1, p2, p3: TCGVector): TCGPlane;
function cgVecSub(v1, v2: TCGVector): TCGVector;
function cgVecAdd(v1, v2: TCGVector): TCGVector;
function cgVecScalarMult(v1 : TCGVector ; scale : Single): TCGVector;
implementation
uses
CgUtils;
type
TAVector = array [0..3] of Single;
var
CG_EPS: Single = 0.0001;
function cgVecSub(v1, v2: TCGVector): TCGVector; //assembler;
Begin
Result.x :=v1.x-v2.x;
Result.y :=v1.y-v2.y;
Result.z :=v1.z-v2.z;
Result.w :=v1.w-v2.w;
end;
{ fld v1.y
fsub v2.y
fstp Result.y
fld v1.z
fsub v2.z
fstp Result.z
fld v1.w
fsub v2.w
fstp Result.w
end;}
function cgVecAdd(v1, v2: TCGVector): TCGVector;// assembler;
//asm
begin
Result.x:=v1.x+v2.x;
Result.y:=v1.y+v2.y;
Result.z:=v1.z+v2.z;
Result.w:=v1.w+v2.w;
end;
{ fld v1.x
fadd v2.x
fstp Result.x
fld v1.y
fadd v2.y
fstp Result.y
fld v1.z
fadd v2.z
fstp Result.z
fld v1.w
fadd v2.w
fstp Result.w
end;
}
function cgVecScalarMult(v1 : TCGVector ; scale : Single): TCGVector;//assembler;
//asm
begin
Result.x:=V1.x*Scale;
Result.y:=V1.y*Scale;
Result.z:=V1.z*Scale;
Result.w:=V1.w*Scale;
end;
{ fld v1.x
fmul scale
fstp Result.x
fld v1.y
fmul scale
fstp Result.y
fld v1.z
fmul scale
fstp Result.z
fld v1.w
fmul scale
fstp Result.w
end;
}
procedure cgSetPrecision(eps: Single);
begin
{ Set precision for vector comparisons. Doesn't really affect floating point
precision, of course... The default of 0.0001 should be adequate in most
cases, but you never know. }
CG_EPS := eps;
end;
function cgPrecision: Single;
begin
{ Return the current vector comparison precision. }
Result := CG_EPS;
end;
function cgOrigin: TCGVector;
const
r: TCGVector = (x: 0; y: 0; z: 0; w: 1);
begin
{ Return the origin. }
Result := r;
end;
function cgXAxis: TCGVector;
const
r: TCGVector = (x: 1; y: 0; z: 0; w: 1);
begin
{ Return a unit vector along the X axis. }
Result := r;
end;
function cgYAxis: TCGVector;
const
r: TCGVector = (x: 0; y: 1; z: 0; w: 1);
begin
{ Return a unit vector along the Y axis. }
Result := r;
end;
function cgZAxis: TCGVector;
const
r: TCGVector = (x: 0; y: 0; z: 1; w: 1);
begin
{ Return a unit vector along the Z axis. }
Result := r;
end;
function cgVectorComp(v1, v2: TCGVector): Boolean;
begin
{ Determine if two vectors are equal. }
Result := (Abs(v1.x - v2.x) < CG_EPS) and (Abs(v1.y - v2.y) < CG_EPS) and
(Abs(v1.z - v2.z) < CG_EPS);
end;
procedure cgTranslate(var v: TCGVector; t: TCGVector); //assembler;
begin
//asm
v.x:=v.x+t.x;
v.y:=v.y+t.y;
v.z:=v.z+t.z;
end;
{ fld v.x
fadd t.x
fstp v.x
fld v.y
fadd t.y
fstp v.y
fld v.z
fadd t.z
fstp v.z
end;
}
procedure cgMirror(var v: TCGVector; mx, my, mz: Boolean);
begin
{label __my , __mz , __exit;
asm
test dl,dl
jz __my
fld v.x
fchs
fstp v.x
__my :
test cl,cl
jz __mz
fld v.y
fchs
fstp v.y
__mz :
cmp mz,$00
jz __exit
fld v.z
fchs
fstp v.z
jb __exit
__exit:}
end;
procedure cgScale(var v: TCGVector; sx, sy, sz: Single); //assembler;
//asm
{ Scale v with the given scale factors for each axis. }
begin
v.x:=v.x*sx;
v.y:=v.y*sy;
v.z:=v.z*sz;
end;
{ fld v.x
fmul sx
fstp v.x
fld v.y
fmul sy
fstp v.y
fld v.z
fmul sz
fstp v.z
end;
}
{
function cgVectorLength(v: TCGVector): Single; assembler;
asm
fld v.x
fmul v.x
fld v.y
fmul v.y
faddp
fld v.z
fmul v.z
faddp
fsqrt
fstp Result
end;
function cgVectorDistance(v1, v2: TCGVector): Single;
begin
// Calculate the distance between two points.
// cgMirror(v1, TRUE, TRUE, TRUE);
asm
fld v1.x
fchs // working faster - no if conditions!
fstp v1.x
fld v1.y
fchs
fstp v1.y
fld v1.z
fchs
fstp v1.z
// cgTranslate(v2, v1);
fld v1.x
fadd v2.x
fstp v2.x
fld v1.y
fadd v2.y
fstp v2.y
fld v1.z
fadd v2.z
fstp v2.z
end;
Result := cgVectorLength(v2);
end;
procedure cgNormalize(var v: TCGVector); assembler;
var
l : Single;
LABEL _EXIT;
asm
fld v.x
fmul v.x
fld v.y
fmul v.y
faddp
fld v.z
fmul v.z
faddp
fsqrt
ftst
jz _EXIT
fstp L
fld v.x
fdiv L
fstp v.x
fld v.y
fdiv L
fstp v.y
fld v.z
fdiv L
fstp v.z
_EXIT:
end;
procedure cgRotateX(var v: TCGVector; a: Single); assembler;
var temp: TCGVector;
sin_ , cos_ : Single;
asm
fld a
fcos
fstp cos_
fld a
fsin
fstp sin_
fld v.y//dword ptr [v.y] // y := (v.y * cos_) + (v.z * -sin_);
fmul cos_
fld v.z//dword ptr [v.z]
fmul sin_
fsubp
fstp temp.y
fld v.y//dword ptr [v.y]
fmul sin_
fld v.z//dword ptr [v.z]
fmul cos_
faddp
fstp v.z//dword ptr [v.z]
fld1
fstp v.w//dword ptr [v.w]
fld temp.y
fstp v.y//dword ptr [v.y]
end;
procedure cgRotateY(var v: TCGVector; a: Single); assembler;
var temp: TCGVector;
sin_ , cos_ : Single;
asm
fld a
fcos
fstp cos_
fld a
fsin
fstp sin_
fld v.x//dword ptr [v.x]
fmul cos_
fld v.z//dword ptr [v.z]
fmul sin_
faddp
fstp temp.x
fld v.z//dword ptr [v.z]
fmul cos_
fld v.x//dword ptr [v.x]
fmul sin_
fsubp
fstp v.z//dword ptr [v.z]
fld1
fstp v.w//dword ptr [v.w]
fld temp.x
fstp v.x//dword ptr [v.x]
end;
procedure cgRotateZ(var v: TCGVector; a: Single);
var temp: TCGVector;
sin_ , cos_ : Single;
asm
fld a
fcos
fstp cos_
fld a
fsin
fstp sin_
fld v.x//dword ptr [v.x]
fmul cos_
fld v.y//dword ptr [v.y]
fmul sin_
fsubp
fstp temp.x
fld v.x//dword ptr [v.x]
fmul sin_
fld v.y//dword ptr [v.y]
fmul cos_
faddp
fstp v.y//dword ptr [v.y]
fld1
fstp v.w//dword ptr [v.w]
fld temp.x
fstp v.x//dword ptr [v.x]
end;
}
procedure cgRotate(var v: TCGVector; P, Q: TCGVector; a: Single);
var
rho, phi, theta: Single; // Spherical coordinates the axis endpoint.
begin
{ Rotate v over a radians around axis PQ. }
// Translate the rotation axis to the origin.
cgMirror(P, TRUE, TRUE, TRUE);
cgTranslate(Q, P);
// Calculate spherical coordinates for Q.
rho := cgVectorLength(v);
phi := cgArcCos(v.z / rho);
// ArcTan is always in [0, 2*pi], which is not good.
if v.x > 0 then theta := ArcTan(v.y / v.x)
else if v.x < 0 then theta := ArcTan(v.y / v.x) + pi
else if v.y >= 0 then theta := pi / 2
else theta := 3*pi / 2;
// Now transform the Z-axis to coincide with Q.
cgRotateZ(v, -theta);
cgRotateY(v, phi);
// Now rotate around the Z/Q-axis.
cgRotateZ(v, a);
// And restore the original coordinate system.
cgRotateY(v, -phi);
cgRotateZ(v, theta);
// Now translate the vector over P (the starting point of the PQ axis).
cgMirror(P, TRUE, TRUE, TRUE);
cgTranslate(v, P);
// The vector v has now been rotated around axis PQ.
end;
{
function cgDotProduct(v1, v2: TCGVector): Single; assembler;
asm
// Return the dot product v1 . v2
// Result := v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
fld v1.x
fmul v2.x
fld v1.y
fmul v2.y
faddp
fld v1.z
fmul v2.z
faddp
fstp Result
end;
function cgCrossProduct(v1, v2: TCGVector): TCGVector; assembler;
asm // Result := cgVector(v1.y * v2.z - v2.y * v1.z,
// v2.x * v1.z - v1.x * v2.z,
// v1.x * v2.y - v2.x * v1.y);
fld v2.y
fmul v1.z
fld v1.y
fmul v2.z
fsubp
fstp Result.x
fld v1.x
fmul v2.z
fld v2.x
fmul v1.z
fsubp
fstp Result.y
fld v2.x
fmul v1.y
fld v1.x
fmul v2.y
fsubp
fstp Result.z
fld1
fstp Result.w
end;
function cgGetNormal(v1, v2, v3: TCGVector): TCGVector;
begin
// Return the normal vector to the plane defined by v1, v2 and v3.
asm
//cgMirror(v2, TRUE, TRUE, TRUE);
fld v2.x
fchs // working faster - no if conditions!
fstp v2.x
fld v2.y
fchs
fstp v2.y
fld v2.z
fchs
fstp v2.z
// cgTranslate(v1, v2);
fld v1.x
fadd v2.x
fstp v1.x
fld v1.y
fadd v2.y
fstp v1.y
fld v1.z
fadd v2.z
fstp v1.z
// cgTranslate(v3, v2);
fld v3.x
fadd v2.x
fstp v3.x
fld v3.y
fadd v2.y
fstp v3.y
fld v3.z
fadd v2.z
fstp v3.z
end;
Result := cgCrossProduct(v1, v3);
cgNormalize(Result);
end;
}
function cgVecMult(v1, v2: TCGVector): TCGMatrix;
var
i, j: Integer;
begin
// Multiply a row and a column vector, resulting in a 4x4 matrix.
for i := 0 to 3 do
begin
for j := 0 to 3 do
begin
Result[i,j] := TAVector(v1) * TAVector(v2)[j];
end;
end;
end;
function cgIdentity: TCGMatrix;
const
i: TCGMatrix = ((1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1));
begin
// Return the identity matrix.
Result := i;
end;
function cgNullMatrix: TCGMatrix;
const
n: TCGMatrix = ((0, 0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0));
begin
// Return the null matrix.
Result := n;
end;
procedure cgApplyMatrix(var v: TCGVector; m: TCGMatrix);
var
t: TCGVector;
r, c: Integer;
begin
// Multiply v with the matrix m.
for c := 0 to 3 do
begin
TAVector(t)[c] := 0;
for r := 0 to 3 do
begin
TAVector(t)[c] := TAVector(t)[c] + TAVector(v)[r] * m[r,c];
end;
end;
v := t;
end;
procedure cgMatrixAdd(var m1: TCGMatrix; m2: TCGMatrix);
var
i, j: Integer;
begin
// Add the second matrix to the first.
for i := 0 to 3 do
begin
for j := 0 to 3 do
begin
m1[i,j] := m1[i,j] + m2[i,j];
end;
end;
end;
procedure cgMatrixSub(var m1: TCGMatrix; m2: TCGMatrix);
var
i, j: Integer;
begin
// Substract the second matrix from the first.
for i := 0 to 3 do
begin
for j := 0 to 3 do
begin
m1[i,j] := m1[i,j] - m2[i,j];
end;
end;
end;
procedure cgMatrixMult(var m1: TCGMatrix; m2: TCGMatrix);
var
r, c, i: Byte;
t: TCGMatrix;
begin
// Multiply two matrices.
t := cgNullMatrix;
for r := 0 to 3 do
begin
for c := 0 to 3 do
begin
for i := 0 to 3 do
begin
t[r,c] := t[r,c] + (m1[r,i] * m2[i,c]);
end;
end;
end;
m1 := t;
end;
procedure cgMScalarMult(var m: TCGMatrix; s: Single);
var
i, j: Integer;
begin
// Multiply a matrix with a scalar.
for i := 0 to 3 do
begin
for j := 0 to 3 do
begin
m[i,j] := m[i,j] * s;
end;
end;
end;
function cgMRotateX(angle: Single): TCGMatrix;
begin
// Return a rotation matrix for the X axis.
Result := cgIdentity;
Result[1,1] := cos(angle);
Result[2,2] := Result[1,1]; // Don't calculate cosine twice.
Result[1,2] := sin(angle);
Result[2,1] := -Result[1,2];
end;
function cgMRotateY(angle: Single): TCGMatrix;
begin
// Return a rotation matrix for the Y axis.
Result := cgIdentity;
Result[0,0] := cos(angle);
Result[2,2] := Result[0,0];
Result[0,2] := -sin(angle);
Result[2,0] := -Result[0,2];
end;
function cgMRotateZ(angle: Single): TCGMatrix;
begin
// Return a rotation matrix for the Z axis.
Result := cgIdentity;
Result[0,0] := cos(angle);
Result[1,1] := Result[0,0];
Result[0,1] := sin(angle);
Result[1,0] := -Result[0,1];
end;
function cgMScale(sx, sy, sz: Single): TCGMatrix;
begin
// Return a transformation matrix for scaling.
Result := cgIdentity;
Result[0,0] := sx;
Result[1,1] := sy;
Result[2,2] := sz;
end;
function cgPlaneFromPoints(p1, p2, p3: TCGVector): TCGPlane;
var
n: TCGVector;
begin
{ Create a TCGPlane from 3 coplanar points. To do this, calculate the normal
to the plane. The x, y and z components of the normal vector correspond to
the A, B and C components of the plane. D can then be very easily calculated
knowing that Ax + By + Cz + D = 0 for any point on the plane, such as p1. }
n := cgGetNormal(p1, p2, p3);
with Result do
begin
A := n.x;
B := n.y;
C := n.z;
D := -(A * p1.x + B * p1.y + c * p1.z);
end;
end;
end.
----------------------------------------------