/* Turn the model file into a model object. */ Model obtainModel(const string & path_to_model) { // Control the file path bfs::path model_path(path_to_model); ModelParsers::testPath(model_path); // Read the file and control its syntax auto model_content = ModelParsers::readModel(model_path); rng::sort(model_content); Model result = parseModel(model_content); result.name = model_path.stem().string(); return result; }
END_TEST START_TEST(test_parseModel_repressilator) { doc = parseModel(EXAMPLES_FILENAME("repressilator.xml"), 0, 1); ck_assert(doc != NULL); model = SBMLDocument_getModel(doc); ck_assert(model != NULL); ck_assert(Model_getNumFunctionDefinitions(model) == 0); ck_assert(Model_getNumUnitDefinitions(model) == 0); ck_assert(Model_getNumCompartmentTypes(model) == 0); ck_assert(Model_getNumSpeciesTypes(model) == 0); ck_assert(Model_getNumCompartments(model) == 1); ck_assert(Model_getNumSpecies(model) == 6); ck_assert(Model_getNumSpeciesWithBoundaryCondition(model) == 0); ck_assert(Model_getNumParameters(model) == 3); ck_assert(Model_getNumInitialAssignments(model) == 0); ck_assert(Model_getNumRules(model) == 6); ck_assert(Model_getNumConstraints(model) == 0); ck_assert(Model_getNumReactions(model) == 0); ck_assert(Model_getNumEvents(model) == 0); CHECK_PARAMETER(model, 0, "alpha"); CHECK_PARAMETER(model, 1, "beta"); CHECK_PARAMETER(model, 2, "rho"); CHECK_RULE(model, 0, "beta * (y1 - x1)"); CHECK_RULE(model, 1, "beta * (y2 - x2)"); CHECK_RULE(model, 2, "beta * (y3 - x3)"); CHECK_RULE(model, 3, "alpha * x1 / (1 + x1 + rho * x3) - y1"); CHECK_RULE(model, 4, "alpha * x2 / (1 + x2 + rho * x1) - y2"); CHECK_RULE(model, 5, "alpha * x3 / (1 + x3 + rho * x2) - y3"); }
END_TEST START_TEST(test_parseModel_basic) { doc = parseModel(EXAMPLES_FILENAME("basic.xml"), 0, 1); ck_assert(doc != NULL); model = SBMLDocument_getModel(doc); ck_assert(model != NULL); ck_assert(Model_getNumFunctionDefinitions(model) == 0); ck_assert(Model_getNumUnitDefinitions(model) == 0); ck_assert(Model_getNumCompartmentTypes(model) == 0); ck_assert(Model_getNumSpeciesTypes(model) == 0); ck_assert(Model_getNumCompartments(model) == 1); ck_assert(Model_getNumSpecies(model) == 2); ck_assert(Model_getNumSpeciesWithBoundaryCondition(model) == 0); ck_assert(Model_getNumParameters(model) == 1); ck_assert(Model_getNumInitialAssignments(model) == 0); ck_assert(Model_getNumRules(model) == 0); ck_assert(Model_getNumConstraints(model) == 0); ck_assert(Model_getNumReactions(model) == 2); ck_assert(Model_getNumEvents(model) == 0); CHECK_PARAMETER(model, 0, "k_1"); CHECK_REACTION(model, 0, "R1", "k_1 * S1"); CHECK_REACTION(model, 1, "R2", "k_2 * S2"); }
void XMLLoader::loadUserData(string username, User * user) { ofxDirList DIR; DIR.allowExt("xml"); int numFiles = DIR.listDir(FOLDER); bool found = false; for(int i = 0; i < numFiles; i++) { cout << DIR.getName(i) << endl; if(username + ".xml" == DIR.getName(i)) { parseModel(DIR.getName(i), user); found = true; } } if(!found) { cout << "No XML File found \n"; _xml.setValue(VIDEOS, ""); _xml.saveFile(FOLDER + username + ".xml"); } }
END_TEST START_TEST(test_Model_odeSolver_repressilator) { doc = parseModel(EXAMPLES_FILENAME("repressilator.xml"), 0, 1); model = SBMLDocument_getModel(doc); results = Model_odeSolver(model, cs); ck_assert(results != NULL); }
END_TEST START_TEST(test_Model_odeSolver_events_2_events_1_assignment_l2) { doc = parseModel(EXAMPLES_FILENAME("events-2-events-1-assignment-l2.xml"), 0, 1); model = SBMLDocument_getModel(doc); results = Model_odeSolver(model, cs); ck_assert(results != NULL); }
END_TEST START_TEST(test_Model_odeSolver_basic_model1_forward_l2) { doc = parseModel(EXAMPLES_FILENAME("basic-model1-forward-l2.xml"), 0, 1); model = SBMLDocument_getModel(doc); results = Model_odeSolver(model, cs); ck_assert(results != NULL); }
END_TEST START_TEST(test_parseModel_huang96) { doc = parseModel(EXAMPLES_FILENAME("huang96.xml"), 0, 1); ck_assert(doc != NULL); model = SBMLDocument_getModel(doc); ck_assert(model != NULL); ck_assert(Model_getNumFunctionDefinitions(model) == 0); ck_assert(Model_getNumUnitDefinitions(model) == 0); ck_assert(Model_getNumCompartmentTypes(model) == 0); ck_assert(Model_getNumSpeciesTypes(model) == 0); ck_assert(Model_getNumCompartments(model) == 1); ck_assert(Model_getNumSpecies(model) == 22); ck_assert(Model_getNumSpeciesWithBoundaryCondition(model) == 0); ck_assert(Model_getNumParameters(model) == 0); ck_assert(Model_getNumInitialAssignments(model) == 0); ck_assert(Model_getNumRules(model) == 0); ck_assert(Model_getNumConstraints(model) == 0); ck_assert(Model_getNumReactions(model) == 20); ck_assert(Model_getNumEvents(model) == 0); CHECK_REACTION(model, 0, "r1a", "a1 * E1 * KKK - d1 * E1_KKK"); CHECK_REACTION(model, 1, "r1b", "k2 * E1_KKK"); CHECK_REACTION(model, 2, "r2a", "a2 * E2 * P_KKK - d2 * E2_P_KKK"); CHECK_REACTION(model, 3, "r2b", "k2 * E2_P_KKK"); CHECK_REACTION(model, 4, "r3a", "a3 * KK * P_KKK - d3 * P_KKK_KK"); CHECK_REACTION(model, 5, "r3b", "k3 * P_KKK_KK"); CHECK_REACTION(model, 6, "r4a", "a4 * P_KK * KKPase - d4 * KKPase_P_KK"); CHECK_REACTION(model, 7, "r4b", "k4 * KKPase_P_KK"); CHECK_REACTION(model, 8, "r5a", "a5 * P_KK * P_KKK - d5 * P_KKK_P_KK"); CHECK_REACTION(model, 9, "r5b", "k5 * P_KKK_P_KK"); CHECK_REACTION(model, 10, "r6a", "a6 * PP_KK * KKPase - d6 * KKPase_PP_KK"); CHECK_REACTION(model, 11, "r6b", "k6 * KKPase_PP_KK"); CHECK_REACTION(model, 12, "r7a", "a7 * K * PP_KK - d7 * PP_KK_K"); CHECK_REACTION(model, 13, "r7b", "k7 * PP_KK_K"); CHECK_REACTION(model, 14, "r8a", "a8 * P_K * KPase - d8 * KPase_P_K"); CHECK_REACTION(model, 15, "r8b", "k8 * KPase_P_K"); CHECK_REACTION(model, 16, "r9a", "a9 * P_K * PP_KK - d9 * PP_KK_P_K"); CHECK_REACTION(model, 17, "r9b", "k9 * PP_KK_P_K"); CHECK_REACTION(model, 18, "r10a", "a10 * PP_K * KPase - d10 * KPase_PP_K"); CHECK_REACTION(model, 19, "r10b", "k10 * KPase_PP_K"); /* TODO */ }
END_TEST START_TEST(test_parseModel_events_1_event_1_assignment_l2) { doc = parseModel(EXAMPLES_FILENAME("events-1-event-1-assignment-l2.xml"), 0, 1); ck_assert(doc != NULL); model = SBMLDocument_getModel(doc); ck_assert(model != NULL); ck_assert(Model_getNumFunctionDefinitions(model) == 0); ck_assert(Model_getNumUnitDefinitions(model) == 0); ck_assert(Model_getNumCompartmentTypes(model) == 0); ck_assert(Model_getNumSpeciesTypes(model) == 0); ck_assert(Model_getNumCompartments(model) == 1); ck_assert(Model_getNumSpecies(model) == 2); ck_assert(Model_getNumSpeciesWithBoundaryCondition(model) == 0); ck_assert(Model_getNumParameters(model) == 0); ck_assert(Model_getNumInitialAssignments(model) == 0); ck_assert(Model_getNumRules(model) == 0); ck_assert(Model_getNumConstraints(model) == 0); ck_assert(Model_getNumReactions(model) == 1); ck_assert(Model_getNumEvents(model) == 1); CHECK_REACTION(model, 0, "R", "S1"); /* TODO */ }
void PDBFormat::PDBParser::parseBioStruct3D(BioStruct3D& biostruct, U2OpStatus& ti) { QByteArray readBuff(DocumentFormat::READ_BUFF_SIZE + 1, 0); char* buf = readBuff.data(); qint64 len = 0; bool firstCompndLine = true; while (!ti.isCoR()) { bool lineOk = true; len = io->readUntil(buf, DocumentFormat::READ_BUFF_SIZE, TextUtils::LINE_BREAKS, IOAdapter::Term_Include, &lineOk); if (len == 0) { break; } // there could be no terminator if this is end of file, so we have to check for this if (!lineOk && !io->isEof()) { ti.setError(U2::PDBFormat::tr("Line is too long")); return; } currentPDBLine = QString(QByteArray(buf, len)); ti.setProgress(io->getProgress() * 0.8); if (currentPDBLine.startsWith("HEADER")) { parseHeader(biostruct, ti); continue; } if (currentPDBLine.startsWith("COMPND")) { parseMacromolecularContent(firstCompndLine, ti); firstCompndLine = false; continue; } if (currentPDBLine.startsWith("SEQRES")) { parseSequence(biostruct, ti); continue; } if (currentPDBLine.startsWith("HELIX ") || currentPDBLine.startsWith("SHEET ") || currentPDBLine.startsWith("TURN ")) { parseSecondaryStructure(biostruct, ti); continue; } if (currentPDBLine.startsWith("ATOM ") || currentPDBLine.startsWith("HETATM")) { parseAtom(biostruct, ti); continue; } if (currentPDBLine.startsWith("TER")) { ++currentChainIndex; continue; } if (currentPDBLine.startsWith("SPLIT ")) { parseSplitSection(ti); continue; } if (currentPDBLine.startsWith("MODEL")) { currentChainIndex = 1; parseModel(biostruct, ti); continue; } if (currentPDBLine.startsWith("ENDMDL")) { flagMultipleModels = true; ++currentModelIndex; continue; } } CHECK_OP(ti,); if (!flagAtomRecordPresent) { ti.setError(U2::PDBFormat::tr("Some mandatory records are absent")); } updateSecStructChainIndexes(biostruct); }
Entity SceneLoader::instantiate(Json def, Resources& resources, const string& pathContext) { ASSERT(def.is_object()); if (def["prefab"].is_string()) { const string& prefabName = def["prefab"].string_value(); auto prefabIter = prefabs.find(prefabName); if (prefabIter != prefabs.end()) { def = assign(prefabIter->second, def); } else if (endsWith(prefabName, ".json")) { string err; Json extPrefab = Json::parse(resources.getText(resolvePath(pathContext, prefabName), Resources::NO_CACHE), err); if (!err.empty()) { logError("Failed to parse prefab \"%s\": %s", prefabName.c_str(), err.c_str()); } else { def = assign(extPrefab, def); prefabs[prefabName] = extPrefab; } } else { logError("Could not find prefab \"%s\"", prefabName.c_str()); } } Entity entity = world->create(); if (def["name"].is_string()) { entity.tag(def["name"].string_value()); #ifdef USE_DEBUG_NAMES DebugInfo info; info.name = def["name"].string_value(); entity.add<DebugInfo>(info); } else { static uint debugId = 0; DebugInfo info; if (def["prefab"].is_string()) info.name = def["prefab"].string_value() + "#"; else if (def["geometry"].is_string()) info.name = def["geometry"].string_value() + "#"; else info.name = "object#"; info.name += std::to_string(debugId++); entity.tag(info.name); entity.add<DebugInfo>(info); #endif } // Parse transform if (!def["position"].is_null() || !def["rotation"].is_null() || !def["scale"].is_null() || !def["geometry"].is_null()) { Transform transform; setVec3(transform.position, def["position"]); setVec3(transform.scale, def["scale"]); if (!def["rotation"].is_null()) { const Json& rot = def["rotation"]; if (rot.is_array() && rot.array_items().size() == 4) transform.rotation = quat(rot[3].number_value(), rot[0].number_value(), rot[1].number_value(), rot[2].number_value()); else transform.rotation = quat(toVec3(rot)); } entity.add(transform); } // Parse light const Json& lightDef = def["light"]; if (!lightDef.is_null()) { Light light; const string& lightType = lightDef["type"].string_value(); if (lightType == "ambient") light.type = Light::AMBIENT_LIGHT; else if (lightType == "point") light.type = Light::POINT_LIGHT; else if (lightType == "directional") light.type = Light::DIRECTIONAL_LIGHT; else if (lightType == "spot") light.type = Light::SPOT_LIGHT; else if (lightType == "area") light.type = Light::AREA_LIGHT; else if (lightType == "hemisphere") light.type = Light::HEMISPHERE_LIGHT; else logError("Unknown light type \"%s\"", lightType.c_str()); setColor(light.color, lightDef["color"]); if (!def["position"].is_null()) light.position = toVec3(def["position"]); if (!lightDef["direction"].is_null()) light.direction = toVec3(lightDef["direction"]); setNumber(light.distance, lightDef["distance"]); setNumber(light.decay, lightDef["decay"]); entity.add(light); numLights++; } if (!def["geometry"].is_null()) { Model model; parseModel(model, def, resources, pathContext); entity.add(model); numModels++; } // Patch bounding box // TODO: Bounding box is not correct if scale changed at runtime if (entity.has<Model>() && entity.has<Transform>()) { Model& model = entity.get<Model>(); const Transform& trans = entity.get<Transform>(); model.bounds.min = model.lods[0].geometry->bounds.min * trans.scale; model.bounds.max = model.lods[0].geometry->bounds.max * trans.scale; model.bounds.radius = model.lods[0].geometry->bounds.radius * glm::compMax(trans.scale); } // Parse body (needs to be after geometry, transform, bounds...) if (!def["body"].is_null()) { const Json& bodyDef = def["body"]; ASSERT(bodyDef.is_object()); ASSERT(entity.has<Model>()); ASSERT(entity.has<Transform>()); const Model& model = entity.get<Model>(); const Transform& transform = entity.get<Transform>(); float mass = 0.f; setNumber(mass, bodyDef["mass"]); btCollisionShape* shape = NULL; const string& shapeStr = bodyDef["shape"].string_value(); vec3 extents = model.bounds.max - model.bounds.min; if (shapeStr == "box") { shape = new btBoxShape(convert(extents * 0.5f)); } else if (shapeStr == "sphere") { shape = new btSphereShape(model.bounds.radius); } else if (shapeStr == "cylinder") { shape = new btCylinderShape(convert(extents * 0.5f)); } else if (shapeStr == "capsule") { float r = glm::max(extents.x, extents.z) * 0.5f; shape = new btCapsuleShape(r, extents.y); } else if (shapeStr == "trimesh") { Geometry* colGeo = nullptr; if (bodyDef["geometry"].is_string()) { colGeo = resources.getGeometry(bodyDef["geometry"].string_value()); } else { if (bodyDef["geometry"].is_array()) logError("LODs not supported for collision mesh."); colGeo = model.lods[0].geometry; } if (!colGeo->collisionMesh) colGeo->generateCollisionTriMesh(); if (mass <= 0.f) { // Static mesh shape = new btBvhTriangleMeshShape(colGeo->collisionMesh, true); } else { shape = new btGImpactMeshShape(colGeo->collisionMesh); static_cast<btGImpactMeshShape*>(shape)->updateBound(); } } else { logError("Unknown shape %s", shapeStr.c_str()); } ASSERT((shapeStr == "trimesh" || bodyDef["geometry"].is_null()) && "Trimesh shape type required if body.geometry is specified"); ASSERT(shape); btVector3 inertia(0, 0, 0); shape->calculateLocalInertia(mass, inertia); btRigidBody::btRigidBodyConstructionInfo info(mass, NULL, shape, inertia); info.m_startWorldTransform = btTransform(convert(transform.rotation), convert(transform.position)); setNumber(info.m_friction, bodyDef["friction"]); setNumber(info.m_rollingFriction, bodyDef["rollingFriction"]); setNumber(info.m_restitution, bodyDef["restitution"]); if (bodyDef["noSleep"].bool_value()) { info.m_linearSleepingThreshold = 0.f; info.m_angularSleepingThreshold = 0.f; } entity.add<btRigidBody>(info); numBodies++; btRigidBody& body = entity.get<btRigidBody>(); if (!bodyDef["angularFactor"].is_null()) body.setAngularFactor(convert(toVec3(bodyDef["angularFactor"]))); if (!bodyDef["linearFactor"].is_null()) body.setLinearFactor(convert(toVec3(bodyDef["linearFactor"]))); if (bodyDef["noGravity"].bool_value()) body.setFlags(body.getFlags() | BT_DISABLE_WORLD_GRAVITY); body.setUserIndex(entity.get_id()); if (world->has_system<PhysicsSystem>()) world->get_system<PhysicsSystem>().add(entity); } if (!def["animation"].is_null()) { ASSERT(entity.has<Model>()); const Json& animDef = def["animation"]; BoneAnimation anim; setNumber(anim.speed, animDef["speed"]); entity.add(anim); if (animDef["play"].is_bool() && animDef["play"].bool_value()) world->get_system<AnimationSystem>().play(entity); else world->get_system<AnimationSystem>().stop(entity); } if (def["trackGround"].bool_value()) { ASSERT(entity.has<btRigidBody>()); entity.add<GroundTracker>(); } if (def["trackContacts"].bool_value()) { ASSERT(entity.has<btRigidBody>()); entity.add<ContactTracker>(); } if (def["triggerVolume"].is_object()) { ASSERT(entity.has<Transform>()); const Json& triggerDef = def["triggerVolume"]; TriggerVolume& trigger = entity.add<TriggerVolume>(); setNumber(trigger.times, triggerDef["times"]); setNumber(trigger.bounds.radius, triggerDef["radius"]); setVec3(trigger.bounds.min, triggerDef["min"]); setVec3(trigger.bounds.min, triggerDef["max"]); if (triggerDef["receiver"].is_string()) trigger.receiverModule = id::hash(triggerDef["receiver"].string_value()); if (triggerDef["enterMessage"].is_string()) trigger.enterMessage = id::hash(triggerDef["enterMessage"].string_value()); else if (triggerDef["enterMessage"].is_number()) trigger.enterMessage = triggerDef["enterMessage"].number_value(); if (triggerDef["exitMessage"].is_string()) trigger.exitMessage = id::hash(triggerDef["exitMessage"].string_value()); else if (triggerDef["exitMessage"].is_number()) trigger.exitMessage = triggerDef["exitMessage"].number_value(); if (triggerDef["groups"].is_number()) trigger.groups = 1 << (uint)triggerDef["groups"].number_value(); else if (triggerDef["groups"].is_array()) { for (const auto& item : triggerDef["groups"].array_items()) trigger.groups |= 1 << (uint)item.number_value(); } } if (def["triggerGroup"].is_number()) { ASSERT(entity.has<Transform>()); entity.add<TriggerGroup>().group = 1 << (uint)def["triggerGroup"].number_value(); } if (!def["moveSound"].is_null()) { const Json& soundDef = def["moveSound"]; MoveSound sound; if (soundDef["event"].is_string()) sound.event = id::hash(soundDef["event"].string_value()); setNumber(sound.stepLength, soundDef["step"]); ASSERT(sound.event); ASSERT(entity.has<Transform>()); sound.prevPos = entity.get<Transform>().position; entity.add(sound); } if (!def["contactSound"].is_null()) { const Json& soundDef = def["contactSound"]; ContactSound sound; if (soundDef["event"].is_string()) sound.event = id::hash(soundDef["event"].string_value()); ASSERT(sound.event); ASSERT(entity.has<Transform>()); ASSERT(entity.has<ContactTracker>()); entity.add(sound); } return entity; }
bool KICADMODULE::Read( SEXPR::SEXPR* aEntry ) { if( NULL == aEntry ) return false; if( aEntry->IsList() ) { size_t nc = aEntry->GetNumberOfChildren(); SEXPR::SEXPR* child = aEntry->GetChild( 0 ); std::string name = child->GetSymbol(); if( name != "module" ) { std::ostringstream ostr; ostr << "* BUG: module parser invoked for type '" << name << "'\n"; wxLogMessage( "%s\n", ostr.str().c_str() ); return false; } bool result = true; for( size_t i = 1; i < nc && result; ++i ) { child = aEntry->GetChild( i ); // skip the module name and the optional 'locked' attribute; // due to the vagaries of the kicad version of sexpr, the // name may be a Symbol or a String if( i <= 2 && ( child->IsSymbol() || child->IsString() ) ) continue; if( !child->IsList() ) { std::ostringstream ostr; ostr << "* corrupt module in PCB file\n"; wxLogMessage( "%s\n", ostr.str().c_str() ); return false; } std::string symname( child->GetChild( 0 )->GetSymbol() ); if( symname == "layer" ) result = result && parseLayer( child ); else if( symname == "at" ) result = result && parsePosition( child ); else if( symname == "fp_text" ) result = result && parseText( child ); else if( symname == "fp_arc" ) result = result && parseCurve( child, CURVE_ARC ); else if( symname == "fp_line" ) result = result && parseCurve( child, CURVE_LINE ); else if( symname == "fp_circle" ) result = result && parseCurve( child, CURVE_CIRCLE ); else if( symname == "pad" ) result = result && parsePad( child ); else if( symname == "model" ) result = result && parseModel( child ); } return result; } std::ostringstream ostr; ostr << "* data is not a valid PCB module\n"; wxLogMessage( "%s\n", ostr.str().c_str() ); return false; }
bool LDModelParser::parseModel( LDLModel *ldlModel, TREModel *treModel, bool bfc, int activeColorNumber) { BFCState newState = ldlModel->getBFCState(); LDObiInfo obiInfo; LDObiInfo *origObiInfo = m_obiInfo; if (m_obiInfo != NULL && m_obiInfo->isActive() && !ldlModel->colorNumberIsTransparent(activeColorNumber)) { obiInfo.start(m_obiInfo->getColor(), m_obiInfo->getEdgeColor(), true); } m_obiInfo = &obiInfo; bfc = ((bfc && (newState == BFCOnState)) || newState == BFCForcedOnState) && getBFCFlag(); if (ldlModel && !performPrimitiveSubstitution(ldlModel, treModel, activeColorNumber, bfc)) { LDLFileLineArray *fileLines = ldlModel->getFileLines(); if (fileLines) { int i; int count = ldlModel->getActiveLineCount(); StringSet obiOrigTokens = m_obiTokens; for (i = 0; i < count && !m_abort; i++) { LDLFileLine *fileLine = (*fileLines)[i]; if (fileLine->isValid()) { if (fileLine->isActionLine() && actionLineIsActive((LDLActionLine *)fileLine)) { if (m_flags.newTexmap) { treModel->startTexture(fileLine->getTexmapType(), fileLine->getTexmapFilename(), fileLine->getTexmapImage(), fileLine->getTexmapPoints()); m_flags.newTexmap = false; m_flags.texmapStarted = true; } //if (m_flags.obi) //{ // ((LDLActionLine *)fileLine)->setObiOverrideActive( // !ldlModel->colorNumberIsTransparent( // activeColorNumber)); //} switch (fileLine->getLineType()) { case LDLLineTypeModel: parseModel((LDLModelLine *)fileLine, treModel, bfc, activeColorNumber); break; case LDLLineTypeLine: parseLine((LDLShapeLine *)fileLine, treModel, activeColorNumber); break; case LDLLineTypeTriangle: parseTriangle((LDLShapeLine *)fileLine, treModel, bfc, false, activeColorNumber); break; case LDLLineTypeQuad: parseQuad((LDLShapeLine *)fileLine, treModel, bfc, false, activeColorNumber); break; case LDLLineTypeConditionalLine: parseConditionalLine( (LDLConditionalLineLine *)fileLine, treModel, activeColorNumber); break; default: break; } m_obiInfo->actionHappened(); if (m_flags.texmapNext) { treModel->endTexture(); } } else if (fileLine->getLineType() == LDLLineTypeComment) { parseCommentLine((LDLCommentLine *)fileLine, treModel); } } if (ldlModel == m_topLDLModel && m_alertSender != NULL) { TCProgressAlert::send("LDLModelParser", TCLocalStrings::get(_UC("ParsingStatus")), (float)(i + 1) / (float)(count + 1), &m_abort, this); } } m_obiTokens = obiOrigTokens; } } m_obiInfo = origObiInfo; return !m_abort; }
bool LDModelParser::parseModel( LDLModelLine *modelLine, TREModel *treModel, bool bfc, int activeColorNumber) { LDLModel *ldlModel = modelLine->getModel(); bool invert = modelLine->getBFCInvert(); if (bfc) { bfc = modelLine->getBFCOn(); } activeColorNumber = getActiveColorNumber(modelLine, activeColorNumber); if (ldlModel) { TREModel *model = NULL; std::string nameKey = modelNameKey(ldlModel, activeColorNumber); model = m_mainTREModel->modelNamed(nameKey.c_str(), bfc); if (model) { return addSubModel(modelLine, treModel, model, bfc && invert, activeColorNumber); } else { model = new TREModel; model->setMainModel(treModel->getMainModel()); model->setName(nameKey.c_str()); model->setPartFlag(ldlModel->isPart()); model->setNoShrinkFlag(ldlModel->getNoShrinkFlag()); if (m_flags.boundingBoxesOnly && ldlModel->isPart()) { TCVector minMax[2]; m_mainTREModel->registerModel(model, bfc); model->release(); ldlModel->getBoundingBox(minMax[0], minMax[1]); for (int i = 0; i < 6; i++) { addBoundingQuad(model, minMax, i); } return addSubModel(modelLine, treModel, model, bfc && invert, activeColorNumber); } else if (parseModel(ldlModel, model, bfc, activeColorNumber)) { m_mainTREModel->registerModel(model, bfc); model->release(); return addSubModel(modelLine, treModel, model, bfc && invert, activeColorNumber); } else { model->release(); return false; } } } else { return false; } }
bool LDModelParser::parseMainModel(LDLModel *mainLDLModel) { int colorNumber = 7; int edgeColorNumber; LDLPalette *palette = mainLDLModel->getMainModel()->getPalette(); m_topLDLModel = (LDLModel *)mainLDLModel->retain(); m_mainTREModel = new TREMainModel; if (m_alertSender != NULL) { m_mainTREModel->setAlertSender(m_alertSender); } else { m_mainTREModel->setSendProgressFlag(false); } m_mainTREModel->setMultiThreadedFlag(getMultiThreadedFlag()); m_mainTREModel->setPartFlag(mainLDLModel->isPart()); m_mainTREModel->setEdgeLinesFlag(getEdgeLinesFlag()); m_mainTREModel->setEdgesOnlyFlag(getEdgesOnlyFlag()); m_mainTREModel->setLightingFlag(getLightingFlag()); m_mainTREModel->setTwoSidedLightingFlag(getTwoSidedLightingFlag()); m_mainTREModel->setBFCFlag(getBFCFlag()); m_mainTREModel->setRedBackFacesFlag(getRedBackFacesFlag()); m_mainTREModel->setGreenFrontFacesFlag(getGreenFrontFacesFlag()); m_mainTREModel->setBlueNeutralFacesFlag(getBlueNeutralFacesFlag()); m_mainTREModel->setGl2psFlag(m_modelViewer->getGl2ps()); switch (m_modelViewer->getMemoryUsage()) { case 0: m_mainTREModel->setCompilePartsFlag(false); m_mainTREModel->setCompileAllFlag(false); m_mainTREModel->setFlattenConditionalsFlag(false); break; case 1: m_mainTREModel->setCompilePartsFlag(true); m_mainTREModel->setCompileAllFlag(false); m_mainTREModel->setFlattenConditionalsFlag(false); break; case 2: m_mainTREModel->setCompilePartsFlag(true); m_mainTREModel->setCompileAllFlag(true); m_mainTREModel->setFlattenConditionalsFlag(true); break; } m_mainTREModel->setPolygonOffsetFlag(getPolygonOffsetFlag()); m_mainTREModel->setEdgeLineWidth(m_modelViewer->getHighlightLineWidth()); m_mainTREModel->setStudAnisoLevel(m_modelViewer->getAnisoLevel()); m_mainTREModel->setAALinesFlag(getAALinesFlag()); m_mainTREModel->setSortTransparentFlag(getSortTransparentFlag()); m_mainTREModel->setStippleFlag(getStippleFlag()); m_mainTREModel->setWireframeFlag(getWireframeFlag()); m_mainTREModel->setConditionalLinesFlag(getConditionalLinesFlag()); m_mainTREModel->setSmoothCurvesFlag(getSmoothCurvesFlag()); m_mainTREModel->setShowAllConditionalFlag(getShowAllConditionalFlag()); m_mainTREModel->setConditionalControlPointsFlag( getConditionalControlPointsFlag()); m_mainTREModel->setStudLogoFlag(getStudLogoFlag()); m_mainTREModel->setStudTextureFilter(m_modelViewer->getTextureFilterType()); m_mainTREModel->setFlattenPartsFlag(getFlattenPartsFlag()); m_mainTREModel->setSeamWidth(getSeamWidth()); if (getDefaultColorNumberSetFlag()) { colorNumber = m_defaultColorNumber; } else if (getDefaultColorSetFlag()) { colorNumber = palette->getColorNumberForRGB(m_defaultR, m_defaultG, m_defaultB, m_flags.defaultTrans); } edgeColorNumber = mainLDLModel->getEdgeColorNumber(colorNumber); m_mainTREModel->setColor(mainLDLModel->getPackedRGBA(colorNumber), mainLDLModel->getPackedRGBA(edgeColorNumber)); m_obiTokens.clear(); if (parseModel(m_topLDLModel, m_mainTREModel, getBFCFlag(), m_defaultColorNumber)) { if (m_mainTREModel->isPart() || getFileIsPartFlag()) { m_mainTREModel->setPartFlag(true); //finishPart(m_mainTREModel); } m_mainTREModel->finish(); if (m_topLDLModel->getName()) { m_mainTREModel->setName(m_topLDLModel->getName()); } else { char *name = filenameFromPath(m_topLDLModel->getFilename()); m_mainTREModel->setName(name); delete name; } if (m_alertSender != NULL) { TCProgressAlert::send("LDModelParser", TCLocalStrings::get(_UC("ParsingStatus")), 1.0f, &m_abort, this); } if (m_abort) { return false; } else { return m_mainTREModel->postProcess(); } } else { return false; } }