void readGeometry(dae_reader_t *reader, MSXML2::IXMLDOMDocument2Ptr xmlDoc)
{
MSXML2::IXMLDOMNodeListPtr nodeList;
nodeList = xmlDoc->selectNodes("/r:COLLADA/r:library_geometries/r:geometry");
int count = nodeList->length;
for (int i = 0; i < count; i++)
{
MSXML2::IXMLDOMNodePtr node = nodeList->Getitem(i);
readMesh(reader, node);
}
}
osgDB::ReaderWriter::ReadResult OsgFbxReader::readFbxMesh(KFbxNode* pNode,
std::vector<StateSetContent>& stateSetList)
{
KFbxMesh* lMesh = KFbxCast<KFbxMesh>(pNode->GetNodeAttribute());
if (!lMesh)
{
return osgDB::ReaderWriter::ReadResult::ERROR_IN_READING_FILE;
}
return readMesh(pNode, lMesh, stateSetList,
pNode->GetName());
}
void WldModel::readModel(const char* modelId)
{
WLD* wld = m_wld;
Frag14* f14 = nullptr;
for (Fragment* frag : wld->getFragsByType(0x14))
{
const char* name = wld->getFragName(frag->nameRef());
if (strcmp(name, modelId) == 0)
{
f14 = (Frag14*)frag;
break;
}
}
if (!f14)
throw 1; //fixme
// f14 -> f11 -> f10 -> f13 -> f12
// |-> f2d -> f36
// OR
// f14 -> f2d -> f36
// Is this an animated model?
Fragment* frag = wld->getFrag(f14->firstRef());
if (!frag)
throw 2; //fixme
if (frag->type() == 0x11)
{
readAnimatedModel((Frag11*)frag);
return;
}
else if (frag->type() != 0x2d)
{
throw 6; //fixme
}
Frag2d* f2d = (Frag2d*)frag;
Frag36* f36 = (Frag36*)wld->getFrag(f2d->ref);
if (!f36 || f36->type() != 0x36)
throw 7; //fixme
readMaterials(f36);
readMesh(f36);
}
void
ColladaGeometry::read(ColladaElement *colElemParent)
{
domGeometryRef geometry = getDOMElementAs<domGeometry>();
domMeshRef mesh = geometry->getMesh();
OSG_COLLADA_LOG(("ColladaGeometry::read id [%s]\n",
geometry->getId()));
if(mesh == NULL)
{
SWARNING << "ColladaGeometry::read: No <mesh>" << std::endl;
return;
}
readMesh(mesh);
}
// Particle stays in the same cell
TEST(testTrackToFaceBasic, trackSame)
{
Mesh *mesh = readMesh("mesh");
vector<Particle> particles = readParticles("particles", mesh);
Particle *particle;
for(int i=0; i<particles.size(); i++) {
if(particles[i].getLabel() == 1) {
particle = &particles[i];
break;
}
}
vector<pair<float, float> > trajectory(particle->getTrajectory());
float lambda;
ASSERT_EQ(-1, particle->trackToFaceBasic(1, -1, 1.5, 3, 2.5, 1.5, &lambda)
);
}
void WldModel::readObjectDefinitions()
{
WLD* wld = m_wld;
PFS* pfs = getPFS();
std::vector<ConvVertexBuffer>& vbs = getVertexBuffers();
std::vector<ConvVertexBuffer>& cvb = getVertexBuffersNoCollide();
for (Fragment* frag : wld->getFragsByType(0x14))
{
Frag14* f14 = (Frag14*)frag;
if (!f14->hasMeshRefs())
continue;
const char* modelName = wld->getFragName(f14);
if (!modelName)
continue;
Frag2d* f2d = (Frag2d*)wld->getFrag(f14->firstRef());
if (!f2d)
continue;
uint32_t type = f2d->type();
ConvModel* objModel = nullptr;
switch (type)
{
case 0x2d:
readMesh((Frag36*)wld->getFrag(f2d->ref), true);
objModel = new ConvModel(pfs);
objModel->takeVertexBuffers(vbs);
objModel->takeVertexBuffersNoCollide(cvb);
break;
case 0x11:
//break;
default:
continue;
}
objModel->setName(modelName);
addObjectDefinition(modelName, objModel);
}
}
void
OgreMeshReader::read(void)
{
OSG_OGRE_LOG(("OgreMeshReader::read\n"));
UInt16 headerId = readUInt16(_is);
if(_is)
{
if(headerId == CHUNK_HEADER)
{
std::string version = readString(_is);
if(version == _versionString)
{
readChunkHeader(_is);
readMesh();
}
else
{
SWARNING << "OgreMeshReader::read: Unsupported version '"
<< version << "'." << std::endl;
_rootN = NULL;
}
}
else
{
SWARNING << "OgreMeshReader::read: Unrecognized file header."
<< std::endl;
_rootN = NULL;
}
}
else
{
SWARNING << "OgreMeshReader::read: Bad stream."
<< std::endl;
_rootN = NULL;
}
}
TEST(testTrackToFaceBasic, anotherTrackingTest)
{
Mesh *mesh = readMesh("mesh");
vector<Particle> particles = readParticles("particles", mesh);
Particle *particle;
for(int i=0; i<particles.size(); i++) {
if(particles[i].getLabel() == 1) {
particle = &particles[i];
break;
}
}
vector<pair<float, float> > trajectory(particle->getTrajectory());
float lambda;
ASSERT_EQ(2, particle->trackToFaceBasic(0, -1, 3.4, 1.79, 3, 3, &lambda));
ASSERT_TRUE(lambda >= 0);
ASSERT_TRUE(lambda <= 1);
}
void readFile(){
char bufline[20];
f = fopen(fname, "rt");
while(fgets(bufline, 20, f) != NULL){
int i;
sscanf(bufline, "%s", g_scannedvariable);
for(i = 0; g_scannedvariable[i]; i++){
g_scannedvariable[i] = tolower(g_scannedvariable[i]);
}
if(strcmp(g_scannedvariable, "object") == 0){
sscanf(bufline, "%*s %s", g_scannedvariable_two);
printf("%s", g_scannedvariable_two);
readMesh(g_scannedvariable_two);
}
}
fclose(f);
tangentChange();
g_time_reset = clock()/((float)CLOCKS_PER_SEC/10);
}
TEST(testTrackToFaceBasic, trackCase2)
{
Mesh *mesh = readMesh("mesh");
vector<Particle> particles = readParticles("particles", mesh);
Particle *particle;
for(int i=0; i<particles.size(); i++) {
if(particles[i].getLabel() == 2) {
particle = &particles[i];
break;
}
}
vector<pair<float, float> > trajectory(particle->getTrajectory());
float lambda;
int faceHit = particle->trackToFaceBasic
(1, 1, 3.23239, 1.11972, 3.4, 1, &lambda);
ASSERT_EQ(-1, faceHit);
ASSERT_TRUE(lambda >= 0);
ASSERT_TRUE(lambda <= 1);
}
void ASELoader::readGeometry(vector<Vertex3> &vertices, vector<int> &triangles, vector<Vertex3> &textures, vector<int> &texturedTriangles)
{
char line[255];
string currentLine = line;
// read the file until we come to a close bracket
m_modelFile.getline(line,255);
currentLine = line;
do
{
if (currentLine.find("*MESH ")!= string::npos)
{
// read mesh data...
readMesh(vertices, triangles, textures, texturedTriangles);
}
else
{
// possible to exdend to handle other blocks
// read an unknown object...
// if the line of the unknown line contains an open curly
// bracket, skip to after the next close curly bracket.
if (currentLine.find("{")!= string::npos)
{
do
{
m_modelFile.getline(line,255);
currentLine = line;
} while (currentLine.find("}") == string::npos);
}
}
m_modelFile.getline(line,255);
currentLine = line;
} while (currentLine.find("}") == string::npos);
}
TEST(TestParticleTracker, testTrackParticle2)
{
Mesh *mesh = readMesh("mesh");
vector<Particle> particles = readParticles("particles", mesh);
Particle *particle;
for(int i=0; i<particles.size(); i++) {
if(particles[i].getLabel() == 2) {
particle = &particles[i];
break;
}
}
vector<pair<float, float> > trajectory(particle->getTrajectory());
particle->trackParticle();
vector<pair<int, float> > cellFraction(particle->getCellFraction());
vector<int> stepCells(particle->getStepCells());
ASSERT_TRUE(stepCells.size() == 3);
ASSERT_EQ(6, cellFraction.size());
ASSERT_EQ(2, cellFraction[cellFraction.size()-1].first);
}
TEST(testTrackToFaceBasic, trackSecondFace)
{
Mesh *mesh = readMesh("mesh");
vector<Particle> particles = readParticles("particles", mesh);
Particle *particle;
for(int i=0; i<particles.size(); i++) {
if(particles[i].getLabel() == 1) {
particle = &particles[i];
break;
}
}
vector<pair<float, float> > trajectory(particle->getTrajectory());
float lambda;
ASSERT_EQ(1, particle->trackToFaceBasic(1, -1,
trajectory[1].first, trajectory[1].second,
trajectory[2].first, trajectory[2].second,
&lambda)
);
ASSERT_TRUE(lambda >= 0);
ASSERT_TRUE(lambda <= 1);
}
void OgreMeshDeserializer::deserialize()
{
// Determine endianness (must be the first thing we do!)
determineEndianness(m_stream);
// Check header
readFileHeader(m_stream);
unsigned short streamID = readChunk(m_stream);
while (!m_stream.eof()) {
switch (streamID) {
case M_MESH:
readMesh();
break;
default:
skipChunk(m_stream);
}
streamID = readChunk(m_stream);
}
}
int main(int argc, char **argv)
{
Mesh *mesh = NULL;
double m, m1, m2;
double s, s1, s2;
double t1, t2;
struct rusage r0, r1, r2;
if (argc < 3) {
fprintf(stderr, "Usage: %s <input_mesh> <output_mesh>\n", argv[0]);
return -1;
}
getrusage(RUSAGE_SELF, &r0);
if (readMesh(argv[1], &mesh)) {
freeMesh(&mesh);
return -1;
}
getrusage(RUSAGE_SELF, &r1);
m1 = (double) r1.ru_utime.tv_usec;
m2 = (double) r0.ru_utime.tv_usec;
m = m1 - m2;
s1 = (double) r1.ru_utime.tv_sec;
s2 = (double) r0.ru_utime.tv_sec;
s = s1 - s2;
t1 = s + m / MICROSEC;
m1 = (double) r1.ru_stime.tv_usec;
m2 = (double) r0.ru_stime.tv_usec;
m = m1 - m2;
s1 = (double) r1.ru_stime.tv_sec;
s2 = (double) r0.ru_stime.tv_sec;
s = s1 - s2;
t2 = s + m / MICROSEC;
printf("Read: %5.4e System: %5.4e Total: %5.4e\n", t1, t2, t1+t2);
getrusage(RUSAGE_SELF, &r1);
optMesh(mesh, 1.0e-6, 2);
getrusage(RUSAGE_SELF, &r2);
m1 = (double) r2.ru_utime.tv_usec;
m2 = (double) r1.ru_utime.tv_usec;
m = m1 - m2;
s1 = (double) r2.ru_utime.tv_sec;
s2 = (double) r1.ru_utime.tv_sec;
s = s1 - s2;
t1 = s + m / MICROSEC;
m1 = (double) r2.ru_stime.tv_usec;
m2 = (double) r1.ru_stime.tv_usec;
m = m1 - m2;
s1 = (double) r2.ru_stime.tv_sec;
s2 = (double) r1.ru_stime.tv_sec;
s = s1 - s2;
t2 = s + m / MICROSEC;
printf("Optimize: User: %5.4e System: %5.4e Total: %5.4e\n", t1, t2, t1+t2);
getrusage(RUSAGE_SELF, &r1);
writeMesh(argv[2], mesh);
getrusage(RUSAGE_SELF, &r2);
m1 = (double) r2.ru_utime.tv_usec;
m2 = (double) r1.ru_utime.tv_usec;
m = m1 - m2;
s1 = (double) r2.ru_utime.tv_sec;
s2 = (double) r1.ru_utime.tv_sec;
s = s1 - s2;
t1 = s + m / MICROSEC;
m1 = (double) r2.ru_stime.tv_usec;
m2 = (double) r1.ru_stime.tv_usec;
m = m1 - m2;
s1 = (double) r2.ru_stime.tv_sec;
s2 = (double) r1.ru_stime.tv_sec;
s = s1 - s2;
t2 = s + m / MICROSEC;
printf("Write: User: %5.4e System: %5.4e Total: %5.4e\n", t1, t2, t1+t2);
freeMesh(&mesh);
getrusage(RUSAGE_SELF, &r2);
m1 = (double) r2.ru_utime.tv_usec;
m2 = (double) r0.ru_utime.tv_usec;
m = m1 - m2;
s1 = (double) r2.ru_utime.tv_sec;
s2 = (double) r0.ru_utime.tv_sec;
s = s1 - s2;
t1 = s + m / MICROSEC;
m1 = (double) r2.ru_stime.tv_usec;
m2 = (double) r0.ru_stime.tv_usec;
m = m1 - m2;
s1 = (double) r2.ru_stime.tv_sec;
s2 = (double) r0.ru_stime.tv_sec;
s = s1 - s2;
t2 = s + m / MICROSEC;
printf("Total: User: %5.4e System: %5.4e Total: %5.4e\n", t1, t2, t1+t2);
return 0;
}
void ModelNode_Witcher::load(Model_Witcher::ParserContext &ctx) {
ctx.mdb->skip(24); // Function pointers
uint32 inheritColor = ctx.mdb->readUint32LE();
uint32 nodeNumber = ctx.mdb->readUint32LE();
_name = Common::readStringFixed(*ctx.mdb, Common::kEncodingASCII, 64);
ctx.mdb->skip(8); // Parent pointers
uint32 childrenOffset, childrenCount;
Model::readArrayDef(*ctx.mdb, childrenOffset, childrenCount);
std::vector<uint32> children;
Model::readArray(*ctx.mdb, ctx.offModelData + childrenOffset, childrenCount, children);
uint32 controllerKeyOffset, controllerKeyCount;
Model::readArrayDef(*ctx.mdb, controllerKeyOffset, controllerKeyCount);
uint32 controllerDataOffset, controllerDataCount;
Model::readArrayDef(*ctx.mdb, controllerDataOffset, controllerDataCount);
std::vector<float> controllerData;
Model::readArray(*ctx.mdb, ctx.offModelData + controllerDataOffset,
controllerDataCount, controllerData);
readNodeControllers(ctx, ctx.offModelData + controllerKeyOffset,
controllerKeyCount, controllerData);
ctx.mdb->skip(4); // Unknown
uint32 imposterGroup = ctx.mdb->readUint32LE();
uint32 fixedRot = ctx.mdb->readUint32LE();
int32 minLOD = ctx.mdb->readUint32LE();
int32 maxLOD = ctx.mdb->readUint32LE();
NodeType type = (NodeType) ctx.mdb->readUint32LE();
switch (type) {
case kNodeTypeTrimesh:
readMesh(ctx);
break;
case kNodeTypeTexturePaint:
readTexturePaint(ctx);
break;
default:
break;
}
// Only render the highest LOD (0), or if the node is not LODing (-1)
if ((minLOD != -1) && (maxLOD != -1) && (minLOD > 0))
_render = false;
for (std::vector<uint32>::const_iterator child = children.begin(); child != children.end(); ++child) {
ModelNode_Witcher *childNode = new ModelNode_Witcher(*_model);
ctx.nodes.push_back(childNode);
childNode->setParent(this);
ctx.mdb->seek(ctx.offModelData + *child);
childNode->load(ctx);
}
}
void ModelNode_KotOR::load(Model_KotOR::ParserContext &ctx) {
uint16 flags = ctx.mdl->readUint16LE();
uint16 superNode = ctx.mdl->readUint16LE();
uint16 nodeNumber = ctx.mdl->readUint16LE();
if (nodeNumber < ctx.names.size())
_name = ctx.names[nodeNumber];
ctx.mdl->skip(6 + 4); // Unknown + parent pointer
_position [0] = ctx.mdl->readIEEEFloatLE();
_position [1] = ctx.mdl->readIEEEFloatLE();
_position [2] = ctx.mdl->readIEEEFloatLE();
_orientation[3] = Common::rad2deg(acos(ctx.mdl->readIEEEFloatLE()) * 2.0);
_orientation[0] = ctx.mdl->readIEEEFloatLE();
_orientation[1] = ctx.mdl->readIEEEFloatLE();
_orientation[2] = ctx.mdl->readIEEEFloatLE();
uint32 childrenOffset, childrenCount;
Model::readArrayDef(*ctx.mdl, childrenOffset, childrenCount);
std::vector<uint32> children;
Model::readArray(*ctx.mdl, ctx.offModelData + childrenOffset, childrenCount, children);
uint32 controllerKeyOffset, controllerKeyCount;
Model::readArrayDef(*ctx.mdl, controllerKeyOffset, controllerKeyCount);
uint32 controllerDataOffset, controllerDataCount;
Model::readArrayDef(*ctx.mdl, controllerDataOffset, controllerDataCount);
std::vector<float> controllerData;
Model::readArray(*ctx.mdl, ctx.offModelData + controllerDataOffset,
controllerDataCount, controllerData);
readNodeControllers(ctx, ctx.offModelData + controllerKeyOffset,
controllerKeyCount, controllerData);
if ((flags & 0xFC00) != 0)
throw Common::Exception("Unknown node flags %04X", flags);
if (flags & kNodeFlagHasLight) {
// TODO: Light
ctx.mdl->skip(0x5C);
}
if (flags & kNodeFlagHasEmitter) {
// TODO: Emitter
ctx.mdl->skip(0xD8);
}
if (flags & kNodeFlagHasReference) {
// TODO: Reference
ctx.mdl->skip(0x44);
}
if (flags & kNodeFlagHasMesh) {
readMesh(ctx);
}
if (flags & kNodeFlagHasSkin) {
// TODO: Skin
ctx.mdl->skip(0x64);
}
if (flags & kNodeFlagHasAnim) {
// TODO: Anim
ctx.mdl->skip(0x38);
}
if (flags & kNodeFlagHasDangly) {
// TODO: Dangly
ctx.mdl->skip(0x18);
}
if (flags & kNodeFlagHasAABB) {
// TODO: AABB
ctx.mdl->skip(0x4);
}
for (std::vector<uint32>::const_iterator child = children.begin(); child != children.end(); ++child) {
ModelNode_KotOR *childNode = new ModelNode_KotOR(*_model);
ctx.nodes.push_back(childNode);
childNode->setParent(this);
ctx.mdl->seek(ctx.offModelData + *child);
childNode->load(ctx);
}
}
void reset() {
mesh = readMesh(fileName, dimensions);
}
CModelFile* CModelReader::read()
{
atUint32 magic = base::readUint32();
if (magic != 0xDEADBABE)
{
Athena::io::MemoryWriter tmp;
decompressFile(tmp, base::data(), base::length());
if (tmp.length() > 0x10)
base::setData(tmp.data(), tmp.length());
magic = base::readUint32();
}
if (magic != 0xDEADBABE /*&& magic != 0x9381000A*/)
THROW_INVALID_DATA_EXCEPTION("Not a valid CMDL magic, expected 0xDEADBABE got 0x%.8X\n", magic);
atUint32 version;
if (magic != 0x9381000A)
version = base::readUint32();
else
version = CModelFile::DKCR;
if (!(version >= CModelFile::MetroidPrime1 && version <= CModelFile::DKCR))
THROW_INVALID_DATA_EXCEPTION("Only Metroid Prime 1 to 3 models are supported got v%i\n", version);
try
{
m_result = new CModelFile;
m_result->m_version = (CModelFile::Version)version;
m_result->m_flags = base::readUint32();
m_result->m_boundingBox.min.x = base::readFloat();
m_result->m_boundingBox.min.y = base::readFloat();
m_result->m_boundingBox.min.z = base::readFloat();
m_result->m_boundingBox.max.x = base::readFloat();
m_result->m_boundingBox.max.y = base::readFloat();
m_result->m_boundingBox.max.z = base::readFloat();
atUint32 sectionCount = base::readUint32();
atInt32 materialCount = base::readInt32();
m_sectionSizes.resize(sectionCount);
if (m_result->m_flags & 0x10)
{
base::readUint32();
atUint32 visGroupCount = base::readUint32();
while((visGroupCount--) > 0)
{
atUint32 len = base::readUint32();
base::readString(len);
}
base::readUint32();
base::readUint32();
base::readUint32();
base::readUint32();
base::readUint32();
}
m_result->m_materialSets.resize(materialCount);
for (atUint32 i = 0; i < sectionCount; i++)
m_sectionSizes[i] = base::readUint32();
base::seekAlign32();
const atUint32 sectionBias = ((m_result->m_version == CModelFile::DKCR || m_result->m_version == CModelFile::MetroidPrime3)
? 1 : materialCount);
Athena::io::MemoryReader sectionReader(new atUint8[2], 2);
sectionReader.setEndian(endian());
for (atUint32 i = 0; i < sectionCount; i++)
{
if (m_sectionSizes[i] == 0)
continue;
if (materialCount > 0)
{
if (m_result->m_version != CModelFile::DKCR && m_result->m_version != CModelFile::MetroidPrime3)
{
atUint8* data = base::readUBytes(m_sectionSizes[i]);
CMaterialReader reader(data, m_sectionSizes[i]);
CMaterialSet materialSet;
switch(m_result->m_version)
{
case CModelFile::MetroidPrime1:
materialSet = reader.read(CMaterial::MetroidPrime1);
break;
case CModelFile::MetroidPrime2:
materialSet = reader.read(CMaterial::MetroidPrime2);
break;
default:
break;
}
m_result->m_materialSets[i] = materialSet;
materialCount--;
continue;
}
else
{
atUint8* data = base::readUBytes(m_sectionSizes[i]);
CMaterialReader reader(data, m_sectionSizes[i]);
atUint32 setIdx = 0;
while ((materialCount--) > 0)
{
CMaterialSet& materialSet = m_result->m_materialSets[setIdx];
switch(m_result->m_version)
{
case CModelFile::MetroidPrime3:
materialSet = reader.read(CMaterial::MetroidPrime3);
break;
case CModelFile::DKCR:
materialSet = reader.read(CMaterial::DKCR);
default:
break;
}
setIdx++;
}
continue;
}
}
else
{
SectionType section = (SectionType)(i - sectionBias);
atUint8* data = base::readUBytes(m_sectionSizes[i]);
sectionReader.setData(data, m_sectionSizes[i]);
switch(section)
{
case SectionType::Vertices:
{
if (m_result->m_flags & 0x20)
readVertices(sectionReader, true);
else
readVertices(sectionReader);
}
break;
case SectionType::Normals:
readNormals(sectionReader);
break;
case SectionType::Colors:
readColors(sectionReader);
break;
case SectionType::TexCoord0:
readTexCoords(0, sectionReader);
break;
case SectionType::TexCoord1orMeshOffsets:
{
if (m_result->m_flags & EFormatFlags::TexCoord1 || m_result->m_version == CModelFile::DKCR)
readTexCoords(1, sectionReader);
else
readMeshOffsets(sectionReader);
break;
}
case SectionType::MeshInfo:
{
if (m_meshOffsets.size() == 0)
{
readMeshOffsets(sectionReader);
break;
}
}
default:
if ((i - sectionBias) >= 5)
readMesh(sectionReader);
break;
}
}
}
}
catch(...)
{
delete m_result;
m_result = nullptr;
throw;
}
return m_result;
}
bool CMyPlug::importData(iModelData * pModelData, const std::string& strFilename)
{
assert(pModelData);
// Loading the mesh.
IOReadBase* pRead = IOReadBase::autoOpen(strFilename);
if (!pRead)
{
return false;
}
// header
readHeader(pRead);
// mesh
if (!pRead->IsEof())
{
unsigned short streamID;
unsigned int uLength;
pRead->Read(&streamID,sizeof(unsigned short));
pRead->Read(&uLength,sizeof(unsigned int));
switch (streamID)
{
case M_MESH:
{
readMesh(pRead,pModelData);
break;
}
}
}
// close file
IOReadBase::autoClose(pRead);
// Loading the materials.
if (!readMaterial(pModelData,ChangeExtension(strFilename,".material")))
{
std::string strMatFilename = GetParentPath(strFilename);
strMatFilename=strMatFilename+GetFilename(strMatFilename)+".material";
if (!readMaterial(pModelData,strMatFilename))
{
strMatFilename=ChangeExtension(strMatFilename,"_tileset.material");
readMaterial(pModelData,strMatFilename);
}
}
// mesh update
pModelData->getMesh().update();
// //m_bbox = mesh.getBBox();
// std::string strMyPath ="Data\\"+GetFilename(GetParentPath(strFilename))+"\\";
// std::string strMatFilename = ChangeExtension(strFilename,".mat.csv");
// std::string strParFilename = ChangeExtension(strFilename,".par.csv");
// if (!IOReadBase::Exists(strMatFilename))
// {
// strMatFilename=strMyPath+ChangeExtension(GetFilename(strFilename),".mat.csv");
// }
// if (!IOReadBase::Exists(strParFilename))
// {
// strParFilename=strMyPath+ChangeExtension(GetFilename(strFilename),".par.csv");
// }
//
// pModelData->loadMaterial(strMatFilename);
// pModelData->loadParticleEmitters(strParFilename);
return true;
}
TEST(TestParticleTracker, testDotProd)
{
Mesh *mesh = readMesh("mesh");
vector<Particle> particles = readParticles("particles", mesh);
ASSERT_FLOAT_EQ(17, particles[0].dotProd(3, 2, 1, 7));
}
void ModelNode_Witcher::load(Model_Witcher::ParserContext &ctx) {
ctx.mdb->skip(24);
uint32 inheritColor = ctx.mdb->readUint32LE();
uint32 nodeNumber = ctx.mdb->readUint32LE();
_name.readFixedASCII(*ctx.mdb, 64);
ctx.mdb->skip(8); // Parent pointers
uint32 childrenOffset, childrenCount;
Model::readArrayDef(*ctx.mdb, childrenOffset, childrenCount);
std::vector<uint32> children;
Model::readArray(*ctx.mdb, ctx.offModelData + childrenOffset, childrenCount, children);
uint32 controllerKeyOffset, controllerKeyCount;
Model::readArrayDef(*ctx.mdb, controllerKeyOffset, controllerKeyCount);
uint32 controllerDataOffset, controllerDataCount;
Model::readArrayDef(*ctx.mdb, controllerDataOffset, controllerDataCount);
std::vector<float> controllerData;
Model::readArray(*ctx.mdb, ctx.offModelData + controllerDataOffset,
controllerDataCount, controllerData);
readNodeControllers(ctx, ctx.offModelData + controllerKeyOffset,
controllerKeyCount, controllerData);
ctx.mdb->skip(20);
uint32 flags = ctx.mdb->readUint32LE();
if ((flags & 0xFFFC0000) != 0)
throw Common::Exception("Unknown node flags %08X", flags);
if (flags & kNodeFlagHasLight) {
// TODO: Light
}
if (flags & kNodeFlagHasEmitter) {
// TODO: Emitter
}
if (flags & kNodeFlagHasReference) {
// TODO: Reference
}
if (flags & kNodeFlagHasMesh) {
readMesh(ctx);
}
if (flags & kNodeFlagHasSkin) {
// TODO: Skin
}
if (flags & kNodeFlagHasAnim) {
// TODO: Anim
}
if (flags & kNodeFlagHasDangly) {
// TODO: Dangly
}
if (flags & kNodeFlagHasAABB) {
// TODO: AABB
}
for (std::vector<uint32>::const_iterator child = children.begin(); child != children.end(); ++child) {
ModelNode_Witcher *childNode = new ModelNode_Witcher(*_model);
ctx.nodes.push_back(childNode);
childNode->setParent(this);
ctx.mdb->seek(ctx.offModelData + *child);
childNode->load(ctx);
}
}
bool Animation3D::loadFromObj(const std::string& path)
{
std::string fullPath = FileUtils::getInstance()->fullPathForFilename(path);
cocos2d::Data meshdata = FileUtils::getInstance()->getDataFromFile(fullPath);
unsigned int len = meshdata.getSize();
const unsigned char *rawdata = meshdata.getBytes();
int pos = 0;
unsigned int magic = *((int*)rawdata);
pos += 4;
unsigned int version = *((int*)(rawdata+pos));
pos += 4;
unsigned short aniFileLen = *((short*)(rawdata + pos));
pos += 2;
pos += aniFileLen;
unsigned short textureFileLen = *((short*)(rawdata + pos));
pos += 2;
pos += textureFileLen;
unsigned int meshNum = *((int*)(rawdata + pos));
pos += 4;
unsigned int i = 0;
while (i < meshNum){
MeshHead *meshhead = new MeshHead();
_meshHeads.push_back(meshhead);
readMesh(rawdata, pos, meshhead);
i++;
}
unsigned int vertNum = *((int*)(rawdata + pos));
pos += 4;
log("magic=%u, ver=%u, meshnum=%u, vertnum=%u", magic, version, meshNum, vertNum);
i = 0;
while (i < vertNum){
Vertex *v = new Vertex();
v->x = *((float*)(rawdata + pos));
pos += 4;
v->y = *((float*)(rawdata + pos));
pos += 4;
v->z = *((float*)(rawdata + pos));
pos += 4;
v->nx = *((float*)(rawdata + pos));
pos += 4;
v->ny = *((float*)(rawdata + pos));
pos += 4;
v->nz = *((float*)(rawdata + pos));
pos += 4;
v->u = *((float*)(rawdata + pos));
pos += 4;
v->v = *((float*)(rawdata + pos));
pos += 4;
for (int j = 0; j < 4; j++){
v->bones[j] = *(rawdata + pos);
pos += 1; //char
}
for (int j = 0; j < 4; j++){
v->weights[j] = *((float*)(rawdata + pos));
pos += 4;
}
_vertices.push_back(v);
i++;
}
unsigned int indicesNum = *((unsigned int*)(rawdata + pos));
pos += 4;
i = 0;
while (i < indicesNum){
unsigned short indice = *((unsigned short*)(rawdata + pos));
_indices.push_back(indice);
pos += 2;
i++;
}
return true;
}
