summaryrefslogtreecommitdiff
path: root/Build/source/utils/asymptote/prc/oPRCFile.h
diff options
context:
space:
mode:
authorKarl Berry <karl@freefriends.org>2010-06-08 13:46:05 +0000
committerKarl Berry <karl@freefriends.org>2010-06-08 13:46:05 +0000
commita960e44eb527236f39aec81babc0474911a86078 (patch)
tree9950eca71791d90820a80a521a7cc252c0955db5 /Build/source/utils/asymptote/prc/oPRCFile.h
parent6443467452320c296faa1f43f0606a9457bd4463 (diff)
asy 1.96
git-svn-id: svn://tug.org/texlive/trunk@18817 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/utils/asymptote/prc/oPRCFile.h')
-rw-r--r--Build/source/utils/asymptote/prc/oPRCFile.h454
1 files changed, 307 insertions, 147 deletions
diff --git a/Build/source/utils/asymptote/prc/oPRCFile.h b/Build/source/utils/asymptote/prc/oPRCFile.h
index 2ee01ddcba4..647f57c7d52 100644
--- a/Build/source/utils/asymptote/prc/oPRCFile.h
+++ b/Build/source/utils/asymptote/prc/oPRCFile.h
@@ -24,6 +24,9 @@
#include <iostream>
#include <fstream>
#include <vector>
+#include <map>
+#include <list>
+#include <stack>
#include <string>
#ifdef HAVE_CONFIG_H
@@ -35,6 +38,7 @@
#include "writePRC.h"
class oPRCFile;
+class PRCFileStructure;
struct RGBAColour
{
@@ -46,145 +50,140 @@ struct RGBAColour
{
return (R==c.R && G==c.G && B==c.B && A==c.A);
}
+ bool operator!=(const RGBAColour &c) const
+ {
+ return !(R==c.R && G==c.G && B==c.B && A==c.A);
+ }
+ bool operator<(const RGBAColour &c) const
+ {
+ if(R!=c.R)
+ return (R<c.R);
+ if(G!=c.G)
+ return (G<c.G);
+ if(B!=c.B)
+ return (B<c.B);
+ return (A<c.A);
+ }
};
+typedef std::map<RGBAColour,uint32_t> PRCcolourMap;
+typedef std::map<PRCRgbColor,uint32_t> PRCcolorMap;
-struct PRCMaterial
+struct PRCmaterial
{
- PRCMaterial() : alpha(1.0),shininess(1.0) {}
- PRCMaterial(const RGBAColour &a, const RGBAColour &d, const RGBAColour &e,
+ PRCmaterial() : alpha(1.0),shininess(1.0) {}
+ PRCmaterial(const RGBAColour &a, const RGBAColour &d, const RGBAColour &e,
const RGBAColour &s, double p, double h) :
ambient(a), diffuse(d), emissive(e), specular(s), alpha(p), shininess(h) {}
RGBAColour ambient,diffuse,emissive,specular;
double alpha,shininess;
- bool operator==(const PRCMaterial &m) const
+ bool operator==(const PRCmaterial &m) const
{
return (ambient==m.ambient && diffuse==m.diffuse && emissive==m.emissive
- && specular==m.specular && shininess==m.shininess);
+ && specular==m.specular && alpha==m.alpha && shininess==m.shininess);
+ }
+ bool operator<(const PRCmaterial &m) const
+ {
+ if(ambient!=m.ambient)
+ return (ambient<m.ambient);
+ if(diffuse!=m.diffuse)
+ return (diffuse<m.diffuse);
+ if(emissive!=m.emissive)
+ return (emissive<m.emissive);
+ if(specular!=m.specular)
+ return (specular<m.specular);
+ if(alpha!=m.alpha)
+ return (alpha<m.alpha);
+ return (shininess<m.shininess);
}
};
+typedef std::map<PRCmaterial,uint32_t> PRCmaterialMap;
-class PRCentity
+struct PRCtessrectangle // rectangle
{
- public:
- PRCentity(oPRCFile *p,const RGBAColour &c, double scale = 1.0,
- std::string name = "") :
- colour(c), useMaterial(false), scale(scale), name(name), parent(p) {}
- PRCentity(oPRCFile *p,const PRCMaterial &m, double scale = 1.0,
- std::string name = "") :
- material(m), useMaterial(true), scale(scale), name(name), parent(p) {}
- uint32_t getGraphicsIndex();
- virtual void writeRepresentationItem(PRCbitStream&,uint32_t) = 0;
- virtual void writeTopologicalContext(PRCbitStream&) = 0;
- virtual void writeExtraGeometryContext(PRCbitStream&) = 0;
- RGBAColour colour;
- PRCMaterial material;
- bool useMaterial;
- double scale;
- std::string name;
- virtual ~PRCentity() {}
- protected:
- oPRCFile *parent;
+ PRCVector3d vertices[4];
+ uint32_t style;
};
+typedef std::vector<PRCtessrectangle> PRCtessrectangleList;
-class PRCsurface : public PRCentity
+struct PRCtessline // polyline
{
- public:
- // contructor with colour
- PRCsurface(oPRCFile *p, uint32_t dU, uint32_t dV, uint32_t nU, uint32_t nV,
- double cP[][3], double *kU, double *kV, const RGBAColour &c,
- double scale = 1.0, bool iR = false, double w[] = 0,
- double g = 0, std::string name = "") :
- PRCentity(p,c,scale,name), degreeU(dU), degreeV(dV),
- numberOfControlPointsU(nU), numberOfControlPointsV(nV),
- knotsU(kU), knotsV(kV), controlPoints(cP),
- isRational(iR), weights(w), granularity(g) {}
- // contructor with material
- PRCsurface(oPRCFile *p, uint32_t dU, uint32_t dV, uint32_t nU, uint32_t nV,
- double cP[][3], double *kU, double *kV, const PRCMaterial &m,
- double scale = 1.0, bool iR = false, double w[] = 0,
- double g = 0, std::string name = "") :
- PRCentity(p,m,scale,name), degreeU(dU), degreeV(dV),
- numberOfControlPointsU(nU), numberOfControlPointsV(nV),
- knotsU(kU), knotsV(kV), controlPoints(cP),
- isRational(iR), weights(w), granularity(g) {}
- virtual void writeRepresentationItem(PRCbitStream&,uint32_t);
- virtual void writeTopologicalContext(PRCbitStream&);
- virtual void writeExtraGeometryContext(PRCbitStream&);
- protected:
- virtual void writeKnots(PRCbitStream &out)
- {
- for(uint32_t i = 0; i < degreeU+numberOfControlPointsU+1; ++i)
- out << knotsU[i];
- for(uint32_t i = 0; i < degreeV+numberOfControlPointsV+1; ++i)
- out << knotsV[i];
- }
- private:
- uint32_t degreeU, degreeV, numberOfControlPointsU, numberOfControlPointsV;
- double *knotsU, *knotsV;
- double (*controlPoints)[3];
- bool isRational;
- double *weights;
- double granularity;
+ std::vector<PRCVector3d> point;
+ PRCRgbColor color;
};
+typedef std::list<PRCtessline> PRCtesslineList;
-class PRCline : public PRCentity
+struct PRCface
{
- public:
- // constructor with colour
- PRCline(oPRCFile *p, uint32_t n, double P[][3], const RGBAColour &c,
- double scale = 1.0, std::string name="") :
- PRCentity(p,c,scale,name), numberOfPoints(n), points(P) {}
- // constructor with material
- PRCline(oPRCFile *p, uint32_t n, double P[][3], const PRCMaterial &m,
- double scale = 1.0, std::string name = "") :
- PRCentity(p,m,scale,name), numberOfPoints(n), points(P) {}
- virtual void writeRepresentationItem(PRCbitStream&,uint32_t);
- virtual void writeTopologicalContext(PRCbitStream&);
- virtual void writeExtraGeometryContext(PRCbitStream&);
- private:
- uint32_t numberOfPoints;
- double (*points)[3];
+ uint32_t style;
+ bool transparent;
+ PRCpGeneralTransformation3d transform;
+ PRCpFace face;
};
+typedef std::tr1::shared_ptr <PRCface> PRCpface;
+typedef std::vector <PRCface> PRCfaceList;
-class PRCcurve : public PRCentity
+struct PRCcompface
{
- public:
- // constructor with colour
- PRCcurve(oPRCFile *p, uint32_t d, uint32_t n, double cP[][3], double *k,
- const RGBAColour &c, double scale = 1.0, bool iR = false,
- double w[] = 0, std::string name="") :
- PRCentity(p,c,scale,name), degree(d),
- numberOfControlPoints(n), knots(k), controlPoints(cP), isRational(iR),
- weights(w) {}
- // constructor with material
- PRCcurve(oPRCFile *p, uint32_t d, uint32_t n, double cP[][3], double *k,
- const PRCMaterial &m, double scale = 1.0, bool iR = false,
- double w[] = 0, std::string name = "") :
- PRCentity(p,m,scale,name), degree(d),
- numberOfControlPoints(n), knots(k), controlPoints(cP), isRational(iR),
- weights(w) {}
- virtual void writeRepresentationItem(PRCbitStream&,uint32_t);
- virtual void writeTopologicalContext(PRCbitStream&);
- virtual void writeExtraGeometryContext(PRCbitStream&);
- protected:
- virtual void writeKnots(PRCbitStream &out)
- {
- for(uint32_t i = 0; i < degree+numberOfControlPoints+1; ++i)
- out << knots[i];
- }
- private:
- uint32_t degree, numberOfControlPoints;
- double *knots;
- double (*controlPoints)[3];
- bool isRational;
- double *weights;
+ uint32_t style;
+ bool transparent;
+ PRCpCompressedFace face;
+};
+typedef std::tr1::shared_ptr <PRCcompface> PRCpcompface;
+typedef std::vector <PRCcompface> PRCcompfaceList;
+
+struct PRCwire
+{
+ uint32_t style;
+ PRCpGeneralTransformation3d transform;
+ PRCpCurve curve;
};
+typedef std::tr1::shared_ptr <PRCwire> PRCpwire;
+typedef std::vector <PRCwire> PRCwireList;
+
+typedef std::map <uint32_t,std::vector<PRCVector3d> > PRCpointsetMap;
+
+class PRCoptions
+{
+public:
+ double compression;
+ double granularity;
+
+ bool closed; // render the surface as one-sided; may yield faster rendering
+ bool tess; // use tessellated mesh to store straight patches
+ bool do_break; //
+ bool no_break; // do not render transparent patches as one-faced nodes
+
+ PRCoptions(double compression=0.0, double granularity=0.0, bool closed=false,
+ bool tess=false, bool do_break=true, bool no_break=false)
+ : compression(compression), granularity(granularity), closed(closed),
+ tess(tess), do_break(do_break), no_break(no_break) {}
+};
+
+class PRCgroup
+{
+ public:
+ PRCgroup() {}
+ PRCgroup(const std::string &name) : name(name) {}
+ PRCfaceList faces;
+ PRCcompfaceList compfaces;
+ PRCtessrectangleList rectangles;
+ PRCtesslineList lines;
+ PRCwireList wires;
+ PRCpointsetMap points;
+ std::string name;
+ std::list<PRCgroup> groupList;
+ PRCpGeneralTransformation3d transform;
+ PRCoptions options;
+};
+typedef std::list<PRCgroup> PRCgroupList;
class PRCCompressedSection
{
public:
- PRCCompressedSection(oPRCFile *p) : data(0),prepared(false),parent(p),
+ PRCCompressedSection(oPRCFile *p) : data(0),prepared(false),parent(p),fileStructure(NULL),
+ out(data,0) {}
+ PRCCompressedSection(PRCFileStructure *fs) : data(0),prepared(false),parent(NULL),fileStructure(fs),
out(data,0) {}
virtual ~PRCCompressedSection()
{
@@ -204,25 +203,31 @@ class PRCCompressedSection
}
bool prepared;
oPRCFile *parent;
+ PRCFileStructure *fileStructure;
PRCbitStream out; // order matters: PRCbitStream must be initialized last
};
class PRCGlobalsSection : public PRCCompressedSection
{
public:
- PRCGlobalsSection(oPRCFile *p, uint32_t i) :
- PRCCompressedSection(p),numberOfReferencedFileStructures(0),
+ PRCGlobalsSection(PRCFileStructure *fs, uint32_t i) :
+ PRCCompressedSection(fs),numberOfReferencedFileStructures(0),
tessellationChordHeightRatio(2000.0),tessellationAngleDegrees(40.0),
- defaultFontFamilyName(""),numberOfFonts(0),numberOfPictures(0),
- numberOfTextureDefinitions(0),numberOfFillPatterns(0),
- numberOfReferenceCoordinateSystems(0),userData(0,0),index(i) {}
+ defaultFontFamilyName(""),
+ numberOfFillPatterns(0),
+ userData(0,0),index(i) {}
uint32_t numberOfReferencedFileStructures;
double tessellationChordHeightRatio;
double tessellationAngleDegrees;
std::string defaultFontFamilyName;
- uint32_t numberOfFonts,numberOfPictures,numberOfTextureDefinitions;
+ std::vector<PRCRgbColor> colors;
+ std::vector<PRCPicture> pictures;
+ PRCTextureDefinitionList texture_definitions;
+ PRCMaterialList materials;
+ PRCStyleList styles;
uint32_t numberOfFillPatterns;
- uint32_t numberOfReferenceCoordinateSystems;
+ PRCCoordinateSystemList reference_coordinate_systems;
+ std::vector<PRCFontKeysSameFont> font_keys_of_font;
UserData userData;
private:
uint32_t index;
@@ -232,8 +237,15 @@ class PRCGlobalsSection : public PRCCompressedSection
class PRCTreeSection : public PRCCompressedSection
{
public:
- PRCTreeSection(oPRCFile *p, uint32_t i) :
- PRCCompressedSection(p),index(i) {}
+ PRCTreeSection(PRCFileStructure *fs, uint32_t i) :
+ PRCCompressedSection(fs),unit(1),index(i) {}
+ PRCPartDefinitionList part_definitions;
+ PRCProductOccurrenceList product_occurrences;
+/*
+ PRCMarkupList markups;
+ PRCAnnotationItemList annotation_entities;
+ */
+ double unit;
private:
uint32_t index;
virtual void writeData();
@@ -242,8 +254,9 @@ class PRCTreeSection : public PRCCompressedSection
class PRCTessellationSection : public PRCCompressedSection
{
public:
- PRCTessellationSection(oPRCFile *p, uint32_t i) :
- PRCCompressedSection(p),index(i) {}
+ PRCTessellationSection(PRCFileStructure *fs, uint32_t i) :
+ PRCCompressedSection(fs),index(i) {}
+ PRCTessList tessellations;
private:
uint32_t index;
virtual void writeData();
@@ -252,8 +265,8 @@ class PRCTessellationSection : public PRCCompressedSection
class PRCGeometrySection : public PRCCompressedSection
{
public:
- PRCGeometrySection(oPRCFile *p, uint32_t i) :
- PRCCompressedSection(p),index(i) {}
+ PRCGeometrySection(PRCFileStructure *fs, uint32_t i) :
+ PRCCompressedSection(fs),index(i) {}
private:
uint32_t index;
virtual void writeData();
@@ -262,8 +275,8 @@ class PRCGeometrySection : public PRCCompressedSection
class PRCExtraGeometrySection : public PRCCompressedSection
{
public:
- PRCExtraGeometrySection(oPRCFile *p, uint32_t i) :
- PRCCompressedSection(p),index(i) {}
+ PRCExtraGeometrySection(PRCFileStructure *fs, uint32_t i) :
+ PRCCompressedSection(fs),index(i) {}
private:
uint32_t index;
virtual void writeData();
@@ -272,7 +285,8 @@ class PRCExtraGeometrySection : public PRCCompressedSection
class PRCModelFile : public PRCCompressedSection
{
public:
- PRCModelFile(oPRCFile *p) : PRCCompressedSection(p) {}
+ PRCModelFile(oPRCFile *p) : PRCCompressedSection(p), unit(1) {}
+ double unit;
private:
virtual void writeData();
};
@@ -283,8 +297,13 @@ void makeAppUUID(uint32_t*);
class PRCUncompressedFile
{
public:
+ PRCUncompressedFile() : file_size(0), data(NULL) {}
+ PRCUncompressedFile(uint32_t fs, uint8_t *d) : file_size(fs), data(d) {}
+// PRCUncompressedFile(uint32_t fs, const std::string &fn) : file_size(fs), data(NULL), file_name(fn) {}
+ ~PRCUncompressedFile() { if(data != NULL) delete[] data; }
uint32_t file_size;
uint8_t *data;
+// std::string file_name;
void write(std::ostream&);
@@ -311,8 +330,8 @@ class PRCFileStructure
uint32_t index;
public:
PRCStartHeader header;
- uint32_t number_of_uncompressed_files;
- PRCUncompressedFile *uncompressedFiles;
+ std::list<PRCUncompressedFile> uncompressedFiles;
+ PRCTopoContextList contexts;
PRCGlobalsSection globals;
PRCTreeSection tree;
@@ -321,11 +340,30 @@ class PRCFileStructure
PRCExtraGeometrySection extraGeometry;
PRCFileStructure(oPRCFile *p, uint32_t i) : parent(p),index(i),
- globals(p,i),tree(p,i),tessellations(p,i),geometry(p,i),
- extraGeometry(p,i) {}
+ globals(this,i),tree(this,i),tessellations(this,i),geometry(this,i),
+ extraGeometry(this,i) {}
void write(std::ostream&);
void prepare();
uint32_t getSize();
+ uint32_t addPicture(EPRCPictureDataFormat format, uint32_t size, const uint8_t *picture, uint32_t width=0, uint32_t height=0, std::string name="");
+ uint32_t addTextureDefinition(PRCTextureDefinition *pTextureDefinition);
+ uint32_t addRgbColor(const PRCRgbColor &color);
+ uint32_t addRgbColorUnique(const PRCRgbColor &color);
+ uint32_t addMaterialGeneric(PRCMaterialGeneric *pMaterialGeneric);
+ uint32_t addTextureApplication(PRCTextureApplication *pTextureApplication);
+ uint32_t addStyle(PRCStyle *pStyle);
+ uint32_t addPartDefinition(PRCPartDefinition *pPartDefinition);
+ uint32_t addProductOccurrence(PRCProductOccurrence *pProductOccurrence);
+ uint32_t addTopoContext(PRCTopoContext *pTopoContext);
+ uint32_t add3DTess(PRC3DTess *p3DTess);
+ uint32_t add3DWireTess(PRC3DWireTess *p3DWireTess);
+/*
+ uint32_t addMarkupTess(PRCMarkupTess *pMarkupTess);
+ uint32_t addMarkup(PRCMarkup *pMarkup);
+ uint32_t addAnnotationItem(PRCAnnotationItem *pAnnotationItem);
+ */
+ uint32_t addCoordinateSystem(PRCCoordinateSystem *pCoordinateSystem);
+ uint32_t addCoordinateSystemUnique(PRCCoordinateSystem *pCoordinateSystem);
};
class PRCFileStructureInformation
@@ -349,27 +387,52 @@ class PRCHeader
PRCFileStructureInformation *fileStructureInformation;
uint32_t model_file_offset;
uint32_t file_size; // not documented
- uint32_t number_of_uncompressed_files;
- PRCUncompressedFile *uncompressedFiles;
+ std::list<PRCUncompressedFile> uncompressedFiles;
void write(std::ostream&);
uint32_t getSize();
};
+typedef std::map <PRCGeneralTransformation3d,uint32_t> PRCtransformMap;
+
class oPRCFile
{
public:
- oPRCFile(std::ostream &os, uint32_t n=1) :
+ oPRCFile(std::ostream &os, double unit=1, uint32_t n=1) :
number_of_file_structures(n),
fileStructures(new PRCFileStructure*[n]),modelFile(this),
- fout(NULL),output(os) {}
-
- oPRCFile(const std::string &name, uint32_t n=1) :
+ fout(NULL),output(os)
+ {
+ for(uint32_t i = 0; i < number_of_file_structures; ++i)
+ {
+ fileStructures[i] = new PRCFileStructure(this,i);
+ fileStructures[i]->header.minimal_version_for_read = PRCVersion;
+ fileStructures[i]->header.authoring_version = PRCVersion;
+ makeFileUUID(fileStructures[i]->header.fileStructureUUID);
+ makeAppUUID(fileStructures[i]->header.applicationUUID);
+ fileStructures[i]->tree.unit = unit;
+ }
+ modelFile.unit = unit;
+ }
+
+ oPRCFile(const std::string &name, double unit=1, uint32_t n=1) :
number_of_file_structures(n),
fileStructures(new PRCFileStructure*[n]),modelFile(this),
fout(new std::ofstream(name.c_str(),
std::ios::out|std::ios::binary|std::ios::trunc)),
- output(*fout) {}
+ output(*fout)
+ {
+ for(uint32_t i = 0; i < number_of_file_structures; ++i)
+ {
+ fileStructures[i] = new PRCFileStructure(this,i);
+ fileStructures[i]->header.minimal_version_for_read = PRCVersion;
+ fileStructures[i]->header.authoring_version = PRCVersion;
+ makeFileUUID(fileStructures[i]->header.fileStructureUUID);
+ makeAppUUID(fileStructures[i]->header.applicationUUID);
+ fileStructures[i]->tree.unit = unit;
+ }
+ modelFile.unit = unit;
+ }
~oPRCFile()
{
@@ -380,23 +443,120 @@ class oPRCFile
delete fout;
}
- void begingroup(std::string name) {}
- void endgroup() {}
+ void begingroup(const char *name, PRCoptions *options=NULL,
+ const double t[][4]=NULL);
+ void endgroup();
- bool add(PRCentity*);
bool finish();
- uint32_t getColourIndex(const RGBAColour&);
- uint32_t getMaterialIndex(const PRCMaterial&);
uint32_t getSize();
const uint32_t number_of_file_structures;
PRCFileStructure **fileStructures;
PRCHeader header;
PRCModelFile modelFile;
- std::vector<PRCentity*> fileEntities;
- std::vector<RGBAColour> colourMap;
- std::vector<PRCMaterial> materialMap;
-
+ PRCcolorMap colorMap;
+ PRCcolourMap colourMap;
+ PRCmaterialMap materialMap;
+ PRCgroup rootGroup;
+ PRCtransformMap transformMap;
+ std::stack<PRCgroupList::iterator> currentGroups;
+ PRCgroup& findGroup();
+ void doGroup(const PRCgroup& group, PRCPartDefinition *parent_part_definition, PRCProductOccurrence *parent_product_occurrence);
+ uint32_t addColor(const PRCRgbColor &color);
+ uint32_t addColour(const RGBAColour &colour);
+ uint32_t addMaterial(const PRCmaterial &material);
+ uint32_t addTransform(const PRCpGeneralTransformation3d &transform);
+ void addPoint(const double P[3], const RGBAColour &c);
+ void addLine(uint32_t n, const double P[][3], const RGBAColour &c);
+ void addBezierCurve(uint32_t n, const double cP[][3], const RGBAColour &c);
+ void addCurve(uint32_t d, uint32_t n, const double cP[][3], const double *k, const RGBAColour &c, const double w[]);
+ void addRectangle(const double P[][3], const PRCmaterial &m);
+ void addPatch(const double cP[][3], const PRCmaterial &m);
+ void addSurface(uint32_t dU, uint32_t dV, uint32_t nU, uint32_t nV,
+ const double cP[][3], const double *kU, const double *kV, const PRCmaterial &m,
+ const double w[]);
+#define PRCFACETRANSFORM const double origin[3]=NULL, const double x_axis[3]=NULL, const double y_axis[3]=NULL, double scale=1, const double t[][4]=NULL
+ void addTube(uint32_t n, const double cP[][3], const double oP[][3], bool straight, const PRCmaterial &m, PRCFACETRANSFORM);
+ void addHemisphere(double radius, const PRCmaterial &m, PRCFACETRANSFORM);
+ void addSphere(double radius, const PRCmaterial &m, PRCFACETRANSFORM);
+ void addDisk(double radius, const PRCmaterial &m, PRCFACETRANSFORM);
+ void addCylinder(double radius, double height, const PRCmaterial &m, PRCFACETRANSFORM);
+ void addTorus(double major_radius, double minor_radius, double angle1, double angle2, const PRCmaterial &m, PRCFACETRANSFORM);
+#undef PRCFACETRANSFORM
+
+
+ uint32_t addPicture(EPRCPictureDataFormat format, uint32_t size, const uint8_t *picture, uint32_t width=0, uint32_t height=0,
+ std::string name="", uint32_t fileStructure=0)
+ { return fileStructures[fileStructure]->addPicture(format, size, picture, width, height, name); }
+ uint32_t addTextureDefinition(PRCTextureDefinition *pTextureDefinition, uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addTextureDefinition(pTextureDefinition);
+ }
+ uint32_t addTextureApplication(PRCTextureApplication *pTextureApplication, uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addTextureApplication(pTextureApplication);
+ }
+ uint32_t addRgbColor(const PRCRgbColor &color,
+ uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addRgbColor(color);
+ }
+ uint32_t addRgbColorUnique(const PRCRgbColor &color,
+ uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addRgbColorUnique(color);
+ }
+ uint32_t addMaterialGeneric(PRCMaterialGeneric *pMaterialGeneric,
+ uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addMaterialGeneric(pMaterialGeneric);
+ }
+ uint32_t addStyle(PRCStyle *pStyle, uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addStyle(pStyle);
+ }
+ uint32_t addPartDefinition(PRCPartDefinition *pPartDefinition, uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addPartDefinition(pPartDefinition);
+ }
+ uint32_t addProductOccurrence(PRCProductOccurrence *pProductOccurrence, uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addProductOccurrence(pProductOccurrence);
+ }
+ uint32_t addTopoContext(PRCTopoContext *pTopoContext, uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addTopoContext(pTopoContext);
+ }
+ uint32_t add3DTess(PRC3DTess *p3DTess, uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->add3DTess(p3DTess);
+ }
+ uint32_t add3DWireTess(PRC3DWireTess *p3DWireTess, uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->add3DWireTess(p3DWireTess);
+ }
+/*
+ uint32_t addMarkupTess(PRCMarkupTess *pMarkupTess, uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addMarkupTess(pMarkupTess);
+ }
+ uint32_t addMarkup(PRCMarkup *pMarkup, uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addMarkup(pMarkup);
+ }
+ uint32_t addAnnotationItem(PRCAnnotationItem *pAnnotationItem, uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addAnnotationItem(pAnnotationItem);
+ }
+ */
+ uint32_t addCoordinateSystem(PRCCoordinateSystem *pCoordinateSystem, uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addCoordinateSystem(pCoordinateSystem);
+ }
+ uint32_t addCoordinateSystemUnique(PRCCoordinateSystem *pCoordinateSystem, uint32_t fileStructure=0)
+ {
+ return fileStructures[fileStructure]->addCoordinateSystemUnique(pCoordinateSystem);
+ }
private:
std::ofstream *fout;
std::ostream &output;