4169 lines
92 KiB
C
4169 lines
92 KiB
C
/* exotic.c
|
|
*
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
|
* All rights reserved.
|
|
*
|
|
*
|
|
* Contributor(s):
|
|
* - Martin DeMello
|
|
* Added dxf_read_arc, dxf_read_ellipse and dxf_read_lwpolyline
|
|
* Copyright (C) 2004 by Etheract Software Labs
|
|
*
|
|
* - Blender Foundation
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****/
|
|
|
|
#include "BLI_storage.h"
|
|
|
|
#include <ctype.h> /* isdigit, isspace */
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <fcntl.h>
|
|
#include <string.h>
|
|
|
|
#ifndef _WIN32
|
|
#include <unistd.h>
|
|
#else
|
|
#include <io.h>
|
|
#define open _open
|
|
#define read _read
|
|
#define close _close
|
|
#define write _write
|
|
#endif
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "DNA_object_types.h"
|
|
#include "DNA_mesh_types.h"
|
|
#include "DNA_meshdata_types.h"
|
|
#include "DNA_material_types.h"
|
|
#include "DNA_lamp_types.h"
|
|
#include "DNA_curve_types.h"
|
|
#include "DNA_image_types.h"
|
|
#include "DNA_camera_types.h"
|
|
#include "DNA_scene_types.h"
|
|
#include "DNA_view3d_types.h"
|
|
#include "DNA_userdef_types.h"
|
|
|
|
#include "BKE_utildefines.h"
|
|
#include "BLI_blenlib.h"
|
|
#include "BLI_arithb.h"
|
|
#include "BLI_editVert.h"
|
|
|
|
#include "BKE_blender.h"
|
|
#include "BKE_global.h"
|
|
#include "BKE_main.h"
|
|
#include "BKE_mesh.h"
|
|
#include "BKE_library.h"
|
|
#include "BKE_global.h"
|
|
#include "BKE_object.h"
|
|
#include "BKE_material.h"
|
|
#include "BKE_exotic.h"
|
|
|
|
/* #include "BKE_error.h" */
|
|
#include "BKE_screen.h"
|
|
#include "BKE_displist.h"
|
|
#include "BKE_DerivedMesh.h"
|
|
#include "BKE_curve.h"
|
|
#include "BKE_customdata.h"
|
|
|
|
#ifndef DISABLE_PYTHON
|
|
#include "BPY_extern.h"
|
|
#endif
|
|
|
|
#include "zlib.h"
|
|
|
|
static int is_dxf(char *str);
|
|
static void dxf_read(Scene *scene, char *filename);
|
|
static int is_stl(char *str);
|
|
|
|
static int is_stl_ascii(char *str)
|
|
{
|
|
FILE *fpSTL;
|
|
char buffer[1000];
|
|
int numread, i;
|
|
|
|
fpSTL = fopen(str, "rb");
|
|
if ( (numread = fread( (void *) buffer, sizeof(char), 1000, fpSTL)) <= 0 )
|
|
{ fclose(fpSTL); return 0; }
|
|
|
|
for (i=0; i < numread; ++i) {
|
|
/* if bit 8 is set we assume binary */
|
|
if (buffer[i] & 0x80)
|
|
{ fclose(fpSTL); return 0; }
|
|
}
|
|
|
|
buffer[5] = '\0';
|
|
if ( !(strstr(buffer, "solid")) && !(strstr(buffer, "SOLID")) )
|
|
{ fclose(fpSTL); return 0; }
|
|
|
|
fclose(fpSTL);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int is_stl(char *str)
|
|
{
|
|
int i;
|
|
i = strlen(str) - 3;
|
|
if ( (str[i] !='s') && (str[i] !='S'))
|
|
return 0;
|
|
i++;
|
|
if ( (str[i] !='t') && (str[i] !='T'))
|
|
return 0;
|
|
i++;
|
|
if ( (str[i] !='l') && (str[i] !='L'))
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
#define READSTLVERT { \
|
|
if (fread(mvert->co, sizeof(float), 3, fpSTL) != 3) { \
|
|
char error_msg[255]; \
|
|
MEM_freeN(vertdata); \
|
|
MEM_freeN(facedata); \
|
|
fclose(fpSTL); \
|
|
sprintf(error_msg, "Problems reading face %d!", i); \
|
|
return; \
|
|
} \
|
|
else { \
|
|
if (ENDIAN_ORDER==B_ENDIAN) { \
|
|
SWITCH_INT(mvert->co[0]); \
|
|
SWITCH_INT(mvert->co[1]); \
|
|
SWITCH_INT(mvert->co[2]); \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
static void simple_vertex_normal_blend(short *no, short *ble)
|
|
{
|
|
if(no[0]==0 && no[1]==0 && no[2]==0) {
|
|
VECCOPY(no, ble);
|
|
}
|
|
else {
|
|
no[0]= (2*no[0] + ble[0])/3;
|
|
no[1]= (2*no[1] + ble[1])/3;
|
|
no[2]= (2*no[2] + ble[2])/3;
|
|
}
|
|
}
|
|
|
|
static void mesh_add_normals_flags(Mesh *me)
|
|
{
|
|
MVert *v1, *v2, *v3, *v4;
|
|
MFace *mface;
|
|
float nor[3];
|
|
int a;
|
|
short sno[3];
|
|
|
|
mface= me->mface;
|
|
for(a=0; a<me->totface; a++, mface++) {
|
|
v1= me->mvert+mface->v1;
|
|
v2= me->mvert+mface->v2;
|
|
v3= me->mvert+mface->v3;
|
|
v4= me->mvert+mface->v4;
|
|
|
|
CalcNormFloat(v1->co, v2->co, v3->co, nor);
|
|
sno[0]= 32767.0*nor[0];
|
|
sno[1]= 32767.0*nor[1];
|
|
sno[2]= 32767.0*nor[2];
|
|
|
|
simple_vertex_normal_blend(v1->no, sno);
|
|
simple_vertex_normal_blend(v2->no, sno);
|
|
simple_vertex_normal_blend(v3->no, sno);
|
|
if(mface->v4) {
|
|
simple_vertex_normal_blend(v4->no, sno);
|
|
}
|
|
mface->edcode= ME_V1V2|ME_V2V3;
|
|
}
|
|
}
|
|
|
|
static void read_stl_mesh_binary(Scene *scene, char *str)
|
|
{
|
|
FILE *fpSTL;
|
|
Object *ob;
|
|
Mesh *me;
|
|
MVert *mvert, *vertdata;
|
|
MFace *mface, *facedata;
|
|
unsigned int numfacets = 0, i, j, vertnum;
|
|
unsigned int maxmeshsize, nummesh, lastmeshsize;
|
|
unsigned int totvert, totface;
|
|
|
|
fpSTL= fopen(str, "rb");
|
|
if(fpSTL==NULL) {
|
|
//XXX error("Can't read file");
|
|
return;
|
|
}
|
|
|
|
fseek(fpSTL, 80, SEEK_SET);
|
|
fread(&numfacets, 4*sizeof(char), 1, fpSTL);
|
|
if (ENDIAN_ORDER==B_ENDIAN) {
|
|
SWITCH_INT(numfacets);
|
|
}
|
|
|
|
maxmeshsize = MESH_MAX_VERTS/3;
|
|
|
|
nummesh = (numfacets / maxmeshsize) + 1;
|
|
lastmeshsize = numfacets % maxmeshsize;
|
|
|
|
if (numfacets) {
|
|
for (j=0; j < nummesh; ++j) {
|
|
/* new object */
|
|
if (j == nummesh-1) {
|
|
totface = lastmeshsize;
|
|
}
|
|
else {
|
|
totface = maxmeshsize;
|
|
}
|
|
totvert = 3 * totface;
|
|
|
|
vertdata = MEM_callocN(totvert*sizeof(MVert), "mverts");
|
|
facedata = MEM_callocN(totface*sizeof(MFace), "mface");
|
|
|
|
vertnum = 0;
|
|
mvert= vertdata;
|
|
mface = facedata;
|
|
for (i=0; i < totface; i++) {
|
|
fseek(fpSTL, 12, SEEK_CUR); /* skip the face normal */
|
|
READSTLVERT;
|
|
mvert++;
|
|
READSTLVERT;
|
|
mvert++;
|
|
READSTLVERT;
|
|
mvert++;
|
|
|
|
mface->v1 = vertnum++;
|
|
mface->v2 = vertnum++;
|
|
mface->v3 = vertnum++;
|
|
mface++;
|
|
|
|
fseek(fpSTL, 2, SEEK_CUR);
|
|
}
|
|
|
|
ob= add_object(scene, OB_MESH);
|
|
me= ob->data;
|
|
me->totvert = totvert;
|
|
me->totface = totface;
|
|
me->mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN,
|
|
vertdata, totvert);
|
|
me->mface = CustomData_add_layer(&me->fdata, CD_MFACE, CD_ASSIGN,
|
|
facedata, totface);
|
|
|
|
mesh_add_normals_flags(me);
|
|
make_edges(me, 0);
|
|
}
|
|
//XXX waitcursor(1);
|
|
}
|
|
fclose(fpSTL);
|
|
|
|
}
|
|
#undef READSTLVERT
|
|
|
|
#define STLALLOCERROR { \
|
|
char error_msg[255]; \
|
|
fclose(fpSTL); \
|
|
sprintf(error_msg, "Can't allocate storage for %d faces!", \
|
|
numtenthousand * 10000); \
|
|
return; \
|
|
}
|
|
|
|
#define STLBAILOUT(message) { \
|
|
char error_msg[255]; \
|
|
fclose(fpSTL); \
|
|
free(vertdata); \
|
|
sprintf(error_msg, "Line %d: %s", linenum, message); \
|
|
return; \
|
|
}
|
|
|
|
#define STLREADLINE { \
|
|
if (!fgets(buffer, 2048, fpSTL)) STLBAILOUT("Can't read line!"); \
|
|
linenum++; \
|
|
}
|
|
|
|
#define STLREADVERT { \
|
|
STLREADLINE; \
|
|
if ( !(cp = strstr(buffer, "vertex")) && \
|
|
!(cp = strstr(buffer, "VERTEX")) ) STLBAILOUT("Bad vertex!"); \
|
|
vp = vertdata + 3 * totvert; \
|
|
if (sscanf(cp + 6, "%f %f %f", vp, vp+1, vp+2) != 3) \
|
|
STLBAILOUT("Bad vertex!"); \
|
|
++totvert; \
|
|
}
|
|
static void read_stl_mesh_ascii(Scene *scene, char *str)
|
|
{
|
|
FILE *fpSTL;
|
|
char buffer[2048], *cp;
|
|
Object *ob;
|
|
Mesh *me;
|
|
MVert *mvert;
|
|
MFace *mface;
|
|
float *vertdata, *vp;
|
|
unsigned int numtenthousand, linenum;
|
|
unsigned int i, vertnum;
|
|
unsigned int totvert, totface;
|
|
|
|
/* ASCII stl sucks ... we don't really know how many faces there
|
|
are until the file is done, so lets allocate faces 10000 at a time */
|
|
|
|
fpSTL= fopen(str, "r");
|
|
if(fpSTL==NULL) {
|
|
//XXX error("Can't read file");
|
|
return;
|
|
}
|
|
|
|
/* we'll use the standard malloc/realloc for now ...
|
|
* lets allocate enough storage to hold 10000 triangles,
|
|
* i.e. 30000 verts, i.e., 90000 floats.
|
|
*/
|
|
numtenthousand = 1;
|
|
vertdata = malloc(numtenthousand*3*30000*sizeof(float)); // uses realloc!
|
|
if (!vertdata); STLALLOCERROR;
|
|
|
|
linenum = 1;
|
|
/* Get rid of the first line */
|
|
STLREADLINE;
|
|
|
|
totvert = 0;
|
|
totface = 0;
|
|
while(1) {
|
|
/* Read in the next line */
|
|
STLREADLINE;
|
|
|
|
/* lets check if this is the end of the file */
|
|
if ( strstr(buffer, "endsolid") || strstr(buffer, "ENDSOLID") )
|
|
break;
|
|
|
|
/* Well, guess that wasn't the end, so lets make
|
|
* sure we have enough storage for some more faces
|
|
*/
|
|
if ( (totface) && ( (totface % 10000) == 0 ) ) {
|
|
++numtenthousand;
|
|
vertdata = realloc(vertdata,
|
|
numtenthousand*3*30000*sizeof(float));
|
|
if (!vertdata); STLALLOCERROR;
|
|
}
|
|
|
|
/* Don't read normal, but check line for proper syntax anyway
|
|
*/
|
|
if ( !(cp = strstr(buffer, "facet")) &&
|
|
!(cp = strstr(buffer, "FACET")) ) STLBAILOUT("Bad normal line!");
|
|
if ( !(strstr(cp+5, "normal")) &&
|
|
!(strstr(cp+5, "NORMAL")) ) STLBAILOUT("Bad normal line!");
|
|
|
|
/* Read in what should be the outer loop line
|
|
*/
|
|
STLREADLINE;
|
|
if ( !(cp = strstr(buffer, "outer")) &&
|
|
!(cp = strstr(buffer, "OUTER")) ) STLBAILOUT("Bad outer loop!");
|
|
if ( !(strstr(cp+5, "loop")) &&
|
|
!(strstr(cp+5, "LOOP")) ) STLBAILOUT("Bad outer loop!");
|
|
|
|
/* Read in the face */
|
|
STLREADVERT;
|
|
STLREADVERT;
|
|
STLREADVERT;
|
|
|
|
/* Read in what should be the endloop line
|
|
*/
|
|
STLREADLINE;
|
|
if ( !strstr(buffer, "endloop") && !strstr(buffer, "ENDLOOP") )
|
|
STLBAILOUT("Bad endloop!");
|
|
|
|
/* Read in what should be the endfacet line
|
|
*/
|
|
STLREADLINE;
|
|
if ( !strstr(buffer, "endfacet") && !strstr(buffer, "ENDFACET") )
|
|
STLBAILOUT("Bad endfacet!");
|
|
|
|
/* Made it this far? Increment face count */
|
|
++totface;
|
|
}
|
|
fclose(fpSTL);
|
|
|
|
/* OK, lets create our mesh */
|
|
ob = add_object(scene, OB_MESH);
|
|
me = ob->data;
|
|
|
|
me->totface = totface;
|
|
me->totvert = totvert;
|
|
me->mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC,
|
|
NULL, totvert);
|
|
me->mface = CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC,
|
|
NULL, totface);
|
|
|
|
/* Copy vert coords and create topology */
|
|
mvert = me->mvert;
|
|
mface = me->mface;
|
|
vertnum = 0;
|
|
for (i=0; i < totface; ++i) {
|
|
memcpy(mvert->co, vertdata+3*vertnum, 3*sizeof(float) );
|
|
mface->v1 = vertnum;
|
|
mvert++;
|
|
vertnum++;
|
|
|
|
memcpy(mvert->co, vertdata+3*vertnum, 3*sizeof(float) );
|
|
mface->v2 = vertnum;
|
|
mvert++;
|
|
vertnum++;
|
|
|
|
memcpy(mvert->co, vertdata+3*vertnum, 3*sizeof(float) );
|
|
mface->v3 = vertnum;
|
|
mvert++;
|
|
vertnum++;
|
|
|
|
mface++;
|
|
}
|
|
free(vertdata);
|
|
|
|
mesh_add_normals_flags(me);
|
|
make_edges(me, 0);
|
|
|
|
//XXX waitcursor(1);
|
|
}
|
|
|
|
#undef STLALLOCERROR
|
|
#undef STLBAILOUT
|
|
#undef STLREADLINE
|
|
#undef STLREADVERT
|
|
|
|
/* ***************** INVENTOR ******************* */
|
|
|
|
|
|
#define IV_MAXSTACK 3000000
|
|
#define IV_MAXFIELD 10
|
|
#define IV_MAXCOL 16
|
|
|
|
static float *iv_data_stack;
|
|
static float ivcolors[IV_MAXCOL][3];
|
|
static Object *ivsurf;
|
|
static ListBase ivbase;
|
|
|
|
struct IvNode {
|
|
struct IvNode *next, *prev;
|
|
char *nodename;
|
|
char *fieldname[IV_MAXFIELD];
|
|
int datalen[IV_MAXFIELD];
|
|
float *data[IV_MAXFIELD];
|
|
};
|
|
|
|
static int iv_curcol=0;
|
|
|
|
static int iv_colornumber(struct IvNode *iv)
|
|
{
|
|
float *fp, fr = 0.0, fg = 0.0, fb = 0.0;
|
|
int a;
|
|
char *cp;
|
|
|
|
/* search back to last material */
|
|
while(iv) {
|
|
if( strcmp(iv->nodename, "Material")==0) {
|
|
fp= iv->data[0];
|
|
if(fp==0) fp= iv->data[1];
|
|
if(fp) {
|
|
fr= fp[0];
|
|
fg= fp[1];
|
|
fb= fp[2];
|
|
}
|
|
break;
|
|
}
|
|
else if( strcmp(iv->nodename, "BaseColor")==0) {
|
|
fp= iv->data[0];
|
|
fr= fp[0];
|
|
fg= fp[1];
|
|
fb= fp[2];
|
|
break;
|
|
}
|
|
else if( strcmp(iv->nodename, "PackedColor")==0) {
|
|
cp= (char *)iv->data[0];
|
|
fr= cp[3]/255.0f;
|
|
fg= cp[2]/255.0f;
|
|
fb= cp[1]/255.0f;
|
|
break;
|
|
}
|
|
iv= iv->prev;
|
|
|
|
}
|
|
if(iv==0) return 0;
|
|
if(iv->datalen[0]<3) return 0;
|
|
|
|
for(a=0; a<iv_curcol; a++) {
|
|
|
|
if(ivcolors[a][0]== fr)
|
|
if(ivcolors[a][1]== fg)
|
|
if(ivcolors[a][2]== fb) return a+1
|
|
;
|
|
}
|
|
|
|
if(a>=IV_MAXCOL) a= IV_MAXCOL-1;
|
|
iv_curcol= a+1;
|
|
ivcolors[a][0]= fr;
|
|
ivcolors[a][1]= fg;
|
|
ivcolors[a][2]= fb;
|
|
|
|
return iv_curcol;
|
|
}
|
|
|
|
static int iv_finddata(struct IvNode *iv, char *field, int fieldnr)
|
|
{
|
|
/* search for "field", count data size and make datablock. return skipdata */
|
|
float *fp;
|
|
int len, stackcount, skipdata=0;
|
|
char *cpa, terminator, str[64];
|
|
intptr_t i;
|
|
|
|
len= strlen(field);
|
|
|
|
cpa= iv->nodename+1;
|
|
while( *cpa != '}' ) {
|
|
|
|
if( *cpa == *field ) {
|
|
if( strncmp(cpa, field, len)==0 ) {
|
|
iv->fieldname[fieldnr]= cpa;
|
|
|
|
/* read until first character */
|
|
cpa+= len;
|
|
skipdata+= len;
|
|
*cpa= 0;
|
|
cpa++;
|
|
skipdata++;
|
|
|
|
while( *cpa==32 || *cpa==13 || *cpa==10 || *cpa==9) cpa++;
|
|
if( *cpa=='[' ) {
|
|
terminator= ']';
|
|
cpa++;
|
|
skipdata++;
|
|
}
|
|
else terminator= 13;
|
|
|
|
stackcount= 0;
|
|
fp= iv_data_stack;
|
|
|
|
while( *cpa!=terminator && *cpa != '}' ) {
|
|
|
|
/* in fact, isdigit should include the dot and minus */
|
|
if( (isdigit(*cpa) || *cpa=='.' || *cpa=='-') && (isspace(cpa[-1]) || cpa[-1]==0 || cpa[-1]==',') ) {
|
|
if(cpa[1]=='x') {
|
|
memcpy(str, cpa, 16);
|
|
str[16]= 0;
|
|
|
|
sscanf(str, "%x", (int *)fp);
|
|
}
|
|
else {
|
|
/* atof doesn't stop after the first float
|
|
* in a long string at Windows... so we copy
|
|
* the float to a new string then atof... */
|
|
char *cpa_temp = strpbrk(cpa, ", \n");
|
|
i = cpa_temp - cpa;
|
|
|
|
if (i>63) *fp= 0.0;
|
|
else {
|
|
memcpy(str, cpa, i);
|
|
str[i]=0;
|
|
|
|
*fp= (float) atof(str);
|
|
}
|
|
}
|
|
|
|
stackcount++;
|
|
if(stackcount>=IV_MAXSTACK) {
|
|
printf("stackoverflow in IV read\n");
|
|
break;
|
|
}
|
|
fp++;
|
|
}
|
|
cpa++;
|
|
skipdata++;
|
|
}
|
|
|
|
iv->datalen[fieldnr]= stackcount;
|
|
if(stackcount) {
|
|
iv->data[fieldnr]= MEM_mallocN(sizeof(float)*stackcount, "iv_finddata");
|
|
memcpy(iv->data[fieldnr], iv_data_stack, sizeof(float)*stackcount);
|
|
}
|
|
else iv->data[fieldnr]= 0;
|
|
|
|
return skipdata;
|
|
}
|
|
}
|
|
cpa++;
|
|
skipdata++;
|
|
}
|
|
|
|
return skipdata;
|
|
}
|
|
|
|
static void read_iv_index(float *data, float *baseadr, float *index, int nr, int coordtype)
|
|
{
|
|
/* write in data: baseadr with offset index (and number nr) */
|
|
float *fp;
|
|
int ofs;
|
|
|
|
while(nr--) {
|
|
ofs= (int) *index;
|
|
fp= baseadr+coordtype*ofs;
|
|
VECCOPY(data, fp);
|
|
data+= 3;
|
|
index++;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static void read_inventor(Scene *scene, char *str, struct ListBase *listb)
|
|
{
|
|
struct IvNode *iv, *ivp, *ivn;
|
|
char *maindata, *md, *cpa;
|
|
float *index, *data, *fp;
|
|
int file, filelen, count, lll, face, nr = 0;
|
|
int skipdata, ok, a, b, tot, first, colnr, coordtype, polytype, *idata;
|
|
struct DispList *dl;
|
|
|
|
ivbase.first= ivbase.last= 0;
|
|
iv_curcol= 0;
|
|
ivsurf= 0;
|
|
|
|
file= open(str, O_BINARY|O_RDONLY);
|
|
if(file== -1) {
|
|
//XXX error("Can't read file\n");
|
|
return;
|
|
}
|
|
|
|
filelen= BLI_filesize(file);
|
|
if(filelen < 1) {
|
|
close(file);
|
|
return;
|
|
}
|
|
|
|
maindata= MEM_mallocN(filelen, "leesInventor");
|
|
read(file, maindata, filelen);
|
|
close(file);
|
|
|
|
iv_data_stack= MEM_mallocN(sizeof(float)*IV_MAXSTACK, "ivstack");
|
|
|
|
/* preprocess: remove comments */
|
|
md= maindata+20;
|
|
count= 20;
|
|
while(count<filelen) {
|
|
if( *md=='#' ) { /* comment */
|
|
while( *md!=13 && *md!=10) { /* enters */
|
|
*md= 32;
|
|
md++;
|
|
count++;
|
|
if(count>=filelen) break;
|
|
}
|
|
}
|
|
md++;
|
|
count++;
|
|
}
|
|
|
|
|
|
/* now time to collect: which are the nodes and fields? */
|
|
md= maindata;
|
|
count= 0;
|
|
while(count<filelen) {
|
|
if( *md=='{' ) { /* read back */
|
|
|
|
cpa= md-1;
|
|
while( *cpa==32 || *cpa==13 || *cpa==10 || *cpa==9) { /* remove spaces/enters/tab */
|
|
*cpa= 0;
|
|
cpa--;
|
|
}
|
|
|
|
while( *cpa>32 && *cpa<128) cpa--;
|
|
cpa++;
|
|
*md= 0;
|
|
|
|
ok= 0;
|
|
skipdata= 0;
|
|
iv= MEM_callocN(sizeof(struct IvNode), "leesInventor");
|
|
iv->nodename= cpa;
|
|
|
|
if(strcmp(cpa, "Coordinate3")==0 || strcmp(cpa, "Coordinate4")==0) {
|
|
skipdata= iv_finddata(iv, "point", 0);
|
|
ok= 1;
|
|
}
|
|
else if(strcmp(cpa, "VertexProperty")==0) {
|
|
skipdata= iv_finddata(iv, "vertex", 0);
|
|
ok= 1;
|
|
}
|
|
else if(strcmp(cpa, "IndexedLineSet")==0) {
|
|
skipdata= iv_finddata(iv, "coordIndex", 0);
|
|
ok= 1;
|
|
}
|
|
else if(strcmp(cpa, "IndexedTriangleMesh")==0) {
|
|
skipdata= iv_finddata(iv, "coordIndex", 0);
|
|
ok= 1;
|
|
}
|
|
else if(strcmp(cpa, "IndexedFaceSet")==0) {
|
|
skipdata= iv_finddata(iv, "coordIndex", 0);
|
|
ok= 1;
|
|
}
|
|
else if(strcmp(cpa, "FaceSet")==0) {
|
|
skipdata= iv_finddata(iv, "numVertices", 0);
|
|
ok= 1;
|
|
}
|
|
else if(strcmp(cpa, "Material")==0) {
|
|
iv_finddata(iv, "diffuseColor", 0);
|
|
iv_finddata(iv, "ambientColor", 1);
|
|
ok= 1;
|
|
}
|
|
else if(strcmp(cpa, "BaseColor")==0) {
|
|
iv_finddata(iv, "rgb", 0);
|
|
ok= 1;
|
|
}
|
|
else if(strcmp(cpa, "PackedColor")==0) {
|
|
iv_finddata(iv, "rgba", 0);
|
|
ok= 1;
|
|
}
|
|
else if(strcmp(cpa, "QuadMesh")==0) {
|
|
iv_finddata(iv, "verticesPerColumn", 0);
|
|
iv_finddata(iv, "verticesPerRow", 1);
|
|
|
|
ok= 1;
|
|
}
|
|
else if(strcmp(cpa, "IndexedTriangleStripSet")==0) {
|
|
skipdata= iv_finddata(iv, "coordIndex", 0);
|
|
ok= 1;
|
|
}
|
|
else if(strcmp(cpa, "TriangleStripSet")==0) {
|
|
skipdata= iv_finddata(iv, "numVertices", 0);
|
|
ok= 1;
|
|
}
|
|
else if(strcmp(cpa, "IndexedNurbsSurface")==0 || strcmp(cpa, "NurbsSurface")==0) {
|
|
iv_finddata(iv, "numUControlPoints", 0);
|
|
iv_finddata(iv, "numVControlPoints", 1);
|
|
iv_finddata(iv, "uKnotVector", 2);
|
|
iv_finddata(iv, "vKnotVector", 3);
|
|
ok= 1;
|
|
}
|
|
else {
|
|
/* to the end */
|
|
while( *md != '}') {
|
|
md++;
|
|
count++;
|
|
if(count<filelen) break;
|
|
}
|
|
}
|
|
|
|
|
|
if(ok) {
|
|
BLI_addtail(&ivbase, iv);
|
|
md+= skipdata;
|
|
count+= skipdata;
|
|
}
|
|
else MEM_freeN(iv);
|
|
|
|
}
|
|
md++;
|
|
count++;
|
|
}
|
|
|
|
/* join nodes */
|
|
iv= ivbase.first;
|
|
|
|
while(iv) {
|
|
ivn= iv->next;
|
|
|
|
if( strncmp(iv->nodename, "Indexed", 7)==0) {
|
|
/* seek back: same name? */
|
|
|
|
ivp= iv->prev;
|
|
while(ivp) {
|
|
if(strcmp(iv->nodename, ivp->nodename)==0) break;
|
|
|
|
if(strcmp(ivp->nodename, "Coordinate3")==0 ||
|
|
strcmp(ivp->nodename, "Coordinate4")==0 ||
|
|
strcmp(ivp->nodename, "VertexProperty")==0) {
|
|
ivp= 0;
|
|
break;
|
|
}
|
|
ivp= ivp->prev;
|
|
}
|
|
|
|
if(ivp) {
|
|
/* add iv to ivp */
|
|
|
|
tot= iv->datalen[0] + ivp->datalen[0];
|
|
if(tot) {
|
|
data= MEM_mallocN(tot*sizeof(float), "samenvoeg iv");
|
|
memcpy(data, ivp->data[0], sizeof(float)*ivp->datalen[0]);
|
|
memcpy(data+ivp->datalen[0], iv->data[0], sizeof(float)*iv->datalen[0]);
|
|
|
|
ivp->datalen[0]+= iv->datalen[0];
|
|
MEM_freeN(ivp->data[0]);
|
|
ivp->data[0]= data;
|
|
|
|
BLI_remlink(&ivbase, iv);
|
|
MEM_freeN(iv->data[0]);
|
|
MEM_freeN(iv);
|
|
}
|
|
}
|
|
}
|
|
|
|
iv= ivn;
|
|
}
|
|
|
|
|
|
/* convert Nodes to DispLists */
|
|
iv= ivbase.first;
|
|
while(iv) {
|
|
|
|
/* printf(" Node: %s\n", iv->nodename); */
|
|
/* if(iv->fieldname[0]) printf(" Field: %s len %d\n", iv->fieldname[0], iv->datalen[0]); */
|
|
coordtype= 3;
|
|
|
|
if( strcmp(iv->nodename, "IndexedLineSet")==0 ) {
|
|
|
|
colnr= iv_colornumber(iv);
|
|
|
|
/* seek back to data */
|
|
ivp= iv;
|
|
while(ivp->prev) {
|
|
ivp= ivp->prev;
|
|
if( strcmp(ivp->nodename, "Coordinate3")==0 ) {
|
|
coordtype= 3;
|
|
break;
|
|
}
|
|
if( strcmp(ivp->nodename, "Coordinate4")==0 ) {
|
|
coordtype= 4;
|
|
break;
|
|
}
|
|
}
|
|
if(ivp) {
|
|
|
|
/* count the nr of lines */
|
|
tot= 0;
|
|
index= iv->data[0];
|
|
lll = iv->datalen[0]-1;
|
|
for(a=0; a<lll; a++) {
|
|
if(index[0]!= -1 && index[1]!= -1) tot++;
|
|
index++;
|
|
}
|
|
|
|
tot*= 2; /* nr of vertices */
|
|
dl= MEM_callocN(sizeof(struct DispList)+tot*3*sizeof(float), "leesInventor1");
|
|
BLI_addtail(listb, dl);
|
|
dl->type= DL_SEGM;
|
|
dl->nr= 2;
|
|
dl->parts= tot/2;
|
|
dl->col= colnr;
|
|
data= (float *)(dl+1);
|
|
|
|
index= iv->data[0];
|
|
for(a=0; a<lll; a++) {
|
|
if(index[0]!= -1 && index[1]!= -1) {
|
|
read_iv_index(data, ivp->data[0], index, 2, coordtype);
|
|
data+= 6;
|
|
}
|
|
index++;
|
|
}
|
|
}
|
|
}
|
|
else if( strcmp(iv->nodename, "FaceSet")==0 ) {
|
|
|
|
colnr= iv_colornumber(iv);
|
|
|
|
/* seek back to data */
|
|
ivp= iv;
|
|
while(ivp->prev) {
|
|
ivp= ivp->prev;
|
|
if( strcmp(ivp->nodename, "Coordinate3")==0 ) {
|
|
coordtype= 3;
|
|
break;
|
|
}
|
|
if( strcmp(ivp->nodename, "Coordinate4")==0 ) {
|
|
coordtype= 4;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ivp) {
|
|
/* count triangles */
|
|
tot= 0;
|
|
|
|
index= iv->data[0];
|
|
polytype= (int) index[0];
|
|
|
|
for(a=0; a<iv->datalen[0]; a++) {
|
|
if(index[0]== polytype) tot++; /* one kind? */
|
|
index++;
|
|
}
|
|
|
|
|
|
tot*= polytype; /* nr of vertices */
|
|
dl= MEM_callocN(sizeof(struct DispList)+tot*3*sizeof(float), "leesInventor4");
|
|
BLI_addtail(listb, dl);
|
|
dl->type= DL_POLY;
|
|
dl->nr= polytype;
|
|
dl->parts= tot/polytype;
|
|
dl->col= colnr;
|
|
data= (float *)(dl+1);
|
|
|
|
index= ivp->data[0];
|
|
first= 1;
|
|
for(a=0; a<iv->datalen[0]; a++) {
|
|
|
|
VECCOPY(data, index);
|
|
data+= 3;
|
|
index+= 3;
|
|
|
|
VECCOPY(data, index);
|
|
data+= 3;
|
|
index+= 3;
|
|
|
|
VECCOPY(data, index);
|
|
data+= 3;
|
|
index+= 3;
|
|
|
|
if(polytype==4) {
|
|
VECCOPY(data, index);
|
|
data+= 3;
|
|
index+= 3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if( strcmp(iv->nodename, "TriangleStripSet")==0 ) {
|
|
|
|
colnr= iv_colornumber(iv);
|
|
|
|
/* seek back to data */
|
|
ivp= iv;
|
|
while(ivp->prev) {
|
|
ivp= ivp->prev;
|
|
if( strcmp(ivp->nodename, "Coordinate3")==0 ) {
|
|
coordtype= 3;
|
|
break;
|
|
}
|
|
if( strcmp(ivp->nodename, "Coordinate4")==0 ) {
|
|
coordtype= 4;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ivp) {
|
|
/* count triangles */
|
|
tot= 0;
|
|
face= 0;
|
|
|
|
index= iv->data[0]; /* strip size */
|
|
|
|
for(a=0; a<iv->datalen[0]; a++) {
|
|
tot+= (int) index[0];
|
|
face+= ((int) index[0]) - 2;
|
|
index++;
|
|
}
|
|
|
|
dl= MEM_callocN(sizeof(struct DispList), "leesInventor4");
|
|
dl->verts= MEM_callocN( tot*3*sizeof(float), "dl verts");
|
|
dl->index= MEM_callocN( face*3*sizeof(int), "dl index");
|
|
|
|
dl->type= DL_INDEX3;
|
|
dl->nr= tot;
|
|
dl->parts= face;
|
|
|
|
BLI_addtail(listb, dl);
|
|
dl->col= colnr;
|
|
|
|
index= iv->data[0]; /* strip size */
|
|
fp= ivp->data[0]; /* vertices */
|
|
data= dl->verts;
|
|
idata= dl->index;
|
|
first= 0;
|
|
|
|
for(a=0; a<iv->datalen[0]; a++) {
|
|
|
|
/* vertices */
|
|
for(b=0; b<index[0]; b++) {
|
|
VECCOPY(data, fp);
|
|
data+= 3;
|
|
fp+= coordtype;
|
|
}
|
|
|
|
/* indices */
|
|
lll = index[0] - 2;
|
|
for(b=0; b<lll; b++) {
|
|
idata[0]= first;
|
|
idata[1]= first+1;
|
|
idata[2]= first+2;
|
|
first++;
|
|
idata+= 3;
|
|
}
|
|
first+= 2;
|
|
|
|
index++;
|
|
}
|
|
}
|
|
}
|
|
else if( strcmp(iv->nodename, "IndexedFaceSet")==0 ) {
|
|
|
|
colnr= iv_colornumber(iv);
|
|
|
|
/* seek back to data */
|
|
ivp= iv;
|
|
while(ivp->prev) {
|
|
ivp= ivp->prev;
|
|
if( strcmp(ivp->nodename, "Coordinate3")==0 ) {
|
|
coordtype= 3;
|
|
break;
|
|
}
|
|
if( strcmp(ivp->nodename, "Coordinate4")==0 ) {
|
|
coordtype= 4;
|
|
break;
|
|
}
|
|
}
|
|
if(ivp) {
|
|
|
|
/* count triangles */
|
|
face= 0;
|
|
index= iv->data[0];
|
|
lll = iv->datalen[0]-2;
|
|
for(a=0; a<lll; a++) {
|
|
if(index[0]!= -1 && index[1]!= -1 && index[2]!= -1) face++;
|
|
index++;
|
|
}
|
|
|
|
/*number of vertices */
|
|
tot= ivp->datalen[0]/coordtype;
|
|
|
|
if(tot) {
|
|
dl= MEM_callocN(sizeof(struct DispList), "leesInventor5");
|
|
BLI_addtail(listb, dl);
|
|
dl->type= DL_INDEX3;
|
|
dl->nr= tot;
|
|
dl->parts= face;
|
|
dl->col= colnr;
|
|
|
|
dl->verts= MEM_callocN( tot*3*sizeof(float), "dl verts");
|
|
dl->index= MEM_callocN(sizeof(int)*3*face, "dl index");
|
|
|
|
/* vertices */
|
|
fp= ivp->data[0];
|
|
data= dl->verts;
|
|
for(b=tot; b>0; b--) {
|
|
VECCOPY(data, fp);
|
|
data+= 3;
|
|
fp+= coordtype;
|
|
}
|
|
|
|
/* indices */
|
|
index= iv->data[0];
|
|
idata= dl->index;
|
|
first= 1;
|
|
lll=iv->datalen[0]-2;
|
|
for(a=0; a<lll; a++) {
|
|
|
|
if(index[0]!= -1 && index[1]!= -1 && index[2]!= -1) {
|
|
|
|
/* this trick is to fill poly's with more than 3 vertices correctly */
|
|
if(first) {
|
|
nr= (int) index[0];
|
|
first= 0;
|
|
}
|
|
idata[0]= nr;
|
|
idata[1]= (int) index[1];
|
|
idata[2]= (int) index[2];
|
|
idata+= 3;
|
|
}
|
|
else first= 1;
|
|
|
|
index++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if( strcmp(iv->nodename, "IndexedTriangleMesh")==0 ||
|
|
strcmp(iv->nodename, "IndexedTriangleStripSet")==0 ) {
|
|
|
|
colnr= iv_colornumber(iv);
|
|
|
|
/* seek back to data */
|
|
ivp= iv;
|
|
while(ivp->prev) {
|
|
ivp= ivp->prev;
|
|
if( strcmp(ivp->nodename, "Coordinate3")==0 ) {
|
|
coordtype= 3;
|
|
break;
|
|
}
|
|
if( strcmp(ivp->nodename, "Coordinate4")==0 ) {
|
|
coordtype= 4;
|
|
break;
|
|
}
|
|
}
|
|
if(ivp) {
|
|
|
|
/* count triangles */
|
|
face= 0;
|
|
index= iv->data[0];
|
|
lll=iv->datalen[0]-2;
|
|
for(a=0; a<lll; a++) {
|
|
if(index[0]!= -1 && index[1]!= -1 && index[2]!= -1) face++;
|
|
index++;
|
|
}
|
|
|
|
/* nr of vertices */
|
|
tot= ivp->datalen[0]/coordtype;
|
|
|
|
dl= MEM_callocN(sizeof(struct DispList), "leesInventor6");
|
|
BLI_addtail(listb, dl);
|
|
dl->type= DL_INDEX3;
|
|
dl->nr= tot;
|
|
dl->parts= face;
|
|
dl->col= colnr;
|
|
|
|
dl->verts= MEM_callocN( tot*3*sizeof(float), "dl verts");
|
|
dl->index= MEM_callocN(sizeof(int)*3*face, "dl index");
|
|
|
|
/* vertices */
|
|
fp= ivp->data[0];
|
|
data= dl->verts;
|
|
for(b=tot; b>0; b--) {
|
|
VECCOPY(data, fp);
|
|
data+= 3;
|
|
fp+= coordtype;
|
|
}
|
|
|
|
/* indices */
|
|
index= iv->data[0];
|
|
idata= dl->index;
|
|
|
|
lll=iv->datalen[0]-2;
|
|
for(a=lll; a>0; a--) {
|
|
|
|
if(index[0]!= -1 && index[1]!= -1 && index[2]!= -1) {
|
|
idata[0]= (int) index[0];
|
|
idata[1]= (int) index[1];
|
|
idata[2]= (int) index[2];
|
|
idata+= 3;
|
|
}
|
|
index++;
|
|
}
|
|
}
|
|
}
|
|
else if( strcmp(iv->nodename, "QuadMesh")==0 ) {
|
|
|
|
colnr= iv_colornumber(iv);
|
|
|
|
/* seek back to data */
|
|
ivp= iv;
|
|
while(ivp->prev) {
|
|
ivp= ivp->prev;
|
|
if( strcmp(ivp->nodename, "Coordinate3")==0 ) {
|
|
coordtype= 3;
|
|
break;
|
|
}
|
|
if( strcmp(ivp->nodename, "VertexProperty")==0 ) {
|
|
coordtype= 3;
|
|
break;
|
|
}
|
|
if( strcmp(ivp->nodename, "Coordinate4")==0 ) {
|
|
coordtype= 4;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ivp) {
|
|
tot= (int) (floor(*(iv->data[0])+0.5) * floor(*(iv->data[1])+0.5));
|
|
|
|
if(tot>0) {
|
|
dl= MEM_callocN(sizeof(struct DispList)+tot*3*sizeof(float), "leesInventor8");
|
|
BLI_addtail(listb, dl);
|
|
dl->type= DL_SURF;
|
|
dl->parts= (int) floor(*(iv->data[0])+0.5);
|
|
dl->nr= (int) floor(*(iv->data[1])+0.5);
|
|
dl->col= colnr;
|
|
data= (float *)(dl+1);
|
|
memcpy(data, ivp->data[0], tot*3*sizeof(float));
|
|
}
|
|
}
|
|
}
|
|
else if(strcmp(iv->nodename, "IndexedNurbsSurface")==0 || strcmp(iv->nodename, "NurbsSurface")==0) {
|
|
|
|
colnr= iv_colornumber(iv);
|
|
|
|
/* sek back to data */
|
|
ivp= iv;
|
|
while(ivp->prev) {
|
|
ivp= ivp->prev;
|
|
if( strcmp(ivp->nodename, "Coordinate3")==0 ) {
|
|
coordtype= 3;
|
|
break;
|
|
}
|
|
if( strcmp(ivp->nodename, "Coordinate4")==0 ) {
|
|
coordtype= 4;
|
|
break;
|
|
}
|
|
}
|
|
if(ivp) {
|
|
a= (int) *(iv->data[0]);
|
|
b= (int) *(iv->data[1]);
|
|
|
|
tot= a*b;
|
|
|
|
if( (a>=4 || b>=4) && tot>6) {
|
|
Object *ob;
|
|
Curve *cu;
|
|
Nurb *nu;
|
|
BPoint *bp;
|
|
|
|
if(ivsurf==0) {
|
|
ob= add_object(scene, OB_SURF);
|
|
ivsurf= ob;
|
|
}
|
|
else ob= ivsurf;
|
|
cu= ob->data;
|
|
nu = (Nurb*) MEM_callocN(sizeof(Nurb),"addNurbprim") ;
|
|
BLI_addtail(&cu->nurb, nu);
|
|
nu->type= CU_NURBS;
|
|
|
|
nu->pntsu= a;
|
|
nu->pntsv= b;
|
|
nu->resolu= 2*a;
|
|
nu->resolv= 2*b;
|
|
|
|
nu->flagu= 0;
|
|
nu->flagv= 0;
|
|
|
|
nu->bp = bp =
|
|
(BPoint*)MEM_callocN(tot * sizeof(BPoint), "addNurbprim3");
|
|
a= tot;
|
|
data= ivp->data[0];
|
|
while(a--) {
|
|
VECCOPY(bp->vec, data);
|
|
if(coordtype==4) {
|
|
bp->vec[3]= data[3];
|
|
VecMulf(bp->vec, 1.0f/data[3]);
|
|
}
|
|
else bp->vec[3]= 1.0;
|
|
data+= coordtype;
|
|
bp++;
|
|
}
|
|
|
|
/* iv->datalen[2] / [3] is number of knots */
|
|
nu->orderu= iv->datalen[2] - nu->pntsu;
|
|
nu->orderv= iv->datalen[3] - nu->pntsv;
|
|
|
|
nu->knotsu= MEM_mallocN( sizeof(float)*(iv->datalen[2]), "knots");
|
|
memcpy(nu->knotsu, iv->data[2], sizeof(float)*(iv->datalen[2]));
|
|
nu->knotsv= MEM_mallocN( sizeof(float)*(iv->datalen[3]), "knots");
|
|
memcpy(nu->knotsv, iv->data[3], sizeof(float)*(iv->datalen[3]));
|
|
|
|
switchdirectionNurb(nu);
|
|
|
|
}
|
|
else {
|
|
dl= MEM_callocN(sizeof(struct DispList)+tot*3*sizeof(float), "leesInventor3");
|
|
BLI_addtail(listb, dl);
|
|
dl->type= DL_SURF;
|
|
dl->nr= (int) *(iv->data[0]);
|
|
dl->parts= (int) *(iv->data[1]);
|
|
dl->col= colnr;
|
|
data= (float *)(dl+1);
|
|
|
|
a= tot;
|
|
fp= ivp->data[0];
|
|
while(a--) {
|
|
VECCOPY(data, fp);
|
|
fp+= coordtype;
|
|
data+= 3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
iv= iv->next;
|
|
}
|
|
|
|
/* free */
|
|
iv= ivbase.first;
|
|
while(iv) {
|
|
for(a=0; a<IV_MAXFIELD; a++) {
|
|
if(iv->data[a]) MEM_freeN(iv->data[a]);
|
|
}
|
|
iv= iv->next;
|
|
}
|
|
|
|
BLI_freelistN(&ivbase);
|
|
MEM_freeN(maindata);
|
|
MEM_freeN(iv_data_stack);
|
|
|
|
}
|
|
|
|
/* ************************************************************ */
|
|
|
|
static void displist_to_mesh(Scene *scene, DispList *dlfirst)
|
|
{
|
|
Object *ob;
|
|
Mesh *me;
|
|
Material *ma;
|
|
DispList *dl;
|
|
MVert *mvert;
|
|
MFace *mface;
|
|
float *data, vec[3], min[3], max[3];
|
|
int a, b, startve, *idata, totedge=0, tottria=0, totquad=0, totvert=0, totface, totcol=0, colnr;
|
|
int p1, p2, p3, p4;
|
|
unsigned int maxvertidx;
|
|
|
|
/* count first */
|
|
INIT_MINMAX(min, max);
|
|
|
|
dl= dlfirst;
|
|
while(dl) {
|
|
|
|
/* PATCH 1 (polyfill) can't be done, there's no listbase here. do that first! */
|
|
/* PATCH 2 */
|
|
if(dl->type==DL_SEGM && dl->nr>2) {
|
|
data= (float *)(dl+1);
|
|
if(data[0]==data[3*(dl->nr-1)]) {
|
|
if(data[1]==data[3*(dl->nr-1)+1]) {
|
|
if(data[2]==data[3*(dl->nr-1)+2]) {
|
|
dl->type= DL_POLY;
|
|
dl->nr--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* colors */
|
|
if(dl->col > totcol) totcol= dl->col;
|
|
|
|
/* size and count */
|
|
if(dl->type==DL_SURF) {
|
|
a= dl->nr;
|
|
b= dl->parts;
|
|
if(dl->flag & DL_CYCL_U) a++;
|
|
if(dl->flag & DL_CYCL_V) b++;
|
|
|
|
totquad+= a*b;
|
|
|
|
totvert+= dl->nr*dl->parts;
|
|
|
|
data= (float *)(dl+1);
|
|
for(a= dl->nr*dl->parts; a>0; a--) {
|
|
DO_MINMAX(data, min, max);
|
|
data+= 3;
|
|
}
|
|
}
|
|
else if(dl->type==DL_POLY) {
|
|
if(dl->nr==3 || dl->nr==4) {
|
|
if(dl->nr==3) tottria+= dl->parts;
|
|
else totquad+= dl->parts;
|
|
|
|
totvert+= dl->nr*dl->parts;
|
|
|
|
data= (float *)(dl+1);
|
|
for(a= dl->nr*dl->parts; a>0; a--) {
|
|
DO_MINMAX(data, min, max);
|
|
data+= 3;
|
|
}
|
|
}
|
|
else if(dl->nr>4) {
|
|
|
|
tottria+= dl->nr*dl->parts;
|
|
totvert+= dl->nr*dl->parts;
|
|
|
|
data= (float *)(dl+1);
|
|
for(a= dl->nr*dl->parts; a>0; a--) {
|
|
DO_MINMAX(data, min, max);
|
|
data+= 3;
|
|
}
|
|
|
|
}
|
|
}
|
|
else if(dl->type==DL_INDEX3) {
|
|
tottria+= dl->parts;
|
|
totvert+= dl->nr;
|
|
|
|
data= dl->verts;
|
|
for(a= dl->nr; a>0; a--) {
|
|
DO_MINMAX(data, min, max);
|
|
data+= 3;
|
|
}
|
|
}
|
|
else if(dl->type==DL_SEGM) {
|
|
|
|
tottria+= (dl->nr-1)*dl->parts;
|
|
totvert+= dl->nr*dl->parts;
|
|
|
|
data= (float *)(dl+1);
|
|
for(a= dl->nr*dl->parts; a>0; a--) {
|
|
DO_MINMAX(data, min, max);
|
|
data+= 3;
|
|
}
|
|
}
|
|
|
|
dl= dl->next;
|
|
}
|
|
|
|
if(totvert==0) {
|
|
return;
|
|
}
|
|
|
|
if(totcol>16) {
|
|
//XXX error("Found more than 16 different colors");
|
|
totcol= 16;
|
|
}
|
|
|
|
vec[0]= (min[0]+max[0])/2;
|
|
vec[1]= (min[1]+max[1])/2;
|
|
vec[2]= (min[2]+max[2])/2;
|
|
|
|
ob= add_object(scene, OB_MESH);
|
|
VECCOPY(ob->loc, vec);
|
|
where_is_object(scene, ob);
|
|
|
|
me= ob->data;
|
|
|
|
/* colors */
|
|
if(totcol) {
|
|
ob->mat= MEM_callocN(sizeof(void *)*totcol, "ob->mat");
|
|
me->mat= MEM_callocN(sizeof(void *)*totcol, "me->mat");
|
|
me->totcol= totcol;
|
|
ob->totcol= (unsigned char) me->totcol;
|
|
ob->actcol= 1;
|
|
}
|
|
|
|
/* materials */
|
|
for(a=0; a<totcol; a++) {
|
|
ma= G.main->mat.first;
|
|
while(ma) {
|
|
if(ma->mtex[0]==0) {
|
|
if(ivcolors[a][0]==ma->r && ivcolors[a][1]==ma->g && ivcolors[a][2]==ma->b) {
|
|
me->mat[a]= ma;
|
|
ma->id.us++;
|
|
break;
|
|
}
|
|
}
|
|
ma= ma->id.next;
|
|
}
|
|
if(ma==0) {
|
|
ma= add_material("ext");
|
|
me->mat[a]= ma;
|
|
ma->r= ivcolors[a][0];
|
|
ma->g= ivcolors[a][1];
|
|
ma->b= ivcolors[a][2];
|
|
automatname(ma);
|
|
}
|
|
}
|
|
|
|
totface= totquad+tottria+totedge;
|
|
|
|
printf("Import: %d vertices %d faces\n", totvert, totface);
|
|
|
|
me->totvert= totvert;
|
|
me->totface= totface;
|
|
me->mvert= CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC,
|
|
NULL, me->totvert);
|
|
me->mface= CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC,
|
|
NULL, me->totface);
|
|
maxvertidx= totvert-1;
|
|
|
|
mvert= me->mvert;
|
|
mface= me->mface;
|
|
|
|
startve= 0;
|
|
|
|
dl= dlfirst;
|
|
while(dl) {
|
|
|
|
colnr= (dl->col>15 ? 15: dl->col);
|
|
if(colnr) colnr--;
|
|
|
|
if(dl->type==DL_SURF) {
|
|
data= (float *)(dl+1);
|
|
|
|
for(a=dl->parts*dl->nr; a>0; a--) {
|
|
mvert->co[0]= data[0] -vec[0];
|
|
mvert->co[1]= data[1] -vec[1];
|
|
mvert->co[2]= data[2] -vec[2];
|
|
|
|
data+=3;
|
|
mvert++;
|
|
}
|
|
|
|
for(a=0; a<dl->parts; a++) {
|
|
|
|
if (surfindex_displist(dl, a, &b, &p1, &p2, &p3, &p4)==0)
|
|
break;
|
|
|
|
p1+= startve;
|
|
p2+= startve;
|
|
p3+= startve;
|
|
p4+= startve;
|
|
|
|
for(; b<dl->nr; b++) {
|
|
|
|
mface->v1= p1;
|
|
mface->v2= p2;
|
|
mface->v3= p4;
|
|
mface->v4= p3;
|
|
|
|
mface->mat_nr= colnr;
|
|
test_index_face(mface, NULL, 0, 4);
|
|
|
|
mface++;
|
|
|
|
p4= p3;
|
|
p3++;
|
|
p2= p1;
|
|
p1++;
|
|
}
|
|
}
|
|
|
|
startve += dl->parts*dl->nr;
|
|
|
|
}
|
|
else if(dl->type==DL_POLY) {
|
|
|
|
if(dl->nr==3 || dl->nr==4) {
|
|
data= (float *)(dl+1);
|
|
|
|
for(a=dl->parts*dl->nr; a>0; a--) {
|
|
mvert->co[0]= data[0] -vec[0];
|
|
mvert->co[1]= data[1] -vec[1];
|
|
mvert->co[2]= data[2] -vec[2];
|
|
data+=3;
|
|
mvert++;
|
|
}
|
|
|
|
for(a=0; a<dl->parts; a++) {
|
|
if(dl->nr==3) {
|
|
mface->v1= startve+a*dl->nr;
|
|
mface->v2= startve+a*dl->nr+1;
|
|
mface->v3= startve+a*dl->nr+2;
|
|
mface->mat_nr= colnr;
|
|
test_index_face(mface, NULL, 0, 3);
|
|
mface++;
|
|
}
|
|
else {
|
|
mface->v1= startve+a*dl->nr;
|
|
mface->v2= startve+a*dl->nr+1;
|
|
mface->v3= startve+a*dl->nr+2;
|
|
mface->v4= startve+a*dl->nr+3;
|
|
mface->mat_nr= colnr;
|
|
test_index_face(mface, NULL, 0, 4);
|
|
mface++;
|
|
}
|
|
}
|
|
startve += dl->parts*dl->nr;
|
|
}
|
|
else if(dl->nr>4) {
|
|
data= (float *)(dl+1);
|
|
|
|
for(a=dl->parts*dl->nr; a>0; a--) {
|
|
mvert->co[0]= data[0] -vec[0];
|
|
mvert->co[1]= data[1] -vec[1];
|
|
mvert->co[2]= data[2] -vec[2];
|
|
|
|
data+=3;
|
|
mvert++;
|
|
}
|
|
|
|
for(b=0; b<dl->parts; b++) {
|
|
for(a=0; a<dl->nr; a++) {
|
|
mface->v1= startve+a;
|
|
|
|
if(a==dl->nr-1) mface->v2= startve;
|
|
else mface->v2= startve+a+1;
|
|
|
|
mface->mat_nr= colnr;
|
|
|
|
mface++;
|
|
}
|
|
startve += dl->nr;
|
|
}
|
|
}
|
|
}
|
|
else if(dl->type==DL_INDEX3) {
|
|
data= dl->verts;
|
|
|
|
for(a=dl->nr; a>0; a--) {
|
|
mvert->co[0]= data[0] -vec[0];
|
|
mvert->co[1]= data[1] -vec[1];
|
|
mvert->co[2]= data[2] -vec[2];
|
|
data+=3;
|
|
mvert++;
|
|
}
|
|
|
|
idata= dl->index;
|
|
for(b=dl->parts; b>0; b--) {
|
|
mface->v1= startve+idata[0];
|
|
mface->v2= startve+idata[1];
|
|
mface->v3= startve+idata[2];
|
|
mface->mat_nr= colnr;
|
|
|
|
if (mface->v1>maxvertidx) mface->v1= maxvertidx;
|
|
if (mface->v2>maxvertidx) mface->v2= maxvertidx;
|
|
if (mface->v3>maxvertidx) mface->v3= maxvertidx;
|
|
|
|
test_index_face(mface, NULL, 0, 3);
|
|
mface++;
|
|
idata+= 3;
|
|
}
|
|
startve += dl->nr;
|
|
}
|
|
else if(dl->type==DL_SEGM) {
|
|
data= (float *)(dl+1);
|
|
|
|
for(a=dl->parts*dl->nr; a>0; a--) {
|
|
mvert->co[0]= data[0] -vec[0];
|
|
mvert->co[1]= data[1] -vec[1];
|
|
mvert->co[2]= data[2] -vec[2];
|
|
data+=3;
|
|
mvert++;
|
|
}
|
|
|
|
for(b=0; b<dl->parts; b++) {
|
|
for(a=0; a<dl->nr-1; a++) {
|
|
mface->v1= startve+a;
|
|
mface->v2= startve+a+1;
|
|
mface->mat_nr= colnr;
|
|
mface++;
|
|
}
|
|
startve += dl->nr;
|
|
}
|
|
}
|
|
dl= dl->next;
|
|
}
|
|
|
|
mesh_add_normals_flags(me);
|
|
make_edges(me, 0);
|
|
}
|
|
|
|
static void displist_to_objects(Scene *scene, ListBase *lbase)
|
|
{
|
|
DispList *dl, *first, *prev, *next;
|
|
ListBase tempbase;
|
|
int maxaantal, curcol, totvert=0, vert;
|
|
|
|
/* irst this: is still active */
|
|
if(ivsurf) {
|
|
where_is_object(scene, ivsurf);
|
|
// XXX docenter_new();
|
|
}
|
|
|
|
dl= lbase->first;
|
|
while(dl) {
|
|
next= dl->next;
|
|
|
|
/* PATCH 1: polyfill */
|
|
if(dl->type==DL_POLY && dl->nr>4) {
|
|
/* solution: put them together in separate listbase */
|
|
;
|
|
}
|
|
/* PATCH 2: poly's of 2 points */
|
|
if(dl->type==DL_POLY && dl->nr==2) dl->type= DL_SEGM;
|
|
|
|
dl= next;
|
|
}
|
|
|
|
/* count vertices */
|
|
|
|
dl= lbase->first;
|
|
while(dl) {
|
|
|
|
if(dl->type==DL_SURF) totvert+= dl->nr*dl->parts;
|
|
else if(dl->type==DL_POLY) {
|
|
if(dl->nr==3 || dl->nr==4) totvert+= dl->nr*dl->parts;
|
|
else if(dl->nr>4) totvert+= dl->nr*dl->parts;
|
|
}
|
|
else if(dl->type==DL_INDEX3) totvert+= dl->nr;
|
|
else if(dl->type==DL_SEGM) totvert+= dl->nr*dl->parts;
|
|
|
|
dl= dl->next;
|
|
}
|
|
|
|
if(totvert==0) {
|
|
|
|
if(ivsurf==0) ; //XXX error("Found no data");
|
|
if(lbase->first) BLI_freelistN(lbase);
|
|
|
|
return;
|
|
}
|
|
|
|
maxaantal= 32000;
|
|
|
|
if(totvert>maxaantal) {
|
|
|
|
/* try to put colors together */
|
|
curcol= 0;
|
|
tempbase.first= tempbase.last= 0;
|
|
|
|
while(lbase->first) {
|
|
dl= lbase->first;
|
|
while(dl) {
|
|
next= dl->next;
|
|
if(dl->col==curcol) {
|
|
BLI_remlink(lbase, dl);
|
|
BLI_addtail(&tempbase, dl);
|
|
dl->col= 0;
|
|
}
|
|
|
|
dl= next;
|
|
}
|
|
|
|
/* in tempbase are all 'curcol' */
|
|
totvert= 0;
|
|
dl= first= tempbase.first;
|
|
while(dl) {
|
|
vert= 0;
|
|
|
|
if(dl->type==DL_SURF) vert= dl->nr*dl->parts;
|
|
else if(dl->type==DL_POLY) {
|
|
if(dl->nr==3 || dl->nr==4) vert= dl->nr*dl->parts;
|
|
else if(dl->nr>4) vert= dl->nr*dl->parts;
|
|
}
|
|
else if(dl->type==DL_INDEX3) totvert+= dl->nr;
|
|
else if(dl->type==DL_SEGM) vert= dl->nr*dl->parts;
|
|
|
|
totvert+= vert;
|
|
if(totvert > maxaantal || dl->next==0) {
|
|
if(dl->next==0) {
|
|
displist_to_mesh(scene, first);
|
|
}
|
|
else if(dl->prev) {
|
|
prev= dl->prev;
|
|
prev->next= 0;
|
|
displist_to_mesh(scene, first);
|
|
prev->next= dl;
|
|
first= dl;
|
|
totvert= 0;
|
|
}
|
|
}
|
|
|
|
dl= dl->next;
|
|
}
|
|
|
|
freedisplist(&tempbase);
|
|
|
|
curcol++;
|
|
}
|
|
}
|
|
else displist_to_mesh(scene, lbase->first);
|
|
|
|
freedisplist(lbase);
|
|
|
|
}
|
|
|
|
int BKE_read_exotic(Scene *scene, char *name)
|
|
{
|
|
ListBase lbase={0, 0};
|
|
int len;
|
|
gzFile gzfile;
|
|
char str[32];
|
|
int *s0 = (int*) str;
|
|
int retval = 0;
|
|
|
|
// make sure we're not trying to read a directory....
|
|
|
|
len= strlen(name);
|
|
if (name[len-1] !='/' && name[len-1] != '\\') {
|
|
gzfile = gzopen(name,"rb");
|
|
|
|
if (NULL == gzfile ) {
|
|
//XXX error("Can't open file: %s", name);
|
|
retval= -1;
|
|
} else {
|
|
gzread(gzfile, str, 31);
|
|
gzclose(gzfile);
|
|
|
|
if ((*s0 != FORM) && (strncmp(str, "BLEN", 4) != 0) && !BLI_testextensie(name,".blend.gz")) {
|
|
|
|
//XXX waitcursor(1);
|
|
if(strncmp(str, "#Inventor V1.0", 14)==0) {
|
|
if( strncmp(str+15, "ascii", 5)==0) {
|
|
read_inventor(scene, name, &lbase);
|
|
displist_to_objects(scene, &lbase);
|
|
retval = 1;
|
|
} else {
|
|
//XXX error("Can only read Inventor 1.0 ascii");
|
|
}
|
|
}
|
|
else if((strncmp(str, "#VRML V1.0 asc", 14)==0)) {
|
|
read_inventor(scene, name, &lbase);
|
|
displist_to_objects(scene, &lbase);
|
|
retval = 1;
|
|
}
|
|
else if(is_dxf(name)) {
|
|
dxf_read(scene, name);
|
|
retval = 1;
|
|
}
|
|
else if(is_stl(name)) {
|
|
if (is_stl_ascii(name))
|
|
read_stl_mesh_ascii(scene, name);
|
|
else
|
|
read_stl_mesh_binary(scene, name);
|
|
retval = 1;
|
|
}
|
|
#ifndef DISABLE_PYTHON
|
|
// TODO: this should not be in the kernel...
|
|
else { // unknown format, call Python importloader
|
|
if (BPY_call_importloader(name)) {
|
|
retval = 1;
|
|
} else {
|
|
//XXX error("Unknown file type or error, check console");
|
|
}
|
|
|
|
}
|
|
#endif /* DISABLE_PYTHON */
|
|
//XXX waitcursor(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (retval);
|
|
}
|
|
|
|
|
|
/* ************************ WRITE ************************** */
|
|
|
|
|
|
char temp_dir[160]= {0, 0};
|
|
|
|
static void write_vert_stl(Object *ob, MVert *verts, int index, FILE *fpSTL)
|
|
{
|
|
float vert[3];
|
|
|
|
VECCOPY(vert, verts[(index)].co);
|
|
Mat4MulVecfl(ob->obmat, vert);
|
|
|
|
if (ENDIAN_ORDER==B_ENDIAN) {
|
|
SWITCH_INT(vert[0]);
|
|
SWITCH_INT(vert[1]);
|
|
SWITCH_INT(vert[2]);
|
|
}
|
|
|
|
fwrite(vert, sizeof(float), 3, fpSTL);
|
|
}
|
|
|
|
static int write_derivedmesh_stl(FILE *fpSTL, Object *ob, DerivedMesh *dm)
|
|
{
|
|
MVert *mvert = dm->getVertArray(dm);
|
|
MFace *mface = dm->getFaceArray(dm);
|
|
int i, numfacets = 0, totface = dm->getNumFaces(dm);
|
|
float zero[3] = {0.0f, 0.0f, 0.0f};
|
|
|
|
for (i=0; i<totface; i++, mface++) {
|
|
fwrite(zero, sizeof(float), 3, fpSTL);
|
|
write_vert_stl(ob, mvert, mface->v1, fpSTL);
|
|
write_vert_stl(ob, mvert, mface->v2, fpSTL);
|
|
write_vert_stl(ob, mvert, mface->v3, fpSTL);
|
|
fprintf(fpSTL, " ");
|
|
numfacets++;
|
|
|
|
if(mface->v4) { /* quad = 2 tri's */
|
|
fwrite(zero, sizeof(float), 3, fpSTL);
|
|
write_vert_stl(ob, mvert, mface->v1, fpSTL);
|
|
write_vert_stl(ob, mvert, mface->v3, fpSTL);
|
|
write_vert_stl(ob, mvert, mface->v4, fpSTL);
|
|
fprintf(fpSTL, " ");
|
|
numfacets++;
|
|
}
|
|
}
|
|
|
|
return numfacets;
|
|
}
|
|
|
|
static int write_object_stl(FILE *fpSTL, Scene *scene, Object *ob, Mesh *me)
|
|
{
|
|
int numfacets = 0;
|
|
DerivedMesh *dm = mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH);
|
|
|
|
numfacets += write_derivedmesh_stl(fpSTL, ob, dm);
|
|
|
|
dm->release(dm);
|
|
|
|
return numfacets;
|
|
}
|
|
|
|
void write_stl(Scene *scene, char *str)
|
|
{
|
|
Object *ob;
|
|
Mesh *me;
|
|
Base *base;
|
|
FILE *fpSTL;
|
|
int numfacets = 0;
|
|
|
|
if(BLI_testextensie(str,".blend")) str[ strlen(str)-6]= 0;
|
|
if(BLI_testextensie(str,".ble")) str[ strlen(str)-4]= 0;
|
|
if(BLI_testextensie(str,".stl")==0) strcat(str, ".stl");
|
|
|
|
if (!during_script()) {
|
|
if (BLI_exists(str))
|
|
; //XXX if(saveover(str)==0)
|
|
//XXX return;
|
|
}
|
|
|
|
fpSTL= fopen(str, "wb");
|
|
|
|
if(fpSTL==NULL) {
|
|
if (!during_script()) ; //XXX error("Can't write file");
|
|
return;
|
|
}
|
|
strcpy(temp_dir, str);
|
|
|
|
//XXX waitcursor(1);
|
|
|
|
/* The header part of the STL */
|
|
/* First 80 characters are a title or whatever you want.
|
|
Lets make the first 32 of those spam and the rest the filename.
|
|
Those first 80 characters will be followed by 4 bytes
|
|
which will be overwritten later with an integer holding
|
|
how many facets are written (we set them to ' ' for now).
|
|
*/
|
|
fprintf(fpSTL, "Binary STL output from Blender: %-48.48s ", str);
|
|
|
|
/* Write all selected mesh objects */
|
|
base= scene->base.first;
|
|
while(base) {
|
|
if (base->flag & SELECT) {
|
|
ob = base->object;
|
|
if (ob->type == OB_MESH) {
|
|
me = ob->data;
|
|
if (me)
|
|
numfacets += write_object_stl(fpSTL, scene, ob, me);
|
|
}
|
|
}
|
|
base= base->next;
|
|
}
|
|
|
|
/* time to write the number of facets in the 4 bytes
|
|
starting at byte 81
|
|
*/
|
|
fseek(fpSTL, 80, SEEK_SET);
|
|
|
|
if (ENDIAN_ORDER==B_ENDIAN) {
|
|
SWITCH_INT(numfacets);
|
|
}
|
|
fwrite(&numfacets, 4*sizeof(char), 1, fpSTL);
|
|
|
|
fclose(fpSTL);
|
|
|
|
//XXX waitcursor(0);
|
|
}
|
|
|
|
/* ******************************* WRITE VRML ***************************** */
|
|
|
|
static void replace_chars(char *str1, char *str2)
|
|
{
|
|
int a= strlen(str2);
|
|
|
|
str1[a]= 0;
|
|
while(a--) {
|
|
if(str2[a]=='.' || str2[a]==' ') str1[a]= '_';
|
|
else str1[a]= str2[a];
|
|
}
|
|
}
|
|
|
|
|
|
static void write_material_vrml(FILE *fp, Material *ma)
|
|
{
|
|
char str[32];
|
|
|
|
replace_chars(str, ma->id.name+2);
|
|
|
|
fprintf(fp, "\tDEF %s\n", str);
|
|
fprintf(fp, "\tMaterial {\n");
|
|
|
|
fprintf(fp, "\t\tdiffuseColor %f %f %f\n", ma->r, ma->g, ma->b);
|
|
fprintf(fp, "\t\tspecularColor %f %f %f\n", ma->specr, ma->specg, ma->specb);
|
|
fprintf(fp, "\t\tshininess %f \n", ((float)ma->har)/100.0);
|
|
fprintf(fp, "\t\ttransparency %f \n", 1.0-ma->alpha);
|
|
|
|
fprintf(fp, "\t}\n");
|
|
|
|
}
|
|
|
|
unsigned int *mcol_to_vcol(Mesh *me)
|
|
{
|
|
MFace *mface;
|
|
unsigned int *mcol, *mcoln, *mcolmain;
|
|
int a;
|
|
|
|
if(me->totface==0 || me->mcol==0) return 0;
|
|
|
|
mcoln= mcolmain= MEM_mallocN(sizeof(int)*me->totvert, "mcoln");
|
|
mcol = (unsigned int *)me->mcol;
|
|
mface= me->mface;
|
|
|
|
for(a=me->totface; a>0; a--, mface++) {
|
|
mcoln[mface->v1]= mcol[0];
|
|
mcoln[mface->v2]= mcol[1];
|
|
mcoln[mface->v3]= mcol[2];
|
|
if(mface->v4) mcoln[mface->v4]= mcol[3];
|
|
|
|
mcol+= 4;
|
|
}
|
|
|
|
return mcolmain;
|
|
}
|
|
|
|
void mcol_to_rgba(unsigned int col, float *r, float *g, float *b, float *a)
|
|
{
|
|
char *cp;
|
|
|
|
cp = (char *)&col;
|
|
|
|
*r= cp[3];
|
|
*r /= 255.0;
|
|
|
|
*g= cp[2];
|
|
*g /= 255.0;
|
|
|
|
*b= cp[1];
|
|
*b /= 255.0;
|
|
|
|
*a= cp[0];
|
|
*a /= 255.0;
|
|
}
|
|
|
|
static void write_mesh_vrml(FILE *fp, Mesh *me)
|
|
{
|
|
Material *ma;
|
|
MVert *mvert;
|
|
MFace *mface;
|
|
MTFace *tface;
|
|
Image *ima;
|
|
int a, b, totcol, texind;
|
|
char str[32];
|
|
|
|
replace_chars(str, me->id.name+2);
|
|
|
|
fprintf(fp, "\tDEF %s\n", str);
|
|
fprintf(fp, "\tSeparator {\n");
|
|
|
|
if(me->mtface) {
|
|
ima= ((MTFace *)me->mtface)->tpage;
|
|
if(ima) {
|
|
fprintf(fp, "\t\tTexture2 {\n");
|
|
fprintf(fp, "\t\t\tfilename %s\n", ima->name);
|
|
fprintf(fp, "\t\t\twrapS REPEAT \n");
|
|
fprintf(fp, "\t\t\twrapT REPEAT \n");
|
|
fprintf(fp, "\t\t}\n");
|
|
}
|
|
}
|
|
|
|
if(me->mcol) {
|
|
unsigned int *mcol, *mcolmain;
|
|
float r, g, b, cola;
|
|
|
|
fprintf(fp, "\t\tMaterial {\n");
|
|
fprintf(fp, "\t\t\tdiffuseColor [\n");
|
|
|
|
a= me->totvert;
|
|
mcol= mcolmain= mcol_to_vcol(me);
|
|
if(mcol) {
|
|
while(a--) {
|
|
mcol_to_rgba(*mcol, &r, &g, &b, &cola);
|
|
fprintf(fp, "\t\t\t\t %f %f %f,\n", r, g, b);
|
|
mcol++;
|
|
}
|
|
MEM_freeN(mcolmain);
|
|
}
|
|
fprintf(fp, "\t\t\t]\n");
|
|
fprintf(fp, "\t\t}\n");
|
|
|
|
fprintf(fp, "\t\tMaterialBinding { value PER_VERTEX_INDEXED }\n");
|
|
}
|
|
|
|
|
|
fprintf(fp, "\t\tCoordinate3 {\n");
|
|
fprintf(fp, "\t\t\tpoint [\n");
|
|
|
|
a= me->totvert;
|
|
mvert= me->mvert;
|
|
while(a--) {
|
|
fprintf(fp, "\t\t\t\t %f %f %f,\n", mvert->co[0], mvert->co[1], mvert->co[2]);
|
|
mvert++;
|
|
}
|
|
fprintf(fp, "\t\t\t]\n");
|
|
fprintf(fp, "\t\t}\n");
|
|
|
|
|
|
totcol= me->totcol;
|
|
if(totcol==0) totcol= 1;
|
|
texind= 0; // index for uv coords
|
|
|
|
for(b=0; b<totcol; b++) {
|
|
|
|
if(me->mcol==0) {
|
|
if(me->mat) {
|
|
ma= me->mat[b];
|
|
if(ma) {
|
|
replace_chars(str, ma->id.name+2);
|
|
|
|
fprintf(fp, "\t\tUSE %s\n\n", str);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(me->mtface) {
|
|
fprintf(fp, "\t\tTextureCoordinate2 {\n");
|
|
fprintf(fp, "\t\t\tpoint [\n");
|
|
|
|
a= me->totface;
|
|
mface= me->mface;
|
|
tface= me->mtface;
|
|
while(a--) {
|
|
if(mface->mat_nr==b) {
|
|
fprintf(fp, "\t\t\t\t %f %f,\n", tface->uv[0][0], tface->uv[0][1]);
|
|
fprintf(fp, "\t\t\t\t %f %f,\n", tface->uv[1][0], tface->uv[1][1]);
|
|
fprintf(fp, "\t\t\t\t %f %f,\n", tface->uv[2][0], tface->uv[2][1]);
|
|
if(mface->v4) fprintf(fp, "\t\t\t\t %f %f,\n", tface->uv[3][0], tface->uv[3][1]);
|
|
}
|
|
mface++;
|
|
tface++;
|
|
}
|
|
fprintf(fp, "\t\t\t]\n");
|
|
fprintf(fp, "\t\t}\n");
|
|
}
|
|
|
|
fprintf(fp, "\t\tIndexedFaceSet {\n");
|
|
fprintf(fp, "\t\t\tcoordIndex [\n");
|
|
|
|
a= me->totface;
|
|
mface= me->mface;
|
|
while(a--) {
|
|
if(mface->mat_nr==b) {
|
|
if(mface->v4) fprintf(fp, "\t\t\t\t %d, %d, %d, %d, -1,\n", mface->v1, mface->v2, mface->v3, mface->v4);
|
|
else fprintf(fp, "\t\t\t\t %d, %d, %d, -1,\n", mface->v1, mface->v2, mface->v3);
|
|
}
|
|
mface++;
|
|
}
|
|
fprintf(fp, "\t\t\t]\n");
|
|
|
|
if(me->mtface) {
|
|
fprintf(fp, "\t\t\ttextureCoordIndex [\n");
|
|
|
|
a= me->totface;
|
|
mface= me->mface;
|
|
while(a--) {
|
|
if(mface->mat_nr==b) {
|
|
if(mface->v4) {
|
|
fprintf(fp, "\t\t\t\t %d, %d, %d, %d, -1,\n", texind, texind+1, texind+2, texind+3);
|
|
texind+= 4;
|
|
}
|
|
else {
|
|
fprintf(fp, "\t\t\t\t %d, %d, %d, -1,\n", texind, texind+1, texind+2);
|
|
texind+= 3;
|
|
}
|
|
}
|
|
mface++;
|
|
}
|
|
fprintf(fp, "\t\t\t]\n");
|
|
}
|
|
fprintf(fp, "\t\t}\n");
|
|
}
|
|
|
|
fprintf(fp, "\t}\n");
|
|
}
|
|
|
|
static void write_camera_vrml(FILE *fp, Object *ob)
|
|
{
|
|
Camera *cam;
|
|
|
|
if(ob==0) return;
|
|
Mat4Invert(ob->imat, ob->obmat);
|
|
|
|
fprintf(fp, "\tMatrixTransform {\n");
|
|
|
|
fprintf(fp, "\tmatrix \n");
|
|
|
|
fprintf(fp, "\t\t%f %f %f %f\n", ob->imat[0][0], ob->imat[0][1], ob->imat[0][2], ob->imat[0][3]);
|
|
fprintf(fp, "\t\t%f %f %f %f\n", ob->imat[1][0], ob->imat[1][1], ob->imat[1][2], ob->imat[1][3]);
|
|
fprintf(fp, "\t\t%f %f %f %f\n", ob->imat[2][0], ob->imat[2][1], ob->imat[2][2], ob->imat[2][3]);
|
|
fprintf(fp, "\t\t%f %f %f %f\n", ob->imat[3][0], ob->imat[3][1], ob->imat[3][2], ob->imat[3][3]);
|
|
|
|
fprintf(fp, "\t}\n");
|
|
|
|
cam= ob->data;
|
|
|
|
fprintf(fp, "\tPerspectiveCamera {\n");
|
|
fprintf(fp, "\t\tfocalDistance %f\n", cam->lens/10.0);
|
|
|
|
fprintf(fp, "\t}\n");
|
|
|
|
}
|
|
|
|
static void write_object_vrml(FILE *fp, Object *ob)
|
|
{
|
|
ID *id;
|
|
char str[32];
|
|
|
|
fprintf(fp, "\tSeparator {\n");
|
|
fprintf(fp, "\t\tMatrixTransform {\n");
|
|
|
|
fprintf(fp, "\t\tmatrix \n");
|
|
|
|
fprintf(fp, "\t\t\t%f %f %f %f\n", ob->obmat[0][0], ob->obmat[0][1], ob->obmat[0][2], ob->obmat[0][3]);
|
|
fprintf(fp, "\t\t\t%f %f %f %f\n", ob->obmat[1][0], ob->obmat[1][1], ob->obmat[1][2], ob->obmat[1][3]);
|
|
fprintf(fp, "\t\t\t%f %f %f %f\n", ob->obmat[2][0], ob->obmat[2][1], ob->obmat[2][2], ob->obmat[2][3]);
|
|
fprintf(fp, "\t\t\t%f %f %f %f\n", ob->obmat[3][0], ob->obmat[3][1], ob->obmat[3][2], ob->obmat[3][3]);
|
|
|
|
fprintf(fp, "\t\t}\n");
|
|
|
|
id= ob->data;
|
|
|
|
replace_chars(str, id->name+2);
|
|
|
|
fprintf(fp, "\t\tUSE %s\n", str);
|
|
fprintf(fp, "\t}\n");
|
|
}
|
|
|
|
|
|
void write_vrml(Scene *scene, char *str)
|
|
{
|
|
Mesh *me;
|
|
Material *ma;
|
|
Base *base;
|
|
FILE *fp;
|
|
|
|
if(BLI_testextensie(str,".blend")) str[ strlen(str)-6]= 0;
|
|
if(BLI_testextensie(str,".ble")) str[ strlen(str)-4]= 0;
|
|
if(BLI_testextensie(str,".wrl")==0) strcat(str, ".wrl");
|
|
//XXX saveover() if(!during_script() && saveover(str)==0) return;
|
|
|
|
fp= fopen(str, "w");
|
|
|
|
if(fp==NULL && !during_script()) {
|
|
//XXX error("Can't write file");
|
|
return;
|
|
}
|
|
strcpy(temp_dir, str);
|
|
|
|
//XXX waitcursor(1);
|
|
|
|
/* FIRST: write all the datablocks */
|
|
|
|
fprintf(fp, "#VRML V1.0 ascii\n\n# Blender V%d\n\n# 'Switch' is used as a hack, to ensure it is not part of the drawing\n\n", BLENDER_VERSION);
|
|
fprintf(fp, "Separator {\n");
|
|
fprintf(fp, "Switch {\n");
|
|
|
|
ma= G.main->mat.first;
|
|
while(ma) {
|
|
if(ma->id.us) {
|
|
write_material_vrml(fp, ma);
|
|
}
|
|
ma= ma->id.next;
|
|
}
|
|
|
|
/* only write meshes we're using in this scene */
|
|
flag_listbase_ids(&G.main->mesh, LIB_DOIT, 0);
|
|
|
|
for(base= scene->base.first; base; base= base->next)
|
|
if(base->object->type== OB_MESH)
|
|
((ID *)base->object->data)->flag |= LIB_DOIT;
|
|
|
|
me= G.main->mesh.first;
|
|
while(me) {
|
|
if(me->id.flag & LIB_DOIT) { /* is the mesh used in this scene ? */
|
|
write_mesh_vrml(fp, me);
|
|
}
|
|
me= me->id.next;
|
|
}
|
|
|
|
/* THEN:Hidden Objects */
|
|
fprintf(fp, "\n\t# Hidden Objects, in invisible layers\n\n");
|
|
base= scene->base.first;
|
|
while(base) {
|
|
if(base->object->type== OB_MESH) {
|
|
if( (base->lay & scene->lay)==0 ) {
|
|
write_object_vrml(fp, base->object);
|
|
}
|
|
}
|
|
base= base->next;
|
|
}
|
|
|
|
fprintf(fp, "}\n");
|
|
fprintf(fp, "\n# Visible Objects\n\n");
|
|
fprintf(fp, "Separator {\n");
|
|
|
|
/* The camera */
|
|
|
|
write_camera_vrml(fp, scene->camera);
|
|
|
|
/* THEN:The Objects */
|
|
|
|
base= scene->base.first;
|
|
while(base) {
|
|
if(base->object->type== OB_MESH) {
|
|
if(base->lay & scene->lay) {
|
|
write_object_vrml(fp, base->object);
|
|
}
|
|
}
|
|
base= base->next;
|
|
}
|
|
|
|
fprintf(fp, "}\n");
|
|
fprintf(fp, "}\n");
|
|
|
|
fclose(fp);
|
|
|
|
//XXX waitcursor(0);
|
|
}
|
|
|
|
|
|
/* ******************************* WRITE DXF ***************************** */
|
|
|
|
#define write_group(id,data) fprintf(fp, "%d\n%s\n", id, data)
|
|
|
|
/* A completely wacky function to try and make good
|
|
indexed (AutoCAD index) values out of straight rgb
|
|
ones... crazy */
|
|
|
|
static int rgb_to_dxf_col (float rf, float gf, float bf)
|
|
{
|
|
int r= (int) (rf*255.0f);
|
|
int g= (int) (gf*255.0f);
|
|
int b= (int) (bf*255.0f);
|
|
float h,s,v;
|
|
int ret;
|
|
|
|
/* Grayscale value */
|
|
if (((int)r/10)==((int)g/10) && ((int)g/10)==((int)b/10)) ret= 250+((int)r/51);
|
|
/* A nice chroma value */
|
|
else {
|
|
rgb_to_hsv (rf,gf,bf,&h,&s,&v);
|
|
|
|
ret= (int) (10.0f + (h*239.0f));
|
|
CLAMP(ret,10,249);
|
|
|
|
/* If its whitish make the index odd */
|
|
if (s<.5 || v>.5) if(ret%2) ret++;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* And its completely wacky complement */
|
|
|
|
static void dxf_col_to_rgb (int cid, float *rf, float *gf, float *bf)
|
|
{
|
|
float h, s, v;
|
|
|
|
/* Grayscale values */
|
|
if (cid>=250 && cid <= 255) {
|
|
*rf= *gf= *bf= (float) ((cid-250)*51)/255;
|
|
CLAMP(*rf, 0.0, 1.0);
|
|
CLAMP(*gf, 0.0, 1.0);
|
|
CLAMP(*bf, 0.0, 1.0);
|
|
|
|
/* Pure values */
|
|
} else if (cid<10) {
|
|
switch (cid) {
|
|
case 1:
|
|
*rf=1.0;
|
|
*gf=0.0;
|
|
*bf=0.0;
|
|
break;
|
|
case 2:
|
|
*rf=1.0;
|
|
*gf=1.0;
|
|
*bf=0.0;
|
|
break;
|
|
case 3:
|
|
*gf=1.0;
|
|
*rf=0.0;
|
|
*bf=0.0;
|
|
break;
|
|
case 4:
|
|
*rf=0.0;
|
|
*gf=1.0;
|
|
*bf=1.0;
|
|
break;
|
|
case 5:
|
|
*rf=0.0;
|
|
*gf=0.0;
|
|
*bf=1.0;
|
|
break;
|
|
case 6:
|
|
*rf=1.0;
|
|
*gf=0.0;
|
|
*bf=1.0;
|
|
break;
|
|
case 7:
|
|
default:
|
|
*rf= *gf= *bf= 1.0;
|
|
break;
|
|
}
|
|
} else {
|
|
/* Get chroma values */
|
|
|
|
h= (float) (cid-10)/239;
|
|
CLAMP(h, 0.0, 1.0);
|
|
|
|
/* If its odd make it a bit whitish */
|
|
if (cid%2) { s=.75; v= 0.25;
|
|
} else { s= 0.25; v= 0.75;}
|
|
|
|
hsv_to_rgb (h, s, v, rf, gf, bf);
|
|
}
|
|
}
|
|
|
|
static void write_mesh_dxf(FILE *fp, Mesh *me)
|
|
{
|
|
Material *ma;
|
|
MVert *mvert;
|
|
MFace *mface;
|
|
int a;
|
|
char str[32];
|
|
|
|
replace_chars(str, me->id.name+2);
|
|
|
|
write_group(0, "BLOCK");
|
|
|
|
write_group(2, str); /* The name */
|
|
|
|
write_group(8, "Meshes"); /* DXF Layer */
|
|
write_group(70, "64"); /* DXF block flags */
|
|
|
|
write_group(10, "0.0"); /* X of base */
|
|
write_group(20, "0.0"); /* Y of base */
|
|
write_group(30, "0.0"); /* Z of base */
|
|
|
|
write_group(3, str); /* The name (again) */
|
|
|
|
write_group(0, "POLYLINE"); /* Start the mesh */
|
|
write_group(66, "1"); /* Vertices follow flag */
|
|
write_group(8,"Meshes"); /* DXF Layer */
|
|
|
|
if (me->totcol) {
|
|
ma= me->mat[0];
|
|
if(ma) {
|
|
sprintf(str,"%d",rgb_to_dxf_col(ma->r,ma->g,ma->b));
|
|
write_group(62, str); /* Color index */
|
|
}
|
|
}
|
|
|
|
write_group(70, "64"); /* Polymesh mesh flag */
|
|
|
|
fprintf(fp, "71\n%d\n", me->totvert); /* Total vertices */
|
|
fprintf(fp, "72\n%d\n", me->totface); /* Total faces */
|
|
|
|
/* Write the vertices */
|
|
a= me->totvert;
|
|
mvert= me->mvert;
|
|
while(a--) {
|
|
write_group(0, "VERTEX"); /* Start a new vertex */
|
|
write_group(8, "Meshes"); /* DXF Layer */
|
|
fprintf (fp, "10\n%f\n", mvert->co[0]); /* X cord */
|
|
fprintf (fp, "20\n%f\n", mvert->co[1]); /* Y cord */
|
|
fprintf (fp, "30\n%f\n", mvert->co[2]); /* Z cord */
|
|
write_group(70, "192"); /* Polymesh vertex flag */
|
|
|
|
mvert++;
|
|
}
|
|
|
|
/* Write the face entries */
|
|
a= me->totface;
|
|
mface= me->mface;
|
|
while(a--) {
|
|
write_group(0, "VERTEX"); /* Start a new face */
|
|
write_group(8, "Meshes");
|
|
|
|
/* Write a face color */
|
|
if (me->totcol) {
|
|
ma= me->mat[(int)mface->mat_nr];
|
|
if(ma) {
|
|
sprintf(str,"%d",rgb_to_dxf_col(ma->r,ma->g,ma->b));
|
|
write_group(62, str); /* Color index */
|
|
}
|
|
}
|
|
else write_group(62, "254"); /* Color Index */
|
|
|
|
/* Not sure what this really corresponds too */
|
|
write_group(10, "0.0"); /* X of base */
|
|
write_group(20, "0.0"); /* Y of base */
|
|
write_group(30, "0.0"); /* Z of base */
|
|
|
|
write_group(70, "128"); /* Polymesh face flag */
|
|
|
|
if(mface->v4) {
|
|
fprintf (fp, "71\n%d\n", mface->v1+1);
|
|
fprintf (fp, "72\n%d\n", mface->v2+1);
|
|
fprintf (fp, "73\n%d\n", mface->v3+1);
|
|
fprintf (fp, "74\n%d\n", mface->v4+1);
|
|
} else {
|
|
fprintf (fp, "71\n%d\n", mface->v1+1);
|
|
fprintf (fp, "72\n%d\n", mface->v2+1);
|
|
fprintf (fp, "73\n%d\n", mface->v3+1);
|
|
}
|
|
mface++;
|
|
}
|
|
|
|
write_group(0, "SEQEND");
|
|
|
|
write_group(0, "ENDBLK");
|
|
}
|
|
|
|
static void write_object_dxf(FILE *fp, Object *ob, int layer)
|
|
{
|
|
ID *id;
|
|
char str[32];
|
|
|
|
id= ob->data;
|
|
|
|
write_group(0, "INSERT"); /* Start an insert group */
|
|
|
|
sprintf(str, "%d", layer);
|
|
write_group(8, str);
|
|
|
|
replace_chars(str, id->name+2);
|
|
write_group(2, str);
|
|
|
|
fprintf (fp, "10\n%f\n", ob->loc[0]); /* X of base */
|
|
fprintf (fp, "20\n%f\n", ob->loc[1]); /* Y of base */
|
|
fprintf (fp, "30\n%f\n", ob->loc[2]); /* Z of base */
|
|
|
|
fprintf (fp, "41\n%f\n", ob->size[0]); /* X scale */
|
|
fprintf (fp, "42\n%f\n", ob->size[1]); /* Y scale */
|
|
fprintf (fp, "43\n%f\n", ob->size[2]); /* Z scale */
|
|
|
|
fprintf (fp, "50\n%f\n", (float) ob->rot[2]*180/M_PI); /* Can only write the Z rot */
|
|
}
|
|
|
|
void write_dxf(struct Scene *scene, char *str)
|
|
{
|
|
Mesh *me;
|
|
Base *base;
|
|
FILE *fp;
|
|
|
|
if(BLI_testextensie(str,".blend")) str[ strlen(str)-6]= 0;
|
|
if(BLI_testextensie(str,".ble")) str[ strlen(str)-4]= 0;
|
|
if(BLI_testextensie(str,".dxf")==0) strcat(str, ".dxf");
|
|
|
|
if (!during_script()) {
|
|
if (BLI_exists(str))
|
|
; //XXX if(saveover(str)==0)
|
|
// return;
|
|
}
|
|
|
|
fp= fopen(str, "w");
|
|
|
|
if(fp==NULL && !during_script()) {
|
|
//XXX error("Can't write file");
|
|
return;
|
|
}
|
|
strcpy(temp_dir, str);
|
|
|
|
//XXX waitcursor(1);
|
|
|
|
/* The header part of the DXF */
|
|
|
|
write_group(0, "SECTION");
|
|
write_group(2, "HEADER");
|
|
write_group(0, "ENDSEC");
|
|
|
|
/* The blocks part of the DXF */
|
|
|
|
write_group(0, "SECTION");
|
|
write_group(2, "BLOCKS");
|
|
|
|
|
|
/* only write meshes we're using in this scene */
|
|
flag_listbase_ids(&G.main->mesh, LIB_DOIT, 0);
|
|
|
|
for(base= scene->base.first; base; base= base->next)
|
|
if(base->object->type== OB_MESH)
|
|
((ID *)base->object->data)->flag |= LIB_DOIT;
|
|
|
|
/* Write all the meshes */
|
|
me= G.main->mesh.first;
|
|
while(me) {
|
|
if(me->id.flag & LIB_DOIT) { /* is the mesh used in this scene ? */
|
|
write_mesh_dxf(fp, me);
|
|
}
|
|
me= me->id.next;
|
|
}
|
|
|
|
write_group(0, "ENDSEC");
|
|
|
|
/* The entities part of the DXF */
|
|
|
|
write_group(0, "SECTION");
|
|
write_group(2, "ENTITIES");
|
|
|
|
/* Write all the mesh objects */
|
|
base= scene->base.first;
|
|
while(base) {
|
|
if(base->object->type== OB_MESH) {
|
|
write_object_dxf(fp, base->object, base->lay);
|
|
}
|
|
base= base->next;
|
|
}
|
|
|
|
write_group(0, "ENDSEC");
|
|
|
|
/* Thats all */
|
|
|
|
write_group(0, "EOF");
|
|
fclose(fp);
|
|
|
|
//XXX waitcursor(0);
|
|
}
|
|
|
|
|
|
static int dxf_line= 0;
|
|
static FILE *dxf_fp= NULL;
|
|
|
|
/* exotic.c(2863) : note C6311: c:/Program Files/Microsoft Visual
|
|
* Studio/VC98/include\ctype.h(268) : see previous definition of
|
|
* 'iswspace' */
|
|
#define ton_iswspace(c) (c==' '||c=='\n'||c=='\t')
|
|
|
|
static void clean_wspace (char *str)
|
|
{
|
|
char *from, *to;
|
|
char t;
|
|
|
|
from= str;
|
|
to=str;
|
|
|
|
while (*from!=0) {
|
|
t= *from;
|
|
*to= t;
|
|
|
|
if(!ton_iswspace(*from)) to++;
|
|
from++;
|
|
}
|
|
*to=0;
|
|
}
|
|
|
|
static int all_wspace(char *str)
|
|
{
|
|
while(*str != 0) {
|
|
if (!ton_iswspace(*str)) return 0;
|
|
str++;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int all_digits(char *str)
|
|
{
|
|
while(*str != 0) {
|
|
if (!isdigit(*str)) return 0;
|
|
str++;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int dxf_get_layer_col(char *layer)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
static int dxf_get_layer_num(Scene *scene, char *layer)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (all_digits(layer) && atoi(layer)<(1<<20)) ret= atoi(layer);
|
|
if (ret == 0) ret = scene->lay;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void dos_clean(char *str)
|
|
{
|
|
while (*str) {
|
|
if (*str == 0x0d) {
|
|
*str='\n';
|
|
*(++str)= 0;
|
|
break;
|
|
}
|
|
str++;
|
|
}
|
|
}
|
|
|
|
static void myfgets(char *str, int len, FILE *fp)
|
|
{
|
|
char c;
|
|
|
|
while(len>0 && (c=getc(dxf_fp)) ) {
|
|
*str= c;
|
|
str++;
|
|
len--;
|
|
/* three types of enters, \n \r and \r\n */
|
|
if(c == '\n') break;
|
|
if(c=='\r') {
|
|
c= getc(dxf_fp); // read the linefeed from stream
|
|
if(c != 10) ungetc(c, dxf_fp); // put back, if it's not one...
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int read_groupf(char *str)
|
|
{
|
|
short c;
|
|
int ret=-1;
|
|
char tmp[256];
|
|
|
|
strcpy(str, " ");
|
|
|
|
while ((c=getc(dxf_fp)) && ton_iswspace(c));
|
|
ungetc(c, dxf_fp);
|
|
if (c==EOF) return -1;
|
|
|
|
myfgets(tmp, 255, dxf_fp);
|
|
|
|
dos_clean(tmp);
|
|
|
|
if(sscanf(tmp, "%d\n", &ret)!=1) return -2;
|
|
|
|
myfgets(tmp, 255, dxf_fp);
|
|
|
|
dos_clean(tmp);
|
|
|
|
if (!all_wspace(tmp)) {
|
|
if (sscanf(tmp, "%s\n", str)!=1) return -2;
|
|
}
|
|
|
|
clean_wspace(str);
|
|
dxf_line+=2;
|
|
|
|
return ret;
|
|
}
|
|
|
|
//XXX error() is now printf until we have a callback error
|
|
#define id_test(id) if(id<0) {char errmsg[128];fclose(dxf_fp); if(id==-1) sprintf(errmsg, "Error inputting dxf, near line %d", dxf_line); else if(id==-2) sprintf(errmsg, "Error reading dxf, near line %d", dxf_line);printf("%s", errmsg); return;}
|
|
|
|
#define read_group(id,str) {id= read_groupf(str); id_test(id);}
|
|
|
|
#define group_is(idtst,str) (id==idtst&&strcmp(val,str)==0)
|
|
#define group_isnt(idtst,str) (id!=idtst||strcmp(val,str)!=0)
|
|
#define id_check(idtst,str) if(group_isnt(idtst,str)) { fclose(dxf_fp); printf("Error parsing dxf, near line %d", dxf_line); return;}
|
|
|
|
static int id;
|
|
static char val[256];
|
|
|
|
static short error_exit=0;
|
|
static short hasbumped=0;
|
|
|
|
static int is_dxf(char *str)
|
|
{
|
|
dxf_line=0;
|
|
|
|
dxf_fp= fopen(str, "r");
|
|
if (dxf_fp==NULL) return 0;
|
|
|
|
id= read_groupf(val);
|
|
if ((id==0 && strcmp(val, "SECTION")==0)||id==999) return 1;
|
|
|
|
fclose(dxf_fp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* NOTES ON THE READER */
|
|
/*
|
|
--
|
|
It turns out that most DXF writers like (LOVE) to
|
|
write meshes as a long string of 3DFACE entities.
|
|
This means the natural way to read a DXF file
|
|
(every entity corresponds to an object) is completely
|
|
unusable, reading in 10,000 faces each as an
|
|
object just doesn't cut it. Thus the 3DFACE
|
|
entry reader holds state, and only finalizes to
|
|
an object when a) the layer name changes, b) the
|
|
entry type changes, c) we are done reading.
|
|
|
|
PS... I decided to do the same thing with LINES,
|
|
apparently the same thing happens sometimes as
|
|
well.
|
|
|
|
PPS... I decided to do the same thing with everything.
|
|
Now it is all really nasty and should be rewritten.
|
|
--
|
|
|
|
Added circular and elliptical arcs and lwpolylines.
|
|
These are all self-contained and have the size known
|
|
in advance, and so I haven't used the held state. -- martin
|
|
*/
|
|
|
|
static void dxf_add_mat (Object *ob, Mesh *me, float color[3], char *layer)
|
|
{
|
|
Material *ma;
|
|
|
|
if (!me) return;
|
|
|
|
if(ob) ob->mat= MEM_callocN(sizeof(void *)*1, "ob->mat");
|
|
if(ob) ob->actcol= 1;
|
|
|
|
me->totcol= 1;
|
|
me->mat= MEM_callocN(sizeof(void *)*1, "me->mat");
|
|
|
|
if (color[0]<0) {
|
|
if (strlen(layer)) dxf_col_to_rgb(dxf_get_layer_col(layer), &color[0], &color[1], &color[2]);
|
|
color[0]= color[1]= color[2]= 0.8f;
|
|
}
|
|
|
|
ma= G.main->mat.first;
|
|
while(ma) {
|
|
if(ma->mtex[0]==0) {
|
|
if(color[0]==ma->r && color[1]==ma->g && color[2]==ma->b) {
|
|
me->mat[0]= ma;
|
|
ma->id.us++;
|
|
break;
|
|
}
|
|
}
|
|
ma= ma->id.next;
|
|
}
|
|
if(ma==0) {
|
|
ma= add_material("ext");
|
|
me->mat[0]= ma;
|
|
ma->r= color[0];
|
|
ma->g= color[1];
|
|
ma->b= color[2];
|
|
automatname(ma);
|
|
}
|
|
}
|
|
|
|
/* General DXF vars */
|
|
static float cent[3]={0.0, 0.0, 0.0};
|
|
static char layname[32]="";
|
|
static char entname[32]="";
|
|
static float color[3]={-1.0, -1.0, -1.0};
|
|
static float *vcenter;
|
|
static float zerovec[3]= {0.0, 0.0, 0.0};
|
|
|
|
#define reset_vars cent[0]= cent[1]= cent[2]=0.0; strcpy(layname, ""); color[0]= color[1]= color[2]= -1.0
|
|
|
|
|
|
static void dxf_get_mesh(Scene *scene, Mesh** m, Object** o, int noob)
|
|
{
|
|
Mesh *me = NULL;
|
|
Object *ob;
|
|
|
|
if (!noob) {
|
|
*o = add_object(scene, OB_MESH);
|
|
ob = *o;
|
|
|
|
if (strlen(entname)) new_id(&G.main->object, (ID *)ob, entname);
|
|
else if (strlen(layname)) new_id(&G.main->object, (ID *)ob, layname);
|
|
|
|
if (strlen(layname)) ob->lay= dxf_get_layer_num(scene, layname);
|
|
else ob->lay= scene->lay;
|
|
// not nice i know... but add_object() sets active base, which needs layer setting too (ton)
|
|
scene->basact->lay= ob->lay;
|
|
|
|
*m = ob->data;
|
|
me= *m;
|
|
|
|
vcenter= ob->loc;
|
|
}
|
|
else {
|
|
*o = NULL;
|
|
*m = add_mesh("Mesh");
|
|
|
|
me = *m;
|
|
ob = *o;
|
|
|
|
((ID *)me)->us=0;
|
|
|
|
if (strlen(entname)) new_id(&G.main->mesh, (ID *)me, entname);
|
|
else if (strlen(layname)) new_id(&G.main->mesh, (ID *)me, layname);
|
|
|
|
vcenter = zerovec;
|
|
}
|
|
me->totvert=0;
|
|
me->totface=0;
|
|
me->mvert= CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, 0);
|
|
me->mface= CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC, NULL, 0);
|
|
}
|
|
|
|
static void dxf_read_point(Scene *scene, int noob) {
|
|
/* Blender vars */
|
|
Object *ob;
|
|
Mesh *me;
|
|
MVert *mvert;
|
|
|
|
reset_vars;
|
|
|
|
read_group(id, val);
|
|
while(id!=0) {
|
|
if (id==8) {
|
|
BLI_strncpy(layname, val, sizeof(layname));
|
|
} else if (id==10) {
|
|
cent[0]= (float) atof(val);
|
|
} else if (id==20) {
|
|
cent[1]= (float) atof(val);
|
|
} else if (id==30) {
|
|
cent[2]= (float) atof(val);
|
|
} else if (id==60) {
|
|
/* short invisible= atoi(val); */
|
|
} else if (id==62) {
|
|
int colorid= atoi(val);
|
|
|
|
CLAMP(colorid, 1, 255);
|
|
dxf_col_to_rgb(colorid, &color[0], &color[1], &color[2]);
|
|
}
|
|
read_group(id, val);
|
|
}
|
|
|
|
dxf_get_mesh(scene, &me, &ob, noob);
|
|
me->totvert= 1;
|
|
me->mvert= MEM_callocN(me->totvert*sizeof(MVert), "mverts");
|
|
CustomData_set_layer(&me->vdata, CD_MVERT, me->mvert);
|
|
|
|
dxf_add_mat (ob, me, color, layname);
|
|
|
|
mvert= me->mvert;
|
|
mvert->co[0]= mvert->co[1]= mvert->co[2]= 0;
|
|
|
|
if (ob) VECCOPY(ob->loc, cent);
|
|
|
|
hasbumped=1;
|
|
}
|
|
|
|
/* Line state vars */
|
|
static Object *linehold=NULL;
|
|
static Mesh *linemhold=NULL;
|
|
|
|
static char oldllay[32];
|
|
static short lwasline=0; /* last was face 3d? */
|
|
|
|
static void dxf_close_line(void)
|
|
{
|
|
linemhold=NULL;
|
|
if (linehold==NULL) return;
|
|
|
|
linehold=NULL;
|
|
}
|
|
|
|
static void dxf_read_line(Scene *scene, int noob) {
|
|
/* Entity specific vars */
|
|
float epoint[3]={0.0, 0.0, 0.0};
|
|
short vspace=0; /* Whether or not coords are relative */
|
|
|
|
/* Blender vars */
|
|
Object *ob;
|
|
Mesh *me;
|
|
MVert *mvert, *vtmp;
|
|
MFace *mface, *ftmp;
|
|
|
|
reset_vars;
|
|
|
|
read_group(id, val);
|
|
while(id!=0) {
|
|
if (id==8) {
|
|
BLI_strncpy(layname, val, sizeof(layname));
|
|
} else if (id==10) {
|
|
cent[0]= (float) atof(val);
|
|
} else if (id==20) {
|
|
cent[1]= (float) atof(val);
|
|
} else if (id==30) {
|
|
cent[2]= (float) atof(val);
|
|
} else if (id==11) {
|
|
epoint[0]= (float) atof(val);
|
|
} else if (id==21) {
|
|
epoint[1]= (float) atof(val);
|
|
} else if (id==31) {
|
|
epoint[2]= (float) atof(val);
|
|
} else if (id==60) {
|
|
/* short invisible= atoi(val); */
|
|
} else if (id==62) {
|
|
int colorid= atoi(val);
|
|
|
|
CLAMP(colorid, 1, 255);
|
|
dxf_col_to_rgb(colorid, &color[0], &color[1], &color[2]);
|
|
} else if (id==67) {
|
|
vspace= atoi(val);
|
|
}
|
|
read_group(id, val);
|
|
}
|
|
|
|
/* Check to see if we need to make a new object */
|
|
|
|
if(!lwasline || strcmp(layname, oldllay)!=0)
|
|
dxf_close_line();
|
|
if(linemhold != NULL && linemhold->totvert>MESH_MAX_VERTS)
|
|
dxf_close_line();
|
|
|
|
if (linemhold==NULL) {
|
|
dxf_get_mesh(scene, &me, &ob, noob);
|
|
|
|
if(ob) VECCOPY(ob->loc, cent);
|
|
|
|
dxf_add_mat (ob, me, color, layname);
|
|
|
|
linehold= ob;
|
|
linemhold= me;
|
|
} else {
|
|
ob= linehold;
|
|
me= linemhold;
|
|
}
|
|
|
|
me->totvert+= 2;
|
|
me->totface++;
|
|
|
|
vtmp= MEM_callocN(me->totvert*sizeof(MVert), "mverts");
|
|
ftmp= MEM_callocN(me->totface*sizeof(MFace), "mface");
|
|
|
|
if(me->mvert) {
|
|
memcpy(vtmp, me->mvert, (me->totvert-2)*sizeof(MVert));
|
|
MEM_freeN(me->mvert);
|
|
}
|
|
me->mvert= CustomData_set_layer(&me->vdata, CD_MVERT, vtmp);
|
|
vtmp=NULL;
|
|
|
|
if(me->mface) {
|
|
memcpy(ftmp, me->mface, (me->totface-1)*sizeof(MFace));
|
|
MEM_freeN(me->mface);
|
|
}
|
|
me->mface= CustomData_set_layer(&me->fdata, CD_MFACE, ftmp);
|
|
ftmp=NULL;
|
|
|
|
mvert= &me->mvert[(me->totvert-2)];
|
|
|
|
VecSubf(mvert->co, cent, vcenter);
|
|
mvert++;
|
|
if (vspace) { VECCOPY(mvert->co, epoint);
|
|
} else VecSubf(mvert->co, epoint, vcenter);
|
|
|
|
mface= &(((MFace*)me->mface)[me->totface-1]);
|
|
mface->v1= me->totvert-2;
|
|
mface->v2= me->totvert-1;
|
|
mface->mat_nr= 0;
|
|
|
|
hasbumped=1;
|
|
}
|
|
|
|
/* 2D Polyline state vars */
|
|
static Object *p2dhold=NULL;
|
|
static Mesh *p2dmhold=NULL;
|
|
static char oldplay[32];
|
|
static short lwasp2d=0;
|
|
|
|
static void dxf_close_2dpoly(void)
|
|
{
|
|
p2dmhold= NULL;
|
|
if (p2dhold==NULL) return;
|
|
|
|
p2dhold=NULL;
|
|
}
|
|
|
|
static void dxf_read_ellipse(Scene *scene, int noob)
|
|
{
|
|
|
|
/*
|
|
* The Parameter option of the ELLIPSE command uses the following equation to define an elliptical arc.
|
|
*
|
|
* p(u)=c+a*cos(u)+b*sin(u)
|
|
*
|
|
* The variables a, b, c are determined when you select the endpoints for the
|
|
* first axis and the distance for the second axis. a is the negative of 1/2
|
|
* of the major axis length, b is the negative of 1/2 the minor axis length,
|
|
* and c is the center point (2-D) of the ellipse.
|
|
*
|
|
* Because this is actually a vector equation and the variable c is actually
|
|
* a point with X and Y values, it really should be written as:
|
|
*
|
|
* p(u)=(Cx+a*cos(u))*i+(Cy+b*sin(u))*j
|
|
*
|
|
* where
|
|
*
|
|
* Cx is the X value of the point c
|
|
* Cy is the Y value of the point c
|
|
* a is -(1/2 of the major axis length)
|
|
* b is -(1/2 of the minor axis length)
|
|
* i and j represent unit vectors in the X and Y directions
|
|
*
|
|
* http://astronomy.swin.edu.au/~pbourke/geomformats/dxf2000/ellipse_command39s_parameter_option_dxf_06.htm
|
|
* (reproduced with permission)
|
|
*
|
|
* NOTE: The start and end angles ('parameters') are in radians, whereas those for the circular arc are
|
|
* in degrees. The 'sense' of u appears to be determined by the extrusion direction (see more detailed comment
|
|
* in the code)
|
|
*
|
|
* TODO: The code is specific to ellipses in the x-y plane right now.
|
|
*
|
|
*/
|
|
|
|
/* Entity specific vars */
|
|
float epoint[3]={0.0, 0.0, 0.0};
|
|
float center[3]={0.0, 0.0, 0.0};
|
|
float extrusion[3]={0.0, 0.0, 1.0};
|
|
float axis_endpoint[3] = {0.0, 0.0, 0.0}; /* major axis endpoint */
|
|
short vspace=0; /* Whether or not coords are relative */
|
|
float a, b, x, y, z;
|
|
float phid = 0.0f, phi = 0.0f, theta = 0.0f;
|
|
float start_angle = 0.0f;
|
|
float end_angle = 2*M_PI;
|
|
float axis_ratio = 1.0f;
|
|
float temp;
|
|
int v, tot;
|
|
int isArc=0;
|
|
/* Blender vars */
|
|
Object *ob;
|
|
Mesh *me;
|
|
MVert *mvert;
|
|
MFace *mface;
|
|
|
|
reset_vars;
|
|
read_group(id, val);
|
|
while(id!=0) {
|
|
if (id==8) {
|
|
BLI_strncpy(layname, val, sizeof(layname));
|
|
} else if (id==10) {
|
|
center[0]= (float) atof(val);
|
|
} else if (id==20) {
|
|
center[1]= (float) atof(val);
|
|
} else if (id==30) {
|
|
center[2]= (float) atof(val);
|
|
} else if (id==11) {
|
|
axis_endpoint[0]= (float) atof(val);
|
|
} else if (id==21) {
|
|
axis_endpoint[1]= (float) atof(val);
|
|
} else if (id==31) {
|
|
axis_endpoint[2]= (float) atof(val);
|
|
} else if (id==40) {
|
|
axis_ratio = (float) atof(val);
|
|
} else if (id==41) {
|
|
printf("dxf: start = %f", atof(val) * 180/M_PI);
|
|
start_angle = -atof(val) + M_PI_2;
|
|
} else if (id==42) {
|
|
printf("dxf: end = %f", atof(val) * 180/M_PI);
|
|
end_angle = -atof(val) + M_PI_2;
|
|
} else if (id==62) {
|
|
int colorid= atoi(val);
|
|
CLAMP(colorid, 1, 255);
|
|
dxf_col_to_rgb(colorid, &color[0], &color[1], &color[2]);
|
|
} else if (id==67) {
|
|
vspace= atoi(val);
|
|
} else if (id==100) {
|
|
isArc = 1;
|
|
} else if (id==210) {
|
|
extrusion[0] = atof(val);
|
|
} else if (id==220) {
|
|
extrusion[1] = atof(val);
|
|
} else if (id==230) {
|
|
extrusion[2] = atof(val);
|
|
}
|
|
read_group(id, val);
|
|
}
|
|
|
|
if(!lwasline || strcmp(layname, oldllay)!=0) dxf_close_line();
|
|
if(linemhold != NULL && linemhold->totvert>MESH_MAX_VERTS)
|
|
dxf_close_line();
|
|
|
|
/* The 'extrusion direction' seems akin to a face normal,
|
|
* insofar as it determines the direction of increasing phi.
|
|
* This is again x-y plane specific; it should be fixed at
|
|
* some point. */
|
|
|
|
if (extrusion[2] < 0) {
|
|
temp = start_angle;
|
|
start_angle = M_PI - end_angle;
|
|
end_angle = M_PI - temp;
|
|
}
|
|
|
|
if(end_angle > start_angle)
|
|
end_angle -= 2 * M_PI;
|
|
|
|
phi = start_angle;
|
|
|
|
x = axis_endpoint[0];
|
|
y = axis_endpoint[1];
|
|
z = axis_endpoint[2];
|
|
a = sqrt(x*x + y*y + z*z);
|
|
b = a * axis_ratio;
|
|
|
|
theta = atan2(y, x);
|
|
|
|
x = a * sin(phi);
|
|
y = b * cos(phi);
|
|
|
|
#ifndef DEBUG_CENTER
|
|
epoint[0] = center[0] + x*cos(theta) - y*sin(theta);
|
|
epoint[1] = center[1] + x*sin(theta) + y*cos(theta);
|
|
epoint[2] = center[2];
|
|
|
|
|
|
cent[0]= epoint[0];
|
|
cent[1]= epoint[1];
|
|
cent[2]= epoint[2];
|
|
#else
|
|
cent[0]= center[0];
|
|
cent[1]= center[1];
|
|
cent[2]= center[2];
|
|
#endif
|
|
|
|
dxf_get_mesh(scene, &me, &ob, noob);
|
|
strcpy(oldllay, layname);
|
|
if(ob) VECCOPY(ob->loc, cent);
|
|
dxf_add_mat (ob, me, color, layname);
|
|
|
|
tot = 32; /* # of line segments to divide the arc into */
|
|
|
|
phid = (end_angle - start_angle)/tot;
|
|
|
|
me->totvert += tot+1;
|
|
me->totface += tot+1;
|
|
|
|
me->mvert = (MVert*) MEM_callocN(me->totvert*sizeof(MVert), "mverts");
|
|
me->mface = (MFace*) MEM_callocN(me->totface*sizeof(MVert), "mface");
|
|
|
|
CustomData_set_layer(&me->vdata, CD_MVERT, me->mvert);
|
|
CustomData_set_layer(&me->fdata, CD_MFACE, me->mface);
|
|
|
|
printf("vertex and face buffers allocated\n");
|
|
|
|
for(v = 0; v <= tot; v++) {
|
|
|
|
x = a * sin(phi);
|
|
y = b * cos(phi);
|
|
epoint[0] = center[0] + x*cos(theta) - y*sin(theta);
|
|
epoint[1] = center[1] + x*sin(theta) + y*cos(theta);
|
|
epoint[2] = center[2];
|
|
|
|
mvert= &me->mvert[v];
|
|
|
|
if (vspace) {
|
|
VECCOPY(mvert->co, epoint);
|
|
} else {
|
|
VecSubf(mvert->co, epoint, vcenter);
|
|
}
|
|
|
|
if (v > 0) {
|
|
mface= &(((MFace*)me->mface)[v-1]);
|
|
mface->v1 = v-1;
|
|
mface->v2 = v;
|
|
mface->mat_nr = 0;
|
|
}
|
|
|
|
hasbumped = 1;
|
|
|
|
VECCOPY(cent, epoint);
|
|
phi+=phid;
|
|
}
|
|
}
|
|
|
|
static void dxf_read_arc(Scene *scene, int noob)
|
|
{
|
|
/* Entity specific vars */
|
|
float epoint[3]={0.0, 0.0, 0.0};
|
|
float center[3]={0.0, 0.0, 0.0};
|
|
float extrusion[3]={0.0, 0.0, 1.0};
|
|
short vspace=0; /* Whether or not coords are relative */
|
|
float dia = 0.0f;
|
|
float phid = 0.0f, phi = 0.0f;
|
|
float start_angle = 0.0f;
|
|
float end_angle = 2*M_PI;
|
|
float temp;
|
|
int v, tot = 32;
|
|
int isArc=0;
|
|
/* Blender vars */
|
|
Object *ob;
|
|
Mesh *me;
|
|
MVert *mvert;
|
|
MFace *mface;
|
|
|
|
reset_vars;
|
|
read_group(id, val);
|
|
while(id!=0) {
|
|
if (id==8) {
|
|
BLI_strncpy(layname, val, sizeof(layname));
|
|
} else if (id==10) {
|
|
center[0]= (float) atof(val);
|
|
} else if (id==20) {
|
|
center[1]= (float) atof(val);
|
|
} else if (id==30) {
|
|
center[2]= (float) atof(val);
|
|
} else if (id==40) {
|
|
dia = (float) atof(val);
|
|
} else if (id==62) {
|
|
int colorid= atoi(val);
|
|
|
|
CLAMP(colorid, 1, 255);
|
|
dxf_col_to_rgb(colorid, &color[0], &color[1], &color[2]);
|
|
} else if (id==67) {
|
|
vspace= atoi(val);
|
|
} else if (id==100) {
|
|
isArc = 1;
|
|
} else if (id==50) {
|
|
start_angle = (90 - atoi(val)) * M_PI/180.0;
|
|
} else if (id==51) {
|
|
end_angle = (90 - atoi(val)) * M_PI/180.0;
|
|
} else if (id==210) {
|
|
extrusion[0] = atof(val);
|
|
} else if (id==220) {
|
|
extrusion[1] = atof(val);
|
|
} else if (id==230) {
|
|
extrusion[2] = atof(val);
|
|
}
|
|
read_group(id, val);
|
|
}
|
|
|
|
if(!lwasline || strcmp(layname, oldllay)!=0) dxf_close_line();
|
|
if(linemhold != NULL && linemhold->totvert>MESH_MAX_VERTS)
|
|
dxf_close_line();
|
|
|
|
/* Same xy-plane-specific extrusion direction code as in read_ellipse
|
|
* (read_arc and read_ellipse should ideally be rewritten to share code)
|
|
*/
|
|
|
|
if (extrusion[2] < 0) {
|
|
temp = start_angle;
|
|
start_angle = M_PI - end_angle;
|
|
end_angle = M_PI - temp;
|
|
}
|
|
|
|
phi = start_angle;
|
|
if(end_angle > start_angle)
|
|
end_angle -= 2 * M_PI;
|
|
|
|
cent[0]= center[0]+dia*sin(phi);
|
|
cent[1]= center[1]+dia*cos(phi);
|
|
cent[2]= center[2];
|
|
|
|
dxf_get_mesh(scene, &me, &ob, noob);
|
|
strcpy(oldllay, layname);
|
|
if(ob) VECCOPY(ob->loc, cent);
|
|
dxf_add_mat (ob, me, color, layname);
|
|
|
|
tot = 32; /* # of line segments to divide the arc into */
|
|
phid = (end_angle - start_angle)/tot; /* fix so that arcs have the same 'resolution' as circles? */
|
|
|
|
me->totvert += tot+1;
|
|
me->totface += tot+1;
|
|
|
|
me->mvert = (MVert*) MEM_callocN(me->totvert*sizeof(MVert), "mverts");
|
|
me->mface = (MFace*) MEM_callocN(me->totface*sizeof(MVert), "mface");
|
|
|
|
CustomData_set_layer(&me->vdata, CD_MVERT, me->mvert);
|
|
CustomData_set_layer(&me->fdata, CD_MFACE, me->mface);
|
|
|
|
for(v = 0; v <= tot; v++) {
|
|
|
|
epoint[0]= center[0]+dia*sin(phi);
|
|
epoint[1]= center[1]+dia*cos(phi);
|
|
epoint[2]= center[2];
|
|
|
|
mvert= &me->mvert[v];
|
|
|
|
if (vspace) {
|
|
VECCOPY(mvert->co, epoint);
|
|
} else {
|
|
VecSubf(mvert->co, epoint, vcenter);
|
|
}
|
|
|
|
if (v > 0) {
|
|
mface= &(((MFace*)me->mface)[v-1]);
|
|
mface->v1 = v-1;
|
|
mface->v2 = v;
|
|
mface->mat_nr = 0;
|
|
}
|
|
|
|
hasbumped=1;
|
|
|
|
VECCOPY(cent, epoint);
|
|
phi+=phid;
|
|
}
|
|
}
|
|
|
|
static void dxf_read_polyline(Scene *scene, int noob) {
|
|
/* Entity specific vars */
|
|
short vspace=0; /* Whether or not coords are relative */
|
|
int flag=0;
|
|
int vflags=0;
|
|
int vids[4];
|
|
int nverts;
|
|
|
|
/* Blender vars */
|
|
Object *ob;
|
|
Mesh *me;
|
|
float vert[3];
|
|
|
|
MVert *mvert, *vtmp;
|
|
MFace *mface, *ftmp;
|
|
|
|
reset_vars;
|
|
|
|
read_group(id, val);
|
|
while(id!=0) {
|
|
if (id==8) {
|
|
BLI_strncpy(layname, val, sizeof(layname));
|
|
} else if (id==10) {
|
|
cent[0]= (float) atof(val);
|
|
} else if (id==20) {
|
|
cent[1]= (float) atof(val);
|
|
} else if (id==30) {
|
|
cent[2]= (float) atof(val);
|
|
} else if (id==60) {
|
|
/* short invisible= atoi(val); */
|
|
} else if (id==62) {
|
|
int colorid= atoi(val);
|
|
|
|
CLAMP(colorid, 1, 255);
|
|
dxf_col_to_rgb(colorid, &color[0], &color[1], &color[2]);
|
|
} else if (id==67) {
|
|
vspace= atoi(val);
|
|
} else if (id==70) {
|
|
flag= atoi(val);
|
|
}
|
|
read_group(id, val);
|
|
}
|
|
|
|
if (flag & 9) { // 1= closed curve, 8= 3d curve
|
|
if(!lwasp2d || strcmp(layname, oldplay)!=0) dxf_close_2dpoly();
|
|
if(p2dmhold != NULL && p2dmhold->totvert>MESH_MAX_VERTS)
|
|
dxf_close_2dpoly();
|
|
|
|
if (p2dmhold==NULL) {
|
|
dxf_get_mesh(scene, &me, &ob, noob);
|
|
|
|
strcpy(oldplay, layname);
|
|
|
|
if(ob) VECCOPY(ob->loc, cent);
|
|
|
|
dxf_add_mat (ob, me, color, layname);
|
|
|
|
p2dhold= ob;
|
|
p2dmhold= me;
|
|
}
|
|
else {
|
|
ob= p2dhold;
|
|
me= p2dmhold;
|
|
}
|
|
|
|
nverts=0;
|
|
while (group_is(0, "VERTEX")) {
|
|
read_group(id, val);
|
|
while(id!=0) {
|
|
if (id==10) {
|
|
vert[0]= (float) atof(val);
|
|
} else if (id==20) {
|
|
vert[1]= (float) atof(val);
|
|
} else if (id==30) {
|
|
vert[2]= (float) atof(val);
|
|
}
|
|
read_group(id, val);
|
|
}
|
|
nverts++;
|
|
me->totvert++;
|
|
|
|
vtmp= MEM_callocN(me->totvert*sizeof(MVert), "mverts");
|
|
|
|
if (me->mvert) {
|
|
memcpy (vtmp, me->mvert, (me->totvert-1)*sizeof(MVert));
|
|
MEM_freeN(me->mvert);
|
|
}
|
|
me->mvert= CustomData_set_layer(&me->vdata, CD_MVERT, vtmp);
|
|
vtmp= NULL;
|
|
|
|
mvert= &me->mvert[me->totvert-1];
|
|
|
|
if (vspace) { VECCOPY(mvert->co, vert);
|
|
} else VecSubf(mvert->co, vert, vcenter);
|
|
}
|
|
|
|
/* make edges */
|
|
if(nverts>1) {
|
|
int a, oldtotface;
|
|
|
|
oldtotface= me->totface;
|
|
me->totface+= nverts-1;
|
|
|
|
ftmp= MEM_callocN(me->totface*sizeof(MFace), "mface");
|
|
|
|
if(me->mface) {
|
|
memcpy(ftmp, me->mface, oldtotface*sizeof(MFace));
|
|
MEM_freeN(me->mface);
|
|
}
|
|
me->mface= CustomData_set_layer(&me->fdata, CD_MFACE, ftmp);
|
|
ftmp=NULL;
|
|
|
|
mface= me->mface;
|
|
mface+= oldtotface;
|
|
|
|
for(a=1; a<nverts; a++, mface++) {
|
|
mface->v1= (me->totvert-nverts)+a-1;
|
|
mface->v2= (me->totvert-nverts)+a;
|
|
mface->mat_nr= 0;
|
|
}
|
|
}
|
|
|
|
lwasp2d=1;
|
|
}
|
|
else if (flag&64) {
|
|
dxf_get_mesh(scene, &me, &ob, noob);
|
|
|
|
if(ob) VECCOPY(ob->loc, cent);
|
|
|
|
dxf_add_mat (ob, me, color, layname);
|
|
|
|
while (group_is(0, "VERTEX")) {
|
|
vflags= 0;
|
|
vids[0]= vids[1]= vids[2]= vids[3]= 0;
|
|
|
|
vflags=0;
|
|
read_group(id, val);
|
|
while(id!=0) {
|
|
if(id==8) {
|
|
; /* Layer def, skip */
|
|
} else if (id==10) {
|
|
vert[0]= (float) atof(val);
|
|
} else if (id==20) {
|
|
vert[1]= (float) atof(val);
|
|
} else if (id==30) {
|
|
vert[2]= (float) atof(val);
|
|
} else if (id==70) {
|
|
vflags= atoi(val);
|
|
} else if (id==71) {
|
|
vids[0]= abs(atoi(val));
|
|
} else if (id==72) {
|
|
vids[1]= abs(atoi(val));
|
|
} else if (id==73) {
|
|
vids[2]= abs(atoi(val));
|
|
} else if (id==74) {
|
|
vids[3]= abs(atoi(val));
|
|
}
|
|
read_group(id, val);
|
|
}
|
|
|
|
if (vflags & 128 && vflags & 64) {
|
|
me->totvert++;
|
|
|
|
/* If we are nearing the limit scan to the next entry */
|
|
if(me->totvert > MESH_MAX_VERTS)
|
|
while(group_isnt(0, "SEQEND")) read_group(id, val);
|
|
|
|
vtmp= MEM_callocN(me->totvert*sizeof(MVert), "mverts");
|
|
|
|
if(me->mvert) {
|
|
memcpy(vtmp, me->mvert, (me->totvert-1)*sizeof(MVert));
|
|
MEM_freeN(me->mvert);
|
|
}
|
|
me->mvert= CustomData_set_layer(&me->vdata, CD_MVERT, vtmp);
|
|
vtmp=NULL;
|
|
|
|
mvert= &me->mvert[(me->totvert-1)];
|
|
|
|
if (vspace) { VECCOPY(mvert->co, vert);
|
|
} else VecSubf(mvert->co, vert, vcenter);
|
|
|
|
} else if (vflags & 128) {
|
|
if(vids[2]==0) {
|
|
//XXX error("(PL) Error parsing dxf, not enough vertices near line %d", dxf_line);
|
|
|
|
error_exit=1;
|
|
fclose(dxf_fp);
|
|
return;
|
|
}
|
|
|
|
me->totface++;
|
|
|
|
ftmp= MEM_callocN(me->totface*sizeof(MFace), "mfaces");
|
|
|
|
if(me->mface) {
|
|
memcpy(ftmp, me->mface, (me->totface-1)*sizeof(MFace));
|
|
MEM_freeN(me->mface);
|
|
}
|
|
me->mface= CustomData_set_layer(&me->fdata, CD_MFACE, ftmp);
|
|
ftmp=NULL;
|
|
|
|
mface= &(((MFace*)me->mface)[me->totface-1]);
|
|
mface->v1= vids[0]-1;
|
|
mface->v2= vids[1]-1;
|
|
mface->v3= vids[2]-1;
|
|
|
|
if(vids[3] && vids[3]!=vids[0]) {
|
|
mface->v4= vids[3]-1;
|
|
test_index_face(mface, NULL, 0, 4);
|
|
}
|
|
else test_index_face(mface, NULL, 0, 3);
|
|
|
|
mface->mat_nr= 0;
|
|
|
|
} else {
|
|
//XXX error("Error parsing dxf, unknown polyline information near %d", dxf_line);
|
|
|
|
error_exit=1;
|
|
fclose(dxf_fp);
|
|
return;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
static void dxf_read_lwpolyline(Scene *scene, int noob) {
|
|
/* Entity specific vars */
|
|
short vspace=0; /* Whether or not coords are relative */
|
|
int flag=0;
|
|
int nverts=0;
|
|
int v;
|
|
|
|
/* Blender vars */
|
|
Object *ob;
|
|
Mesh *me;
|
|
float vert[3];
|
|
|
|
MVert *mvert;
|
|
MFace *mface;
|
|
|
|
reset_vars;
|
|
|
|
id = -1;
|
|
|
|
/* block structure is
|
|
* {...}
|
|
* 90 => nverts
|
|
* 70 => flags
|
|
* nverts.times { 10 => x, 20 => y }
|
|
*/
|
|
while(id!=70) {
|
|
read_group(id, val);
|
|
if (id==8) {
|
|
BLI_strncpy(layname, val, sizeof(layname));
|
|
} else if (id==38) {
|
|
vert[2]= (float) atof(val);
|
|
} else if (id==60) {
|
|
/* short invisible= atoi(val); */
|
|
} else if (id==62) {
|
|
int colorid= atoi(val);
|
|
|
|
CLAMP(colorid, 1, 255);
|
|
dxf_col_to_rgb(colorid, &color[0], &color[1], &color[2]);
|
|
} else if (id==67) {
|
|
vspace= atoi(val);
|
|
} else if (id==70) {
|
|
flag= atoi(val);
|
|
} else if (id==90) {
|
|
nverts= atoi(val);
|
|
}
|
|
}
|
|
printf("nverts %d\n", nverts);
|
|
if (nverts == 0)
|
|
return;
|
|
|
|
dxf_get_mesh(scene, &me, &ob, noob);
|
|
strcpy(oldllay, layname);
|
|
if(ob) VECCOPY(ob->loc, cent);
|
|
dxf_add_mat (ob, me, color, layname);
|
|
|
|
me->totvert += nverts;
|
|
me->totface += nverts;
|
|
|
|
me->mvert = (MVert*) MEM_callocN(me->totvert*sizeof(MVert), "mverts");
|
|
me->mface = (MFace*) MEM_callocN(me->totface*sizeof(MVert), "mface");
|
|
|
|
CustomData_set_layer(&me->vdata, CD_MVERT, me->mvert);
|
|
CustomData_set_layer(&me->fdata, CD_MFACE, me->mface);
|
|
|
|
for (v = 0; v < nverts; v++) {
|
|
read_group(id,val);
|
|
if (id == 10) {
|
|
vert[0]= (float) atof(val);
|
|
} else {
|
|
//XXX error("Error parsing dxf, expected (10, <x>) at line %d", dxf_line);
|
|
}
|
|
|
|
read_group(id,val);
|
|
if (id == 20) {
|
|
vert[1]= (float) atof(val);
|
|
} else {
|
|
//XXX error("Error parsing dxf, expected (20, <y>) at line %d", dxf_line);
|
|
}
|
|
|
|
mvert = &me->mvert[v];
|
|
|
|
if (vspace) {
|
|
VECCOPY(mvert->co, vert);
|
|
} else {
|
|
VecSubf(mvert->co, vert, vcenter);
|
|
}
|
|
|
|
if (v > 0) {
|
|
mface= &(((MFace*)me->mface)[v-1]);
|
|
mface->v1 = v-1;
|
|
mface->v2 = v;
|
|
mface->mat_nr = 0;
|
|
}
|
|
}
|
|
|
|
/* flag & 1 -> closed polyline
|
|
* TODO: give the polyline actual 2D faces if it is closed */
|
|
|
|
if (flag&1) {
|
|
if(me->mface) {
|
|
mface= &(((MFace*)me->mface)[nverts - 1]);
|
|
mface->v1 = nverts-1;
|
|
mface->v2 = 0;
|
|
mface->mat_nr = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* 3D Face state vars */
|
|
static Object *f3dhold=NULL;
|
|
static Mesh *f3dmhold=NULL;
|
|
static char oldflay[32];
|
|
static short lwasf3d=0; /* last was face 3d? */
|
|
|
|
/* how can this function do anything useful (ton)? */
|
|
static void dxf_close_3dface(void)
|
|
{
|
|
f3dmhold= NULL;
|
|
if (f3dhold==NULL) return;
|
|
|
|
f3dhold=NULL;
|
|
}
|
|
|
|
static void dxf_read_3dface(Scene *scene, int noob)
|
|
{
|
|
/* Entity specific vars */
|
|
float vert2[3]={0.0, 0.0, 0.0};
|
|
float vert3[3]={0.0, 0.0, 0.0};
|
|
float vert4[3]={0.0, 0.0, 0.0};
|
|
short vspace=0;
|
|
|
|
int nverts=0;
|
|
|
|
/* Blender vars */
|
|
Object *ob;
|
|
Mesh *me;
|
|
MVert *mvert, *vtmp;
|
|
MFace *mface, *ftmp;
|
|
|
|
reset_vars;
|
|
|
|
read_group(id, val);
|
|
while(id!=0) {
|
|
if (id==8) {
|
|
BLI_strncpy(layname, val, sizeof(layname));
|
|
|
|
/* First vert/origin */
|
|
} else if (id==10) {
|
|
cent[0]= (float) atof(val);
|
|
if (nverts<1)nverts++;
|
|
} else if (id==20) {
|
|
cent[1]= (float) atof(val);
|
|
if (nverts<1)nverts++;
|
|
} else if (id==30) {
|
|
cent[2]= (float) atof(val);
|
|
if (nverts<1)nverts++;
|
|
|
|
/* Second vert */
|
|
} else if (id==11) {
|
|
vert2[0]= (float) atof(val);
|
|
if (nverts<2)nverts++;
|
|
} else if (id==21) {
|
|
vert2[1]= (float) atof(val);
|
|
if (nverts<2)nverts++;
|
|
} else if (id==31) {
|
|
vert2[2]= (float) atof(val);
|
|
if (nverts<2)nverts++;
|
|
|
|
/* Third vert */
|
|
} else if (id==12) {
|
|
vert3[0]= (float) atof(val);
|
|
if (nverts<3)nverts++;
|
|
} else if (id==22) {
|
|
vert3[1]= (float) atof(val);
|
|
if (nverts<3)nverts++;
|
|
} else if (id==32) {
|
|
vert3[2]= (float) atof(val);
|
|
if (nverts<3)nverts++;
|
|
|
|
/* Fourth vert */
|
|
} else if (id==13) {
|
|
vert4[0]= (float) atof(val);
|
|
if (nverts<4)nverts++;
|
|
} else if (id==23) {
|
|
vert4[1]= (float) atof(val);
|
|
if (nverts<4)nverts++;
|
|
} else if (id==33) {
|
|
vert4[2]= (float) atof(val);
|
|
if (nverts<4)nverts++;
|
|
|
|
/* Other */
|
|
} else if (id==60) {
|
|
/* short invisible= atoi(val); */
|
|
} else if (id==62) {
|
|
int colorid= atoi(val);
|
|
|
|
CLAMP(colorid, 1, 255);
|
|
dxf_col_to_rgb(colorid, &color[0], &color[1], &color[2]);
|
|
} else if (id==67) {
|
|
vspace= atoi(val);
|
|
}
|
|
read_group(id, val);
|
|
}
|
|
|
|
/* Check to see if we need to make a new object */
|
|
|
|
if(!lwasf3d || strcmp(layname, oldflay)!=0) dxf_close_3dface();
|
|
if(f3dmhold != NULL && f3dmhold->totvert>MESH_MAX_VERTS)
|
|
dxf_close_3dface();
|
|
|
|
if(nverts<3) {
|
|
//XXX error("(3DF) Error parsing dxf, not enough vertices near line %d", dxf_line);
|
|
|
|
error_exit=1;
|
|
fclose(dxf_fp);
|
|
return;
|
|
}
|
|
|
|
if (f3dmhold==NULL) {
|
|
dxf_get_mesh(scene, &me, &ob, noob);
|
|
|
|
strcpy(oldflay, layname);
|
|
|
|
if(ob) VECCOPY(ob->loc, cent);
|
|
|
|
dxf_add_mat (ob, me, color, layname);
|
|
|
|
f3dhold= ob;
|
|
f3dmhold= me;
|
|
} else {
|
|
ob= f3dhold;
|
|
me= f3dmhold;
|
|
}
|
|
|
|
me->totvert+= nverts;
|
|
me->totface++;
|
|
|
|
vtmp= MEM_callocN(me->totvert*sizeof(MVert), "mverts");
|
|
ftmp= MEM_callocN(me->totface*sizeof(MFace), "mface");
|
|
|
|
if(me->mvert) {
|
|
memcpy(vtmp, me->mvert, (me->totvert-nverts)*sizeof(MVert));
|
|
MEM_freeN(me->mvert);
|
|
}
|
|
me->mvert= CustomData_set_layer(&me->vdata, CD_MVERT, vtmp);
|
|
vtmp=NULL;
|
|
|
|
if(me->mface) {
|
|
memcpy(ftmp, me->mface, (me->totface-1)*sizeof(MFace));
|
|
MEM_freeN(me->mface);
|
|
}
|
|
me->mface= CustomData_set_layer(&me->fdata, CD_MFACE, ftmp);
|
|
ftmp=NULL;
|
|
|
|
mvert= &me->mvert[(me->totvert-nverts)];
|
|
VecSubf(mvert->co, cent, vcenter);
|
|
|
|
mvert++;
|
|
if (vspace) { VECCOPY(mvert->co, vert2);
|
|
} else VecSubf(mvert->co, vert2, vcenter);
|
|
|
|
mvert++;
|
|
if (vspace) { VECCOPY(mvert->co, vert3);
|
|
} else VecSubf(mvert->co, vert3, vcenter);
|
|
|
|
if (nverts==4) {
|
|
mvert++;
|
|
if (vspace) { VECCOPY(mvert->co, vert4);
|
|
} else VecSubf(mvert->co, vert4, vcenter);
|
|
}
|
|
|
|
mface= &(((MFace*)me->mface)[me->totface-1]);
|
|
mface->v1= (me->totvert-nverts)+0;
|
|
mface->v2= (me->totvert-nverts)+1;
|
|
mface->v3= (me->totvert-nverts)+2;
|
|
|
|
if (nverts==4)
|
|
mface->v4= (me->totvert-nverts)+3;
|
|
|
|
mface->mat_nr= 0;
|
|
|
|
test_index_face(mface, NULL, 0, nverts);
|
|
|
|
hasbumped=1;
|
|
}
|
|
|
|
static void dxf_read(Scene *scene, char *filename)
|
|
{
|
|
Mesh *lastMe = G.main->mesh.last;
|
|
|
|
/* clear ugly global variables, that can hang because on error the code
|
|
below returns... tsk (ton) */
|
|
dxf_line=0;
|
|
dxf_close_3dface();
|
|
dxf_close_2dpoly();
|
|
dxf_close_line();
|
|
|
|
dxf_fp= fopen(filename, "r");
|
|
if (dxf_fp==NULL) return;
|
|
|
|
while (1) {
|
|
read_group(id, val);
|
|
if (group_is(0, "EOF")) break;
|
|
|
|
if (id==999) continue;
|
|
id_check(0, "SECTION");
|
|
|
|
read_group(id, val);
|
|
if (group_is(2, "HEADER")) {
|
|
} else if (group_is(2, "TABLES")) {
|
|
} else if (group_is(2, "OBJECTS")) {
|
|
} else if (group_is(2, "CLASSES")) {
|
|
} else if (group_is(2, "BLOCKS")) {
|
|
while(1) {
|
|
read_group(id, val);
|
|
if (group_is(0, "BLOCK")) {
|
|
while(group_isnt(0, "ENDBLK")) {
|
|
read_group(id, val);
|
|
|
|
if(id==2) {
|
|
BLI_strncpy(entname, val, sizeof(entname));
|
|
} else if (id==3) {
|
|
/* Now the object def should follow */
|
|
if(strlen(entname)==0) {
|
|
//XXX error("Error parsing dxf, no mesh name near %d", dxf_line);
|
|
fclose(dxf_fp);
|
|
return;
|
|
}
|
|
|
|
/* Now the object def should follow */
|
|
while(group_isnt(0, "ENDBLK")) {
|
|
read_group(id, val);
|
|
|
|
if(group_is(0, "POLYLINE")) {
|
|
dxf_read_polyline(scene, 1);
|
|
if(error_exit) return;
|
|
lwasf3d=0;
|
|
lwasline=0;
|
|
|
|
while(group_isnt(0, "SEQEND")) read_group(id, val);
|
|
|
|
} else if(group_is(0, "LWPOLYLINE")) {
|
|
dxf_read_lwpolyline(scene, 1);
|
|
if(error_exit) return;
|
|
lwasf3d=0;
|
|
lwasline=0;
|
|
|
|
while(group_isnt(0, "SEQEND")) read_group(id, val);
|
|
} else if(group_is(0, "ATTRIB")) {
|
|
while(group_isnt(0, "SEQEND")) read_group(id, val);
|
|
lwasf3d=0;
|
|
lwasp2d=0;
|
|
lwasline=0;
|
|
} else if(group_is(0, "POINT")) {
|
|
dxf_read_point(scene, 1);
|
|
if(error_exit) return;
|
|
lwasf3d=0;
|
|
lwasp2d=0;
|
|
lwasline=0;
|
|
} else if(group_is(0, "LINE")) {
|
|
dxf_read_line(scene, 1);
|
|
if(error_exit) return;
|
|
lwasline=1;
|
|
lwasp2d=0;
|
|
lwasf3d=0;
|
|
} else if(group_is(0, "3DFACE")) {
|
|
dxf_read_3dface(scene, 1);
|
|
if(error_exit) return;
|
|
lwasf3d=1;
|
|
lwasp2d=0;
|
|
lwasline=0;
|
|
} else if (group_is(0, "CIRCLE")) {
|
|
dxf_read_arc(scene, 1);
|
|
} else if (group_is(0, "ELLIPSE")) {
|
|
dxf_read_ellipse(scene, 1);
|
|
} else if (group_is(0, "ENDBLK")) {
|
|
break;
|
|
}
|
|
}
|
|
} else if (group_is(0, "ENDBLK")) {
|
|
break;
|
|
}
|
|
}
|
|
while(id!=0) read_group(id, val);
|
|
|
|
} else if(group_is(0, "ENDSEC")) {
|
|
break;
|
|
}
|
|
}
|
|
} else if (group_is(2, "ENTITIES")) {
|
|
while(group_isnt(0, "ENDSEC")) {
|
|
char obname[32]="";
|
|
char layname[32]="";
|
|
float cent[3]={0.0, 0.0, 0.0};
|
|
float obsize[3]={1.0, 1.0, 1.0};
|
|
float obrot[3]={0.0, 0.0, 0.0};
|
|
|
|
if(!hasbumped) read_group(id, val);
|
|
hasbumped=0;
|
|
if (group_is(0, "INSERT")) {
|
|
Base *base;
|
|
Object *ob;
|
|
void *obdata;
|
|
|
|
read_group(id, val);
|
|
|
|
while(id!=0) {
|
|
if(id==2) {
|
|
BLI_strncpy(obname, val, sizeof(obname));
|
|
} else if (id==8) {
|
|
BLI_strncpy(layname, val, sizeof(layname));
|
|
} else if (id==10) {
|
|
cent[0]= (float) atof(val);
|
|
} else if (id==20) {
|
|
cent[1]= (float) atof(val);
|
|
} else if (id==30) {
|
|
cent[2]= (float) atof(val);
|
|
} else if (id==41) {
|
|
obsize[0]= (float) atof(val);
|
|
} else if (id==42) {
|
|
obsize[1]= (float) atof(val);
|
|
} else if (id==43) {
|
|
obsize[2]= (float) atof(val);
|
|
} else if (id==50) {
|
|
obrot[2]= (float) (atof(val)*M_PI/180.0);
|
|
} else if (id==60) {
|
|
/* short invisible= atoi(val); */
|
|
}
|
|
|
|
read_group(id, val);
|
|
|
|
}
|
|
|
|
if(strlen(obname)==0) {
|
|
//XXX error("Error parsing dxf, no object name near %d", dxf_line);
|
|
fclose(dxf_fp);
|
|
return;
|
|
}
|
|
|
|
obdata= find_id("ME", obname);
|
|
|
|
if (obdata) {
|
|
ob= alloc_libblock(&G.main->object, ID_OB, obname);
|
|
|
|
ob->type= OB_MESH;
|
|
|
|
ob->dt= OB_SHADED;
|
|
if(U.flag & USER_MAT_ON_OB) ob->colbits= -1;
|
|
|
|
ob->trackflag= OB_POSY;
|
|
ob->upflag= OB_POSZ;
|
|
|
|
ob->ipoflag = OB_OFFS_OB+OB_OFFS_PARENT;
|
|
|
|
ob->dupon= 1; ob->dupoff= 0;
|
|
ob->dupsta= 1; ob->dupend= 100;
|
|
ob->recalc= OB_RECALC; /* needed because of weird way of adding libdata directly */
|
|
|
|
ob->data= obdata;
|
|
((ID*)ob->data)->us++;
|
|
|
|
VECCOPY(ob->loc, cent);
|
|
VECCOPY(ob->size, obsize);
|
|
VECCOPY(ob->rot, obrot);
|
|
|
|
ob->mat= MEM_callocN(sizeof(void *)*1, "ob->mat");
|
|
ob->totcol= (unsigned char) ((Mesh*)ob->data)->totcol;
|
|
ob->actcol= 1;
|
|
|
|
/* note: materials are either linked to mesh or object, if both then
|
|
you have to increase user counts. below line is not needed.
|
|
I leave it commented out here as warning (ton) */
|
|
//for (i=0; i<ob->totcol; i++) ob->mat[i]= ((Mesh*)ob->data)->mat[i];
|
|
|
|
if (strlen(layname)) ob->lay= dxf_get_layer_num(scene, layname);
|
|
else ob->lay= scene->lay;
|
|
|
|
/* link to scene */
|
|
base= MEM_callocN( sizeof(Base), "add_base");
|
|
BLI_addhead(&scene->base, base);
|
|
|
|
base->lay= ob->lay;
|
|
|
|
base->object= ob;
|
|
}
|
|
|
|
hasbumped=1;
|
|
|
|
lwasf3d=0;
|
|
lwasp2d=0;
|
|
lwasline=0;
|
|
} else if(group_is(0, "POLYLINE")) {
|
|
dxf_read_polyline(scene, 0);
|
|
if(error_exit) return;
|
|
lwasf3d=0;
|
|
lwasline=0;
|
|
|
|
while(group_isnt(0, "SEQEND")) read_group(id, val);
|
|
|
|
} else if(group_is(0, "LWPOLYLINE")) {
|
|
dxf_read_lwpolyline(scene, 0);
|
|
if(error_exit) return;
|
|
lwasf3d=0;
|
|
lwasline=0;
|
|
//while(group_isnt(0, "SEQEND")) read_group(id, val);
|
|
|
|
} else if(group_is(0, "ATTRIB")) {
|
|
while(group_isnt(0, "SEQEND")) read_group(id, val);
|
|
lwasf3d=0;
|
|
lwasp2d=0;
|
|
lwasline=0;
|
|
} else if(group_is(0, "POINT")) {
|
|
dxf_read_point(scene, 0);
|
|
if(error_exit) return;
|
|
lwasf3d=0;
|
|
lwasp2d=0;
|
|
lwasline=0;
|
|
} else if(group_is(0, "LINE")) {
|
|
dxf_read_line(scene, 0);
|
|
if(error_exit) return;
|
|
lwasline=1;
|
|
lwasp2d=0;
|
|
lwasf3d=0;
|
|
} else if(group_is(0, "3DFACE")) {
|
|
dxf_read_3dface(scene, 0);
|
|
if(error_exit) return;
|
|
lwasline=0;
|
|
lwasp2d=0;
|
|
lwasf3d=1;
|
|
} else if (group_is(0, "CIRCLE") || group_is(0, "ARC")) {
|
|
dxf_read_arc(scene, 0);
|
|
} else if (group_is(0, "ELLIPSE")) {
|
|
dxf_read_ellipse(scene, 0);
|
|
} else if(group_is(0, "ENDSEC")) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
while(group_isnt(0, "ENDSEC")) read_group(id, val);
|
|
}
|
|
id_check(0, "EOF");
|
|
|
|
fclose (dxf_fp);
|
|
|
|
/* Close any remaining state held stuff */
|
|
dxf_close_3dface();
|
|
dxf_close_2dpoly();
|
|
dxf_close_line();
|
|
|
|
if (lastMe) {
|
|
lastMe = lastMe->id.next;
|
|
} else {
|
|
lastMe = G.main->mesh.first;
|
|
}
|
|
for (; lastMe; lastMe=lastMe->id.next) {
|
|
mesh_add_normals_flags(lastMe);
|
|
make_edges(lastMe, 0);
|
|
}
|
|
}
|