static void parseFaceList()
{
unsigned short cnt;
in.sgetn((char*)&cnt, 2);
_log("FaceList cnt=" + itoa(cnt));
while (cnt--) {
unsigned short v[4];
in.sgetn((char*)v, 8);
Face3DS face;
face.verts[0] = v[0];
face.verts[1] = v[1];
face.verts[2] = v[2];
if (flip_tris)
std::swap(face.verts[1], face.verts[2]);
faces.push_back(face);
}
enterChunk();
while (int id = nextChunk()) {
switch (id) {
case CHUNK_FACEMAT:
parseFaceMat();
break;
}
}
leaveChunk();
}
static void parseKeyFramer(MeshModel* root)
{
_log("KeyFramer");
enterChunk();
std::string file_3ds;
unsigned short rev, curr_time = 0;
while (int id = nextChunk()) {
switch (id) {
case 0xb009: //CURR_TIME
in.sgetn((char*)&curr_time, 2);
_log("CURR_TIME: " + itoa(curr_time));
break;
case 0xb00a: //KFHDR
in.sgetn((char*)&rev, 2);
file_3ds = parseString();
in.sgetn((char*)&anim_len, 2);
_log("KFHDR: revision=" + itoa(rev) + " 3dsfile=" + file_3ds + " anim_len=" + itoa(anim_len));
break;
case 0xb002: //object keyframer data...
parseMeshInfo(root, curr_time);
break;
}
}
if (!collapse) {
root->setAnimator(new Animator(root, anim_len));
}
leaveChunk();
}
static MeshModel* parseFile()
{
unsigned short id;
int len;
in.sgetn((char*)&id, 2);
in.sgetn((char*)&len, 4);
if (id != CHUNK_MAIN)
return 0;
chunk_end = (int)in.pubseekoff(0, std::ios_base::cur) + len - 6;
enterChunk();
MeshModel* root = new MeshModel();
while (int id = nextChunk()) {
switch (id) {
case CHUNK_SCENE:
parseScene(root);
break;
case CHUNK_KEYFRAMER:
parseKeyFramer(root);
break;
}
}
leaveChunk();
return root;
}
MeshModel* Loader_3DS::load(const std::string& filename, const Transform& t, int hint)
{
conv_tform = t;
conv = flip_tris = false;
if (conv_tform != Transform()) {
conv = true;
if (conv_tform.m.i.cross(conv_tform.m.j).dot(conv_tform.m.k) < 0)
flip_tris = true;
}
collapse = !!(hint & MeshLoader::HINT_COLLAPSE);
animonly = !!(hint & MeshLoader::HINT_ANIMONLY);
if (!in.open(filename.c_str(), std::ios_base::in | std::ios_base::binary)) {
return 0;
}
MeshModel* root = parseFile();
in.close();
materials_map.clear();
name_map.clear();
id_map.clear();
return root;
}
void pluginUnload()
{
if(fileBuf.is_open()){
fileBuf.close();
}
/* called when plugin is unloaded, cleanup here */
}
void ImageFileRecorder::start()
{
if ( !m_running )
{
filebuffer.open ( m_logfile.string().c_str(), std::ios::out );
if( !filebuffer.is_open() )
UBITRACK_THROW( "Error opening file" );
m_running = true;
}
}
static int nextChunk()
{
in.pubseekoff(chunk_end, std::ios_base::beg);
if (chunk_end == parent_end.back())
return 0;
unsigned short id;
int len;
in.sgetn((char*)&id, 2);
in.sgetn((char*)&len, 4);
chunk_end = (int)in.pubseekoff(0, std::ios_base::cur) + len - 6;
return id;
}
static void parseVertList()
{
unsigned short cnt;
in.sgetn((char*)&cnt, 2);
_log("VertList cnt=" + itoa(cnt));
while (cnt--) {
Surface::Vertex v;
in.sgetn((char*)&v.coords, 12);
if (conv)
v.coords = conv_tform * v.coords;
MeshLoader::addVertex(v);
}
}
static void parseFaceMat()
{
std::string name = parseString();
_log("FaceMat: " + name);
Brush mat = materials_map[name];
unsigned short cnt;
in.sgetn((char*)&cnt, 2);
while (cnt--) {
unsigned short face;
in.sgetn((char*)&face, 2);
faces[face].brush = mat;
}
}
static void parseMapList()
{
_log("MapList");
unsigned short cnt;
in.sgetn((char*)&cnt, 2);
for (int k = 0; k < cnt; ++k) {
float uv[2];
in.sgetn((char*)uv, 8);
Surface::Vertex& v = MeshLoader::refVertex(k);
v.tex_coords[0][0] = v.tex_coords[1][0] = uv[0];
v.tex_coords[0][1] = v.tex_coords[1][1] = 1 - uv[1];
// v->tex_coords[0]=v->tex_coords[1]=Vector( uv[0],1-uv[1],1 );
}
}
void pluginLoad() {
if(notifyPeriod != 0) {
Environment<>::get().PluginConnector().setNotificationPeriod(this, notifyPeriod);
// Set default resources to log
if (properties.empty()) {
properties.push_back("rank");
properties.push_back("position");
properties.push_back("currentStep");
properties.push_back("cellCount");
properties.push_back("particleCount");
propertyMap["rank"] = true;
propertyMap["position"] = true;
propertyMap["currentStep"] = true;
propertyMap["particleCount"] = true;
propertyMap["cellCount"] = true;
}
else {
for (size_t i = 0; i < properties.size(); ++i) {
propertyMap[properties[i]] = true;
}
}
// Prepare file for output stream
if (streamType == "file") {
size_t rank = static_cast<size_t>(Environment<simDim>::get().GridController().getGlobalRank());
std::stringstream ss;
ss << outputFilePrefix << rank;
boost::filesystem::path resourceLogPath(ss.str());
fileBuf.open(resourceLogPath.string().c_str(), std::ios::out);
}
}
}
static std::string parseString()
{
std::string t;
while (int c = in.sbumpc())
t += char(c);
return t;
}
void ImageFileRecorder::stop()
{
if ( m_running )
{
filebuffer.close();
m_running = false;
}
}
static Vector parseColor()
{
Vector v;
unsigned char rgb[3];
enterChunk();
while (int id = nextChunk()) {
switch (id) {
case CHUNK_RGBF:
in.sgetn((char*)&v, 12);
break;
case CHUNK_RGBB:
in.sgetn((char*)rgb, 3);
v = Vector(rgb[0] / 255.0f, rgb[1] / 255.0f, rgb[2] / 255.0f);
}
}
leaveChunk();
return v;
}
boost::filesystem::path Appender::DoOpen(std::filebuf &file, Path& path)
{
const boost::filesystem::path PATH(SelectPathToUseHideErrors(path));
CreateDirectoryTree(PATH.branch_path( ));
using namespace std;
file.open(PATH.string( ).c_str( ), ios::out | ios::app | ios::ate);
return PATH;
}
static void enterChunk()
{
parent_end.push_back(chunk_end);
chunk_end = (int)in.pubseekoff(0, std::ios_base::cur);
}
static void parseAnimKeys(Animation* anim, int type)
{
int cnt = 0;
short t_flags;
in.sgetn((char*)&t_flags, 2);
in.pubseekoff(8, std::ios_base::cur);
in.sgetn((char*)&cnt, 2);
in.pubseekoff(2, std::ios_base::cur);
_log("ANIM_TRACK: frames=" + itoa(cnt));
Vector pos, axis, scale;
float angle;
Quat quat;
for (int k = 0; k < cnt; ++k) {
int time;
short flags;
in.sgetn((char*)&time, 4);
in.sgetn((char*)&flags, 2);
float tens = 0, cont = 0, bias = 0, ease_to = 0, ease_from = 0;
if (flags & 1)
in.sgetn((char*)&tens, 4);
if (flags & 2)
in.sgetn((char*)&cont, 4);
if (flags & 4)
in.sgetn((char*)&bias, 4);
if (flags & 8)
in.sgetn((char*)&ease_to, 4);
if (flags & 16)
in.sgetn((char*)&ease_from, 4);
switch (type) {
case 0xb020: //POS_TRACK_TAG
in.sgetn((char*)&pos, 12);
if (conv)
pos = conv_tform * pos;
// _log( "POS_KEY: time="+itoa(time)+" pos="+ftoa( pos.x )+","+ftoa( pos.y )+","+ftoa( pos.z ) );
if (time <= anim_len)
anim->setPositionKey(time, pos);
break;
case 0xb021: //ROT_TRACK_TAG
in.sgetn((char*)&angle, 4);
in.sgetn((char*)&axis, 12);
// _log( "ROT_KEY: time="+itoa(time)+" angle="+ftoa(angle)+" axis="+ftoa(axis.x)+","+ftoa(axis.y)+","+ftoa(axis.z) );
if (axis.length() > FLT_EPSILON) {
if (flip_tris)
angle = -angle;
if (conv)
axis = conv_tform.m * axis;
quat = Quat(cosf(angle / 2), axis.normalized() * sinf(angle / 2)) * quat;
quat.normalize();
}
if (time <= anim_len)
anim->setRotationKey(time, quat);
break;
case 0xb022: //SCL_TRACK_TAG
in.sgetn((char*)&scale, 12);
if (conv)
scale = conv_tform.m * scale;
// scale.x=fabs(scale.x);scale.y=fabs(scale.y);scale.z=fabs(scale.z);
_log("SCL_KEY: time=" + itoa(time) + " scale=" + ftoa(scale.x) + "," + ftoa(scale.y) + "," + ftoa(scale.z));
if (time <= anim_len)
anim->setScaleKey(time, scale);
break;
}
}
}
static void parseTriMesh(MeshModel* mesh)
{
_log("TriMesh");
enterChunk();
Transform tform;
faces.clear();
MeshLoader::beginMesh();
while (int id = nextChunk()) {
switch (id) {
case CHUNK_VERTLIST:
if (!animonly)
parseVertList();
break;
case CHUNK_MAPLIST:
if (!animonly)
parseMapList();
break;
case CHUNK_FACELIST:
if (!animonly)
parseFaceList();
break;
case CHUNK_TRMATRIX:
in.sgetn((char*)&tform, 48);
if (conv)
tform = conv_tform * tform * -conv_tform;
break;
}
}
leaveChunk();
//should really do something here...
// bool neg_x=tform.m.j.cross(tform.m.k).dot(tform.m.i)<0;
int k;
mesh->SetWorldTransform(tform);
if (animonly) {
MeshLoader::endMesh(0);
return;
}
Transform inv_tform = -tform;
for (k = 0; k < MeshLoader::numVertices(); ++k) {
Surface::Vertex& v = MeshLoader::refVertex(k);
v.coords = inv_tform * v.coords;
}
for (k = 0; k < faces.size(); ++k) {
const Face3DS& f = faces[k];
MeshLoader::addTriangle(f.verts, f.brush);
}
MeshLoader::endMesh(mesh);
mesh->updateNormals();
faces.clear();
}
virtual void write( char c )
{
buff.sputc(c);
buff.pubsync();
}
static void parseMeshInfo(MeshModel* root, float curr_time)
{
_log("OBJECT_NODE_TAG");
enterChunk();
std::string name, inst;
Vector pivot;
Animation anim;
unsigned short id = 65535, parent = 65535, flags1, flags2;
Box box = Box(Vector(), Vector());
Vector box_centre;
while (int chunk_id = nextChunk()) {
switch (chunk_id) {
case 0xb030: //NODE_ID
in.sgetn((char*)&id, 2);
_log("NODE_ID: " + itoa(id));
break;
case 0xb010: //NODE_HDR
name = parseString();
in.sgetn((char*)&flags1, 2);
in.sgetn((char*)&flags2, 2);
in.sgetn((char*)&parent, 2);
_log("NODE_HDR: name=" + name + " parent=" + itoa(parent));
break;
case 0xb011: //INSTANCE NAME
inst = parseString();
_log("INSTANCE_NAME: " + inst);
break;
case 0xb013: //PIVOT
in.sgetn((char*)&pivot, 12);
if (conv)
pivot = conv_tform * pivot;
_log("PIVOT: " + ftoa(pivot.x) + "," + ftoa(pivot.y) + "," + ftoa(pivot.z));
break;
case 0xb014: //BOUNDBOX
in.sgetn((char*)&(box.a), 12);
in.sgetn((char*)&(box.b), 12);
box_centre = box.centre();
if (conv)
box_centre = conv_tform * box_centre;
_log("BOUNDBOX: min=" + ftoa(box.a.x) + "," + ftoa(box.a.y) + "," + ftoa(box.a.z) + " max=" + ftoa(box.b.x)
+ "," + ftoa(box.b.y) + "," + ftoa(box.b.z));
break;
case 0xb020: //POS_TRACK_TAG
case 0xb021: //ROT_TRACK_TAG
case 0xb022: //SCALE_TRACK_TAG
if (!collapse)
parseAnimKeys(&anim, chunk_id);
break;
}
}
leaveChunk();
MeshModel* p = root;
if (parent != 65535) {
std::map<int, MeshModel*>::const_iterator it = id_map.find(parent);
if (it == id_map.end())
return;
p = it->second;
}
MeshModel* mesh = 0;
if (name == "$$$DUMMY") {
mesh = new MeshModel();
mesh->SetName(inst);
mesh->SetParent(p);
} else {
std::map<std::string, MeshModel*>::const_iterator it = name_map.find(name);
if (it == name_map.end())
return;
mesh = it->second;
name_map.erase(name);
if (pivot != Vector()) {
mesh->transform(-pivot);
}
Transform t = mesh->GetWorldTransform();
mesh->SetParent(p);
mesh->SetWorldTransform(t);
}
mesh->setAnimation(anim);
if (id != 65535)
id_map[id] = mesh;
}
