int vect_strcmp(const vector vector1,const vector vector2)
{
int ret = 0;
vector vector_temp1;
vector vector_temp2;
if(!vector1 || !vector2) //空指针 出错
return -1;
if(vect_getelmtype(vector1) !=STRING || vect_getelmtype(vector2) !=STRING) //保存的不是字符串 出错
return -1;
if(vect_getlength(vector1) !=vect_getlength(vector2)) //保存的字符串个数不一致 肯定不相等
return 1;
//拷贝副本
vector_temp1=vect_copy(vector1);
if(!vector_temp1)
return -1;
vector_temp2=vect_copy(vector2);
if(!vector_temp2)
return -1;
vect_sortstr(vector_temp1);
vect_sortstr(vector_temp2);
ret = vect_strcmp_order(vector_temp1, vector_temp2);
vect_free(vector_temp1);
vect_free(vector_temp2);
return (ret);
}
void CWindModifier::m_Force (float4 framepos, AD_Vect3D *pos, AD_Vect3D *vel, AD_Vect3D *accel)
{
AD_Vect3D posrel, tf, p, force, p2;
float4 dist, freq, turb;
freq=p_Frequency;
turb=p_Turbolence;
if (p_Mapping==FORCE_PLANAR)
{
if (p_Decay!=0.0f)
{
vect_sub(pos, &p_CurrentPosition, &posrel);
dist=fabsf(vect_dot(&p_Force, &posrel));
vect_scale(&p_ScaledForce, (float4)exp(-p_Decay*dist), accel);
}
else vect_copy(&p_ScaledForce, accel);
}
else
{
vect_sub(pos, &p_CurrentPosition, &force);
dist = vect_length(&force);
if (dist != 0) vect_auto_scale(&force, 1.0f/dist);
if (p_Decay != 0)
vect_scale(&force, p_ScaledStrength*(float4)exp(-p_Decay*dist), accel);
else
vect_scale(&force, p_ScaledStrength, accel);
}
if (turb != 0)
{
vect_sub(pos, &p_CurrentPosition, &p2);
freq *= 0.01f;
vect_copy(&p2, &p);
p.x = freq * framepos;
tf.x = noise3(p.x*p_Scale, p.y*p_Scale, p.z*p_Scale);
vect_copy(&p2, &p);
p.y = freq * framepos;
tf.y = noise3(p.x*p_Scale, p.y*p_Scale, p.z*p_Scale);
vect_copy(&p2, &p);
p.z = freq * framepos;
tf.z = noise3(p.x*p_Scale, p.y*p_Scale, p.z*p_Scale);
turb *= 0.0001f*forceScaleFactor;
vect_auto_scale(&tf, turb);
vect_add(accel, &tf, accel);
}
}
void AD_FFDModifier::Map2(AD_Vect3D *pos, AD_Vect3D *out)
{
AD_Vect3D q, pp, v;
float kw;
mat_mulvect(&tm, pos, &pp);
if (invol)
{
if (pp.x<-EPSILON || pp.x>1.0f+EPSILON)
{
vect_copy(pos, out);
return;
}
if (pp.y<-EPSILON || pp.y>1.0f+EPSILON)
{
vect_copy(pos, out);
return;
}
if (pp.z<-EPSILON || pp.z>1.0f+EPSILON)
{
vect_copy(pos, out);
return;
}
}
q.x=q.y=q.z=0;
// Compute the deformed point as a weighted average of all
// 64 control points.
for (int i=0; i<dim1; i++)
{
for (int j=0; j<dim2; j++)
{
for (int k=0; k<dim3; k++)
{
v=cpoints[GRIDINDEX22(i,j,k)];
kw=BPoly2(i, pp.x)*BPoly2(j, pp.z)*BPoly2(k, pp.y);
v.x=v.x*kw;
v.y=v.y*kw;
v.z=v.z*kw;
vect_add_inline(&q, &v, &q);
}
}
}
mat_mulvect(&invtm, &q, out);
return;
}
void CGravityModifier::m_Force (float4 framepos, AD_Vect3D *pos, AD_Vect3D *vel, AD_Vect3D *accel)
{
AD_Vect3D posrel, force;
float4 dist;
if (p_Mapping==FORCE_PLANAR)
{
if (p_Decay!=0)
{
vect_sub(pos, &p_CurrentPosition, &posrel);
dist = fabsf(vect_dot(&p_Force, &posrel));
vect_scale(&p_ScaledForce, (float4)exp(-p_Decay*dist), accel);
}
else
vect_copy(&p_ScaledForce, accel);
}
else
{
vect_sub(&p_CurrentPosition, pos, &force);
dist = vect_length(&force);
if (dist != 0) vect_auto_scale(&force, 1.0f/dist);
if (p_Decay != 0)
{
vect_scale(&force, p_ScaledStrength*(float4)exp(-p_Decay*dist), accel);
}
else
vect_scale(&force, p_ScaledStrength, accel);
}
}
void CCamera::m_Ray (float4 screenX, float4 screenY, int32 space, Ray *out)
{
// screenX e screenY vanno nel range [-1;1]
AD_Vect3D cam_x, cam_y, cam_z;
float4 fx, fy;
if (!out) return;
fx=(float4)tan(p_CurrentFov*0.5);
fy=(float4)tan(p_CurrentFov*0.5);
if (space==WORLDSPACE_RAY)
{
vect_copy(&p_CurrentPosition, &out->base);
mat_get_row(&p_CurrentRotationMatrix, 0, &cam_x);
mat_get_row(&p_CurrentRotationMatrix, 1, &cam_y);
mat_get_row(&p_CurrentRotationMatrix, 2, &cam_z);
vect_auto_scale(&cam_x, screenX*fx);
vect_auto_scale(&cam_y, screenY*fy*480.0f/640.0f);
vect_add(&cam_x, &cam_y, &out->direction);
vect_auto_add(&out->direction, &cam_z);
vect_auto_normalize(&out->direction);
}
else
if (space==CAMERASPACE_RAY)
{
vect_set(&out->base, 0, 0, 0);
vect_set(&out->direction, screenX*fx, screenY*fy, 1);
}
vect_auto_normalize(&out->direction);
}
void AD_NoiseModifier::Map(AD_Vect3D *pos, AD_Vect3D *out)
{
AD_Vect3D d, sp, p;
p.x=pos->x-center.x;
p.y=pos->y-center.y;
p.z=pos->z-center.z;
sp.x=(0.5f + p.x*scale);
sp.y=(0.5f + p.y*scale);
sp.z=(0.5f + p.z*scale);
if (fractal)
{
/*
d.x = fBm1(Point3(sp.y,sp.z,time),rough,2.0f,iterations);
d.y = fBm1(Point3(sp.x,sp.z,time),rough,2.0f,iterations);
d.z = fBm1(Point3(sp.x,sp.y,time),rough,2.0f,iterations);
*/
vect_copy(pos, out);
return;
}
else
{
d.x = noise3(sp.z, time, sp.y);
d.z = noise3(sp.x, time, sp.y);
d.y = noise3(sp.x, time, sp.z);
}
out->x = (p.x + d.x*strength.x) + center.x;
out->y = (p.y + d.y*strength.y) + center.y;
out->z = (p.z + d.z*strength.z) + center.z;
}
int32 CGeometricObject::m_CopyTEX1Vertex(int32 baseIndex, void *dest,
CMesh *mesh)
{
FVFGeometryUV1 *l_dest;
int32 i;
l_dest=(FVFGeometryUV1 *)dest;
/*if (!p_BaseMaterial->m_MapNeedUVTransform(1))
for (i=0; i<mesh->p_NumDriverVertex; i++)
{
vect_copy(&mesh->p_DriverVertex[i].point, &l_dest[i+baseIndex].point);
vect_copy(&mesh->p_DriverVertex[i].normal, &l_dest[i+baseIndex].normal);
l_dest[i+baseIndex].uv1.u=mesh->p_DriverVertex[i].uv1.u;
l_dest[i+baseIndex].uv1.v=-mesh->p_DriverVertex[i].uv1.v;
}
else*/
for (i=0; i<mesh->p_NumDriverVertex; i++)
{
//vect_copy(&mesh->p_DriverVertex[i].point, &l_dest[i+baseIndex].point);
vect_sub(&mesh->p_DriverVertex[i].point, &p_Pivot, &l_dest[i+baseIndex].point);
vect_copy(&mesh->p_DriverVertex[i].normal, &l_dest[i+baseIndex].normal);
l_dest[i+baseIndex].uv1.u=mesh->p_DriverVertex[i].uv1.u;
l_dest[i+baseIndex].uv1.v=mesh->p_DriverVertex[i].uv1.v;
}
return (mesh->p_NumDriverVertex);
}
int32 CGeometricObject::m_Clone(CGeometricObject *source)
{
if (!source) return(0);
strcpy(p_FatherName, source->p_FatherName);
p_Father=source->p_Father;
p_HasChildrens=source->p_HasChildrens;
p_BaseMaterial=source->p_BaseMaterial;
for (int32 i=0; i<MAX_LODS; i++)
p_Lods[i]=source->p_Lods[i];
p_NumLods=source->p_NumLods;
p_VertexBuffer=source->p_VertexBuffer;
p_StaticVertex=source->p_StaticVertex;
p_PosTrack=source->p_PosTrack;
p_RotTrack=source->p_RotTrack;
p_ScaleTrack=source->p_ScaleTrack;
vect_copy(&source->p_Pivot, &p_Pivot);
vect_copy(&source->p_CurrentPosition, &p_CurrentPosition);
quat_copy(&source->p_CurrentRotationQuaternion, &p_CurrentRotationQuaternion);
mat_copy(&source->p_CurrentRotationMatrix, &p_CurrentRotationMatrix);
vect_copy(&source->p_CurrentScale, &p_CurrentScale);
vect_copy(&source->p_TotalScale, &p_TotalScale);
mat_copy(&source->p_WorldMatrix, &p_WorldMatrix);
if (source->p_SPHEREBoundVolume)
{
p_SPHEREBoundVolume=new CBoundVolume;
source->p_SPHEREBoundVolume->m_Copy(CLONE, p_SPHEREBoundVolume);
}
if (source->p_AABBBoundVolume)
{
p_AABBBoundVolume=new CBoundVolume;
source->p_AABBBoundVolume->m_Copy(CLONE, p_AABBBoundVolume);
}
if (source->p_OBBBoundVolume)
{
p_OBBBoundVolume=new CBoundVolume;
source->p_OBBBoundVolume->m_Copy(CLONE, p_OBBBoundVolume);
}
return(1);
}
int32 CGeometricObject::m_CopyTEX1DOT3Vertex(int32 baseIndex, void *dest, CMesh *mesh)
{
VSGeometryUV1DOT3 *l_dest;
int32 i;
l_dest=(VSGeometryUV1DOT3 *)dest;
for (i=0; i<mesh->p_NumDriverVertex; i++)
{
//vect_copy(&mesh->p_DriverVertex[i].point, &l_dest[i+baseIndex].point);
vect_sub(&mesh->p_DriverVertex[i].point, &p_Pivot, &l_dest[i+baseIndex].point);
vect_copy(&mesh->p_DriverVertex[i].normal, &l_dest[i+baseIndex].normal);
l_dest[i+baseIndex].uv1.u=mesh->p_DriverVertex[i].uv1.u;
l_dest[i+baseIndex].uv1.v=mesh->p_DriverVertex[i].uv1.v;
vect_copy(&mesh->p_DriverVertex[i].bumpspace.T, &l_dest[i+baseIndex].T);
}
return (mesh->p_NumDriverVertex);
}
/* Transform the given vector */
void vect_transform (Vector v1, Vector v2, Matrix mat)
{
Vector tmp;
tmp[X] = (v2[X] * mat[0][0]) + (v2[Y] * mat[1][0]) + (v2[Z] * mat[2][0]) + mat[3][0];
tmp[Y] = (v2[X] * mat[0][1]) + (v2[Y] * mat[1][1]) + (v2[Z] * mat[2][1]) + mat[3][1];
tmp[Z] = (v2[X] * mat[0][2]) + (v2[Y] * mat[1][2]) + (v2[Z] * mat[2][2]) + mat[3][2];
vect_copy (v1, tmp);
}
void AD_WindModifier::build_objectmatrix (float4 framepos)
{
AD_Vect3D postmp, stmp;
AD_Quaternion objrot;
AD_Matrix posttrans, scaling, maux;
accum_scale.x=accum_scale.y=accum_scale.z=1.0f;
mat_identity(¤tmatrix_rot);
// estrazione dei dati col keyframer: niente di piu' facile col c++ !!!
if (rotationtrack.numkey>0)
{
rotationtrack.get_data(framepos, &objrot);
quat_rotquat_to_matrix(&objrot, ¤tmatrix_rot);
}
mat_copy(¤tmatrix_rot, ¤tmatrix);
if (scaletrack.numkey>0)
{
scaletrack.get_data(framepos, &stmp);
mat_setmatrix_of_scaling(&scaling, stmp.x, stmp.y, stmp.z);
accum_scale.x*=stmp.x;
accum_scale.y*=stmp.y;
accum_scale.z*=stmp.z;
}
else mat_identity(&scaling);
if (positiontrack.numkey>0) positiontrack.get_data(framepos, ¤tpos);
mat_setmatrix_of_pretraslation(&posttrans, ¤tpos);
mat_mul(&scaling, ¤tmatrix_rot, &maux);
mat_mul(&posttrans, &maux, ¤tmatrix);
if (father!=(AD_Object3D *)NULL)
{
mat_mulaffine(&father->currentmatrix_rot, ¤tmatrix_rot, ¤tmatrix_rot);
mat_mul(&father->currentmatrix, ¤tmatrix, ¤tmatrix);
mat_mulvect(&father->currentmatrix, ¤tpos, &postmp);
vect_copy(&postmp, ¤tpos);
accum_scale.x*=father->accum_scale.x;
accum_scale.y*=father->accum_scale.y;
accum_scale.z*=father->accum_scale.z;
}
mat_transpose(¤tmatrix_rot, &inverse_rotmatrix);
mat_get_row(¤tmatrix, 1, &forza);
vect_auto_normalize(&forza);
vect_scale(&forza, strenght*0.00016f*forceScaleFactor, &forza);
}
void AD_PatchObject::build_objectmatrix (float4 framepos)
// costruisce la matrice di trasformazione, che servira' poi per trasformare
// i vertici dell'oggetto;
{
AD_Vect3D postmp, stmp;
AD_Quaternion objrot;
AD_Matrix posttrans, scaling, maux;
accum_scale.x=accum_scale.y=accum_scale.z=1.0f;
mat_identity(¤tmatrix_rot);
// estrazione dei dati col keyframer: niente di piu' facile col c++ !!!
if (rotationtrack.numkey>0)
{
rotationtrack.get_data(framepos, &objrot);
quat_rotquat_to_matrix(&objrot, ¤tmatrix_rot);
}
mat_copy(¤tmatrix_rot, ¤tmatrix);
if (scaletrack.numkey>0)
{
scaletrack.get_data(framepos, &stmp);
mat_setmatrix_of_scaling(&scaling, stmp.x, stmp.y, stmp.z);
accum_scale.x=accum_scale.x*stmp.x;
accum_scale.y=accum_scale.x*stmp.y;
accum_scale.z=accum_scale.x*stmp.z;
}
else mat_identity(&scaling);
if (positiontrack.numkey>0) positiontrack.get_data(framepos, ¤tpos);
mat_setmatrix_of_pretraslation(&posttrans, ¤tpos);
mat_mul(&scaling, ¤tmatrix_rot, &maux);
mat_mul(&posttrans, &maux, ¤tmatrix);
if (father!=(AD_Object3D *)NULL)
{
mat_mulaffine(&father->currentmatrix_rot, ¤tmatrix_rot, ¤tmatrix_rot);
mat_mul(&father->currentmatrix, ¤tmatrix, ¤tmatrix);
mat_mulvect(&father->currentmatrix, ¤tpos, &postmp);
vect_copy(&postmp, ¤tpos);
accum_scale.x*=father->accum_scale.x;
accum_scale.y*=father->accum_scale.y;
accum_scale.z*=father->accum_scale.z;
}
mat_transpose(¤tmatrix_rot, &inverse_rotmatrix);
}
void AD_StretchModifier::Map(AD_Vect3D *pos, AD_Vect3D *out)
{
float fraction, normHeight;
float xyScale, zScale, a, b, c;
AD_Vect3D p;
if (stretch == 0 || (heightMax - heightMin == 0))
{
vect_copy(pos, out);
return;
}
mat_mulvect(&tm, pos, &p);
if (dolim && p.y > uplim)
normHeight = (uplim - heightMin) / (heightMax - heightMin);
else if (dolim && p.y < lowlim)
normHeight = (lowlim - heightMin) / (heightMax - heightMin);
else
normHeight = (p.y - heightMin) / (heightMax - heightMin);
if (stretch < 0) { // Squash
xyScale = (amplify * -stretch + 1.0f);
zScale = (-1.0f / (stretch - 1.0f));
} else { // Stretch
xyScale = 1.0f / (amplify * stretch + 1.0f);
zScale = stretch + 1.0f;
}
// a, b, and c are the coefficients of the quadratic function f(x)
// such that f(0) = 1, f(1) = 1, and f(0.5) = xyScale
a = 4.0F * (1.0F - xyScale);
b = -4.0F * (1.0F - xyScale);
c = 1.0F;
fraction = (((a * normHeight) + b) * normHeight) + c;
p.x *= fraction;
p.z *= fraction;
if (dolim && p.y < lowlim)
p.y += (zScale - 1.0F) * lowlim;
else if (dolim && p.y <= uplim)
p.y *= zScale;
else if (dolim && p.y > uplim)
p.y += (zScale - 1.0F) * uplim;
else
p.y *= zScale;
mat_mulvect(&invtm, &p, out);
}
void AD_Object3D::get_vertex_normal (int16 quale, AD_Vect3D *vnorm)
{
int16 tt;
AD_Vect3D somma;
AD_Vertex3D *quale_ptr;
vect_set(&somma, 0, 0, 0);
quale_ptr=&vertex3D[quale];
for (tt=0; tt<num_tria; tt++)
{
if ((tria[tt].v1==quale_ptr) || (tria[tt].v2==quale_ptr) || (tria[tt].v3==quale_ptr))
vect_add(&somma, &tria[tt].normal, &somma);
}
vect_normalize(&somma);
vect_copy(&somma, vnorm);
}
void CGeometricObject::m_Update(float4 frame)
{
AD_Vect3D postmp;
int32 i;
if (p_HideTrack)
p_HideTrack->m_GetData(frame, &p_Visible);
if (p_RotTrack)
p_RotTrack->m_GetData(frame, &p_CurrentRotationQuaternion);
vect_set(&p_TotalScale, 1, 1, 1);
if (p_ScaleTrack)
{
p_ScaleTrack->m_GetData(frame, &p_CurrentScale);
p_TotalScale.x*=p_CurrentScale.x;
p_TotalScale.y*=p_CurrentScale.y;
p_TotalScale.z*=p_CurrentScale.z;
}
if (p_PosTrack)
p_PosTrack->m_GetData(frame, &p_CurrentPosition);
m_BuildWorldMatrix();
if (p_Father)
{
mat_mulvect(&p_Father->p_WorldMatrix, &p_CurrentPosition, &postmp);
vect_copy(&postmp, &p_CurrentPosition);
}
// update degli OSMs
for (i=0; i<p_NumOSMs; i++) p_OSMs[i]->m_Update(frame, &p_Pivot);
// update e del volume gerarchico + fine di tutti
if (p_SPHEREBoundVolume)
p_Lods[0].Mesh->p_SPHEREBoundVolume.m_Update(&p_WorldMatrix, p_SPHEREBoundVolume);
if (p_AABBBoundVolume)
p_Lods[0].Mesh->p_AABBBoundVolume.m_Update(&p_WorldMatrix, p_AABBBoundVolume);
if (p_OBBBoundVolume)
p_Lods[0].Mesh->p_OBBBoundVolume.m_Update(&p_WorldMatrix, p_OBBBoundVolume);
}
int32 CGeometricObject::m_CopyTEX2Vertex(int32 baseIndex, void *dest,
CMesh *mesh)
{
FVFGeometryUV2 *l_dest;
int32 i;
l_dest=(FVFGeometryUV2 *)dest;
for (i=0; i<mesh->p_NumDriverVertex; i++)
{
//vect_copy(&mesh->p_DriverVertex[i].point, &l_dest[i+baseIndex].point);
vect_sub(&mesh->p_DriverVertex[i].point, &p_Pivot, &l_dest[i+baseIndex].point);
vect_copy(&mesh->p_DriverVertex[i].normal, &l_dest[i+baseIndex].normal);
l_dest[i+baseIndex].uv1.u=mesh->p_DriverVertex[i].uv1.u;
l_dest[i+baseIndex].uv1.v=mesh->p_DriverVertex[i].uv1.v;
l_dest[i+baseIndex].uv2.u=mesh->p_DriverVertex[i].uv2.u;
l_dest[i+baseIndex].uv2.v=mesh->p_DriverVertex[i].uv2.v;
}
return (mesh->p_NumDriverVertex);
}
void AD_TaperModifier::Map(AD_Vect3D *pos, AD_Vect3D *out)
{
float f, z;
AD_Vect3D p;
if (l == 0)
{
vect_copy(pos, out);
return;
}
mat_mulvect(&tm, pos, &p);
if (dolim)
{
if (p.y<lowlim)
{
z = lowlim/l;
}
else
if (p.y>uplim)
{
z = uplim/l;
}
else
{
z = p.y/l;
}
}
else
{
z = p.y/l;
}
if (symmetry && z<0.0f) z = -z;
f = 1 + z*amount + curve*z*(1-z);
if (doX) p.x *= f;
if (doY) p.z *= f;
mat_mulvect(&invtm, &p, out);
}
void AD_Object3D::precalc_radius(void)
{
int16 i;
float4 aux=-1.0, mn;
AD_Vect3D midp, paux;
vect_set(&midp, 0, 0, 0);
for (i=0; i<num_vertex3D; i++)
{
vect_add(&midp, &vertex3D[i].point, &midp);
}
vect_scale(&midp, 1.0f/(float)num_vertex3D, &midp);
vect_copy(&midp, &mid_point);
for (i=0; i<num_vertex3D; i++)
{
vect_sub(&vertex3D[i].point, &midp, &paux);
mn=vect_lenght(&paux);
if (mn>aux) aux=mn;
}
radius=aux;
}
void AD_TwistModifier::Map(AD_Vect3D *pos, AD_Vect3D *out)
{
AD_Vect3D v;
float x, y, z, a, cosine, sine;
if (angle==0.0f)
{
vect_copy(pos, out);
return;
}
mat_mulvect (&tm, pos, &v);
x = v.x;
z = v.z;
if (dolim)
{
if (v.y < lowlim) y = lowlim;
else if (v.y > uplim) y = uplim;
else y = v.y;
}
else y = v.y;
if (bias>0)
{
float u = y/height;
a = angle * (float)pow(fabs(u), bias);
if (u<0.0) a = -a;
}
else a = y * angleOverHeight;
cosine = cosf(a);
sine = sinf(a);
v.x = cosine*x + sine*z;
v.z = -sine*x + cosine*z;
mat_mulvect (&invtm, &v, out);
}
void AD_BendModifier::Map(AD_Vect3D *pos, AD_Vect3D *out)
{
AD_Vect3D p, v;
float x, y, c, s, yr;
if (r==0)
{
vect_copy(pos, out);
return;
}
mat_mulvect (&tm, pos, &p);
if (dolim)
{
if (p.y < lowlim)
{
mat_mulvect (&tmBelow, &p, &v);
mat_mulvect (&invtm, &v, out);
return;
}
else if (p.y > uplim)
{
mat_mulvect (&tmAbove, &p, &v);
mat_mulvect (&invtm, &v, out);
return;
}
}
x = p.x;
y = p.y;
yr = y/r;
c = cosf((float)(M_PI-yr));
s = sinf((float)(M_PI-yr));
p.x = r*c + r - x*c;
p.y = r*s - x*s;
mat_mulvect (&invtm, &p, out);
}
int32 CGeometricObject::m_CopyVertex(int32 baseIndex, void *dest,
CMesh *mesh)
{
FVFOnlyGeometry *l_dest;
int32 i;
// if (p_ScaleTrack)
// p_ScaleTrack->m_GetData(0, &p_CurrentScale);
l_dest=(FVFOnlyGeometry *)dest;
for (i=0; i<mesh->p_NumDriverVertex; i++)
{
//vect_copy(&mesh->p_DriverVertex[i].point, &l_dest[i+baseIndex].point);
vect_sub(&mesh->p_DriverVertex[i].point, &p_Pivot, &l_dest[i+baseIndex].point);
vect_copy(&mesh->p_DriverVertex[i].normal, &l_dest[i+baseIndex].normal);
/*
l_dest[i+baseIndex].normal.x*=p_CurrentScale.x;
l_dest[i+baseIndex].normal.y*=p_CurrentScale.y;
l_dest[i+baseIndex].normal.z*=p_CurrentScale.z;
*/
}
return (mesh->p_NumDriverVertex);
}
void CGeometricObject::m_DoOSMs(int32 witchLod)
{
int32 i, j, k;
AD_Vect3D *point_tr, pp;
DriverVertex *l_DriverVertex;
HRESULT hr;
uint32 start_lock, end_lock, vsize;
BYTE *l_Data;
k=p_Lods[witchLod].Mesh->p_NumDriverVertex;
l_DriverVertex=p_Lods[witchLod].Mesh->p_DriverVertex;
vsize=p_BaseMaterial->p_InputVertexFormat.vertexSize;
start_lock=p_Lods[witchLod].VBStart*vsize;
end_lock=p_Lods[witchLod].VBLong*vsize;
locka:
;
hr=p_VertexBuffer->Lock(start_lock, end_lock,
(BYTE **)&l_Data, D3DLOCK_NOOVERWRITE );// 0);
if (hr!=D3D_OK) goto locka;
for (i=0; i<k; i++)
{
point_tr=(AD_Vect3D *)l_Data;
//vect_copy(&l_DriverVertex[i].point, &pp);
vect_sub(&l_DriverVertex[i].point, &p_Pivot, &pp);
for (j=0; j<p_NumOSMs; j++)
{
p_OSMs[j]->m_Map(&pp, &pp);
}
vect_copy(&pp, point_tr);
l_Data+=vsize;
}
hr=p_VertexBuffer->Unlock();
}
void CParticleSystem::m_Paint(void *arg1, void *arg2, void *arg3)
{
CRenderLib *RL;
HRESULT hr;
ParticleVBVertex *l_Particles;
AD_Matrix l_identity;
int32 numLive, i, alpha;
DWORD zw, ab;
RL=(CRenderLib *)arg1;
if (!RL) return;
hr=RL->p_Device->GetRenderState(D3DRS_ALPHABLENDENABLE, &ab);
hr=RL->p_Device->GetRenderState(D3DRS_ZWRITEENABLE, &zw);
// matrice identita', i particle vivono gia' nello spazio mondo!!!
mat_identity(&l_identity);
RL->m_SetWorldMatrix(&l_identity);
hr=RL->p_Device->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE);
hr=RL->p_Device->SetRenderState(D3DRS_POINTSCALEENABLE, TRUE);
hr=RL->p_Device->SetRenderState(D3DRS_POINTSIZE, F2DW(p_Attenuation0));
hr=RL->p_Device->SetRenderState(D3DRS_POINTSIZE_MIN, F2DW(0.0f));
//RL->p_Device->SetRenderState(D3DRS_POINTSIZE_MAX, F2DW(50.0f));
hr=RL->p_Device->SetRenderState(D3DRS_POINTSCALE_A, F2DW(p_Attenuation1));
hr=RL->p_Device->SetRenderState(D3DRS_POINTSCALE_B, F2DW(p_Attenuation2));
hr=RL->p_Device->SetRenderState(D3DRS_POINTSCALE_C, F2DW(p_Attenuation3));
hr=RL->p_Device->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
hr=RL->p_Device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
hr=RL->p_Device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
hr=RL->p_Device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
// SERVE SENNO' SONO CAZZI
hr=RL->p_Device->SetRenderState(D3DRS_LIGHTING, FALSE);
hr=RL->p_Device->SetRenderState(D3DRS_FOGENABLE, FALSE);
hr=RL->p_Device->SetTexture(0, p_Texture->p_HWSurfaces[0]);
hr=RL->p_Device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
hr=RL->p_Device->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
hr=RL->p_Device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
hr=RL->p_Device->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
hr=RL->p_Device->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
hr=RL->p_Device->SetTexture(1, NULL);
hr=RL->p_Device->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
hr=RL->p_Device->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
hr=RL->p_Device->SetTexture(2, NULL);
hr=RL->p_Device->SetTextureStageState(2, D3DTSS_COLOROP, D3DTOP_DISABLE);
hr=RL->p_Device->SetTextureStageState(2, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
// Set up the vertex buffer to be rendered
RL->p_Device->SetStreamSource(0, p_VertexBuffer, sizeof(ParticleVBVertex));
RL->p_Device->SetVertexShader(FVF_PARTICLE);
begin:
//hr=p_VertexBuffer->Lock(0, 0, (BYTE **)&l_Particles, D3DLOCK_NOOVERWRITE);
hr=p_VertexBuffer->Lock(0, 0, (BYTE **)&l_Particles, 0);
if (hr!=0) goto begin;
numLive=0;
if (p_FadedParticles<=0)
for (i=0; i<p_MaxParticles; i++)
{
// lock e paint con drawprimitve
if (p_Particles[i].age > 0)
{
vect_copy(&p_Particles[i].pos, &l_Particles[numLive].pos);
l_Particles[numLive].color=0xffffffff;
numLive++;
}
}
else
{
float4 h=p_FadedParticles*p_Life;
float4 invLife=255.0f/(p_Life-h);
float4 fStart=0.08f*p_Life;
for (i=0; i<p_MaxParticles; i++)
{
// lock e paint con drawprimitve
if (p_Particles[i].age > 0)
{
vect_copy(&p_Particles[i].pos, &l_Particles[numLive].pos);
if (p_Particles[i].age<=fStart)
{
alpha=(int32)(255.0f*p_Particles[i].age/fStart);
}
else
if (p_Particles[i].age<=h) alpha=255;
else
{
alpha=((int32)((p_Particles[i].age-h)*invLife)) & 0xFF;
alpha=255-alpha;
}
//l_Particles[numLive].color=0x00ffffff | (alpha <<24);
//l_Particles[numLive].color=(bb) | (gg<<8) | (rr<<16) | (alpha <<24);
l_Particles[numLive].color=p_Particles[numLive].color | (alpha <<24);
numLive++;
}
}
}
again:
hr=p_VertexBuffer->Unlock();
if (hr!=0) goto again;
if (numLive>0)
hr=RL->p_Device->DrawPrimitive(D3DPT_POINTLIST, 0, numLive);
hr=RL->p_Device->SetRenderState(D3DRS_POINTSPRITEENABLE, FALSE);
hr=RL->p_Device->SetRenderState(D3DRS_POINTSCALEENABLE, FALSE);
hr=RL->p_Device->SetRenderState(D3DRS_ZWRITEENABLE, zw);
hr=RL->p_Device->SetRenderState(D3DRS_ALPHABLENDENABLE, ab);
}
void start( void *data, const char *el, const char **attr ) {
parse_data *pdata = (parse_data*)data;
float xyz[3];
if( pdata == NULL ) {
fprintf( stderr, "*** xml: parse data is NULL\n" );
exit( 1 );
}
if( strcmp( el, "scene" ) == 0 ) {
}
else if( pdata->prim == NULL ) {
pdata->prim = (primitive*)calloc( 1, sizeof( primitive ) );
if( strcmp( el, "sphere" ) == 0 ) {
pdata->prim->type = SPHERE;
pdata->prim->intersect = &sphere_isect;
pdata->prim->normal = &sphere_normal;
pdata->prim->data = (sphere_data*)malloc( sizeof( sphere_data ) );
parse_light( pdata->prim, attr );
parse_xyz( xyz, attr );
((sphere_data*)pdata->prim->data)->radius = parse_attrf(
"radius", attr, 0.0f );
((sphere_data*)pdata->prim->data)->center.x = xyz[0];
((sphere_data*)pdata->prim->data)->center.y = xyz[1];
((sphere_data*)pdata->prim->data)->center.z = xyz[2];
vect_copy( &pdata->prim->center,
&((sphere_data*)pdata->prim->data)->center );
/* set some defaults */
pdata->prim->mat.col.x = 1.0f;
pdata->prim->mat.col.y = 1.0f;
pdata->prim->mat.col.z = 1.0f;
pdata->prim->mat.diffuse = 1.0f;
pdata->prim->mat.specular = 0.0f;
pdata->prim->mat.refl = 0.0f;
pdata->prim->mat.is_refr = 0;
}
else if( strcmp( el, "plane" ) == 0 ) {
pdata->prim->type = PLANE;
pdata->prim->intersect = &plane_isect;
pdata->prim->normal = &plane_normal;
pdata->prim->data = (plane_data*)malloc( sizeof( plane_data ) );
parse_light( pdata->prim, attr );
parse_xyz( xyz, attr );
((plane_data*)pdata->prim->data)->normal.x = xyz[0];
((plane_data*)pdata->prim->data)->normal.y = xyz[1];
((plane_data*)pdata->prim->data)->normal.z = xyz[2];
((plane_data*)pdata->prim->data)->dist = parse_attrf(
"distance", attr, 0.0f );
vect_copy( &pdata->prim->center,
&((plane_data*)pdata->prim->data)->normal );
/* set some defaults */
pdata->prim->mat.col.x = 1.0f;
pdata->prim->mat.col.y = 1.0f;
pdata->prim->mat.col.z = 1.0f;
pdata->prim->mat.diffuse = 1.0f;
pdata->prim->mat.specular = 0.0f;
pdata->prim->mat.refl = 0.0f;
pdata->prim->mat.is_refr = 0;
}
else if( strcmp( el, "box" ) == 0 ) {
pdata->prim->type = BOX;
pdata->prim->intersect = &box_isect;
pdata->prim->normal = &box_normal;
pdata->prim->data = (box_data*)malloc( sizeof( box_data ) );
parse_xyz( xyz, attr );
((box_data*)pdata->prim->data)->point.x = xyz[0];
((box_data*)pdata->prim->data)->point.y = xyz[1];
((box_data*)pdata->prim->data)->point.z = xyz[2];
((box_data*)pdata->prim->data)->size.x = parse_attrf(
"width", attr, 0.0f );
((box_data*)pdata->prim->data)->size.y = parse_attrf(
"height", attr, 0.0f );
((box_data*)pdata->prim->data)->size.z = parse_attrf(
"depth", attr, 0.0f );
pdata->prim->center.x = xyz[0] +
(0.5f * ((box_data*)pdata->prim->data)->size.x);
pdata->prim->center.y = xyz[1] +
(0.5f * ((box_data*)pdata->prim->data)->size.y);
pdata->prim->center.z = xyz[2] +
(0.5f * ((box_data*)pdata->prim->data)->size.z);
parse_light( pdata->prim, attr );
/* set some defaults */
pdata->prim->mat.col.x = 1.0f;
pdata->prim->mat.col.y = 1.0f;
pdata->prim->mat.col.z = 1.0f;
pdata->prim->mat.diffuse = 1.0f;
pdata->prim->mat.specular = 0.0f;
pdata->prim->mat.refl = 0.0f;
pdata->prim->mat.is_refr = 0;
}
else {
fprintf( stderr,
"*** xml: unknown primitive type \"%s\" at line %lu\n",
el, XML_GetCurrentLineNumber( pdata->parser ) );
exit( 1 );
}
pdata->prim->next = pdata->head;
pdata->head = pdata->prim;
}
else if( strcmp( el, "material" ) == 0 ) {
pdata->prim->mat.col.x = parse_attrf( "r", attr, 1.0f );
pdata->prim->mat.col.y = parse_attrf( "g", attr, 1.0f );
pdata->prim->mat.col.z = parse_attrf( "b", attr, 1.0f );
pdata->prim->mat.diffuse = parse_attrf( "diffuse", attr, 1.0f );
pdata->prim->mat.specular = parse_attrf( "specular", attr, 0.0f );
pdata->prim->mat.refl = parse_attrf( "reflectivity", attr, 0.0f );
pdata->prim->mat.is_refr = parse_attrb( "refractive", attr, 0 );
if( pdata->prim->mat.is_refr ) {
pdata->prim->mat.refr = parse_attrf( "refractivity", attr, 1.0f );
}
}
else if( strcmp( el, "light" ) == 0 ) {
}
}
void AD_Object3D::paint_modifiers(float4 pos, AD_Camera *telecamera, AD_Omnilight *omnilight)
{
int i, j, w;
AD_Matrix matrixrot_all, matrixtransform_all;
AD_Matrix matrixtall_clip;
AD_Vect3D p1, p2, vtmp, p;
AD_Vertex3D *v;
float invz;
// float x1, y1, z1, x2, y2, z2;
// calcolo delle matrici di traspfromazione tra spazi
mat_mulaffine(&telecamera->currentmatrix_rot, ¤tmatrix_rot, &matrixrot_all);
mat_mul(&telecamera->currentmatrix, ¤tmatrix, &matrixtall_clip);
// calcolo della matrice di trasformazione con inclusi i
// fattori di aspect ratio;
mat_copy(&matrixtall_clip, &matrixtransform_all);
for (w=0; w<4; w++)
{
matrixtransform_all.a[0][w]=matrixtransform_all.a[0][w]*telecamera->prospettivaX;
matrixtransform_all.a[1][w]=matrixtransform_all.a[1][w]*telecamera->prospettivaY;
}
/*
for (j=0; j<num_OSMmods; j++)
{
// if (j>0)
// OSMmods[j]->set_bbox(x1, y1, z1, x2, y2, z2);
OSMmods[j]->update(pos);
// calcolo bounding box per poi settarla negli OSM
x1=y1=z1=1E10;
x2=y2=z2=-1E10;
for (i=0; i<num_vertex; i++)
{
OSMmods[j]->Map(&points_tr[i], &points_tr[i]);
if (points_tr[i].x < x1) x1 = points_tr[i].x;
if (points_tr[i].y < y1) y1 = points_tr[i].y;
if (points_tr[i].z < z1) z1 = points_tr[i].z;
if (points_tr[i].x > x2) x2 = points_tr[i].x;
if (points_tr[i].y > y2) y2 = points_tr[i].y;
if (points_tr[i].z > z2) z2 = points_tr[i].z;
}
}
*/
for (j=0; j<num_OSMmods; j++)
OSMmods[j]->update(pos);
for (i=0; i<num_vertex3D; i++)
{
// trasformazione tramite OSM di tutti i vertici e
// salvataggio dentro points_tr (i points originali devono
// essere preservati)
vect_copy(&vertex3D[i].point, &vertex3D[i].tpoint);
vertex3D[i].flags=0;
vect_set(&normals[i], 0, 0, 0);
for (j=0; j<num_OSMmods; j++)
{
OSMmods[j]->Map(&vertex3D[i].tpoint, &vertex3D[i].tpoint);
}
}
// TRIA_PIPELINE_ENVRGB_MODIFIERS
// TRIA_PIPELINE_RGB_MODIFIERS
TRIA_PIPELINE_ENVMAP_MODIFIERS
TRIA_PIPELINE_ELSE_MODIFIERS
}
color* trace( ray *aray, primitive *scene, int depth, float refr, float *dist,
int shadows ){
intersection *isect;
primitive *prim, *iter;
vector isect_pt, pn, lv, ln, tmpv1, tmpv2;
ray tmpr;
float tmpf1, tmpf2, tmpf3, shade;
color *tmpc;
color *c = (color*)malloc( sizeof( color ) );
if( c == NULL ) {
fprintf( stderr, "*** error: could not allocate color memory\n" );
exit( 1 );
}
c->x = 0.0f;
c->y = 0.0f;
c->z = 0.0f;
isect = intersect( aray, scene );
if( isect == NULL ) {
return c;
}
*dist = isect->dist;
prim = isect->prim;
if( prim->is_light ) {
vect_copy( c, &(isect->prim->mat.col) );
free( isect );
return c;
}
vect_copy( &isect_pt, aray->dir );
vect_multf( &isect_pt, isect->dist );
vect_add( &isect_pt, aray->origin );
prim->normal( prim, &isect_pt, &pn );
iter = scene;
while( iter != NULL ) {
if( iter->is_light ) {
vect_copy( &lv, &iter->center );
vect_sub( &lv, &isect_pt );
vect_copy( &ln, &lv );
vect_normalize( &ln );
shade = calc_shade( iter, &isect_pt, &lv, &ln, scene, shadows );
if( shade > 0.0f ) {
/* determine the diffuse component */
tmpf1 = prim->mat.diffuse;
if( tmpf1 > 0.0f ) {
tmpf2 = vect_dot( &pn, &ln );
if( tmpf2 > 0.0f ) {
tmpf1 *= tmpf2 * shade;
vect_copy( &tmpv1, &prim->mat.col );
vect_mult( &tmpv1, &iter->mat.col );
vect_multf( &tmpv1, tmpf1 );
vect_add( c, &tmpv1 );
}
}
/* determine the specular component */
tmpf1 = prim->mat.specular;
if( tmpf1 > 0.0f ) {
vect_copy( &tmpv1, &pn );
vect_copy( &tmpv2, &ln );
tmpf2 = 2.0f * vect_dot( &ln, &pn );
vect_multf( &tmpv1, tmpf2 );
vect_sub( &tmpv2, &tmpv1 );
tmpf2 = vect_dot( aray->dir, &tmpv2 );
if( tmpf2 > 0.0f ) {
tmpf1 = powf( tmpf2, 20.0f ) * tmpf1 * shade;
vect_copy( &tmpv1, &iter->mat.col );
vect_multf( &tmpv1, tmpf1 );
vect_add( c, &tmpv1 );
}
}
}
}
iter = iter->next;
}
/* calculate reflection */
if( prim->mat.refl > 0.0f && depth < TRACE_DEPTH ) {
vect_copy( &tmpv1, &pn );
vect_multf( &tmpv1, 2.0f * vect_dot( &pn, aray->dir ) );
vect_copy( &tmpv2, aray->dir );
vect_sub( &tmpv2, &tmpv1 );
vect_copy( &tmpv1, &tmpv2 );
vect_multf( &tmpv1, EPSILON );
vect_add( &tmpv1, &isect_pt );
tmpr.origin = &tmpv1;
tmpr.dir = &tmpv2;
tmpc = trace( &tmpr, scene, depth + 1, refr, &tmpf1, shadows );
vect_multf( tmpc, prim->mat.refl );
vect_copy( &tmpv1, &prim->mat.col );
vect_mult( &tmpv1, tmpc );
vect_add( c, &tmpv1 );
free( tmpc );
}
/* calculate refraction */
if( prim->mat.is_refr && depth < TRACE_DEPTH ) {
vect_copy( &tmpv1, &pn );
if( isect->inside ) {
vect_multf( &tmpv1, -1.0f );
}
tmpf1 = refr / prim->mat.refr;
tmpf2 = -( vect_dot( &tmpv1, aray->dir ) );
tmpf3 = 1.0f - tmpf1 * tmpf1 * (1.0f - tmpf2 * tmpf2);
if( tmpf3 > 0.0f ) {
vect_copy( &tmpv2, aray->dir );
vect_multf( &tmpv2, tmpf1 );
vect_multf( &tmpv1, tmpf1 * tmpf2 - sqrtf( tmpf3 ) );
vect_add( &tmpv1, &tmpv2 );
vect_copy( &tmpv2, &tmpv1 );
vect_multf( &tmpv2, EPSILON );
vect_add( &tmpv2, &isect_pt );
tmpr.origin = &tmpv2;
tmpr.dir = &tmpv1;
tmpc = trace( &tmpr, scene, depth + 1, refr, &tmpf1, shadows );
vect_copy( &tmpv1, &prim->mat.col );
vect_multf( &tmpv1, prim->mat.absorb * tmpf1 );
tmpv2.x = expf( -tmpv1.x );
tmpv2.y = expf( -tmpv1.y );
tmpv2.z = expf( -tmpv1.z );
vect_mult( tmpc, &tmpv2 );
vect_add( c, tmpc );
free( tmpc );
}
}
free( isect );
if( c->x > 1.0f ) {
c->x = 1.0f;
}
else if( c->x < 0.0f ) {
c->x = 0.0f;
}
if( c->y > 1.0f ) {
c->y = 1.0f;
}
else if( c->y < 0.0f ) {
c->y = 0.0f;
}
if( c->z > 1.0f ) {
c->z = 1.0f;
}
else if( c->z < 0.0f ) {
c->z = 0.0f;
}
return c;
}
float calc_shade( primitive *light, vector *isect_pt, vector *lv, vector *ln,
primitive *scene, int shadows ) {
float shade = 1.0f;
float l_dist;
int i;
ray r;
vector o, dir;
intersection *isect;
primitive *iter;
if( light->is_light == AREA_LIGHT && shadows > 1 && light->grid != NULL ) {
for( i = 0; i < shadows; i++ ) {
dir.x = light->grid[(i&63)*3] +
((float)rand()/RAND_MAX)*light->dx;
dir.y = light->grid[(i&63)*3+1] +
((float)rand()/RAND_MAX)*light->dy;
dir.z = light->grid[(i&63)*3+2] +
((float)rand()/RAND_MAX)*light->dz;
vect_sub( &dir, isect_pt );
l_dist = vect_length( &dir );
vect_multf( &dir, 1.0f / l_dist );
vect_copy( &o, &dir );
vect_multf( &o, EPSILON );
vect_add( &o, isect_pt );
r.origin = &o;
r.dir = &dir;
for( iter = scene; iter != NULL; iter = iter->next ) {
isect = iter->intersect( iter, &r );
if( isect != NULL &&
!iter->is_light && isect->dist < l_dist ) {
shade -= 1.0f / shadows;
free( isect );
break;
}
free( isect );
}
}
}
else {
/* setup the ray */
vect_copy( &o, ln );
vect_multf( &o, EPSILON );
vect_add( &o, isect_pt );
r.origin = &o;
r.dir = ln;
l_dist = vect_length( lv );
for( iter = scene; iter != NULL; iter = iter->next ) {
isect = iter->intersect( iter, &r );
if( isect != NULL && !iter->is_light && isect->dist < l_dist ) {
shade = 0.0f;
free( isect );
break;
}
free( isect );
}
}
return shade;
}
void AD_Object3D::init_normals(void)
// le normali dei triangoli devono essere gia' state calcolate
// vertici triangoli e smoothing groups devono già essare in memoria
{
#define normal_err 0.0001f
// indica l'errore massimo possibile x riciclare una normale: + e' alto il numero piu'
// si perde qualita' visiva e si guadagna velocita': bisogna trovare un buon compromesso
int *condivisi;
int *smooth, *nosmooth; // array di triangoli condivisi da smoothare
AD_Vect3D *tempnormal;
AD_Vect3D normadd;
int num_condivisi, i, j, tr, num_smooth, num_nosmooth;
int num_normal, norm;
float maxerr, err;
condivisi=new int[num_tria]; // nel caso peggiore tutti i triangoli sono condivisi
smooth=new int[num_tria];
nosmooth=new int[num_tria];
tempnormal=new AD_Vect3D[num_tria*3]; // nel caso peggiore ci sono 3 normali per triangolo
num_normal=0;
for (i=0; i<num_vertex3D; i++)
{
// trovo i triangoli che condividono il vertice i
num_condivisi=0;
for (j=0; j<num_tria; j++)
{
if ((tria[j].v1==&vertex3D[i]) ||
(tria[j].v2==&vertex3D[i]) ||
(tria[j].v3==&vertex3D[i]))
{
condivisi[num_condivisi]=j;
num_condivisi++;
}
}
while (num_condivisi>0)
{
tr=condivisi[0]; // triangolo di riferimento
num_smooth=0;
num_nosmooth=0;
smooth[num_smooth]=tr;
num_smooth++;
for(j=1; j<num_condivisi; j++)
{
if ((triasmoothgroup[tr] & triasmoothgroup[condivisi[j]])!=0)
{
smooth[num_smooth]=condivisi[j];
num_smooth++;
}
else
{
nosmooth[num_nosmooth]=condivisi[j];
num_nosmooth++;
}
}
// cacolo la normale
vect_set(&normadd, 0, 0, 0);
for (j=0; j<num_smooth; j++)
vect_add(&normadd, &tria[smooth[j]].normal, &normadd);
vect_normalize(&normadd);
// cerco se ne esiste gia' una molto simile
j=0;
norm=-1;
maxerr=normal_err;
while (j < num_normal)
{
// trovo l'errore massimo della normale j
err=fmax(fmax(fabsf(normadd.x-tempnormal[j].x),
fabsf(normadd.y-tempnormal[j].y)),
fabsf(normadd.z-tempnormal[j].z));
if (err < maxerr)
{
// trovata normale + precisa
maxerr=err;
norm=j;
}
j++;
}
if (norm==-1)
{ // non trovata: la creo
vect_copy(&normadd, &tempnormal[num_normal]);
norm=num_normal;
num_normal++;
}
for (j=0; j<num_smooth; j++)
{
// la assegno al triangolo (cercando il vertice giusto)
if (tria[smooth[j]].v1==&vertex3D[i]) tria[smooth[j]].n1=&tempnormal[norm];
if (tria[smooth[j]].v2==&vertex3D[i]) tria[smooth[j]].n2=&tempnormal[norm];
if (tria[smooth[j]].v3==&vertex3D[i]) tria[smooth[j]].n3=&tempnormal[norm];
}
// tolgo quelli assegnati e ricompatto gli altri
for (j=0; j<num_nosmooth; j++) condivisi[j]=nosmooth[j];
num_condivisi-=num_smooth;
}
}
// copio la parte usata di tempnormal in normal
normals = new AD_Vect3D[num_normal];
num_normals=num_normal;
for (j=0; j<num_normal; j++)
{
vect_copy(&tempnormal[j], &normals[j]);
for (i=0; i<num_tria; i++)
{
if (tria[i].n1==&tempnormal[j]) tria[i].n1=&normals[j];
if (tria[i].n2==&tempnormal[j]) tria[i].n2=&normals[j];
if (tria[i].n3==&tempnormal[j]) tria[i].n3=&normals[j];
}
}
delete [] condivisi;
delete [] smooth;
delete [] nosmooth;
delete [] tempnormal;
delete [] triasmoothgroup; // non servono piu'
}
int AD_Object3D::init(void)
{
// AD_Lod lodder;
int k;
AD_Quaternion q;
AD_Matrix M;
//AD_Vect3D v;
float x1, y1, z1, x2, y2, z2;
AD_OSMObject *OSMaux[100];
// ############ INIZIALIZZAZIONI DELLE KEYFRAMER ############
if (positiontrack.init()==-1) return(-1);
if (rotationtrack.init()==-1) return(-1);
if (scaletrack.init()==-1) return(-1);
// cistruisco le quantita' che mi permettono di costruire una
// eventuale matrice di skin se questo oggetto fosse usato come
// osso
if (rotationtrack.numkey>0)
{
rotationtrack.get_data(0, &q);
quat_rotquat_to_matrix(&q, &M);
mat_transpose(&M, &rot0);
}else mat_identity(&rot0);
if (scaletrack.numkey>0) scaletrack.get_data(0, &scale0);
else vect_set(&scale0, 1, 1, 1);
if (positiontrack.numkey>0) positiontrack.get_data(0, &pos0);
else vect_set(&pos0, 0, 0, 0);
/*
if ((positiontrack.numkey==1) && (positiontrack.posizioni[0].posintrack==0) &&
(father==(AD_Object3D *)NULL) && (have_childrens<=0))
{
currentpos=positiontrack.posizioni[0].p;
positiontrack.numkey=0;
}
*/
if (type==DUMMY)
{
// sistemo il flare connesso; devo creare i 2 triangoli,
// i vertici 2D, 3D (solo per linkare i v2D), il materiale
// trasparente
if (flare!=(texture *)NULL)
{
latoX=(float)flare->dimx;
latoY=(float)flare->dimy;
// setto le uv dei vertici per il flare; i vertici sono cosi'
// disposti
// 0----1
// | |
// | |
// 2----3
vertex2D[0].u=0.0f*TEXTURE_PRECISION;
vertex2D[0].v=0.0f*TEXTURE_PRECISION;
vertex2D[1].u=0.99f*TEXTURE_PRECISION;
vertex2D[1].v=0.0f*TEXTURE_PRECISION;
vertex2D[2].u=0.0f*TEXTURE_PRECISION;
vertex2D[2].v=0.99f*TEXTURE_PRECISION;
vertex2D[3].u=0.99f*TEXTURE_PRECISION;
vertex2D[3].v=0.99f*TEXTURE_PRECISION;
// i vertici 3D li setto sempre da non clippare visto
// che quando devo disegnare i flare sono sicuro che non
// devo clipparli e solo quando disegno li inserisco nella
// lista dei triangoli trasparenti
vertex3D[0].flags=0;
vertex3D[1].flags=0;
vertex3D[2].flags=0;
vertex3D[3].flags=0;
// setto il materiale
matflare.texture_ptr=flare;
matflare.flags=(0 | PAINT_TEXTURE | IS_TRASPARENT);
matflare.trasparencytype=MIXTYPE_ADD;
AddUpdate_Material(&matflare);
// ATTENZIONE: non cambiare gli indici perche' a causa
// del settaggio di cull2D della scheda3D i triangoli
// devono essere in senso antiorario
// setto i triangoli
tria[0].materiale=&matflare;
tria[0].v1=&vertex3D[0];
tria[0].v2=&vertex3D[2];
tria[0].v3=&vertex3D[3];
tria[0].sp1=&vertex2D[0];
tria[0].sp2=&vertex2D[2];
tria[0].sp3=&vertex2D[3];
tria[1].materiale=&matflare;
tria[1].v1=&vertex3D[3];
tria[1].v2=&vertex3D[1];
tria[1].v3=&vertex3D[0];
tria[1].sp1=&vertex2D[3];
tria[1].sp2=&vertex2D[1];
tria[1].sp3=&vertex2D[0];
}
return(0);
}
if (type==BONE) return(0);
/* NON PIU' FATTIBILE A CAUSA DEGLI OSM
------------------------------------------
-----------------------------------------
// OTTIMIZAZIONE !!!
if ((rotationtrack.numkey==1) && (rotationtrack.rotazioni[0].posintrack==0) &&
(father==(AD_Object3D *)NULL) && (have_childrens<=0))
{
q=rotationtrack.rotazioni[0].rotquat;
quat_rotquat_to_matrix(&q, &M);
rotationtrack.numkey=0;
mat_identity(¤tmatrix_rot);
for (k=0; k<num_vertex; k++)
{
mat_mulvect(&M, &points[k], &v);
vect_copy(&v, &points[k]);
}
}
if ((scaletrack.numkey==1) && (scaletrack.posizioni[0].posintrack==0) &&
(father==(AD_Object3D *)NULL) && (have_childrens<=0))
{
for (k=0; k<num_vertex; k++)
{
points[k].x*=scaletrack.posizioni[0].p.x;
points[k].y*=scaletrack.posizioni[0].p.y;
points[k].z*=scaletrack.posizioni[0].p.z;
}
scaletrack.numkey=0;
}
*/
// calcolo bounding box per poi settarla negli OSM
x1=y1=z1=1E10;
x2=y2=z2=-1E10;
for (k=0; k<num_vertex3D; k++)
{
if (vertex3D[k].point.x < x1) x1 = vertex3D[k].point.x;
if (vertex3D[k].point.y < y1) y1 = vertex3D[k].point.y;
if (vertex3D[k].point.z < z1) z1 = vertex3D[k].point.z;
if (vertex3D[k].point.x > x2) x2 = vertex3D[k].point.x;
if (vertex3D[k].point.y > y2) y2 = vertex3D[k].point.y;
if (vertex3D[k].point.z > z2) z2 = vertex3D[k].point.z;
}
// inverto l'ordine degli OSM perche' vanno applicati
// al contrario
for (k=0; k<(int)num_OSMmods; k++)
OSMaux[k]=OSMmods[k];
for (k=0; k<(int)num_OSMmods; k++)
OSMmods[num_OSMmods-k-1]=OSMaux[k];
// Inizializzazione OSM modifiers
for (k=0; k<(int)num_OSMmods; k++)
{
OSMmods[k]->init();
OSMmods[k]->set_bbox(x1, y1, z1, x2, y2, z2);
}
precalc_radius(); // precalcola raggio sfera circoscritta
init_tria(); // calcola: normale, punto medio e raggio circoscritto
init_texture_coordinate(); // rende positive le uv
init_vertex(); // alloca e prepara le normali ai vertici tenendo
// conto degli smoothing groups; inoltre setta
// opportunamente i campi n1, n2, n3, sp1, sp2, sp3
// dei triangoli
if (vertexUV!=(AD_VectUV *)NULL) delete [] vertexUV;
if (bones_matrix!=(AD_Matrix **)NULL)
for (k=0; k<num_vertex3D; k++)
{
// questo perchè in fase di lettura (UtilsA3D) i punti nello
// spazio delle bonez vengono messi in points_tr
vect_copy(&vertex3D[k].tpoint, &vertex3D[k].point);
}
// NB: IL LOD VA INSERITO IN QUESTO PUNTO !!!!
// NE' PRIMA (perche' le uv ai vertici devono essere sistemate)
// NE' DOPO (perche' i tringoli devono eseere inizializzati
// tutti (anche quelli del modello semplificato) dopo)
// [ad]TURBO ROXXXXXXXXXXXXXXXXX
/*
lodder.apply_lod(vertex3D, num_vertex,
tria, num_tria,
70,
&vertex3D, &num_vertex,
&tria, &num_tria,
GEOMETRIC_LOD);
*/
split_tria_list();
return(0);
}
void AD_Object3D::build_objectmatrix (float4 framepos)
// costruisce la matrice di trasformazione, che servira' poi per trasformare
// i vertici dell'oggetto;
{
AD_Vect3D postmp, stmp, ptmp;
AD_Quaternion objrot;
AD_Matrix posttrans, scaling, maux, pretrans;
accum_scale.x=accum_scale.y=accum_scale.z=1.0f;
mat_identity(¤tmatrix_rot);
if (rotationtrack.numkey>0)
{
rotationtrack.get_data(framepos, &objrot);
quat_rotquat_to_matrix(&objrot, ¤tmatrix_rot);
}
mat_copy(¤tmatrix_rot, ¤tmatrix);
if (scaletrack.numkey>0)
{
scaletrack.get_data(framepos, &stmp);
mat_setmatrix_of_scaling(&scaling, stmp.x, stmp.y, stmp.z);
accum_scale.x*=stmp.x;
accum_scale.y*=stmp.y;
accum_scale.z*=stmp.z;
} else mat_identity(&scaling);
if (positiontrack.numkey>0) positiontrack.get_data(framepos, ¤tpos);
mat_setmatrix_of_pretraslation(&posttrans, ¤tpos);
if (type==BONE)
{
mat_mul(&scaling, ¤tmatrix_rot, &maux);
mat_mul(&posttrans, &maux, ¤tmatrix);
}
else
{
mat_mul(¤tmatrix_rot, &scaling, &maux);
mat_mul(&posttrans, &maux, ¤tmatrix);
}
// per le bone si costruiscono gia' le matrici comprese
// di padre; per oggetti non bone invece si costruiscono
// matrici relative e quindi devo 'accodarci' pure
// la trasformazione del padre
if (type!=BONE)
{
if (father!=(AD_Object3D *)NULL)
{
mat_mulaffine(&father->currentmatrix_rot, ¤tmatrix_rot, ¤tmatrix_rot);
mat_mul(&father->currentmatrix, ¤tmatrix, ¤tmatrix);
mat_mulvect(&father->currentmatrix, ¤tpos, &postmp);
vect_copy(&postmp, ¤tpos);
accum_scale.x*=father->accum_scale.x;
accum_scale.y*=father->accum_scale.y;
accum_scale.z*=father->accum_scale.z;
}
}
mat_transpose(¤tmatrix_rot, &inverse_rotmatrix);
if (skinned_object!=(AD_Object3D *)NULL)
{
if (father==(AD_Object3D *)NULL)
{
vect_copy(¤tpos, &ptmp);
vect_neg(&ptmp, &ptmp);
mat_setmatrix_of_pretraslation(&pretrans, &ptmp);
vect_neg(&ptmp, &ptmp);
mat_setmatrix_of_pretraslation(&posttrans, &ptmp);
mat_copy(&pretrans, &maux);
mat_mul(¤tmatrix_rot, &maux, &maux);
mat_mul(&rot0, &maux, &maux);
mat_mul(&scaling, &maux, &maux);
mat_setmatrix_of_scaling(&scaling, 1.0f/scale0.x, 1.0f/scale0.y, 1.0f/scale0.z);
mat_mul(&scaling, &maux, &maux);
//vect_sub(¤tpos, &pos0);
mat_mul(&posttrans, &maux, &skin_matrix);
}
else
{
/*
if (positiontrack.numkey>0) positiontrack.get_data(framepos, &ptmp);
vect_neg(&ptmp, &ptmp);
mat_setmatrix_of_pretraslation(&pretrans, &ptmp);
vect_neg(&ptmp, &ptmp);
mat_setmatrix_of_pretraslation(&posttrans, &ptmp);
mat_mul(&father->inverse_rotmatrix, ¤tmatrix_rot, &maux);
maux.a[0][3]=maux.a[1][3]=maux.a[2][3]=0;
mat_mul(&maux, &pretrans, &maux);
mat_mul(&scaling, &maux, &maux);
mat_mul(&posttrans, &maux, &skin_matrix);
mat_mul(&father->skin_matrix, &skin_matrix, &skin_matrix);
*/
mat_copy(&father->skin_matrix, &skin_matrix);
}
}
}
