csPtr<iBase> csHazeLoader::Parse (iDocumentNode* node,
iStreamSource*, iLoaderContext* ldr_context,
iBase*)
{
csRef<iMeshObject> mesh;
csRef<iHazeFactoryState> hazefactorystate;
csRef<iHazeState> hazestate;
csVector3 a;
csRef<iDocumentNodeIterator> it = node->GetNodes ();
while (it->HasNext ())
{
csRef<iDocumentNode> child = it->Next ();
if (child->GetType () != CS_NODE_ELEMENT) continue;
const char* value = child->GetValue ();
csStringID id = xmltokens.Request (value);
switch (id)
{
case XMLTOKEN_FACTORY:
{
const char* factname = child->GetContentsValue ();
iMeshFactoryWrapper* fact = ldr_context->FindMeshFactory (factname);
if(!fact)
{
synldr->ReportError (
"crystalspace.hazeloader.parse.badfactory",
child, "Could not find factory '%s'!", factname);
return 0;
}
mesh = fact->GetMeshObjectFactory ()->NewInstance ();
hazestate = scfQueryInterface<iHazeState> (mesh);
if (!hazestate)
{
synldr->ReportError (
"crystalspace.hazeloader.parse.badfactory",
child, "Factory '%s' doesn't appear to be a haze factory!",
factname);
return 0;
}
hazefactorystate = scfQueryInterface<iHazeFactoryState> (
fact->GetMeshObjectFactory());
}
break;
case XMLTOKEN_MATERIAL:
{
const char* matname = child->GetContentsValue ();
iMaterialWrapper* mat = ldr_context->FindMaterial (matname);
if (!mat)
{
synldr->ReportError (
"crystalspace.hazeloader.parse.badmaterial",
child, "Could not find material '%s'!", matname);
return 0;
}
CHECK_MESH (mesh);
mesh->SetMaterialWrapper (mat);
}
break;
case XMLTOKEN_MIXMODE:
{
uint mode;
if (!synldr->ParseMixmode (child, mode))
return 0;
CHECK_MESH (mesh);
mesh->SetMixMode (mode);
}
break;
case XMLTOKEN_ORIGIN:
if (!synldr->ParseVector (child, a))
return 0;
CHECK_MESH (hazestate);
hazestate->SetOrigin (a);
break;
case XMLTOKEN_DIRECTIONAL:
if (!synldr->ParseVector (child, a))
return 0;
CHECK_MESH (hazestate);
hazestate->SetDirectional (a);
break;
case XMLTOKEN_LAYER:
{
float layerscale = 1.0;
iHazeHull *hull = ParseHull (xmltokens, reporter, synldr,
child, hazefactorystate, layerscale);
CHECK_MESH (hazestate);
hazestate->AddLayer (hull, layerscale);
}
break;
default:
synldr->ReportBadToken (child);
return 0;
}
}
return csPtr<iBase> (mesh);
}
csPtr<iBase> csNullMeshLoader::Parse (iDocumentNode* node,
iStreamSource*, iLoaderContext* ldr_context, iBase*)
{
csRef<iMeshObject> mesh;
csRef<iNullMeshState> state;
csRef<iDocumentNodeIterator> it = node->GetNodes ();
while (it->HasNext ())
{
csRef<iDocumentNode> child = it->Next ();
if (child->GetType () != CS_NODE_ELEMENT) continue;
const char* value = child->GetValue ();
csStringID id = xmltokens.Request (value);
switch (id)
{
case XMLTOKEN_BOX:
{
csBox3 box;
if (!synldr->ParseBox (child, box))
return 0;
CHECK_MESH (state);
state->SetBoundingBox (box);
}
break;
case XMLTOKEN_RADIUS:
CHECK_MESH (state);
state->SetRadius (child->GetContentsValueAsFloat ());
break;
case XMLTOKEN_FACTORY:
{
const char* factname = child->GetContentsValue ();
iMeshFactoryWrapper* fact = ldr_context->FindMeshFactory (factname);
if(!fact)
{
synldr->ReportError (
"crystalspace.nullmeshloader.parse.unknownfactory",
child, "Couldn't find factory '%s'!", factname);
return 0;
}
mesh = fact->GetMeshObjectFactory ()->NewInstance ();
state = scfQueryInterface<iNullMeshState> (mesh);
if (!state)
{
synldr->ReportError (
"crystalspace.nullmeshloader.parse.badfactory",
child, "Factory '%s' doesn't appear to be a null factory!",
factname);
return 0;
}
}
break;
default:
synldr->ReportBadToken (child);
return 0;
}
}
return csPtr<iBase> (mesh);
}
csPtr<iBase> csTerrainObjectLoader::Parse (iDocumentNode* node,
iStreamSource*, iLoaderContext* ldr_context, iBase* /*context*/)
{
csRef<iMeshObject> mesh;
csRef<iTerrainObjectState> state;
bool palette_set = false;
bool material_map_set = false;
csRef<iDocumentNodeIterator> it = node->GetNodes ();
while (it->HasNext ())
{
csRef<iDocumentNode> child = it->Next ();
if (child->GetType () != CS_NODE_ELEMENT) continue;
const char *value = child->GetValue ();
csStringID id = xmltokens.Request (value);
switch (id)
{
case XMLTOKEN_FACTORY:
{
const char* factname = child->GetContentsValue ();
csRef<iMeshFactoryWrapper> fact = ldr_context->FindMeshFactory (
factname);
if(!fact)
{
synldr->ReportError ("crystalspace.terrain.object.loader",
child, "Couldn't find factory '%s'!", factname);
return 0;
}
mesh = fact->GetMeshObjectFactory ()->NewInstance ();
state = scfQueryInterface<iTerrainObjectState> (mesh);
if (!state)
{
synldr->ReportError (
"crystalspace.terrain.parse.badfactory",
child, "Factory '%s' doesn't appear to be a terrain factory!",
factname);
return 0;
}
break;
}
case XMLTOKEN_COLOR:
{
csColor c;
if (!synldr->ParseColor (child, c))
{
synldr->ReportError ("crystalspace.terrain.object.loader",
child, "Error reading color value!");
return 0;
}
CHECK_MESH (mesh);
mesh->SetColor (c);
break;
}
case XMLTOKEN_MATERIAL:
{
const char* matname = child->GetContentsValue ();
csRef<iMaterialWrapper> mat = ldr_context->FindMaterial (matname);
if (!mat)
{
synldr->ReportError ("crystalspace.terrain.object.loader",
child, "Couldn't find material '%s'!", matname);
return 0;
}
CHECK_MESH (mesh);
mesh->SetMaterialWrapper (mat);
break;
}
case XMLTOKEN_MATERIALPALETTE:
{
csArray<iMaterialWrapper*> pal;
if (!ParseMaterialPalette (child, ldr_context, pal))
{
synldr->ReportError ("crystalspace.terrain.object.loader",
child, "Error parsing material palette!");
return 0;
}
CHECK_MESH (state);
state->SetMaterialPalette (pal);
palette_set = true;
break;
}
case XMLTOKEN_MATERIALMAP:
{
synldr->ReportError ("crystalspace.terrain.factory.loader",
child, "Materialmaps are now handled by the Formers!");
return 0;
break;
}
case XMLTOKEN_MATERIALALPHAMAP:
{
synldr->ReportError ("crystalspace.terrain.factory.loader",
child, "Alphamaps are now handled by the Formers!");
return 0;
break;
}
case XMLTOKEN_LODVALUE:
{
//@@@
if (material_map_set)
{
synldr->ReportError ("crystalspace.terrain.factory.loader",
child, "<lodvalue> must be set before <materialmap>!");
return 0;
}
const char* name = child->GetAttributeValue ("name");
if (name == 0)
{
synldr->ReportError ("crystalspace.terrain.factory.loader",
child, "<lodvalue> has no 'name' attribute");
return 0;
}
float val = child->GetContentsValueAsFloat ();
CHECK_MESH (state);
state->SetLODValue (name, val);
break;
}
case XMLTOKEN_STATICLIGHTING:
{
bool staticLighting;
if (!synldr->ParseBool (child, staticLighting, true))
return 0;
CHECK_MESH (state);
state->SetStaticLighting (staticLighting);
}
break;
case XMLTOKEN_CASTSHADOWS:
{
bool castShadows;
if (!synldr->ParseBool (child, castShadows, true))
return 0;
CHECK_MESH (state);
state->SetCastShadows (castShadows);
}
break;
default:
synldr->ReportError ("crystalspace.terrain.object.loader",
child, "Unknown token");
}
}
return csPtr<iBase>(mesh);
}
csPtr<iBase> FurMeshLoader::Parse (iDocumentNode* node,
iStreamSource*, iLoaderContext* ldr_context, iBase*)
{
csRef<iMeshObject> mesh;
csRef<CS::Mesh::iFurMeshState> meshstate;
csRef<iDocumentNodeIterator> it = node->GetNodes ();
while (it->HasNext ())
{
csRef<iDocumentNode> child = it->Next ();
if (child->GetType () != CS_NODE_ELEMENT) continue;
const char* value = child->GetValue ();
csStringID id = xmltokens.Request (value);
switch (id)
{
case XMLTOKEN_STRANDWIDTH:
{
float strandWidth = child->GetContentsValueAsFloat();
CHECK_MESH(meshstate);
meshstate->SetStrandWidth(strandWidth);
}
break;
case XMLTOKEN_DISPLACEMENT:
{
float displacement = child->GetContentsValueAsFloat();
CHECK_MESH(meshstate);
meshstate->SetDisplacement(displacement);
}
break;
case XMLTOKEN_DENSITYMAP:
{
const char* densityMapName = child->GetContentsValue ();
iTextureWrapper* tex = ldr_context->FindTexture(densityMapName);
if(!tex)
{
synldr->ReportError (
"crystalspace.furmeshloader.parse.unknownfactory",
child, "Couldn't find texture %s!", CS::Quote::Single (densityMapName));
return 0;
}
meshstate->SetDensityMap(tex);
}
break;
case XMLTOKEN_HEIGHTMAP:
{
const char* heightMapName = child->GetContentsValue ();
iTextureWrapper* tex = ldr_context->FindTexture(heightMapName);
if(!tex)
{
synldr->ReportError (
"crystalspace.furmeshloader.parse.unknownfactory",
child, "Couldn't find texture %s!", CS::Quote::Single (heightMapName));
return 0;
}
meshstate->SetHeightMap(tex);
}
break;
case XMLTOKEN_DENSITYFACTORGUIDEFURS:
{
float densityFactorGuideFurs = child->GetContentsValueAsFloat();
CHECK_MESH(meshstate);
meshstate->SetDensityFactorGuideFurs(densityFactorGuideFurs);
}
break;
case XMLTOKEN_DENSITYFACTORFURSTRANDS:
{
float densityFactorFurStrands = child->GetContentsValueAsFloat();
CHECK_MESH(meshstate);
meshstate->SetDensityFactorFurStrands(densityFactorFurStrands);
}
break;
case XMLTOKEN_HEIGHTFACTOR:
{
float heightFactor = child->GetContentsValueAsFloat();
CHECK_MESH(meshstate);
meshstate->SetHeightFactor(heightFactor);
}
break;
case XMLTOKEN_AVERAGECONTROLPOINTSCOUNT:
{
uint averageControlPointsCount = child->GetContentsValueAsInt();
CHECK_MESH(meshstate);
meshstate->SetAverageControlPointsCount(averageControlPointsCount);
}
break;
case XMLTOKEN_THICKNESSVARIATION:
{
float thicknessVariation = child->GetContentsValueAsFloat();
CHECK_MESH(meshstate);
meshstate->SetThicknessVariation(thicknessVariation);
}
break;
case XMLTOKEN_POINTINESS:
{
float pointiness = child->GetContentsValueAsFloat();
CHECK_MESH(meshstate);
meshstate->SetPointiness(pointiness);
}
break;
case XMLTOKEN_FURSTRANDDEVIATION:
{
float furStrandDeviation = child->GetContentsValueAsFloat();
CHECK_MESH(meshstate);
meshstate->SetFurStrandDeviation(furStrandDeviation);
}
break;
case XMLTOKEN_CONTROLPOINTSDEVIATION:
{
float positionDeviation = child->GetContentsValueAsFloat();
CHECK_MESH(meshstate);
meshstate->SetControlPointsDeviation(positionDeviation);
}
break;
case XMLTOKEN_GROWTANGENTS:
{
CHECK_MESH(meshstate);
meshstate->SetGrowTangent(true);
}
break;
case XMLTOKEN_SMALLFUR:
{
CHECK_MESH(meshstate);
meshstate->SetSmallFur(true);
}
break;
case XMLTOKEN_MIXMODE:
{
uint mixmode;
if (!synldr->ParseMixmode(child, mixmode))
return 0;
CHECK_MESH(meshstate);
meshstate->SetMixmode(mixmode);
}
break;
case XMLTOKEN_PRIORITY:
{
CS::Graphics::RenderPriority priority = engine->GetRenderPriority (child->GetContentsValue ());
CHECK_MESH(meshstate);
meshstate->SetRenderPriority(priority);
}
break;
case XMLTOKEN_FACTORY:
{
const char* factname = child->GetContentsValue ();
iMeshFactoryWrapper* fact = ldr_context->FindMeshFactory (factname);
if(!fact)
{
synldr->ReportError (
"crystalspace.furmeshloader.parse.unknownfactory",
child, "Couldn't find factory %s!", CS::Quote::Single (factname));
return 0;
}
mesh = fact->GetMeshObjectFactory ()->NewInstance ();
CS_ASSERT (mesh != 0);
meshstate = scfQueryInterface<CS::Mesh::iFurMeshState> (mesh);
if (!meshstate)
{
synldr->ReportError (
"crystalspace.furmeshloader.parse.badfactory",
child, "Factory %s doesn't appear to be a furmesh factory!",
CS::Quote::Single (factname));
return 0;
}
}
break;
default:
csZBufMode zbufmode;
if (synldr->ParseZMode (child, zbufmode))
{
meshstate->SetZBufMode(zbufmode);
break;
}
synldr->ReportBadToken (child);
}
}
return csPtr<iBase> (mesh);
}
