static void parseKeyFramer( MeshModel *root ){
_log( "KeyFramer" );
enterChunk();
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( d_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;
}
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();
}
/**
* @brief Checks if the current chunk has enough items left.
*
* If the chunk has not enough items left, the next chunk is
* loaded.
*
* @param items The maximum number of items to store.
*/
CODI_INLINE void reserveItems(const size_t items) {
codiAssert(items <= chunkSize);
if(chunkSize < curChunk->getUsedSize() + items) {
nextChunk();
}
}
String SharedBufferChunkReader::nextChunkAsUTF8StringWithLatin1Fallback(bool includeSeparator)
{
Vector<char> data;
if (!nextChunk(data, includeSeparator))
return String();
return data.size() ? String::fromUTF8WithLatin1Fallback(data.data(), data.size()) : emptyString();
}
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->setWorldTform( 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();
}
uint16_t Bank::getCode(uint8_t numChunks) {
uint16_t c = 0;
while (numChunks--) {
c <<= 1;
if (nextChunk()) {
c |= 1;
}
}
return c;
}
static void parseMaterial()
{
_log("Material");
Brush mat;
std::string name, tex_name;
enterChunk();
while (int id = nextChunk()) {
switch (id) {
case CHUNK_MATNAME:
name = parseString();
break;
case CHUNK_DIFFUSE:
mat.setColor(parseColor());
break;
case CHUNK_AMBIENT:
break;
case CHUNK_SPECULAR:
break;
case CHUNK_TEXTURE:
enterChunk();
while (int id = nextChunk()) {
switch (id) {
case CHUNK_MAPFILE:
tex_name = parseString();
break;
}
}
leaveChunk();
break;
}
}
if (tex_name.size()) {
mat.setTexture(0, Texture(tex_name, 0), 0);
mat.setColor(Vector(1, 1, 1));
}
if (name.size()) {
materials_map[name] = mat;
}
leaveChunk();
}
void Kleo::QGpgMEKeyListJob::slotOperationDoneEvent( GpgME::Context * context, const GpgME::Error & ) {
if ( context != mCtx )
return;
mResult.mergeWith( mCtx->keyListResult() );
if ( !mResult.error() )
if ( const char* * chunk = nextChunk() ) {
if ( const GpgME::Error err = mCtx->startKeyListing( chunk, mSecretOnly ) )
mResult.mergeWith( GpgME::KeyListResult( 0, err ) );
else
return;
}
emit done();
emit result( mResult );
deleteLater();
}
static void parseScene( MeshModel *root ){
_log( "Scene" );
enterChunk();
while( int id=nextChunk() ){
switch( id ){
case CHUNK_OBJECT:
parseObject( root );
break;
case CHUNK_MATERIAL:
if( !animonly ) parseMaterial();
break;
}
}
leaveChunk();
}
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;
}
GpgME::KeyListResult Kleo::QGpgMEKeyListJob::attemptSyncKeyListing( std::vector<GpgME::Key> & keys ) {
GpgME::KeyListResult result;
for ( const char* * chunk = patterns() ; chunk ; chunk = nextChunk() ) {
if ( const GpgME::Error err = mCtx->startKeyListing( chunk, mSecretOnly ) )
return GpgME::KeyListResult( 0, err );
GpgME::Error err;
do
keys.push_back( mCtx->nextKey( err ) );
while ( !err );
keys.pop_back();
result.mergeWith( mCtx->endKeyListing() );
if ( result.error() )
break;
}
return result;
}
static void parseObject( MeshModel *root ){
//skip name
string name=parseString();
_log( "Object:"+name );
MeshModel *mesh=0;
enterChunk();
while( int id=nextChunk() ){
switch( id ){
case CHUNK_TRIMESH:
mesh=d_new MeshModel();
mesh->setName( name );
mesh->setParent( root );
name_map[name]=mesh;
parseTriMesh( mesh );
break;
}
}
leaveChunk();
}
void BlendLoader::reindexType(uint32_t &chunk, BlendLoader::VertexType vtype, const BlendData *blendData,
uint16_t* new_faces)
{
uint32_t pos_offset;
uint16_t mat = 0;
uint32_t face;
uint32_t fcount;
uint32_t vert;
uint32_t verts;
uint32_t new_offset;
uint64_t start = PlatformAdapter::currentMillis();
P3dMap<VertexIndex, uint32_t>* vertexMap = nullptr;
fcount = blendData->totface;
// tris
pos_offset = 0;
VertexIndex index;
index.type = vtype;
uint16_t new_index;
new_offset = 0; //TODO: should be passed in?
for(face = 0; face < fcount; ++face)
{
mat = blendData->mats[face];
/* start a new chunk for very first face. */
if(face == 0)
{
nextChunk(chunk, vtype, new_offset, m_new_pos_count / 3, true);
m_chunks[chunk].material = mat;
m_chunks[chunk].hasUvs = blendData->uvs != nullptr;
vertexMap = m_vertex_maps[m_chunks[chunk].vertOffset];
}
/* start a new chunk when a new material is found (Not yet used for blend reading. */
else if(mat != m_chunks[chunk].material)
{
nextChunk(chunk, vtype, new_offset, m_chunks[chunk].vertOffset, false);
m_chunks[chunk].material = mat;
m_chunks[chunk].hasUvs = blendData->uvs != nullptr;
vertexMap = m_vertex_maps[m_chunks[chunk].vertOffset];
}
/* if we get more than 65530 vertices in map we need start new chunk. */
if(vertexMap->size() > 65530)
{
// next chunk
nextChunk(chunk, vtype, new_offset, m_new_pos_count / 3, false);
m_chunks[chunk].material = mat;
m_chunks[chunk].hasUvs = blendData->uvs != nullptr;
vertexMap = m_vertex_maps[m_chunks[chunk].vertOffset];
}
verts = 3;
for(vert = 0; vert < verts; ++vert)
{
index.pos = blendData->faces[pos_offset];
pos_offset++;
/* TODO: norm */
index.norm = 0;
index.uv = index.pos;
if(vertexMap->count(index))
{
new_index = (*vertexMap)[index];
}
else
{
new_index = vertexMap->size();
vertexMap->insert(index, new_index);
m_new_pos_count += 3;
m_new_norm_count += 3;
m_new_empty_norm_count += 3;
m_new_uv_count += 2;
}
new_faces[new_offset] = (uint16_t)new_index;
++new_offset;
}
}
m_chunks[chunk].vertCount = (m_new_pos_count - STRIDE * m_chunks[chunk].vertOffset) / 3;
logger.debug("reindex type Blender took: %lldms", PlatformAdapter::durationMillis(start));
}
bool FgXmlProtocol::parseDOM(QString& err_msg) {
QDomElement dom_elem_base = m_xml_dom.documentElement();
if (dom_elem_base.nodeName()!=ProtXmlDef::NodePropertyList) {
err_msg="Protocol file not valid " + ProtXmlDef::NodePropertyList;
return false;
}
QDomElement dom_elem_prot = dom_elem_base.firstChildElement(ProtXmlDef::NodeProtocolType).firstChildElement(ProtXmlDef::NodeProtocolOut);
if (dom_elem_prot.isNull()) {
err_msg="invalid FG generic protocol file";
return false;
}
QDomElement current_elem;
//FIXME: all of simgear/props/props.cxx SGPropertyNode::getBoolValue () could be construed as
//setting binary mode. Considered silly either ways, pulling in simgear dependency
//for this case, or to reimplement and track the checks for all possibilities just to deny
//them.
if (getFirstChildElement(current_elem, dom_elem_prot, ProtXmlDef::NodeBinary, err_msg, "")) {
err_msg="Not implemented yet: PITA of deciding if " + ProtXmlDef::NodeBinary
+ " is used. It isn't implemented here anyways. Please remove <"
+ ProtXmlDef::NodeBinary + "> tag.";
return false;
}
err_msg.clear(); //it's not an error here
if (!getFirstChildElement(current_elem, dom_elem_prot, ProtXmlDef::NodeLineSep,
err_msg, "No needed <" + ProtXmlDef::NodeLineSep +"> set")) return false;
m_line_separator=setSep(current_elem.text());
if (m_line_separator.pattern().isEmpty()) {
err_msg="Empty <" + ProtXmlDef::NodeLineSep +"> value not allowed";
return false;
}
if (!getFirstChildElement(current_elem, dom_elem_prot, ProtXmlDef::NodeVarSep,
err_msg, "No needed <" + ProtXmlDef::NodeVarSep +"> set")) return false;
m_var_separator=setSep(current_elem.text());
if (m_var_separator.pattern().isEmpty()) {
err_msg="Empty <" + ProtXmlDef::NodeVarSep +"> value not allowed";
return false;
}
if (!getFirstChildElement(current_elem, dom_elem_prot, ProtXmlDef::NodeChunk,
err_msg, "No protocol chunk defined")) return false;
QDomElement info_elem;
while (!current_elem.isNull()) {
if (getFirstChildElement(info_elem, current_elem, ProtXmlDef::NodeName, err_msg)) {
if (!insertChunkName(info_elem.text())) {
current_elem=current_elem.nextSiblingElement(ProtXmlDef::NodeChunk);
break; //that chunk is not known, discard
}
}
if (getFirstChildElement(info_elem, current_elem, ProtXmlDef::NodeType, err_msg)) {
if (info_elem.text()=="bool")
insertChunkType(FG_BOOL);
else if (info_elem.text()=="float")
insertChunkType(FG_DOUBLE);
else if (info_elem.text()=="string")
insertChunkType(FG_STRING);
else if (info_elem.text()=="double")
insertChunkType(FG_INT);
//really! actually it just falls through to default, which happens to be
//FG_INT (set it explicitly here to avoid confusion, been there, done that...)
else
insertChunkType(FG_INT);
}
if (getFirstChildElement(info_elem, current_elem, ProtXmlDef::NodeCount, err_msg)) {
insertChunkCount(info_elem.text().toInt());
}
//tmpDesc.index=QModelIndex(tmpIndex);
//m_protinfo.append(tmpDesc);
if (!nextChunk()) break; //target data does not like another chunk
current_elem=current_elem.nextSiblingElement(ProtXmlDef::NodeChunk);
};
return true;
};
static void parseMeshInfo( MeshModel *root,float curr_time ){
_log( "OBJECT_NODE_TAG" );
enterChunk();
string name,inst;
Vector pivot;
Animation anim;
unsigned short id=65535,parent=65535,flags1,flags2;
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 ){
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=d_new MeshModel();
mesh->setName( inst );
mesh->setParent( p );
}else{
map<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->getWorldTform();
mesh->setParent( p );
mesh->setWorldTform( t );
}
mesh->setAnimation( anim );
if( id!=65535 ) id_map[id]=mesh;
}
