//----------------------------------------------------------------//
bool _vecToXYPlane ( const ZLVec3D& v0, const ZLVec3D& v1, ZLVec2D& result ) {
ZLVec3D vec;
vec = v1;
vec.Sub ( v0 );
if ( vec.mZ != 0.0f ) {
result.mX = vec.mX;
result.mY = vec.mY;
float t = v0.mZ / -vec.mZ;
if (( t > 0.0f ) && ( t <= 1.0f )) {
result.Scale ( t );
result.mX += v0.mX;
result.mY += v0.mY;
return true;
}
}
return false;
}
//----------------------------------------------------------------//
bool MOAIVertexFormat::ComputeBounds ( void* buffer, u32 size, ZLBox& bounds ) {
u32 total = this->mVertexSize ? ( size / this->mVertexSize ) : 0;
if ( !total ) return false;
u32 coordAttributeIdx = this->mAttributeUseTable [ ARRAY_VERTEX ].mAttrID;
if ( coordAttributeIdx >= this->mTotalAttributes ) return false;
MOAIVertexAttribute& coordAttr = this->mAttributes [ coordAttributeIdx ];
if ( coordAttr.mType != ZGL_TYPE_FLOAT ) return false; // TODO: handle other types
if ( coordAttr.mSize < 2 ) return false;
buffer = ( void* )(( size_t )buffer + coordAttr.mOffset );
float* components = ( float* )buffer;
ZLVec3D coord ( components [ 0 ], components [ 1 ], ( coordAttr.mSize > 2 ? components [ 2 ] : 0.0f ));
bounds.Init ( coord );
bounds.Inflate ( 0.0000001f ); // prevent 'empty' bounds on cardinal direction lines or single vertex objects
for ( u32 i = 1; i < total; ++i ) {
buffer = ( void* )(( size_t )buffer + this->mVertexSize );
components = ( float* )buffer;
coord.Init ( components [ 0 ], components [ 1 ], ( coordAttr.mSize > 2 ? components [ 2 ] : 0.0f ));
bounds.Grow ( coord );
}
return true;
}
//----------------------------------------------------------------//
float ZLBox::GetRadius () const {
ZLVec3D spans = mMax;
spans.Sub ( mMin );
spans.Scale ( 0.5f );
return spans.Length ();
}
//----------------------------------------------------------------//
void ZLPrism::GetCenter ( ZLVec3D& center ) const {
center = this->mXAxis;
center.Add ( this->mYAxis );
center.Add ( this->mZAxis );
center.Scale ( 0.5f );
center.Add ( this->mLoc );
}
//----------------------------------------------------------------//
ZLVec3D MOAIAnimCurveVec::GetCurveDelta () const {
ZLVec3D delta;
u32 size = this->mKeys.Size ();
if ( size > 1 ) {
delta = this->mSamples [ size - 1 ];
delta.Sub ( this->mSamples [ 0 ]);
}
else {
delta.Init ( 0.0f, 0.0f, 0.0f );
}
return delta;
}
//----------------------------------------------------------------//
void ZLPrism::GetAABB ( ZLBox& box ) const {
ZLVec3D walker = mLoc;
box.Init ( walker );
walker.Add ( mYAxis );
box.Grow ( walker );
walker.Add ( mZAxis );
box.Grow ( walker );
walker.Sub ( mYAxis );
box.Grow ( walker );
walker.Add ( mXAxis );
box.Grow ( walker );
walker.Sub ( mZAxis );
box.Grow ( walker );
walker.Add ( mYAxis );
box.Grow ( walker );
walker.Add ( mZAxis );
box.Grow ( walker );
}
int GIIHelper::_setWorldLoc( lua_State *L ){
MOAILuaState state (L);
if ( !state.CheckParams ( 1, "UN" )) return 0;
MOAITransform* dst = state.GetLuaObject< MOAITransform >(1, true);
float x = state.GetValue< float >( 2, 0.0f );
float y = state.GetValue< float >( 3, 0.0f );
float z = state.GetValue< float >( 4, 0.0f );
ZLVec3D loc;
loc.Init( x, y, z );
const ZLAffine3D* inherit = dst->GetLinkedValue < ZLAffine3D* >( PACK_ATTR ( MOAITransformBase, MOAITransformBase::INHERIT_TRANSFORM ), 0 );
if( inherit ) {
ZLAffine3D inverse;
inverse.Inverse( *inherit );
inverse.Transform( loc );
}
dst->SetLoc( loc );
dst->ScheduleUpdate();
return 0;
}
//----------------------------------------------------------------//
void ZLQuaternion::Multiply ( const ZLQuaternion& rhs ) {
ZLVec3D cross;
cross.Cross ( mV, rhs.mV );
ZLVec3D resultVec;
resultVec.Init ( rhs.mV );
resultVec.Scale ( mS );
ZLVec3D scaledVec;
scaledVec.Init ( mV );
scaledVec.Scale ( rhs.mS );
resultVec.Add ( scaledVec );
resultVec.Sub ( cross );
mS = mS * rhs.mS - mV.Dot ( rhs.mV );
mV.Init ( resultVec );
}
//----------------------------------------------------------------//
ZLVec3D MOAIAnimCurveVec::GetValue ( const MOAIAnimKeySpan& span ) const {
MOAIAnimKey& key = this->mKeys [ span.mKeyID ];
ZLVec3D v0 = this->mSamples [ span.mKeyID ];
if ( span.mTime > 0.0f ) {
ZLVec3D v1 = this->mSamples [ span.mKeyID + 1 ];
v0.mX = ZLInterpolate::Interpolate ( key.mMode, v0.mX, v1.mX, span.mTime, key.mWeight );
v0.mY = ZLInterpolate::Interpolate ( key.mMode, v0.mY, v1.mY, span.mTime, key.mWeight );
v0.mZ = ZLInterpolate::Interpolate ( key.mMode, v0.mZ, v1.mZ, span.mTime, key.mWeight );
}
if ( span.mCycle != 0.0f ) {
ZLVec3D curveDelta = this->GetCurveDelta ();
curveDelta.Scale ( span.mCycle );
v0.Add ( curveDelta );
}
return v0;
}
//----------------------------------------------------------------//
void MOAIParticleForce::Eval ( const ZLVec3D& loc, float mass, ZLVec3D& acceleration, ZLVec3D& offset ) {
ZLVec3D force ( 0.0f, 0.0f, 0.0f );
ZLVec3D origin = this->mLocalToWorldMtx.GetTranslation ();
switch ( this->mShape ) {
case ATTRACTOR: {
ZLVec3D vec = origin;
vec.Sub ( loc );
float dist = vec.NormSafe () / this->mRadius;
if ( dist <= 1.0f ) {
dist = 1.0f - dist;
dist = dist * dist * this->mPull;
force.mX = vec.mX * dist;
force.mY = vec.mY * dist;
}
break;
}
case BASIN: {
ZLVec3D vec = origin;
vec.Sub ( loc );
float dist = vec.NormSafe () / this->mRadius;
dist = dist * dist * this->mPull;
force.mX = vec.mX * dist;
force.mY = vec.mY * dist;
break;
}
case LINEAR: {
force = this->mWorldVec;
break;
}
case RADIAL: {
force = origin;
force.Sub ( loc );
force.NormSafe ();
force.Scale ( this->mPull );
break;
}
}
switch ( this->mType ) {
case FORCE:
force.Scale ( 1.0f / mass );
acceleration.Add ( force );
break;
case GRAVITY:
acceleration.Add ( force );
break;
case OFFSET:
offset.Add ( force );
break;
}
}
