IntVector3 PListValue::GetIntVector3() const
{
if (type_ != PLVT_STRING)
return IntVector3::ZERO;
int x, y, z;
sscanf(string_->CString(), "{%d,%d,%d}", &x, &y, &z);
return IntVector3(x, y, z);
}
Variant ValueAnimation::LinearInterpolation(unsigned index1, unsigned index2, float scaledTime) const
{
const VAnimKeyFrame& keyFrame1 = keyFrames_[index1];
const VAnimKeyFrame& keyFrame2 = keyFrames_[index2];
float t = (scaledTime - keyFrame1.time_) / (keyFrame2.time_ - keyFrame1.time_);
const Variant& value1 = keyFrame1.value_;
const Variant& value2 = keyFrame2.value_;
switch (valueType_)
{
case VAR_FLOAT:
return Lerp(value1.GetFloat(), value2.GetFloat(), t);
case VAR_VECTOR2:
return value1.GetVector2().Lerp(value2.GetVector2(), t);
case VAR_VECTOR3:
return value1.GetVector3().Lerp(value2.GetVector3(), t);
case VAR_VECTOR4:
return value1.GetVector4().Lerp(value2.GetVector4(), t);
case VAR_QUATERNION:
return value1.GetQuaternion().Slerp(value2.GetQuaternion(), t);
case VAR_COLOR:
return value1.GetColor().Lerp(value2.GetColor(), t);
case VAR_INTRECT:
{
float s = 1.0f - t;
const IntRect& r1 = value1.GetIntRect();
const IntRect& r2 = value2.GetIntRect();
return IntRect((int)(r1.left_ * s + r2.left_ * t), (int)(r1.top_ * s + r2.top_ * t), (int)(r1.right_ * s + r2.right_ * t),
(int)(r1.bottom_ * s + r2.bottom_ * t));
}
case VAR_INTVECTOR2:
{
float s = 1.0f - t;
const IntVector2& v1 = value1.GetIntVector2();
const IntVector2& v2 = value2.GetIntVector2();
return IntVector2((int)(v1.x_ * s + v2.x_ * t), (int)(v1.y_ * s + v2.y_ * t));
}
case VAR_INTVECTOR3:
{
float s = 1.0f - t;
const IntVector3& v1 = value1.GetIntVector3();
const IntVector3& v2 = value2.GetIntVector3();
return IntVector3((int)(v1.x_ * s + v2.x_ * t), (int)(v1.y_ * s + v2.y_ * t), (int)(v1.z_ * s + v2.z_ * t));
}
case VAR_DOUBLE:
return value1.GetDouble() * (1.0f - t) + value2.GetDouble() * t;
default:
ATOMIC_LOGERROR("Invalid value type for linear interpolation");
return Variant::EMPTY;
}
}
//=============================================================================
//=============================================================================
void StaticModelPoolMgr::AddStaticModelData(Node *pNode, StaticModel *pStaticModel)
{
NvMeshData nvMeshData;
StaticModelData staticModelData;
Model *pModel = pStaticModel->GetModel();
// only one geom currently supprted
assert( pModel && pModel->GetNumGeometries() == 1 && "multiple gemoetries currently NOT supported" );
Matrix3x4 objMatrix = pNode->GetTransform();
Quaternion objRotation = pNode->GetRotation();
Geometry *pGeometry = pModel->GetGeometry(0, 0);
VertexBuffer *pVbuffer = pGeometry->GetVertexBuffer(0);
unsigned uElementMask = pVbuffer->GetElementMask();
unsigned vertexSize = pVbuffer->GetVertexSize();
const unsigned char *pVertexData = (const unsigned char*)pVbuffer->Lock(0, pVbuffer->GetVertexCount());
// get verts, normals, uv, etc.
if ( pVertexData )
{
unsigned numVertices = pVbuffer->GetVertexCount();
for ( unsigned i = 0; i < numVertices; ++i )
{
unsigned char *pDataAlign = (unsigned char *)(pVertexData + i * vertexSize);
if ( uElementMask & MASK_POSITION )
{
const Vector3 vPos = *reinterpret_cast<Vector3*>( pDataAlign );
pDataAlign += sizeof( Vector3 );
Vector3 vxformPos = objMatrix * vPos; // xform
// verts list
staticModelData.listVerts.Push( vxformPos );
nvMeshData.listVerts.push_back( Vec3f( vxformPos.x_, vxformPos.y_, vxformPos.z_ ) );
}
if ( uElementMask & MASK_NORMAL )
{
const Vector3 vNorm = *reinterpret_cast<Vector3*>( pDataAlign );
pDataAlign += sizeof( Vector3 );
// normal list
Vector3 vxformNorm = objRotation * vNorm; // xform
staticModelData.listNormals.Push( vxformNorm );
nvMeshData.listNormals.push_back( Vec3f( vxformNorm.x_, vxformNorm.y_, vxformNorm.z_ ) );
}
if ( uElementMask & MASK_COLOR )
{
const unsigned uColor = *reinterpret_cast<unsigned*>( pDataAlign );
pDataAlign += sizeof( unsigned );
}
if ( uElementMask & MASK_TEXCOORD1 )
{
const Vector2 vUV = *reinterpret_cast<Vector2*>( pDataAlign );
pDataAlign += sizeof( Vector2 );
// uv list
staticModelData.listUVs.Push( vUV );
}
// skip other mask elements - we got what we wanted
}
//unlock
pVbuffer->Unlock();
}
else
{
// error
assert( false && "failed to unlock vertex buffer" );
}
// get indeces
IndexBuffer *pIbuffer = pGeometry->GetIndexBuffer();
const unsigned *pIndexData = (const unsigned *)pIbuffer->Lock( 0, pIbuffer->GetIndexCount() );
const unsigned short *pUShortData = (const unsigned short *)pIndexData;
if ( pUShortData )
{
unsigned numIndeces = pIbuffer->GetIndexCount();
unsigned indexSize = pIbuffer->GetIndexSize();
assert( indexSize == sizeof(unsigned short) );
for( unsigned i = 0; i < numIndeces; i += 3 )
{
int idx0 = (int)pUShortData[i ];
int idx1 = (int)pUShortData[i+1];
int idx2 = (int)pUShortData[i+2];
staticModelData.listTris.Push( IntVector3( idx0, idx1, idx2 ) );
nvMeshData.listTris.push_back( Vec3i( idx0, idx1, idx2 ) );
}
//unlock
pIbuffer->Unlock();
}
else
{
// error
assert( false && "failed to unlock index buffer" );
}
// rest of the static model data
staticModelData.node = pNode;
staticModelData.drawable = pStaticModel;
staticModelData.begVertex = m_pNvScene->getNumVertices();
staticModelData.begTriList = m_pNvScene->getNumTriangles();
// resize coeff lists
staticModelData.listVertexUnshadoweCoeff.Resize( staticModelData.listVerts.Size() );
staticModelData.listVertexShadowCoeff.Resize( staticModelData.listVerts.Size() );
staticModelData.listVertexDiffuseColor.Resize( staticModelData.listVerts.Size() );
staticModelData.listVertexSampleOcclude.resize( staticModelData.listVerts.Size() );
// find material matcolor
VertexUtil *pVertexUtil = GetScene()->GetComponent<VertexUtil>();
staticModelData.materialColor = pVertexUtil->GetModelMaterialColor( pStaticModel );
// save model
m_vStaticModelPool.Push( staticModelData );
// push it to nv Scene
m_pNvScene->AddTriangleMesh( nvMeshData );
}
IntVector3 Deserializer::ReadIntVector3()
{
int data[3];
Read(data, sizeof data);
return IntVector3(data);
}
