void Water::Load(const char * source)
{
DataStreamPtr stream = ResourceManager::Instance()->OpenResource(source);
if (stream == NULL)
return ;
int Magic, Version;
stream->Read(&Magic, sizeof(int));
stream->Read(&Version, sizeof(int));
d_assert (Magic == K_Magic);
d_assert (Version == 0);
if (Version == 0)
{
int sizeX, sizeZ;
stream->Read(&sizeX, sizeof(int));
stream->Read(&sizeZ, sizeof(int));
d_assert (sizeX == mSizeX && sizeZ == mSizeZ);
stream->Read(&mHeight, sizeof(float));
stream->Read(mData, sizeX * sizeZ);
}
_initBlock();
}
void MeshLoader_v0::ReadIndexStream(SubMesh * sm, DataStreamPtr & stream)
{
int count = sm->GetIndexStream()->GetCount();
unsigned char stride;
bool index16 = true;;
stream->Read(&stride, sizeof(unsigned char));
switch (stride)
{
case sizeof(short):
index16 = true;
break;
case sizeof(int):
index16 = false;
break;
default:
EXCEPTION_DEBUG(0, "invalid index format.");
break;
}
IndexBufferPtr pIndexBuffer = VideoBufferManager::Instance()->CreateIndexBuffer(stride * count, index16);
void * indices;
int start;
stream->Read(&start, sizeof(int));
indices = pIndexBuffer->Lock(0, 0, LOCK_DISCARD);
stream->Read(indices, stride * count);
pIndexBuffer->Unlock();
sm->GetIndexStream()->Bind(pIndexBuffer, start);
}
void MeshLoader_v0::ReadVertexStream(VertexBufferPtr & vb, int & stride, int count, DataStreamPtr & stream)
{
EXCEPTION_DEBUG(vb.IsNull(), "model file error.");
stream->Read(&stride, sizeof(int));
vb = VideoBufferManager::Instance()->CreateVertexBuffer(stride * count, stride);
void * data = vb->Lock(0, 0, LOCK_DISCARD);
stream->Read(data, stride * count);
vb->Unlock();
}
void MeshLoader_v0::ReadDeclaration(short id, VertexDeclarationPtr & decl, DataStreamPtr & stream)
{
short offset;
unsigned char type;
unsigned char usage;
unsigned char index;
stream->Read(&offset, sizeof(short));
stream->Read(&type, sizeof(unsigned char));
stream->Read(&usage, sizeof(unsigned char));
stream->Read(&index, sizeof(unsigned char));
decl->AddElement(id, offset, (DECL_TYPE)type, (DECL_USAGE)usage, index);
}
void MeshLoader_v0::ReadBounds(MeshPtr mesh, DataStreamPtr & stream)
{
Vec3 vMin, vMax, vCenter;
float fRadius;
stream->Read(&vMin, sizeof(Vec3));
stream->Read(&vMax, sizeof(Vec3));
stream->Read(&vCenter, sizeof(Vec3));
stream->Read(&fRadius, sizeof(float));
mesh->SetAabb(vMin, vMax);
mesh->SetBoundingSphere(vCenter, fRadius);
}
void MeshLoader_v1::ReadSkelAnim(MeshPtr mesh, DataStreamPtr & stream)
{
Skeleton * skel = mesh->GetSkeleton();
int version = -1;
stream->Read(&version, sizeof (int));
d_assert (version == K_SkelAnim_Version);
char name[128];
stream->Read(name, 128);
Animation * anim = mesh->CreateAnimation(name);
int numAnims = 0;
stream->Read(&numAnims, sizeof(int));
for (int i = 0; i < numAnims; ++i)
{
int boneId, count;
stream->Read(&boneId, sizeof(int));
stream->Read(&count, sizeof(int));
if (count == 0)
continue;
SkeletonAnimation * skel_anim;
skel_anim = anim->CreateSkeletonAnimation(boneId);
KeyFrame * kf;
float time;
Vec3 trans;
Quat rotate;
Vec3 scale;
for (int i = 0; i < count; ++i)
{
stream->Read(&time, sizeof(float));
stream->Read(&trans, sizeof(float) * 3);
stream->Read(&rotate, sizeof(float) * 4);
stream->Read(&scale, sizeof(float) * 3);
kf = skel_anim->CreateKeyFrame();
kf->SetTime(time);
kf->SetTranslate(trans);
kf->SetRotation(rotate);
kf->SetScale(scale);
}
}
anim->_calcuLength();
}
void MeshLoader_v1::ReadBounds(MeshPtr mesh, DataStreamPtr & stream)
{
int iVerison;
Vec3 vMin, vMax, vCenter;
float fRadius;
stream->Read(&iVerison, sizeof(int));
d_assert (iVerison == K_Bound_Version);
stream->Read(&vMin, sizeof(Vec3));
stream->Read(&vMax, sizeof(Vec3));
stream->Read(&vCenter, sizeof(Vec3));
stream->Read(&fRadius, sizeof(float));
mesh->SetAabb(vMin, vMax);
mesh->SetBoundingSphere(vCenter, fRadius);
}
bool Terrain::Load(const String & filename)
{
DataStreamPtr stream = ResourceManager::Instance()->OpenResource(filename);
if (stream == NULL || !IsValid())
return false;
ISerializerD IS(stream);
int magic, version;
IS >> magic;
IS >> version;
d_assert (magic == K_FILE_MAGIC);
d_assert (version == K_VERSION);
int ckId;
while (IS.Read(&ckId, sizeof(int)) && ckId != 0)
{
if (ckId == 1001)
{
Int2 vertexCount;
IS >> vertexCount;
if (vertexCount == mInfo.VertexCount)
{
stream->Read(&mHeights[0], sizeof(float) * vertexCount.x * vertexCount.y);
}
else if (vertexCount.x < mInfo.VertexCount.x && vertexCount.y < mInfo.VertexCount.y)
{
for (int i = 0; i < vertexCount.y; ++i)
{
stream->Read(&mHeights[i * vertexCount.x], sizeof(float) * vertexCount.x);
}
}
else
{
d_log("?: terrain vertex count don't matched.");
}
_calcuNormals();
}
else
{
void MeshLoader_v1::ReadSkeleton(MeshPtr mesh, DataStreamPtr & stream)
{
Skeleton * skel = mesh->GetSkeleton();
int version = -1;
stream->Read(&version, sizeof (int));
d_assert (version == K_Skeleton_Version);
int boneCount = 0;
stream->Read(&boneCount, sizeof (int));
for (int i = 0; i < boneCount; ++i)
{
char Name[128];
int flag;
Vec3 Position;
Quat Orientation;
Vec3 Scale;
stream->Read(&Name[0], 128);
stream->Read(&flag, sizeof(int));
stream->Read(&Position, sizeof(Vec3));
stream->Read(&Orientation, sizeof(Quat));
stream->Read(&Scale, sizeof(Vec3)); // equal ratio scale.
joint * bn = skel->CreateJoint(Name);
bn->flag = flag;
bn->position = Position;
bn->orientation = Orientation;
bn->scale = Scale;
}
for (int i = 0; i < boneCount; ++i)
{
short parent;
short child;
stream->Read(&parent, sizeof(short));
stream->Read(&child, sizeof(short));
skel->SetupHiberarchy(parent, child);
}
}
void MeshLoader::Load(MeshPtr mesh, DataStreamPtr stream)
{
profile_code();
char magic[MODEL_FILE_MAGIC_LEN];
int version;
stream->Read(magic, MODEL_FILE_MAGIC_LEN);
d_assert (strcmp(magic, MODEL_FILE_MAGIC) == 0);
stream->Read(&version, sizeof(int));
if (version == MODEL_FILE_VERSION)
MeshLoader_v0::Load(mesh, stream);
else if (version == MeshLoader_v1::K_File_Verion)
MeshLoader_v1::Load(mesh, stream);
else
d_assert (0);
stream->Close();
}
XmlNodePtr XmlDoc::Parse(DataStreamPtr const & pSource)
{
pSource->Seekg(0, std::ios_base::end);
int len = static_cast<int>(pSource->Tellg());
pSource->Seekg(0, std::ios_base::beg);
m_cXmlSrcs.resize(len + 1, 0);
pSource->Read(&m_cXmlSrcs[0], len);
static_cast<rapidxml::xml_document<>*>(m_pDoc.get())->parse<0>(&m_cXmlSrcs[0]);
m_pNodeRoot = MakeSharedPtr<XmlNode>(static_cast<rapidxml::xml_document<>*>(m_pDoc.get())->first_node());
return m_pNodeRoot;
}
void MeshLoader_v1::ReadMaterial(SubMesh * sm, DataStreamPtr & stream)
{
int version;
int doubleSide, blendMode;
Color4 emissive, ambient, diffuse, specular;
float specularPower;
char emissiveMap[128], diffuseMap[128], normalMap[128], specularMap[128];
stream->Read(&version, sizeof(int));
d_assert (version == K_Material_Version);
stream->Read(&doubleSide, sizeof(int));
stream->Read(&blendMode, sizeof(int));
stream->Read(&emissive, sizeof(Color4));
stream->Read(&ambient, sizeof(Color4));
stream->Read(&diffuse, sizeof(Color4));
stream->Read(&specular, sizeof(Color4));
stream->Read(&specularPower, sizeof(float));
stream->Read(emissiveMap, 128);
stream->Read(diffuseMap, 128);
stream->Read(normalMap, 128);
stream->Read(specularMap, 128);
Material * mtl = sm->GetMaterial();
if (doubleSide == 1)
{
mtl->SetCullMode(CULL_NONE);
}
mtl->SetBlendMode((BLEND_MODE)blendMode);
mtl->SetAlphaTestRef(0.5f);
mtl->SetEmissive(emissive);
mtl->SetAmbient(ambient);
mtl->SetDiffuse(diffuse);
mtl->SetSpecular(specular);
mtl->SetEmissiveMap(emissiveMap);
mtl->SetDiffuseMap(diffuseMap);
mtl->SetNormalMap(normalMap);
mtl->SetSpecularMap(specularMap);
}
void MeshLoader_v1::ReadSubMesh(SubMesh * sm, DataStreamPtr & stream)
{
const int K_Version = 0;
int iVersion;
int iVertexCount;
int iIndexCount;
int iVertexElems;
stream->Read(&iVersion, sizeof(int));
d_assert (iVersion == K_SubMesh_Version || iVersion == K_SubMesh_Version_1);
stream->Read(&iVertexCount, sizeof(int));
stream->Read(&iIndexCount, sizeof(int));
stream->Read(&iVertexElems, sizeof(int));
int iPrimitiveCount = iIndexCount / 3;
int iPrimitiveType = PRIM_TRIANGLELIST;
d_assert (iVertexElems | VE_POSITION);
sm->GetVertexStream()->SetCount(iVertexCount);
sm->GetIndexStream()->SetCount(iIndexCount);
sm->SetPrimitiveCount(iPrimitiveCount);
sm->SetPrimitiveType((PRIMITIVE_TYPE)iPrimitiveType);
VertexDeclarationPtr decl = VideoBufferManager::Instance()->CreateVertexDeclaration();
int vstride = GenVertexDecl(decl, iVertexElems);
VertexBufferPtr vb = VideoBufferManager::Instance()->CreateVertexBuffer(vstride * iVertexCount, vstride);
void * vdata = vb->Lock(0, 0, LOCK_NORMAL);
{
stream->Read(vdata, vstride * iVertexCount);
}
vb->Unlock();
bool index16 = true;
if (iIndexCount > 65535)
index16 = false;
int istride = index16 ? 2 : 4;
IndexBufferPtr ib = VideoBufferManager::Instance()->CreateIndexBuffer(istride * iIndexCount, index16);
void * idata = ib->Lock(0, 0, LOCK_NORMAL);
{
stream->Read(idata, istride * iIndexCount);
}
ib->Unlock();
sm->GetVertexStream()->SetDeclaration(decl);
sm->GetVertexStream()->Bind(0, vb, vstride);
sm->GetIndexStream()->Bind(ib, 0);
if (iVersion >= K_SubMesh_Version_1)
{
Array<short> & boneMap = sm->GetBoneIdMap();
int numBoneMap = 0;
stream->Read(&numBoneMap, sizeof(int));
if (numBoneMap > 0 && numBoneMap < MAX_BLEND_MATRIX_VS)
{
boneMap.Resize(numBoneMap);
stream->Read(&boneMap[0], sizeof(short) * numBoneMap);
}
}
ReadMaterial(sm, stream);
}
void MeshLoader_v0::ReadSubMesh(SubMesh * sm, DataStreamPtr & stream)
{
int iVertexCount;
int iIndexCount;
int iPrimitiveCount;
int iPrimitiveType;
String sMaterial;
stream->Read(&iVertexCount, sizeof(int));
stream->Read(&iIndexCount, sizeof(int));
stream->Read(&iPrimitiveCount, sizeof(int));
stream->Read(&iPrimitiveType, sizeof(int));
sm->GetVertexStream()->SetCount(iVertexCount);
sm->GetIndexStream()->SetCount(iIndexCount);
sm->SetPrimitiveCount(iPrimitiveCount);
sm->SetPrimitiveType((PRIMITIVE_TYPE)iPrimitiveType);
stream->ReadString(sMaterial);
//sm->SetMaterialName(sMaterial.c_str());
VertexDeclarationPtr decl = VideoBufferManager::Instance()->CreateVertexDeclaration();
sm->GetVertexStream()->SetDeclaration(decl);
//read sub chunk
chunk ck;
while (ReadChunk(ck, stream) &&
(ck.id == MC_SUBMESH_TRANSFROM_STREAM ||
ck.id == MC_SUBMESH_LIGHT_STREAM ||
ck.id == MC_SUBMESH_TEXCOORD_STREAM ||
ck.id == MC_SUBMESH_ANIMATION_STREAM ||
ck.id == MC_SUBMESH_INDEX_STREAM))
{
switch (ck.id)
{
case MC_SUBMESH_TRANSFROM_STREAM:
debug_assert(sm->GetVertexStream()->GetStream(_GEOM_STREAM).IsNull(), "model file error.");
ReadTransStream(sm, stream);
break;
case MC_SUBMESH_LIGHT_STREAM:
debug_assert(sm->GetVertexStream()->GetStream(_LIGHT_STREAM).IsNull(), "model file error.");
ReadLightStream(sm, stream);
break;
case MC_SUBMESH_TEXCOORD_STREAM:
debug_assert(sm->GetVertexStream()->GetStream(_TEXC_STREAM).IsNull(), "model file error.");
ReadTexcStream(sm, stream);
break;
case MC_SUBMESH_ANIMATION_STREAM:
debug_assert(sm->GetVertexStream()->GetStream(_ANIM_STREAM).IsNull(), "model file error.");
ReadAnimStream(sm, stream);
break;
case MC_SUBMESH_INDEX_STREAM:
debug_assert(sm->GetIndexStream()->GetStream().IsNull(), "model file error.");
ReadIndexStream(sm, stream);
break;
}
}
decl->Init();
d_assert(sm->GetVertexStream()->GetStream(_GEOM_STREAM).NotNull());
//skip
if (!stream->Eof())
stream->Skip(-MC_CHUNK_SIZE);
}
