summaryrefslogtreecommitdiff
path: root/Build/source/utils/asymptote/prc/oPRCFile.h
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/utils/asymptote/prc/oPRCFile.h')
-rw-r--r--Build/source/utils/asymptote/prc/oPRCFile.h418
1 files changed, 374 insertions, 44 deletions
diff --git a/Build/source/utils/asymptote/prc/oPRCFile.h b/Build/source/utils/asymptote/prc/oPRCFile.h
index 643a0ff6e44..29b7f20b880 100644
--- a/Build/source/utils/asymptote/prc/oPRCFile.h
+++ b/Build/source/utils/asymptote/prc/oPRCFile.h
@@ -25,9 +25,11 @@
#include <fstream>
#include <vector>
#include <map>
+#include <set>
#include <list>
#include <stack>
#include <string>
+#include <cstring>
#ifdef HAVE_CONFIG_H
#include "config.h"
@@ -46,6 +48,10 @@ struct RGBAColour
R(r), G(g), B(b), A(a) {}
double R,G,B,A;
+ void Set(double r, double g, double b, double a=1.0)
+ {
+ R = r; G = g; B = b; A = a;
+ }
bool operator==(const RGBAColour &c) const
{
return (R==c.R && G==c.G && B==c.B && A==c.A);
@@ -64,6 +70,11 @@ struct RGBAColour
return (B<c.B);
return (A<c.A);
}
+ friend RGBAColour operator * (const RGBAColour& a, const double d)
+ { return RGBAColour(a.R*d,a.G*d,a.B*d,a.A*d); }
+ friend RGBAColour operator * (const double d, const RGBAColour& a)
+ { return RGBAColour(a.R*d,a.G*d,a.B*d,a.A*d); }
+
};
typedef std::map<RGBAColour,uint32_t> PRCcolourMap;
@@ -101,26 +112,45 @@ typedef std::map<PRCRgbColor,uint32_t> PRCcolorMap;
struct PRCmaterial
{
PRCmaterial() : alpha(1.0),shininess(1.0),
- picture(NULL), picture_width(0), picture_height(0), picture_rgba(false), picture_replace(false) {}
+ picture_data(NULL), picture_format(KEPRCPicture_BITMAP_RGB_BYTE), picture_width(0), picture_height(0), picture_size(0),
+ picture_replace(false), picture_repeat(false) {}
PRCmaterial(const RGBAColour &a, const RGBAColour &d, const RGBAColour &e,
const RGBAColour &s, double p, double h,
- const uint8_t* pic=NULL, uint32_t picw=0, uint32_t pich=0, bool pica=false, bool picr=false) :
+ const uint8_t* pic=NULL, EPRCPictureDataFormat picf=KEPRCPicture_BITMAP_RGB_BYTE,
+ uint32_t picw=0, uint32_t pich=0, uint32_t pics=0, bool picreplace=false, bool picrepeat=false) :
ambient(a), diffuse(d), emissive(e), specular(s), alpha(p), shininess(h),
- picture(pic), picture_width(picw), picture_height(pich), picture_rgba(pica), picture_replace(picr) {}
+ picture_data(pic), picture_format(picf), picture_width(picw), picture_height(pich), picture_size(pics),
+ picture_replace(picreplace), picture_repeat(picrepeat) {
+ if(picture_size==0)
+ {
+ if (picture_format==KEPRCPicture_BITMAP_RGB_BYTE)
+ picture_size = picture_width*picture_height*3;
+ if (picture_format==KEPRCPicture_BITMAP_RGBA_BYTE)
+ picture_size = picture_width*picture_height*4;
+ if (picture_format==KEPRCPicture_BITMAP_GREY_BYTE)
+ picture_size = picture_width*picture_height*1;
+ if (picture_format==KEPRCPicture_BITMAP_GREYA_BYTE)
+ picture_size = picture_width*picture_height*2;
+ }
+ }
RGBAColour ambient,diffuse,emissive,specular;
double alpha,shininess;
- const uint8_t* picture;
+ const uint8_t* picture_data;
+ EPRCPictureDataFormat picture_format;
uint32_t picture_width;
uint32_t picture_height;
- bool picture_rgba; // is there alpha component?
+ uint32_t picture_size;
bool picture_replace; // replace material color with texture color? if false - just modify
+ bool picture_repeat; // repeat texture? if false - clamp to edge
bool operator==(const PRCmaterial &m) const
{
return (ambient==m.ambient && diffuse==m.diffuse && emissive==m.emissive
&& specular==m.specular && alpha==m.alpha && shininess==m.shininess
- && picture==m.picture && picture_width==m.picture_width && picture_height==m.picture_height
- && picture_rgba==m.picture_rgba && picture_replace==m.picture_replace);
+ && picture_replace==m.picture_replace && picture_repeat==m.picture_repeat
+ && picture_format==m.picture_format
+ && picture_width==m.picture_width && picture_height==m.picture_height && picture_size==m.picture_size
+ && (picture_data==m.picture_data || memcmp(picture_data,m.picture_data,picture_size)==0) );
}
bool operator<(const PRCmaterial &m) const
{
@@ -136,19 +166,201 @@ struct PRCmaterial
return (alpha<m.alpha);
if(shininess!=m.shininess)
return (shininess<m.shininess);
- if(picture!=m.picture)
- return (picture<m.picture);
+ if(picture_replace!=m.picture_replace)
+ return (picture_replace<m.picture_replace);
+ if(picture_repeat!=m.picture_repeat)
+ return (picture_repeat<m.picture_repeat);
+ if(picture_format!=m.picture_format)
+ return (picture_format<m.picture_format);
if(picture_width!=m.picture_width)
return (picture_width<m.picture_width);
if(picture_height!=m.picture_height)
return (picture_height<m.picture_height);
- if(picture_rgba!=m.picture_rgba)
- return (picture_rgba<m.picture_rgba);
- return (picture_replace<m.picture_replace);
+ if(picture_size!=m.picture_size)
+ return (picture_size<m.picture_size);
+ if(picture_data!=m.picture_data)
+ return (memcmp(picture_data,m.picture_data,picture_size)<0);
+ return false;
}
};
typedef std::map<PRCmaterial,uint32_t> PRCmaterialMap;
+struct PRCpicture
+{
+ PRCpicture() :
+ data(NULL), format(KEPRCPicture_BITMAP_RGB_BYTE),
+ width(0), height(0), size(0) {}
+ PRCpicture(const uint8_t* pic, EPRCPictureDataFormat picf,
+ uint32_t picw, uint32_t pich, uint32_t pics=0) :
+ data(pic), format(picf),
+ width(picw), height(pich), size(pics)
+ {
+ if(size==0)
+ {
+ if (format==KEPRCPicture_BITMAP_RGB_BYTE)
+ size = width*height*3;
+ if (format==KEPRCPicture_BITMAP_RGBA_BYTE)
+ size = width*height*4;
+ if (format==KEPRCPicture_BITMAP_GREY_BYTE)
+ size = width*height*1;
+ if (format==KEPRCPicture_BITMAP_GREYA_BYTE)
+ size = width*height*2;
+ }
+ }
+ PRCpicture(const PRCmaterial& m) :
+ data(m.picture_data), format(m.picture_format),
+ width(m.picture_width), height(m.picture_height), size(m.picture_size) {}
+
+ const uint8_t* data;
+ EPRCPictureDataFormat format;
+ uint32_t width;
+ uint32_t height;
+ uint32_t size;
+ bool operator==(const PRCpicture& p) const
+ {
+ return ( format==p.format
+ && width==p.width && height==p.height && size==p.size
+ && (data==p.data || memcmp(data,p.data,size)==0) );
+ }
+ bool operator<(const PRCpicture& p) const
+ {
+ if(format!=p.format)
+ return (format<p.format);
+ if(width!=p.width)
+ return (width<p.width);
+ if(height!=p.height)
+ return (height<p.height);
+ if(size!=p.size)
+ return (size<p.size);
+ if(data!=p.data)
+ return (memcmp(data,p.data,size)<0);
+ return false;
+ }
+};
+
+typedef std::map<PRCpicture,uint32_t> PRCpictureMap;
+
+struct PRCmaterialgeneric
+{
+ PRCmaterialgeneric() : alpha(1.0),shininess(1.0) {}
+ PRCmaterialgeneric(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) {}
+ PRCmaterialgeneric(const PRCmaterial& m) :
+ ambient(m.ambient), diffuse(m.diffuse), emissive(m.emissive), specular(m.specular), alpha(m.alpha), shininess(m.shininess) {}
+ RGBAColour ambient,diffuse,emissive,specular;
+ double alpha,shininess;
+
+ bool operator==(const PRCmaterialgeneric& m) const
+ {
+ return (ambient==m.ambient && diffuse==m.diffuse && emissive==m.emissive
+ && specular==m.specular && alpha==m.alpha && shininess==m.shininess);
+ }
+ bool operator<(const PRCmaterialgeneric& 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);
+ if(shininess!=m.shininess)
+ return (shininess<m.shininess);
+ return false;
+ }
+};
+typedef std::map<PRCmaterialgeneric,uint32_t> PRCmaterialgenericMap;
+
+struct PRCtexturedefinition
+{
+ PRCtexturedefinition() :
+ picture_index(m1), picture_replace(false), picture_repeat(false) {}
+ PRCtexturedefinition(uint32_t picindex, bool picreplace=false, bool picrepeat=false) :
+ picture_index(picindex), picture_replace(picreplace), picture_repeat(picrepeat) {}
+ PRCtexturedefinition(uint32_t picindex, const PRCmaterial& m) :
+ picture_index(picindex), picture_replace(m.picture_replace), picture_repeat(m.picture_repeat) {}
+ uint32_t picture_index;
+ bool picture_replace; // replace material color with texture color? if false - just modify
+ bool picture_repeat; // repeat texture? if false - clamp to edge
+
+ bool operator==(const PRCtexturedefinition& t) const
+ {
+ return (picture_index==t.picture_index
+ && picture_replace==t.picture_replace && picture_repeat==t.picture_repeat);
+ }
+ bool operator<(const PRCtexturedefinition& t) const
+ {
+ if(picture_index!=t.picture_index)
+ return (picture_index<t.picture_index);
+ if(picture_replace!=t.picture_replace)
+ return (picture_replace<t.picture_replace);
+ if(picture_repeat!=t.picture_repeat)
+ return (picture_repeat<t.picture_repeat);
+ return false;
+ }
+};
+typedef std::map<PRCtexturedefinition,uint32_t> PRCtexturedefinitionMap;
+
+struct PRCtextureapplication
+{
+ PRCtextureapplication() :
+ material_generic_index(m1), texture_definition_index(m1) {}
+ PRCtextureapplication(uint32_t matindex, uint32_t texindex) :
+ material_generic_index(matindex), texture_definition_index(texindex) {}
+ uint32_t material_generic_index;
+ uint32_t texture_definition_index;
+
+ bool operator==(const PRCtextureapplication& t) const
+ {
+ return (material_generic_index==t.material_generic_index
+ && texture_definition_index==t.texture_definition_index);
+ }
+ bool operator<(const PRCtextureapplication& t) const
+ {
+ if(material_generic_index!=t.material_generic_index)
+ return (material_generic_index<t.material_generic_index);
+ if(texture_definition_index!=t.texture_definition_index)
+ return (texture_definition_index<t.texture_definition_index);
+ return false;
+ }
+};
+typedef std::map<PRCtextureapplication,uint32_t> PRCtextureapplicationMap;
+
+struct PRCstyle
+{
+ PRCstyle() :
+ line_width(0), alpha(1), is_material(false), color_material_index(m1) {}
+ PRCstyle(double linewidth, double alph, bool ismat, uint32_t colindex=m1) :
+ line_width(linewidth), alpha(alph), is_material(ismat), color_material_index(colindex) {}
+ double line_width;
+ double alpha;
+ bool is_material;
+ uint32_t color_material_index;
+
+ bool operator==(const PRCstyle& s) const
+ {
+ return (line_width==s.line_width && alpha==s.alpha && is_material==s.is_material
+ && color_material_index==s.color_material_index);
+ }
+ bool operator<(const PRCstyle& s) const
+ {
+ if(line_width!=s.line_width)
+ return (line_width<s.line_width);
+ if(alpha!=s.alpha)
+ return (alpha<s.alpha);
+ if(is_material!=s.is_material)
+ return (is_material<s.is_material);
+ if(color_material_index!=s.color_material_index)
+ return (color_material_index<s.color_material_index);
+ return false;
+ }
+};
+typedef std::map<PRCstyle,uint32_t> PRCstyleMap;
+
struct PRCtessrectangle // rectangle
{
PRCVector3d vertices[4];
@@ -156,15 +368,25 @@ struct PRCtessrectangle // rectangle
};
typedef std::vector<PRCtessrectangle> PRCtessrectangleList;
-struct PRCtesstriangles // triangle
+struct PRCtessquad // rectangle
{
- std::vector<PRCVector3d> vertices;
- std::vector<PRCVector3d> normals;
- std::vector<RGBAColour> colors;
+ PRCVector3d vertices[4];
+ RGBAColour colours[4];
+};
+typedef std::vector<PRCtessquad> PRCtessquadList;
+/*
+struct PRCtesstriangle // textured triangle
+{
+ PRCtesstriangle() :
+ style(m1) {}
+ PRCVector3d vertices[3];
+// PRCVector3d normals[3];
+// RGBAColour colors[3];
+ PRCVector2d texcoords[3];
uint32_t style;
};
-typedef std::vector<PRCtesstriangles> PRCtesstrianglesList;
-
+typedef std::vector<PRCtesstriangle> PRCtesstriangleList;
+*/
struct PRCtessline // polyline
{
std::vector<PRCVector3d> point;
@@ -213,33 +435,38 @@ public:
bool tess; // use tessellated mesh to store straight patches
bool do_break; //
bool no_break; // do not render transparent patches as one-faced nodes
+ double crease_angle; // crease angle for meshes
PRCoptions(double compression=0.0, double granularity=0.0, bool closed=false,
- bool tess=false, bool do_break=true, bool no_break=false)
+ bool tess=false, bool do_break=true, bool no_break=false, double crease_angle=25.8419)
: compression(compression), granularity(granularity), closed(closed),
- tess(tess), do_break(do_break), no_break(no_break) {}
+ tess(tess), do_break(do_break), no_break(no_break), crease_angle(crease_angle) {}
};
class PRCgroup
{
public:
- PRCgroup() : transform(NULL) {}
- PRCgroup(const std::string &name) : name(name), transform(NULL) {}
+ PRCgroup() :
+ product_occurrence(NULL), parent_product_occurrence(NULL), part_definition(NULL), parent_part_definition(NULL), transform(NULL) {}
+ PRCgroup(const std::string& name) :
+ product_occurrence(NULL), parent_product_occurrence(NULL), part_definition(NULL), parent_part_definition(NULL), transform(NULL), name(name) {}
+ PRCProductOccurrence *product_occurrence, *parent_product_occurrence;
+ PRCPartDefinition *part_definition, *parent_part_definition;
PRCfaceList faces;
PRCcompfaceList compfaces;
PRCtessrectangleList rectangles;
+// PRCtesstriangleList triangles;
+ PRCtessquadList quads;
PRCtesslineMap lines;
PRCwireList wires;
PRCpointsetMap points;
std::vector<PRCPointSet*> pointsets;
std::vector<PRCPolyBrepModel*> polymodels;
std::vector<PRCPolyWire*> polywires;
- std::string name;
- std::list<PRCgroup> groupList;
PRCGeneralTransformation3d* transform;
+ std::string name;
PRCoptions options;
};
-typedef std::list<PRCgroup> PRCgroupList;
void makeFileUUID(PRCUniqueId&);
void makeAppUUID(PRCUniqueId&);
@@ -249,11 +476,9 @@ 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&) const;
@@ -417,6 +642,15 @@ class oPRCFile
makeAppUUID(fileStructures[i]->application_uuid);
fileStructures[i]->unit = u;
}
+
+ groups.push(PRCgroup());
+ PRCgroup &group = groups.top();
+ group.name="root";
+ group.transform = NULL;
+ group.product_occurrence = new PRCProductOccurrence(group.name);
+ group.parent_product_occurrence = NULL;
+ group.part_definition = new PRCPartDefinition;
+ group.parent_part_definition = NULL;
}
oPRCFile(const std::string &name, double u=1, uint32_t n=1) :
@@ -437,6 +671,15 @@ class oPRCFile
makeAppUUID(fileStructures[i]->application_uuid);
fileStructures[i]->unit = u;
}
+
+ groups.push(PRCgroup());
+ PRCgroup &group = groups.top();
+ group.name="root";
+ group.transform = NULL;
+ group.product_occurrence = new PRCProductOccurrence(group.name);
+ group.parent_product_occurrence = NULL;
+ group.part_definition = new PRCPartDefinition;
+ group.parent_part_definition = NULL;
}
~oPRCFile()
@@ -447,12 +690,17 @@ class oPRCFile
if(fout != NULL)
delete fout;
free(modelFile_data);
+ for(PRCpictureMap::iterator it=pictureMap.begin(); it!=pictureMap.end(); ++it) delete it->first.data;
}
void begingroup(const char *name, PRCoptions *options=NULL,
- const double t[][4]=NULL);
+ const double* t=NULL);
void endgroup();
+ std::string lastgroupname;
+ std::vector<std::string> lastgroupnames;
+ std::string calculate_unique_name(const ContentPRCBase *prc_entity,const ContentPRCBase *prc_occurence);
+
bool finish();
uint32_t getSize();
@@ -465,32 +713,110 @@ class oPRCFile
PRCcolorMap colorMap;
PRCcolourMap colourMap;
PRCcolourwidthMap colourwidthMap;
- PRCmaterialMap materialMap;
+ PRCmaterialgenericMap materialgenericMap;
+ PRCtexturedefinitionMap texturedefinitionMap;
+ PRCtextureapplicationMap textureapplicationMap;
+ PRCstyleMap styleMap;
+ PRCpictureMap pictureMap;
PRCgroup rootGroup;
PRCtransformMap transformMap;
- std::stack<PRCgroupList::iterator> currentGroups;
+ std::stack<PRCgroup> groups;
PRCgroup& findGroup();
- void doGroup(PRCgroup& group, PRCPartDefinition *parent_part_definition, PRCProductOccurrence *parent_product_occurrence);
+ void doGroup(PRCgroup& group);
uint32_t addColor(const PRCRgbColor &color);
uint32_t addColour(const RGBAColour &colour);
uint32_t addColourWidth(const RGBAColour &colour, double width);
+ uint32_t addLineMaterial(const RGBAColour& c, double width)
+ { return addColourWidth(c,width); }
uint32_t addMaterial(const PRCmaterial &material);
uint32_t addTransform(PRCGeneralTransformation3d*& transform);
+ uint32_t addTransform(const double* t);
+ uint32_t addTransform(const double origin[3], const double x_axis[3], const double y_axis[3], double scale);
void addPoint(const double P[3], const RGBAColour &c, double w=1.0);
void addPoints(uint32_t n, const double P[][3], const RGBAColour &c, double w=1.0);
void addLines(uint32_t nP, const double P[][3], uint32_t nI, const uint32_t PI[],
- const RGBAColour &c, double w, bool segment_color,
- uint32_t nC, const RGBAColour C[], uint32_t nCI, const uint32_t CI[]);
+ const RGBAColour& c, double w,
+ bool segment_color, uint32_t nC, const RGBAColour C[], uint32_t nCI, const uint32_t CI[]);
+ uint32_t createLines(uint32_t nP, const double P[][3], uint32_t nI, const uint32_t PI[],
+ bool segment_color, uint32_t nC, const RGBAColour C[], uint32_t nCI, const uint32_t CI[]);
void addTriangles(uint32_t nP, const double P[][3], uint32_t nI, const uint32_t PI[][3], const PRCmaterial &m,
uint32_t nN, const double N[][3], const uint32_t NI[][3],
uint32_t nT, const double T[][2], const uint32_t TI[][3],
uint32_t nC, const RGBAColour C[], const uint32_t CI[][3],
- uint32_t nM, const PRCmaterial M[], const uint32_t MI[]);
+ uint32_t nM, const PRCmaterial M[], const uint32_t MI[], double ca);
+ uint32_t createTriangleMesh(uint32_t nP, const double P[][3], uint32_t nI, const uint32_t PI[][3], uint32_t style_index,
+ uint32_t nN, const double N[][3], const uint32_t NI[][3],
+ uint32_t nT, const double T[][2], const uint32_t TI[][3],
+ uint32_t nC, const RGBAColour C[], const uint32_t CI[][3],
+ uint32_t nS, const uint32_t S[], const uint32_t SI[], double ca);
+ uint32_t createTriangleMesh(uint32_t nP, const double P[][3], uint32_t nI, const uint32_t PI[][3], const PRCmaterial& m,
+ uint32_t nN, const double N[][3], const uint32_t NI[][3],
+ uint32_t nT, const double T[][2], const uint32_t TI[][3],
+ uint32_t nC, const RGBAColour C[], const uint32_t CI[][3],
+ uint32_t nM, const PRCmaterial M[], const uint32_t MI[], double ca)
+ {
+ const uint32_t style = addMaterial(m);
+ if(M!=NULL && nM>0)
+ {
+ uint32_t* const styles = new uint32_t[nM];
+ for(uint32_t i=0; i<nM; i++)
+ styles[i]=addMaterial(M[i]);
+ const uint32_t meshid = createTriangleMesh(nP, P, nI, PI, style, nN, N, NI, nT, T, TI, nC, C, CI, nM, styles, MI, ca);
+ delete[] styles;
+ return meshid;
+ }
+ else
+ return createTriangleMesh(nP, P, nI, PI, style, nN, N, NI, nT, T, TI, nC, C, CI, 0, NULL, NULL, ca);
+ }
void addQuads(uint32_t nP, const double P[][3], uint32_t nI, const uint32_t PI[][4], const PRCmaterial &m,
uint32_t nN, const double N[][3], const uint32_t NI[][4],
uint32_t nT, const double T[][2], const uint32_t TI[][4],
uint32_t nC, const RGBAColour C[], const uint32_t CI[][4],
- uint32_t nM, const PRCmaterial M[], const uint32_t MI[]);
+ uint32_t nM, const PRCmaterial M[], const uint32_t MI[], double ca);
+ uint32_t createQuadMesh(uint32_t nP, const double P[][3], uint32_t nI, const uint32_t PI[][4], uint32_t style_index,
+ uint32_t nN, const double N[][3], const uint32_t NI[][4],
+ uint32_t nT, const double T[][2], const uint32_t TI[][4],
+ uint32_t nC, const RGBAColour C[], const uint32_t CI[][4],
+ uint32_t nS, const uint32_t S[], const uint32_t SI[], double ca);
+ uint32_t createQuadMesh(uint32_t nP, const double P[][3], uint32_t nI, const uint32_t PI[][4], const PRCmaterial& m,
+ uint32_t nN, const double N[][3], const uint32_t NI[][4],
+ uint32_t nT, const double T[][2], const uint32_t TI[][4],
+ uint32_t nC, const RGBAColour C[], const uint32_t CI[][4],
+ uint32_t nM, const PRCmaterial M[], const uint32_t MI[], double ca)
+ {
+ const uint32_t style = addMaterial(m);
+ if(M!=NULL && nM>0)
+ {
+ uint32_t* const styles = new uint32_t[nM];
+ for(uint32_t i=0; i<nM; i++)
+ styles[i]=addMaterial(M[i]);
+ const uint32_t meshid = createQuadMesh(nP, P, nI, PI, style, nN, N, NI, nT, T, TI, nC, C, CI, nM, styles, MI, ca);
+ delete[] styles;
+ return meshid;
+ }
+ else
+ return createQuadMesh(nP, P, nI, PI, style, nN, N, NI, nT, T, TI, nC, C, CI, 0, NULL, NULL, ca);
+ }
+#define PRCTRANSFORM const double origin[3]=NULL, const double x_axis[3]=NULL, const double y_axis[3]=NULL, double scale=1, const double* t=NULL
+#define PRCCARTRANSFORM const double origin[3], const double x_axis[3], const double y_axis[3], double scale
+#define PRCGENTRANSFORM const double* t=NULL
+#define PRCNOMATERIALINDEX m1
+ void useMesh(uint32_t tess_index, uint32_t style_index, PRCGENTRANSFORM);
+ void useMesh(uint32_t tess_index, const PRCmaterial& m, PRCGENTRANSFORM)
+ { useMesh(tess_index,addMaterial(m),t); }
+ void useMesh(uint32_t tess_index, uint32_t style_index, PRCCARTRANSFORM);
+ void useMesh(uint32_t tess_index, const PRCmaterial& m, PRCCARTRANSFORM)
+ { useMesh(tess_index,addMaterial(m),origin, x_axis, y_axis, scale); }
+
+ void useLines(uint32_t tess_index, uint32_t style_index, PRCGENTRANSFORM);
+ void useLines(uint32_t tess_index, const RGBAColour& c, double w, PRCGENTRANSFORM)
+ { useLines(tess_index, addLineMaterial(c,w), t); }
+ void useLines(uint32_t tess_index, uint32_t style_index, PRCCARTRANSFORM);
+ void useLines(uint32_t tess_index, const RGBAColour& c, double w, PRCCARTRANSFORM)
+ { useLines(tess_index,addLineMaterial(c,w),origin, x_axis, y_axis, scale); }
+
+// void addTriangle(const double P[][3], const double T[][2], uint32_t style_index);
+
void addLine(uint32_t n, const double P[][3], const RGBAColour &c, double w=1.0);
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[]);
@@ -501,20 +827,24 @@ class oPRCFile
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 addCone(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
+ void addTube(uint32_t n, const double cP[][3], const double oP[][3], bool straight, const PRCmaterial& m, PRCTRANSFORM);
+ void addHemisphere(double radius, const PRCmaterial& m, PRCTRANSFORM);
+ void addSphere(double radius, const PRCmaterial& m, PRCTRANSFORM);
+ void addDisk(double radius, const PRCmaterial& m, PRCTRANSFORM);
+ void addCylinder(double radius, double height, const PRCmaterial& m, PRCTRANSFORM);
+ void addCone(double radius, double height, const PRCmaterial& m, PRCTRANSFORM);
+ void addTorus(double major_radius, double minor_radius, double angle1, double angle2, const PRCmaterial& m, PRCTRANSFORM);
+#undef PRCTRANSFORM
+#undef PRCCARTRANSFORM
+#undef PRCGENTRANSFORM
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 addPicture(const PRCpicture& pic,
+ std::string name="", uint32_t fileStructure=0)
+ { return fileStructures[fileStructure]->addPicture(pic.format, pic.size, pic.data, pic.width, pic.height, name); }
uint32_t addTextureDefinition(PRCTextureDefinition*& pTextureDefinition, uint32_t fileStructure=0)
{
return fileStructures[fileStructure]->addTextureDefinition(pTextureDefinition);