/* 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;
}
}
