boolean PostScriptView::Emit (ostream& out) {
SetPSFonts();
Graphic* g = GetGraphicComp()->GetGraphic();
Transformer* t = SaveTransformer(g);
ScaleToPostScriptCoords(g);
Comments(out);
Prologue(out);
Version(out);
GridSpacing(out);
out << "\n\n%%Page: 1 1\n\n";
out << "Begin\n";
FullGS(out);
out << "/originalCTM matrix currentmatrix def\n\n";
boolean status = Definition(out);
out << "End " << MARK << " eop\n\n";
out << "showpage\n\n";
Trailer(out);
RestoreTransformer(g, t);
return status;
}
Definition& Definition::operator[](LPCWSTR type)
{
Definition* pRetDef = NULL;
if(m_type2def.Lookup(type, pRetDef))
return *pRetDef;
pRetDef = DNew Definition(m_pnf, L"");
pRetDef->m_priority = PLow;
pRetDef->m_type = type;
m_type2def[type] = pRetDef;
CAtlList<Definition*> l;
GetChildDefs(l, type);
while(!l.IsEmpty())
{
Definition* pDef = l.RemoveHead();
pRetDef->m_priority = pDef->m_priority;
pRetDef->m_parent = pDef->m_parent;
if(pDef->IsValue())
{
pRetDef->SetAsValue(pDef->m_status, pDef->m_value, pDef->m_unit);
}
else
{
pRetDef->m_status = node;
pRetDef->m_nodes.AddTailList(&pDef->m_nodes);
}
}
return *pRetDef;
}
Definition* NodeFactory::CreateDef(Reference* pParentRef, CStringW type, CStringW name, NodePriority priority)
{
Definition* pDef = NULL;
if(name.IsEmpty())
{
name = GenName();
}
else
{
pDef = GetDefByName(name);
if(pDef)
{
if(!pDef->m_predefined)
{
throw Exception(_T("redefinition of '%s' is not allowed"), CString(name));
}
if(!pDef->IsTypeUnknown() && !pDef->IsType(type))
{
throw Exception(_T("cannot redefine type of %s to %s"), CString(name), CString(type));
}
}
}
if(!pDef)
{
pDef = DNew Definition(this, name);
m_nodes.SetAt(name, pDef);
m_newnodes.AddTail(name);
if(pParentRef)
{
pParentRef->AddTail(pDef);
pDef->m_parent = pParentRef;
}
}
pDef->m_type = type;
pDef->m_priority = priority;
pDef->m_predefined = m_predefined;
return pDef;
}
Material::Material(const std::string& filename)
{
Definition currMaterial;
std::string currMaterialName = "";
std::ifstream file;
file.open(filename.c_str(), std::ios_base::in);
if(!file.is_open())
return;
while(!file.eof())
{
// Read first line of file.
std::string line;
std::getline(file, line);
// Copy line to a stringstream and copy first word into string key
std::stringstream streamLine;
std::string key;
streamLine.str(line);
streamLine >> key;
if(key == "newmtl")
{
if(currMaterialName != "") // It is not the first material read
{
// Save previous material, making sure the material does not already exist in Materials
assert(Materials.find(currMaterialName) == Materials.end());
Materials[currMaterialName] = currMaterial;
}
// Set new material name and clear current material
streamLine >> currMaterialName;
currMaterial = Definition();
}
else if(key == "Ka") // Ambient color
{
streamLine >> currMaterial.Ambient.x;
streamLine >> currMaterial.Ambient.y;
streamLine >> currMaterial.Ambient.z;
}
PhysicsCollisionShape::Definition PhysicsCollisionShape::Definition::create(Node* node, Properties* properties)
{
GP_ASSERT(node);
// Check if the properties is valid and has a valid namespace.
if (!properties || !(strcmp(properties->getNamespace(), "collisionObject") == 0))
{
GP_ERROR("Failed to load physics collision shape from properties object: must be non-null object and have namespace equal to 'collisionObject'.");
return Definition();
}
// Set values to their defaults.
PhysicsCollisionShape::Type type = PhysicsCollisionShape::SHAPE_BOX;
Vector3 extents, center;
bool extentsSpecified = false;
bool centerSpecified = false;
float radius = -1.0f;
float width = -1.0f;
float height = -1.0f;
bool centerIsAbsolute = false;
const char* imagePath = NULL;
float maxHeight = 0;
float minHeight = 0;
bool shapeSpecified = false;
// Load the defined properties.
properties->rewind();
const char* name;
while (name = properties->getNextProperty())
{
if (strcmp(name, "shape") == 0)
{
std::string shapeStr = properties->getString();
if (shapeStr == "BOX")
type = SHAPE_BOX;
else if (shapeStr == "SPHERE")
type = SHAPE_SPHERE;
else if (shapeStr == "MESH")
type = SHAPE_MESH;
else if (shapeStr == "HEIGHTFIELD")
type = SHAPE_HEIGHTFIELD;
else if (shapeStr == "CAPSULE")
type = SHAPE_CAPSULE;
else
{
GP_ERROR("Could not create physics collision shape; unsupported value for collision shape type: '%s'.", shapeStr.c_str());
return Definition();
}
shapeSpecified = true;
}
else if (strcmp(name, "image") == 0)
{
imagePath = properties->getString();
}
else if (strcmp(name, "maxHeight") == 0)
{
maxHeight = properties->getFloat();
}
else if (strcmp(name, "minHeight") == 0)
{
minHeight = properties->getFloat();
}
else if (strcmp(name, "radius") == 0)
{
radius = properties->getFloat();
}
else if (strcmp(name, "width") == 0)
{
width = properties->getFloat();
}
else if (strcmp(name, "height") == 0)
{
height = properties->getFloat();
}
else if (strcmp(name, "extents") == 0)
{
properties->getVector3("extents", &extents);
extentsSpecified = true;
}
else if (strcmp(name, "center") == 0)
{
properties->getVector3("center", ¢er);
centerSpecified = true;
}
else if (strcmp(name, "centerAbsolute") == 0)
{
centerIsAbsolute = properties->getBool();
}
else
{
// Ignore this case (these are the properties for the rigid body, character, or ghost object that this collision shape is for).
}
}
if (!shapeSpecified)
{
GP_ERROR("Missing 'shape' specifier for collision shape definition.");
return Definition();
}
// Create the collision shape.
Definition shape;
switch (type)
{
case SHAPE_BOX:
if (extentsSpecified)
{
if (centerSpecified)
{
shape = box(extents, center, centerIsAbsolute);
}
else
{
shape = box(extents);
}
}
else
{
shape = box();
}
break;
case SHAPE_SPHERE:
if (radius != -1.0f)
{
if (centerSpecified)
{
shape = sphere(radius, center, centerIsAbsolute);
}
else
{
shape = sphere(radius);
}
}
else
{
shape = sphere();
}
break;
case SHAPE_CAPSULE:
if (radius != -1.0f && height != -1.0f)
{
if (centerSpecified)
{
shape = capsule(radius, height, center, centerIsAbsolute);
}
else
{
shape = capsule(radius, height);
}
}
else
{
shape = capsule();
}
break;
case SHAPE_MESH:
{
// Mesh is required on node.
Mesh* nodeMesh = node->getModel() ? node->getModel()->getMesh() : NULL;
if (nodeMesh == NULL)
{
GP_ERROR("Cannot create mesh collision object for node without model/mesh.");
}
else
{
// Check that the node's mesh's primitive type is supported.
switch (nodeMesh->getPrimitiveType())
{
case Mesh::TRIANGLES:
shape = mesh(nodeMesh);
break;
case Mesh::LINES:
case Mesh::LINE_STRIP:
case Mesh::POINTS:
case Mesh::TRIANGLE_STRIP:
GP_ERROR("Mesh collision objects are currently only supported on meshes with primitive type equal to TRIANGLES.");
break;
}
}
}
break;
case SHAPE_HEIGHTFIELD:
{
if (imagePath == NULL)
{
// Node requires a valid terrain
if (node->getTerrain() == NULL)
{
GP_ERROR("Heightfield collision objects can only be specified on nodes that have a valid terrain, or that specify an image path.");
}
else
{
shape = PhysicsCollisionShape::heightfield();
}
}
else
{
std::string ext = FileSystem::getExtension(imagePath);
HeightField* heightfield = NULL;
if (ext == ".PNG")
heightfield = HeightField::createFromImage(imagePath, minHeight, maxHeight);
else if (ext == ".RAW" || ext == ".R16")
heightfield = HeightField::createFromRAW(imagePath, (unsigned int)width, (unsigned int)height, minHeight, maxHeight);
if (heightfield)
{
shape = PhysicsCollisionShape::heightfield(heightfield);
SAFE_RELEASE(heightfield);
}
}
}
break;
default:
GP_ERROR("Unsupported physics collision shape type (%d).", type);
break;
}
return shape;
}
OGLPLUS_LIB_FUNC
std::string BlendFileStructField::Name(void) const
{
return _sdna->_field_name_from_def(Definition());
}
boolean ExternView::Emit (ostream& out) { return Definition(out); }
Material::Material()
{
Materials["default"] = Definition();
}
