GEEKING

CSG/sgCore/Core/APLICAT/DXF/DXF_ARC.cpp

@@ -0,0 +1,90 @@
+#include "../../sg.h"
+
+BOOL dxf_arc(lpLISTH listh)
+{
+	sgFloat		height = 0;		
+	D_POINT		vc, vb, ve, tmp;
+	D_POINT		v = {0,0,1};	
+	GEO_ARC		geo;
+	sgFloat		ab, ae, r;
+	MATR			gcs_pl, pl_gcs;
+	BOOL			flag_h = FALSE;
+	short			color = 0;
+	int			num;
+	LAYER			elem;
+
+	ab = 0;
+	ae = 2*M_PI;
+
+	while (1) {
+		if ( !get_group(dxfg)) return FALSE;
+		switch (dxfg->gr) {
+			case 8:
+				num = 0;
+				if (find_elem(&dxfg->layers, &num, dxf_cmp_func, (void*)dxfg->str)) {
+					if (!read_elem(&dxfg->layers, num, &elem)) return FALSE;
+					color = elem.color;
+				}
+				continue;
+			case 62:
+				color = dxfg->p;
+				continue;
+			case 10:	// center
+				vc	= dxfg->xyz;
+				continue;
+			case 50: /* begin angle */
+				ab	= d_radian(dxfg->a);
+				continue;
+			case 51: /* end angle */
+				ae	= d_radian(dxfg->a);
+				continue;
+			case 40:	// radius
+				r	= dxfg->v;
+				continue;
+			case 210:	// ort
+				v = dxfg->xyz;
+				continue;
+			case 39:	/* extrus */
+				height = dxfg->v;
+				if (height > eps_d) flag_h = TRUE;
+				continue;
+			case 0:	
+				break;
+			default:
+				continue;
+		}
+		color = dxf_color(color);
+		break;
+	}
+	if (r < eps_d) return TRUE;
+
+	vb.x = vc.x + r * cos(ab);
+	vb.y = vc.y + r * sin(ab);
+	vb.z = vc.z;
+	ve.x = vc.x + r * cos(ae);
+	ve.y = vc.y + r * sin(ae);
+	ve.z = vc.z;
+	
+	ocs_gcs(&v, dxfg->ocs_gcs, dxfg->gcs_ocs);
+	o_hcncrd(dxfg->ocs_gcs, &vc, &vc);
+	o_hcncrd(dxfg->ocs_gcs, &vb, &vb);
+	o_hcncrd(dxfg->ocs_gcs, &ve, &ve);
+	
+	o_hcunit(gcs_pl);
+	o_tdtran(gcs_pl, dpoint_inv(&vc, &tmp));
+	o_hcrot1(gcs_pl, &v);
+	o_minv(gcs_pl, pl_gcs);
+	o_hcncrd(gcs_pl, &vc, &vc);
+	o_hcncrd(gcs_pl, &vb, &vb);
+	o_hcncrd(gcs_pl, &ve, &ve);
+	
+	if (!arc_b_e_c(&vb, &ve, &vc,
+								 TRUE, FALSE, FALSE, &geo)) return TRUE;
+	
+	o_hcncrd(pl_gcs, &geo.vc, &geo.vc);
+	o_hcncrd(pl_gcs, &geo.vb, &geo.vb);
+	o_hcncrd(pl_gcs, &geo.ve, &geo.ve);
+	geo.n = v;
+	return dxf_extrude(OARC, color, (lpGEO_SIMPLE)&geo, listh,
+										 flag_h, &v, height, FALSE);
+}

CSG/sgCore/Core/APLICAT/DXF/DXF_CIRC.cpp

@@ -0,0 +1,53 @@
+#include "../../sg.h"
+
+BOOL dxf_circle(lpLISTH listh)
+{
+	sgFloat			height = 0;	
+	D_POINT			v = {0,0,1};	
+	GEO_CIRCLE	geo;
+	BOOL				flag_h = FALSE;
+	short				color = 0;
+	int					num;
+	LAYER				elem;
+
+	while (1) {
+		if ( !get_group(dxfg)) return FALSE;
+		switch (dxfg->gr) {
+			case 8:
+				num = 0;
+				if (find_elem(&dxfg->layers, &num, dxf_cmp_func, (void*)dxfg->str)) {
+					if (!read_elem(&dxfg->layers, num, &elem)) return FALSE;
+					color = elem.color;
+				}
+				continue;
+			case 62:
+				color = dxfg->p;
+				continue;
+			case 10:	
+				geo.vc	= dxfg->xyz;
+				continue;
+			case 40:	
+				geo.r	= dxfg->v;
+				continue;
+			case 210:	
+				v = dxfg->xyz;
+				continue;
+			case 39:	
+				height = dxfg->v;
+				if (height > eps_d) flag_h = TRUE;
+				continue;
+			case 0:	
+				break;
+			default:
+				continue;
+		}
+		color = dxf_color(color);
+		break;
+	}
+	ocs_gcs(&v, dxfg->ocs_gcs, dxfg->gcs_ocs);
+	o_hcncrd(dxfg->ocs_gcs, &geo.vc, &geo.vc);
+	geo.n = v;
+	if (geo.r < eps_d) return TRUE;	
+	return dxf_extrude(OCIRCLE, color, (lpGEO_SIMPLE)&geo, listh,
+										 flag_h, &v, height, FALSE);
+}

CSG/sgCore/Core/APLICAT/DXF/DXF_EXTD.cpp

@@ -0,0 +1,64 @@
+#include "../../sg.h"
+
+BOOL dxf_extrude(OBJTYPE type, short color, lpGEO_SIMPLE geo, lpLISTH listh,
+								 BOOL flag_h, lpD_POINT v, sgFloat height, BOOL closed)
+{
+	LISTH 		listh2;
+	hOBJ			hobj, htail;
+	lpOBJ			obj;
+	OSCAN_COD	cod;
+	BOOL			Bool = TRUE;
+	MATR			matr;
+
+	if ( !cr_add_obj(type, color, geo, listh, NULL, FALSE)) return FALSE;
+	if (type == OPATH || type == OSPLINE) {
+		htail = listh->htail;
+		if (type == OPATH) {
+			obj = (lpOBJ)htail;
+			listh2 = ((lpGEO_PATH)obj->geo_data)->listh;
+			hobj = listh2.hhead;
+			while (hobj) {
+				obj = (lpOBJ)hobj;
+				obj->hhold = htail;
+				get_next_item(hobj, &hobj);
+			}
+			if (!set_contacts_on_path(htail)) return FALSE;
+		}
+		obj = (lpOBJ)htail;
+		if (is_path_on_one_line(htail))
+		{
+			obj->status |= ST_ON_LINE;
+			obj->status &= ~ST_FLAT;
+		}
+		else
+		{
+			if (set_flat_on_path(htail, NULL))
+				obj->status |= ST_FLAT;
+			else      
+				obj->status &= ~ST_FLAT;
+		}
+		//if (!set_flat_on_path(htail, NULL)) return FALSE;
+		if ((cod = test_self_cross_path(htail,NULL)) == OSFALSE) return FALSE;
+//cod = OSTRUE;
+		if (cod == OSTRUE) {
+			obj = (lpOBJ)htail;
+			obj->status |= ST_SIMPLE;
+		} else closed = FALSE;	
+	}
+	if (flag_h) {
+		htail = listh->htail;
+		init_listh(&listh2);
+		detach_item(listh, htail);
+		attach_item_head(&listh2, htail);
+		dpoint_scal(v, height, v);
+		o_hcunit(matr);
+		o_tdtran(matr, v);
+		Bool = extrud_mesh(&listh2, 0, matr, closed, &hobj);
+		o_free(htail, NULL);
+		if (!hobj) return FALSE;
+		obj = (lpOBJ)hobj;
+		obj->color = (BYTE)color;
+		attach_item_tail(listh, hobj);
+	}
+	return Bool;
+}

CSG/sgCore/Core/APLICAT/DXF/DXF_FACE.cpp

@@ -0,0 +1,56 @@
+#include "../../sg.h"
+
+
+BOOL dxf_3dface(lpVDIM faces)
+{
+	FACE4 	face;
+	short		color = 0;
+	int			num = 0;
+	LAYER		elem;
+
+	memset(&face, 0, sizeof(face));
+	while (TRUE) {
+		if (!get_group(dxfg)) return FALSE;
+		switch (dxfg->gr) {
+			case 8:
+				if (find_elem(&dxfg->layers, &num, dxf_cmp_func, (void*)dxfg->str)) {
+					if (!read_elem(&dxfg->layers, num, &elem)) return FALSE;
+					color = elem.color;
+				} else {
+					strncpy(elem.name, dxfg->str, LEN_NAME_LAYER);
+					elem.name[LEN_NAME_LAYER] = 0;
+					elem.color = 0;
+					if (!add_elem(&dxfg->layers, &elem)) return FALSE;
+					num = dxfg->layers.num_elem - 1;
+				}
+				continue;
+			case 62:
+				color = dxfg->p;
+				continue;
+			case 10:
+				face.p1 = dxfg->xyz;
+				continue;
+			case 11:
+				face.p2 = dxfg->xyz;
+				continue;
+			case 12:
+				face.p3 = dxfg->xyz;
+				continue;
+			case 13:
+				face.p4 = dxfg->xyz;
+				continue;
+			case 70:                  
+				face.flag_v = dxfg->f;
+				continue;
+			case 0:
+				break;
+			default:
+				continue;
+		}
+		face.color = dxf_color(color);
+		break;
+	}
+	face.layer = (short)num;
+	face.flag = TRUE;
+	return add_elem(faces, &face);
+}

CSG/sgCore/Core/APLICAT/DXF/DXF_INS.cpp

@@ -0,0 +1,104 @@
+#include "../../sg.h"
+
+BOOL dxf_insert(lpLISTH listh, int last_block)
+{
+	D_POINT 		v = {0,0,1};                  
+	D_POINT 		point, p, min, max;              
+  hOBJ				hobj;
+	MATR 				A;
+	char 				name[MAXBLOCKNAME];
+	short 				i, j;
+	int				cur_blk;
+	sgFloat 			sx = 1., sy = 1., sz = 1., az = 0.;
+	short 				nx = 1, ny = 1;
+	sgFloat 			dx = 0., dy = 0.;
+	GEO_INSERT	geo;
+	IBLOCK			blk;
+
+	while (1) {
+		if (!get_group(dxfg)) return FALSE;
+		switch (dxfg->gr) {
+			case 2:
+				strncpy(name, dxfg->str, MAXBLOCKNAME);
+				name[MAXBLOCKNAME - 1] = 0;
+				cur_blk = last_block;
+				if (!find_elem(&vd_blocks, &cur_blk, dxf_cmp_func, name)) {
+					dxf_err(NO_SUCH_BLOCK);
+					return TRUE;
+				}
+				continue;
+			case 10:
+				point = dxfg->xyz;
+				continue;
+			case 41:
+				sx = dxfg->v;
+				continue;
+			case 42:
+				sy = dxfg->v;
+				continue;
+			case 43:
+				sz = dxfg->v;
+				continue;
+			case 44:
+				dx = dxfg->v;
+				continue;
+			case 45:
+				dy = dxfg->v;
+				continue;
+			case 50:
+				az = dxfg->a;
+				continue;
+			case 70:
+				nx = dxfg->f;
+				continue;
+			case 71:
+				ny = dxfg->f;
+				continue;
+			case 210:                 
+				v = dxfg->xyz;
+				continue;
+			case 0:
+				break;
+
+			default:
+				continue;
+		}
+		break;
+	}
+
+	ocs_gcs(&v, dxfg->ocs_gcs, dxfg->gcs_ocs);
+
+	for (i = 0; i < nx; i++) {
+		for (j = 0; j < ny; j++) {
+
+			o_hcunit(A);
+			o_tdscal(A, 1, sx);
+			o_tdscal(A, 2, sy);
+			o_tdscal(A, 3, sz);
+			p.x = i * dx;
+			p.y = j * dy;
+			p.z = 0;
+			o_tdtran(A, &p);
+			o_tdrot(A, 3, az);
+			o_tdtran(A, &point);
+
+			o_hcmult(A, dxfg->ocs_gcs);
+
+			memcpy(geo.matr, A, sizeof(MATR));
+			geo.num = cur_blk;
+			geo.min.x = geo.min.y = geo.min.z =  GAB_NO_DEF;
+			geo.max.x = geo.max.y = geo.max.z = -GAB_NO_DEF;
+			if (!read_elem(&vd_blocks, cur_blk, &blk)) return FALSE;
+			hobj = blk.listh.hhead;
+			while (hobj) {
+				if (!get_object_limits_lsk(hobj, &min, &max, A)) return FALSE;
+				union_limits(&min, &max, &geo.min, &geo.max);
+				get_next_item(hobj, &hobj);
+			}
+
+			if ( !cr_add_obj(OINSERT, CTRANSP, (lpGEO_SIMPLE)&geo, listh,
+											 NULL, FALSE)) return FALSE;
+		}
+	}
+	return TRUE;
+}

CSG/sgCore/Core/APLICAT/DXF/DXF_KEYS.cpp

@@ -0,0 +1,36 @@
+#include "../../sg.h"
+
+char *dxf_keys[] = {
+	"SECTION",       //DXF_SECTION
+	"ENDSEC",        //DXF_ENDSEC
+	"HEADER",        //DXF_HEADER
+	"TABLES",        //DXF_TABLES
+	"TABLE",         //DXF_TABLE
+	"ENDTAB",        //DXF_ENDTAB
+	"LTYPE",         //DXF_LTYPE
+	"LAYER",         //DXF_LAYER
+	"STYLE",         //DXF_STYLE
+	"VIEW",          //DXF_VIEW
+	"BLOCKS",        //DXF_BLOCKS
+  "ENTITIES",      //DXF_ENTITIES
+	"EOF",           //DXF_EOF
+
+	"LINE",          //DXF_LINE
+	"POINT",         //DXF_POINT
+	"CIRCLE",        //DXF_CIRCLE
+	"ARC",           //DXF_ARC
+	"TRACE",         //DXF_TRACE
+	"SOLID",         //DXF_SOLID
+	"TEXT",          //DXF_TEXT
+	"SHAPE",         //DXF_SHAPE
+	"BLOCK",         //DXF_BLOCK
+	"ENDBLK",        //DXF_ENDBLK
+	"INSERT",        //DXF_INSERT
+	"ATTDEF",        //DXF_ATTDEF
+	"ATTRIB",        //DXF_ATTRIB
+	"POLYLINE",      //DXF_POLYLINE
+	"VERTEX",        //DXF_VERTEX
+	"SEQEND",        //DXF_SEQEND
+	"3DLINE",        //DXF_3DLINE
+	"3DFACE",        //DXF_3DFACE
+};

CSG/sgCore/Core/APLICAT/DXF/DXF_LINE.cpp

@@ -0,0 +1,56 @@
+#include "../../sg.h"
+
+BOOL dxf_line(lpLISTH listh)
+{
+	GEO_LINE	line;
+	sgFloat		height = 0;		
+	D_POINT		tmp, v = {0,0,1};	
+	BOOL			flag_h = FALSE;
+	short			color = 0;
+	int			  num;
+	LAYER			elem;
+
+	while (1) {
+		if ( !get_group(dxfg)) return FALSE;
+		switch (dxfg->gr) {
+			case 8:
+				num = 0;
+				if (find_elem(&dxfg->layers, &num, dxf_cmp_func, (void*)dxfg->str)) {
+					if (!read_elem(&dxfg->layers, num, &elem)) return FALSE;
+					color = elem.color;
+				}
+				continue;
+			case 62:
+				color = dxfg->p;
+				continue;
+			case 10:
+				line.v1 = dxfg->xyz;
+				continue;
+			case 11:
+				line.v2 = dxfg->xyz;
+				continue;
+			case 210:									
+				v = dxfg->xyz;
+				continue;
+			case 39:									
+				height = dxfg->v;
+				if (height > eps_d) flag_h = TRUE;
+				continue;
+			case 0:
+				break;
+			default:
+				continue;
+		}
+		color = dxf_color(color);
+		break;
+	}
+	if (dpoint_eq(&line.v1, &line.v2, eps_d))
+		return TRUE;	
+	if (flag_h) {
+		if (coll_tst(&v, TRUE, dpoint_sub(&line.v2, &line.v1, &tmp), FALSE))
+			flag_h = FALSE;	
+	}
+	return dxf_extrude(OLINE, color, (lpGEO_SIMPLE)&line, listh,
+										 flag_h, &v, height, FALSE);
+}
+

CSG/sgCore/Core/APLICAT/DXF/DXF_POLY.cpp

@@ -0,0 +1,75 @@
+#include "../../sg.h"
+
+BOOL dxf_poly(lpLISTH listh)
+{
+	short   m = 0, m2 = 0, flag = 0;
+//	int		n = 0, n2 = 0;
+	int			num;
+	short		type = 0;
+	sgFloat  height = 0;      
+	BOOL		flag_h = FALSE;
+	D_POINT v = {0,0,1}, p10;
+	short   color = 0;
+	LAYER		elem;
+
+	while (1) {
+		if (!get_group(dxfg)) return FALSE;
+		switch (dxfg->gr) {
+			case 10:                 
+				p10 = dxfg->xyz;
+				continue;
+			case 8:
+				num = 0;
+				if (find_elem(&dxfg->layers, &num, dxf_cmp_func, (void*)dxfg->str)) {
+					if (!read_elem(&dxfg->layers, num, &elem)) return FALSE;
+					color = elem.color;
+				}
+				continue;
+			case 62:
+				color = dxfg->p;
+				continue;
+			case 70:
+				flag = dxfg->f;
+				continue;
+//			case 71:
+//				n = dxfg->f;
+//				continue;
+			case 72:
+				m = dxfg->f;
+				continue;
+//			case 73:
+//				n2 = dxfg->f;
+//				continue;
+			case 74:
+				m2 = dxfg->f;
+				continue;
+			case 75:
+				type = dxfg->f;	
+				continue;
+			case 210:                
+				v = dxfg->xyz;
+				continue;
+			case 39:                  
+				height = dxfg->v;
+				if (height > eps_d) flag_h = TRUE;
+				continue;
+			case 0:
+				break;
+			default:
+				continue;
+		}
+		color = dxf_color(color);
+		break;
+	}
+	if (flag &  16) { 
+		if (flag & 4) {
+			m = m2;	// n = n2;
+		}
+		return poly_mesh(m, flag, color, listh);
+	}
+	if (flag &  64) return poly_mesh64(color, listh);	
+	ocs_gcs(&v, dxfg->ocs_gcs, dxfg->gcs_ocs);
+	
+	return poly_path(height, flag, type, color,
+									 listh, flag_h, &v, &p10);
+}

CSG/sgCore/Core/APLICAT/DXF/DXF_SOL.cpp

@@ -0,0 +1,115 @@
+#include "../../sg.h"
+
+BOOL dxf_solid(lpLISTH listh, lpVDIM faces)
+{
+	sgFloat 		height = 0;               
+	D_POINT 	v = {0,0,1};              
+	D_POINT		p1, p2, p3, p4;
+	BOOL			flag_h = FALSE;
+	short     color = 0;
+	int			  num = 0;
+	LAYER			elem;
+	GEO_LINE	line;
+	GEO_PATH	path;
+	LISTH			listh2;
+	hOBJ			hobj;
+	FACE4 		face;
+
+	while (1) {
+		if (!get_group(dxfg)) return FALSE;
+		switch (dxfg->gr) {
+			case 8:
+				if (find_elem(&dxfg->layers, &num, dxf_cmp_func, (void*)dxfg->str)) {
+					if (!read_elem(&dxfg->layers, num, &elem)) return FALSE;
+					color = elem.color;
+				}
+				continue;
+			case 62:
+				color = dxfg->p;
+				continue;
+			case 10:
+				p1 = dxfg->xyz;
+				continue;
+			case 11:
+				p2 = dxfg->xyz;
+				continue;
+			case 12:
+				p4 = dxfg->xyz;
+				continue;
+			case 13:
+				p3 = dxfg->xyz;
+				continue;
+			case 210:                  
+				v = dxfg->xyz;
+				continue;
+			case 39:                 
+				height = dxfg->v;
+				if (height > eps_d) flag_h = TRUE;
+				continue;
+			case 0:
+				break;
+			default:
+				continue;
+		}
+		color = dxf_color(color);
+		break;
+	}
+
+	init_listh(&listh2);
+	ocs_gcs(&v, dxfg->ocs_gcs, dxfg->gcs_ocs);
+	o_hcncrd(dxfg->ocs_gcs, &p1, &p1);
+	o_hcncrd(dxfg->ocs_gcs, &p2, &p2);
+	o_hcncrd(dxfg->ocs_gcs, &p3, &p3);
+	o_hcncrd(dxfg->ocs_gcs, &p4, &p4);
+	if (!flag_h) {	
+		face.color = color;
+		face.flag_v = 0;
+		face.layer = (short)num;
+		face.flag = TRUE;
+    face.p1 = p1;
+		face.p2 = p2;
+		face.p3 = p3;
+		face.p4 = p4;
+		return add_elem(faces, &face);
+	}
+	if (!dpoint_eq(&p1, &p2, eps_d)) {
+		line.v1 = p1;
+		line.v2 = p2;
+		if ( !cr_add_obj(OLINE, color, (lpGEO_SIMPLE)&line,
+										 &listh2, NULL, FALSE)) goto err;
+	}
+	if (!dpoint_eq(&p2, &p3, eps_d)) {
+		line.v1 = p2;
+		line.v2 = p3;
+		if ( !cr_add_obj(OLINE, color, (lpGEO_SIMPLE)&line,
+										 &listh2, NULL, FALSE)) goto err;
+	}
+	if (!dpoint_eq(&p3, &p4, eps_d)) {
+		line.v1 = p3;
+		line.v2 = p4;
+		if ( !cr_add_obj(OLINE, color, (lpGEO_SIMPLE)&line,
+										 &listh2, NULL, FALSE)) goto err;
+	}
+	if (!dpoint_eq(&p4, &p1, eps_d)) {
+		line.v1 = p4;
+		line.v2 = p1;
+		if ( !cr_add_obj(OLINE, color, (lpGEO_SIMPLE)&line,
+										 &listh2, NULL, FALSE)) goto err;
+	}
+	if (!listh2.num) return TRUE;
+	memset(&path, 0, sizeof(path));
+	o_hcunit(path.matr);
+	path.listh = listh2;
+	hobj = listh2.hhead;
+	path.min.x = path.min.y =  path.min.z =  GAB_NO_DEF;
+	path.max.x = path.max.y =  path.max.z = -GAB_NO_DEF;
+	while (hobj) {
+		if (!get_object_limits(hobj, &p1, &p2)) goto err;
+		union_limits(&p1, &p2, &path.min, &path.max);
+		get_next_item(hobj, &hobj);
+	}
+	return dxf_extrude(OPATH, color, (lpGEO_SIMPLE)&path, listh,
+										 flag_h, &v, height, TRUE);
+err:
+	return FALSE;
+}

CSG/sgCore/Core/APLICAT/DXF/DXF_TEXT.cpp

@@ -0,0 +1,88 @@
+#include "../../sg.h"
+
+BOOL dxf_text(lpLISTH listh)
+{
+GEO_TEXT 	gtext;
+sgFloat		height;		
+D_POINT		vc;
+D_POINT		vn = {0,0,1};	
+sgFloat		a;
+short			color = 0;
+LAYER			elem;
+BOOL      flag_h;
+int				num;
+
+
+	gtext.text_id = 0;
+	gtext.font_id = ft_bd->curr_font;
+	gtext.style.status = 0;
+	gtext.style.height = 5.;
+	gtext.style.scale = 100.;
+	gtext.style.angle = 0;
+	gtext.style.dhor = 0;
+	gtext.style.dver = 50;
+
+	while (1) {
+		if ( !get_group(dxfg)) return FALSE;
+		switch (dxfg->gr) {
+			case 8:
+				num = 0;
+				if (find_elem(&dxfg->layers, &num, dxf_cmp_func, (void*)dxfg->str)) {
+					if (!read_elem(&dxfg->layers, num, &elem)) return FALSE;
+					color = elem.color;
+				}
+				continue;
+			case 62:
+				color = dxfg->p;
+				continue;
+			case 10:	
+				vc	= dxfg->xyz;
+				continue;
+			case 50: 
+				a	= d_radian(dxfg->a);
+				continue;
+			case 51: 
+				gtext.style.angle	= dxfg->a;
+				continue;
+			case 40:	
+				gtext.style.height = dxfg->v/get_grf_coeff();
+				continue;
+			case 41:	
+				gtext.style.scale = dxfg->v*100;
+				continue;
+			case 210:	
+				vn = dxfg->xyz;
+				continue;
+			case 39:	
+				continue;
+			case 1:	
+				gtext.text_id = add_ft_value(FTTEXT, dxfg->str, strlen(dxfg->str) + 1);
+				continue;
+			case 0:	
+				break;
+			default:
+				continue;
+		}
+		color = dxf_color(color);
+		break;
+	}
+	if(!gtext.text_id)
+		return TRUE;
+	o_hcunit(gtext.matr);
+	gtext.min.x = gtext.min.y = gtext.min.z =  GAB_NO_DEF;
+	gtext.max.x = gtext.max.y = gtext.max.z = -GAB_NO_DEF;
+
+	if(!draw_geo_text(&gtext, text_gab_lsk, &gtext.min)) return TRUE;
+	if(gtext.min.x == GAB_NO_DEF) return TRUE;
+
+	ocs_gcs(&vn, dxfg->ocs_gcs, dxfg->gcs_ocs);
+	o_tdrot(gtext.matr, -3, a);
+	o_hcmult(gtext.matr, dxfg->ocs_gcs);
+	o_tdtran(gtext.matr, &vc);
+
+	flag_h = FALSE;
+	height = 0;
+	return dxf_extrude(OTEXT, color, (lpGEO_SIMPLE)&gtext, listh,
+										 flag_h, &vn, height, FALSE);
+}
+

CSG/sgCore/Core/APLICAT/DXF/DXF_UTIL.cpp

@@ -0,0 +1,70 @@
+#include "../../sg.h"
+
+short dxf_color(short color)
+{
+	short     acad_color[16] = { 0, 12, 14, 10, 11,  9, 13,  7,
+														 8,  4,  6,  2,  3,  1,  5, 15 };
+
+	if (color > 15) color = 0;
+	color = acad_color[color];
+//	if (color == vport_bg || color == blink_color) color = obj_attrib.color;
+//	if (color == vport_bg) color = obj_attrib.color;
+	return color;
+}
+
+BOOL dxf_cmp_func(void *elem, void *data)
+{
+	if (!strcmp(((lpLAYER)elem)->name, (char*)data)) return TRUE;
+	return FALSE;
+}
+
+BOOL skip_vertex(void)
+{
+	while (TRUE) {
+		if (!get_group(dxfg)) return FALSE;
+		if (dxfg->gr == 0 && !memcmp(dxfg->str,dxf_keys[DXF_SEQEND],6)) break;
+	}
+	while (TRUE) {
+		if (!get_group(dxfg)) return FALSE;
+		if (dxfg->gr == 0) break;
+	}
+	return TRUE;
+}
+
+short dxf_convert_color(short color)
+{
+  switch ( color )
+  {
+    case IDXLIGHTRED:      return 1;
+    case IDXYELLOW:        return 2;
+    case IDXLIGHTGREEN:    return 3;
+    case IDXLIGHTCYAN:     return 4;
+    case IDXLIGHTBLUE:     return 5;
+		case IDXLIGHTMAGENTA:  return 6;
+		case IDXBLACK:         return 7;
+    case IDXDARKGRAY:      return 8;
+    case IDXRED:           return 9;
+    case IDXBROWN:         return 10;
+    case IDXGREEN:         return 11;
+    case IDXCYAN:          return 12;
+    case IDXBLUE:          return 13;
+    case IDXMAGENTA:       return 14;
+    case IDXWHITE:         return 15;
+    default:               return 15;
+  }
+}
+
+void dxf_err(CODE_MSG code)
+{
+	char str[80], num[20];
+
+	if (dxfg->binary) {
+		strcpy(str, get_message(DXF_ADDRESS)->str);
+	//	ltoa(dxfg->bd->p_beg + dxfg->bd->cur_buf, num, 10);
+	} else {
+		strcpy(str, get_message(DXF_NUM_LINE)->str);
+	//	ltoa(dxfg->bd->cur_line, num, 10);
+	}
+	strcat(str, num);
+	put_message(code, str, 0);
+}

CSG/sgCore/Core/APLICAT/DXF/GET_GROU.cpp

@@ -0,0 +1,178 @@
+#include "../../sg.h"
+
+#define GR_SHIFT 10000
+
+static  BOOL dxf_str(void);
+static  BOOL dxf_gr(void);
+
+extern BOOL ACAD_R13;
+
+static sgFloat dxf_round_coord(char *str)
+{
+	if (static_data->RoundOn)
+		 return round(atof(str), export_floating_precision);
+	return atof(str);
+}
+
+BOOL get_group(lpDXF_GROUP dxfg)
+{
+	int						len, gr1;
+	static int		g1 = 0;
+	static sgFloat dxf_38 = 0.;
+
+//	step_grad(dxfg->num_proc , dxfg->bd->p_beg + dxfg->bd->cur_buf);
+	if (application_interface && application_interface->GetProgresser() && dxfg->bd->len_file>0)  
+		application_interface->GetProgresser()->Progress(100*(dxfg->bd->p_beg + dxfg->bd->cur_buf)/dxfg->bd->len_file);
+
+	if (ctrl_c_press) {
+		put_message(CTRL_C_PRESS, NULL, 0);
+		return FALSE;
+	}
+	if (g1 >= GR_SHIFT) {
+		dxfg->gr  = g1 - GR_SHIFT;
+		g1 = 0;
+	} else
+		if (!dxf_gr()) goto err;
+
+	if (0 > dxfg->gr/* || dxfg->gr > 1079*/) {
+		dxf_err(BAD_DXF_GROUP);
+		return FALSE;
+	}
+
+	if (!dxfg->binary) {
+		if ( !load_str(dxfg->bd,sizeof(dxfg->str),dxfg->str) )		goto err;
+		
+		len = strlen(dxfg->str);
+		while (len > 0) {
+			if (dxfg->str[len - 1] == ' ') len--;
+			else break;
+		}
+	}
+	if (dxfg->gr <= 9 || (999 <= dxfg->gr && dxfg->gr <= 1009)) {
+		if ( !dxfg->gr ) dxf_38 = 0.;
+		if (dxfg->binary) return dxf_str();
+		return TRUE;
+	}
+	if (38 <= dxfg->gr && dxfg->gr <= 49) {
+		if (dxfg->binary) {
+			if (!load_data(dxfg->bd, sizeof(sgFloat), &dxfg->v)) goto err;
+		} else dxfg->v = atof(dxfg->str);
+		if (dxfg->gr == 38) dxf_38 = dxfg->v;
+		return TRUE;
+	}
+	if (50 <= dxfg->gr && dxfg->gr <= 59) {
+		if (dxfg->binary) {
+			if (!load_data(dxfg->bd, sizeof(sgFloat), &dxfg->a)) goto err;
+		} else dxfg->a = atof(dxfg->str);
+		return TRUE;
+	}
+	if (60 <= dxfg->gr && dxfg->gr <= 69) {
+		if (dxfg->binary) {
+			if (!load_data(dxfg->bd, sizeof(short), &dxfg->p)) goto err;
+		} else dxfg->p = atoi(dxfg->str);
+		return TRUE;
+	}
+	if (70 <= dxfg->gr && dxfg->gr <= 79) {
+		if (dxfg->binary) {
+			if (!load_data(dxfg->bd, sizeof(short), &dxfg->f)) goto err;
+		} else dxfg->f = atoi(dxfg->str);
+		return TRUE;
+	}
+	if (140 <= dxfg->gr && dxfg->gr <= 147) {
+		if (dxfg->binary) {
+			if (!load_data(dxfg->bd, sizeof(sgFloat), &dxfg->a)) goto err;
+		} else dxfg->a = atof(dxfg->str);
+		return TRUE;
+	}
+	if ((170 <= dxfg->gr && dxfg->gr <= 179) ||
+			(270 <= dxfg->gr && dxfg->gr <= 289)) {
+		if (dxfg->binary) {
+			if (!load_data(dxfg->bd, sizeof(short), &dxfg->p)) goto err;
+		} else dxfg->p = atoi(dxfg->str);
+		return TRUE;
+	}
+	if (1010 <= dxfg->gr && dxfg->gr <= 1059) {
+		if (dxfg->binary) {
+			if (!load_data(dxfg->bd, sizeof(sgFloat), &dxfg->a)) goto err;
+		} else dxfg->a = atof(dxfg->str);
+		return TRUE;
+	}
+	if (1060 <= dxfg->gr && dxfg->gr <= 1079) {
+		if (dxfg->binary) {
+			if (!load_data(dxfg->bd, sizeof(short), &dxfg->p)) goto err;
+		} else dxfg->p = atoi(dxfg->str);
+		return TRUE;
+	}
+	if (dxfg->gr >= 20 && (dxfg->gr < 210 || dxfg->gr > 219)) {
+		if (dxfg->binary) return dxf_str();
+		return TRUE;
+//		dxf_err(BAD_DXF_GROUP);
+//		return FALSE;
+	}
+	if (dxfg->binary) {
+		if (!load_data(dxfg->bd, sizeof(sgFloat), &dxfg->xyz.x)) goto err;
+	} else dxfg->xyz.x = dxf_round_coord(dxfg->str);
+	gr1 = dxfg->gr;
+	if (!dxf_gr()) goto err;
+	if (gr1 + 10 != dxfg->gr) {
+		dxf_err(BAD_DXF_GROUP);
+		return FALSE;
+	}
+	if (dxfg->binary) {
+		if (!load_data(dxfg->bd, sizeof(sgFloat), &dxfg->xyz.y)) goto err;
+	} else {
+		if ( !load_str(dxfg->bd,sizeof(dxfg->str),dxfg->str) )	goto err;
+		dxfg->xyz.y = dxf_round_coord(dxfg->str);
+	}
+	if (!dxf_gr()) goto err;
+	if (gr1 + 20 != dxfg->gr) {
+		g1 = dxfg->gr + GR_SHIFT;
+		dxfg->gr = gr1;
+		dxfg->xyz.z = dxf_38;
+	} else {
+		dxfg->gr = gr1;
+		if (dxfg->binary) {
+			if (!load_data(dxfg->bd, sizeof(sgFloat), &dxfg->xyz.z)) goto err;
+		} else {
+			if ( !load_str(dxfg->bd,sizeof(dxfg->str),dxfg->str) )	goto err;
+			dxfg->xyz.z = dxf_round_coord(dxfg->str);
+		}
+	}
+	return TRUE;
+err:
+	dxf_err(DXF_ERROR);
+	return FALSE;
+}
+
+static  BOOL dxf_str(void)
+{
+	short i;
+
+	for (i = 0; i < sizeof(dxfg->str); i++) {
+		if (!load_data(dxfg->bd, sizeof(char), &dxfg->str[i])) return FALSE;
+		if (!dxfg->str[i]) break;
+	}
+	if (i == sizeof(dxfg->str)) return FALSE;
+	return TRUE;
+}
+
+static  BOOL dxf_gr(void)
+{
+	UCHAR	gr;
+
+	if (dxfg->binary) {
+		if (ACAD_R13) {
+			
+			if (!load_data(dxfg->bd, sizeof(short), &dxfg->gr)) return FALSE;
+		} else {
+			if (!load_data(dxfg->bd, sizeof(UCHAR), &gr)) return FALSE;
+			if (gr == 255) {
+				if (!load_data(dxfg->bd, sizeof(short), &dxfg->gr)) return FALSE;
+			} else dxfg->gr = gr;
+		}
+	} else {
+		if (!load_str(dxfg->bd,sizeof(dxfg->str),dxfg->str)) return FALSE;
+		dxfg->gr = atoi(dxfg->str);
+	}
+	return TRUE;
+}

CSG/sgCore/Core/APLICAT/DXF/I_DXF.cpp

@@ -0,0 +1,316 @@
+#include "../../sg.h"
+
+lpDXF_GROUP dxfg;
+
+static  BOOL load_entities(lpLISTH listh, int last_block, BOOL first);
+static  BOOL load_blocks(int last_block);
+static  BOOL load_tables(void);
+
+BOOL ACAD_R13 = FALSE;
+
+short ImportDxf(lpBUFFER_DAT bd, lpLISTH listh)
+{
+	DXF_GROUP dxfgg;
+	short			count = (short)listh->num;
+	int			  last_block;
+	int				len;
+	char			code[2];
+
+	dxfg = &dxfgg;		
+	dxfg->bd = bd;    
+	len = strlen(dxf_binary_tytle) + 1;
+	if (load_data(bd, len, dxfg->str) != (WORD)len) return 0;
+	if (!strcmp(dxfg->str, dxf_binary_tytle)) {
+		dxfg->binary = TRUE;
+		if (load_data(bd, sizeof(code), code) != sizeof(code)) return 0;
+		if (code[1] == 0) ACAD_R13 = TRUE;
+		else              ACAD_R13 = FALSE;
+		if (!seek_buf(bd, (int)len)) return 0;
+	} else {
+		dxfg->binary = FALSE;
+		if (!seek_buf(bd, 0L)) return 0;
+	}
+	init_vdim(&dxfg->layers, sizeof(LAYER));
+	last_block = vd_blocks.num_elem;
+
+//	dxfg->num_proc = start_grad(GetIDS(IDS_SG004), bd->len_file);
+
+	if (application_interface && application_interface->GetProgresser()) 
+		application_interface->GetProgresser()->Progress(0);
+	while (1) {
+		if (!get_group(dxfg)) goto end;
+		switch (dxfg->gr ) {
+			case 0:
+				if (!memcmp(dxfg->str,dxf_keys[DXF_SECTION],7)) {
+					if (!get_group(dxfg)) goto end;
+					switch (dxfg->gr ) {
+						case 2:
+							if (!memcmp(dxfg->str,dxf_keys[DXF_TABLES],6)) {
+								if (!load_tables()) goto end;
+								break;
+							}
+							if (!memcmp(dxfg->str,dxf_keys[DXF_BLOCKS],6)) {
+								if (!load_blocks(last_block)) goto end;
+								break;
+							}
+							if (!memcmp(dxfg->str,dxf_keys[DXF_ENTITIES],8)) {
+								if (!load_entities(listh, last_block, FALSE)) goto end;
+								break;
+							}
+							break;
+					}
+					continue;
+				}
+				if (!memcmp(dxfg->str,dxf_keys[DXF_EOF],3)) goto end;
+		}
+	}
+end:
+//	end_grad(dxfg->num_proc , bd->len_file);
+	if (application_interface && application_interface->GetProgresser()) 
+		application_interface->GetProgresser()->Progress(100);
+	free_vdim(&dxfg->layers);
+	return ((short)listh->num) - count;
+}
+
+#pragma argsused
+static  BOOL load_entities(lpLISTH listh, int last_block, BOOL first)
+{
+	VDIM 	faces;
+	BOOL	ret;
+
+	init_vdim(&faces, sizeof(FACE4));
+	if (!first) {
+		if (!get_group(dxfg)) goto err;
+	}
+	while (1) {
+		if (dxfg->gr )	{
+			if (!get_group(dxfg)) goto err;
+			continue;  
+		}
+
+		if (!memcmp(dxfg->str,dxf_keys[DXF_LINE],4)) {
+			if (!dxf_line(listh)) goto err;
+			continue;
+		}
+		if (!memcmp(dxfg->str,dxf_keys[DXF_3DLINE],6)) {
+			if (!dxf_line(listh)) goto err;
+			continue;
+		}
+		if (!memcmp(dxfg->str,dxf_keys[DXF_CIRCLE],6)) {
+			if (!dxf_circle(listh)) goto err;
+			continue;
+		}
+		if (!memcmp(dxfg->str,dxf_keys[DXF_ARC],3)) {
+			if (!dxf_arc(listh)) goto err;
+			continue;
+		}
+		if (!memcmp(dxfg->str,dxf_keys[DXF_TEXT],4)) {
+			if (!dxf_text(listh)) goto err;
+			continue;
+		}
+		if (!memcmp(dxfg->str,dxf_keys[DXF_POLYLINE],8)) {
+			if (!dxf_poly(listh)) goto err;
+			continue;
+		}
+		if (!memcmp(dxfg->str,dxf_keys[DXF_INSERT],6)) {
+			if (!dxf_insert(listh, last_block)) goto err;
+			continue;
+		}
+		if (!memcmp(dxfg->str,dxf_keys[DXF_3DFACE],6)) {
+			if (!dxf_3dface(&faces)) goto err;
+			continue;
+		}
+		if (!memcmp(dxfg->str,dxf_keys[DXF_SOLID],5)) {
+			if (!dxf_solid(listh, &faces)) goto err;
+			continue;
+		}
+		if (!memcmp(dxfg->str,dxf_keys[DXF_ENDBLK],6)) goto ex;
+		if (!memcmp(dxfg->str,dxf_keys[DXF_ENDSEC],6)) goto ex;
+		if (!get_group(dxfg)) goto err;
+	}
+ex:
+	ret = TRUE;
+	{	
+		TRI_BIAND		trb;
+		lpFACE4			face;
+		BOOL				first;
+		int					i, color, layer, flag;
+		OBJ_ATTRIB	save_obj_attrib;
+		int				rest;
+
+		rest = faces.num_elem;
+		while (rest > 0) {
+			if ( !begin_tri_biand(&trb) ) goto err;
+			first = TRUE;
+			if (!begin_rw(&faces, 0)) goto err;
+			for	(i = 0; i < faces.num_elem; i++) {
+				if ((face = (FACE4*)get_next_elem(&faces)) == NULL) goto err;
+				if (face->flag) {
+					if (first) {
+						color = face->color;
+						layer = face->layer;
+						first = FALSE;
+					}
+					if (face->color == color &&
+							face->layer == layer) {
+						flag = 0;
+						flag |= (face->flag_v & 1) ? TRP_DUMMY      : TRP_APPROCH;
+						flag |= (face->flag_v & 2) ? TRP_DUMMY << 2 : TRP_APPROCH << 2;
+						flag |= (face->flag_v & 4) ? TRP_DUMMY << 4 : TRP_APPROCH << 4;
+						flag |= (face->flag_v & 8) ? TRP_DUMMY << 6 : TRP_APPROCH << 6;
+						if (!(ret = put_face_4(&face->p1, &face->p2,
+																	 &face->p3, &face->p4,
+																	 flag,
+																	 &trb))) break;
+						face->flag = FALSE;
+						if (!(--rest)) break;	
+					}
+				}
+			}	// for
+			end_rw(&faces);
+			save_obj_attrib = obj_attrib;
+			obj_attrib.color = (BYTE)color;
+			obj_attrib.flg_transp	= TRUE;
+			ret = end_tri_biand(&trb, listh);
+			obj_attrib = save_obj_attrib;
+			if (!ret) break;
+		}	// while
+	}
+ex2:
+	free_vdim(&faces);
+	return ret;
+err:
+	ret = FALSE;
+	goto ex2;
+}
+
+
+static  BOOL load_blocks(int last_block)
+{
+	IBLOCK		blk;
+	D_POINT		v;            
+	int				flag;
+	hOBJ			hobj, hnext;
+	D_POINT		min, max;
+	MATR			matr;
+	BOOL			Bool;
+
+	if (!get_group(dxfg)) goto err;
+	while (1) {
+		switch (dxfg->gr ) {
+			case 0:
+				if (!memcmp(dxfg->str,dxf_keys[DXF_BLOCK],5)) {
+					
+					memset(&blk,0,sizeof(blk));
+					memset(&v,0,sizeof(v));
+					flag = 0;
+					while (1) {
+						if (!get_group(dxfg)) goto err;
+						switch (dxfg->gr) {
+							case 0:
+								break;
+							case 2:	
+								strncpy(blk.name, dxfg->str, MAXBLOCKNAME);
+								blk.name[MAXBLOCKNAME - 1] = 0;
+								continue;
+							case 70:	
+								flag = dxfg->f;
+								continue;
+							case 10:	
+								v = dxfg->xyz;
+								continue;
+							default:
+								continue;
+						}
+						break;
+					}
+					if ((flag & (4 | 16 | 32)) != 0 && (flag & 64) == 0)
+						break;	
+					Bool = load_entities(&blk.listh, last_block, TRUE);
+					if (blk.listh.num) {							
+						
+						o_hcunit(matr);
+						o_tdtran(matr, dpoint_inv(&v, &v));
+						
+						hobj = blk.listh.hhead;
+						blk.min.x = blk.min.y = blk.min.z =  GAB_NO_DEF;
+						blk.max.x = blk.max.y = blk.max.z = -GAB_NO_DEF;
+						while (hobj) {
+							if (!o_trans(hobj, matr)) goto del;
+							if (!get_object_limits(hobj, &min, &max)) goto del;
+							union_limits(&min, &max, &blk.min, &blk.max);
+							get_next_item(hobj, &hobj);
+						}
+						if (!add_elem(&vd_blocks,&blk)) goto del;
+					}
+					if (!Bool && !blk.listh.num) goto err;
+					break;
+				}
+				if (!memcmp(dxfg->str,dxf_keys[DXF_ENDSEC],6)) goto ex;
+		}
+		if (!get_group(dxfg)) goto err;
+	}
+del:
+	hobj = blk.listh.hhead;
+	while (hobj) {
+		get_next_item(hobj, &hnext);
+		o_free(hobj, NULL);
+		hobj = hnext;
+	}
+	goto err;
+ex:
+	return TRUE;
+err:
+	return FALSE;
+}
+
+static  BOOL load_tables(void)
+{
+	LAYER	elem;
+	BOOL	tog;
+
+	if (!get_group(dxfg)) goto err;
+	while (1) {
+		switch (dxfg->gr ) {
+			case 0:
+				if (!memcmp(dxfg->str,dxf_keys[DXF_TABLE],5)) {
+					
+					if (!get_group(dxfg)) break;
+					if (!memcmp(dxfg->str,dxf_keys[DXF_LAYER],5)) {
+						
+						tog = FALSE;
+						while (1) {
+							if (!get_group(dxfg)) break;
+							switch (dxfg->gr) {
+								case 0:
+									if (tog) break;
+									continue;
+								case 2:
+									strncpy(elem.name,dxfg->str,LEN_NAME_LAYER);
+									elem.name[LEN_NAME_LAYER] = 0;
+									tog = TRUE;
+									continue;
+								case 62:
+									elem.color = dxfg->p;
+									continue;
+								default:
+									continue;
+							}
+							if (tog) {
+								if (!add_elem(&dxfg->layers, &elem)) goto err;
+								tog = FALSE;
+							}
+							if (!memcmp(dxfg->str,dxf_keys[DXF_ENDTAB],5)) break;
+						}
+					}
+				}
+				if (!memcmp(dxfg->str,dxf_keys[DXF_ENDSEC],6)) goto ex;
+		}
+		if (!get_group(dxfg)) goto err;
+	}
+ex:
+	return TRUE;
+err:
+	return FALSE;
+}
+

CSG/sgCore/Core/APLICAT/DXF/OCS_GCS.cpp

@@ -0,0 +1,26 @@
+
+#include "../../sg.h"
+
+void ocs_gcs(lpD_POINT N, MATR A, MATR iA)
+{
+	D_POINT Wy = {0, 1, 0}, Wz = {0, 0, 1}, Ax, Ay;
+	sgFloat c = 1. / 64.;
+
+	
+	if (fabs(N->x) < c && fabs(N->y) < c) dvector_product(&Wy, N, &Ax);
+	else 																	dvector_product(&Wz, N, &Ax);
+	dnormal_vector(&Ax);
+	dvector_product(N, &Ax, &Ay);
+	dnormal_vector(&Ay);
+	o_hcunit(A);
+	A[0]  = Ax.x;
+	A[1]  = Ay.x;
+	A[2]  = N->x;
+	A[4]  = Ax.y;
+	A[5]  = Ay.y;
+	A[6]  = N->y;
+	A[8]  = Ax.z;
+	A[9]  = Ay.z;
+	A[10] = N->z;
+	o_minv(A, iA);
+}

CSG/sgCore/Core/APLICAT/DXF/POL_M64.cpp

@@ -0,0 +1,115 @@
+#include "../../sg.h"
+
+static BOOL get_vertex(lpVDIM vertex, int num, int count, lpD_POINT p);
+
+BOOL poly_mesh64(short color, lpLISTH listh)
+{
+	short      		count;     
+	D_POINT 		v;
+	int					flag_v;
+	TRI_BIAND		trb;
+	BOOL				ret;
+	OBJ_ATTRIB	save_obj_attrib;
+	VDIM				vertex;
+	int					num1, num2, num3, num4, flag;
+	D_POINT			p1, p2, p3, p4;
+	GEO_LINE		line;
+
+	if (!init_vdim(&vertex, sizeof(D_POINT))) return FALSE;
+
+	if ( !begin_tri_biand(&trb) ) goto fat_err;
+	count = 0;	
+	for (;;) {
+		if (!memcmp(dxfg->str,dxf_keys[DXF_VERTEX],6))  {
+			num1 = num2 = num3 = num4 = 0;
+			while (1) {
+				if (!get_group(dxfg)) goto err2;
+				switch (dxfg->gr) {
+					case 10:
+						v = dxfg->xyz;
+						continue;
+					case 70:
+						flag_v = dxfg->f;
+						continue;
+					case 71:
+						num1 = dxfg->f;
+						continue;
+					case 72:
+						num2 = dxfg->f;
+						continue;
+					case 73:
+						num3 = dxfg->f;
+						continue;
+					case 74:
+						num4 = dxfg->f;
+						continue;
+					case 0:
+						break;
+					default:
+						continue;
+				}
+				break;
+			}
+			if (flag_v & 64) {	
+				if (!add_elem(&vertex, &v)) goto err2;
+				count++;
+				continue;
+			}
+			if (!num1) continue;
+			if (!get_vertex(&vertex, num1, count, &p1)) goto err2;
+			if (!num2) continue;
+			if (!get_vertex(&vertex, num2, count, &p2)) goto err2;
+			if (!num3) {
+				line.v1 = p1;
+				line.v2 = p2;
+				if ( !cr_add_obj(OLINE, color, (lpGEO_SIMPLE)&line,
+												 listh, NULL, FALSE)) goto err2;
+				continue;
+			}
+			if (!get_vertex(&vertex, num3, count, &p3)) goto err2;
+			if (num4) {
+				if (!get_vertex(&vertex, num4, count, &p4)) goto err2;
+			} else p4 = p3;
+			flag = 0;
+			flag |= (num1 < 0) ? TRP_DUMMY      : TRP_APPROCH;
+			flag |= (num2 < 0) ? TRP_DUMMY << 2 : TRP_APPROCH << 2;
+			flag |= (num3 < 0) ? TRP_DUMMY << 4 : TRP_APPROCH << 4;
+			flag |= (num4 < 0) ? TRP_DUMMY << 6 : TRP_APPROCH << 6;
+			if (!put_face_4(&p1, &p2, &p3, &p4, flag, &trb)) goto err2;
+			continue;
+		}
+		if (memcmp(dxfg->str,dxf_keys[DXF_SEQEND],6) == 0) break;
+		put_message(INTERNAL_ERROR,"pol_m64.c",0);
+		goto err2;	
+	}
+	free_vdim(&vertex);
+	save_obj_attrib = obj_attrib;
+	obj_attrib.color = (BYTE) color;
+	obj_attrib.flg_transp	= TRUE;
+	ret = end_tri_biand(&trb, listh);
+	obj_attrib = save_obj_attrib;
+	return ret;
+
+err2:
+	save_obj_attrib = obj_attrib;
+	obj_attrib.color = (BYTE) color;
+	obj_attrib.flg_transp	= TRUE;
+	/*nb ret = */end_tri_biand(&trb, listh);
+	obj_attrib = save_obj_attrib;
+fat_err:
+	free_vdim(&vertex);
+	skip_vertex();
+	return FALSE;
+}
+
+static BOOL get_vertex(lpVDIM vertex, int num, int count, lpD_POINT p)
+{
+	int	n = abs(num);
+
+	if (n > count) {
+		dxf_err(DXF_ERROR);
+		return FALSE;
+	}
+	if (!read_elem(vertex, n - 1, p)) return FALSE;
+	return TRUE;
+}

CSG/sgCore/Core/APLICAT/DXF/POL_MESH.cpp

@@ -0,0 +1,126 @@
+#include "../../sg.h"
+
+static BOOL write_sloy(lpD_POINT v1, lpD_POINT v2, int num, lpTRI_BIAND trb);
+
+BOOL poly_mesh(short m, short flag, short color, lpLISTH listh)
+{
+	D_POINT 		*sl = NULL; 
+	D_POINT 		*v1;
+	D_POINT 		*v2;
+	short      		count;      
+	D_POINT 		v;
+	int					flag_v;
+	int					first = 1;
+	TRI_BIAND		trb;
+	BOOL				ret;
+	int					m1;
+	OBJ_ATTRIB	save_obj_attrib;
+
+	if (flag & 32) m1 = m + 1;	
+	else           m1 = m;
+	if ((v1 = (D_POINT*)SGMalloc(m1 * sizeof(D_POINT))) == NULL) {
+skip1:
+		put_message(NOT_ENOUGH_HEAP, NULL, 0);
+		return skip_vertex();
+	}
+	if ((v2 = (D_POINT*)SGMalloc(m1 * sizeof(D_POINT))) == NULL) {
+skip2:
+		SGFree(v1);
+ //nb 		v1 = NULL;
+		goto skip1;
+	}
+	if (flag & 1) {	
+		if ((sl =(D_POINT*)SGMalloc(m1 * sizeof(D_POINT))) == NULL) {
+//nb skip3:
+			SGFree(v2);
+ //nb 			v2 = NULL;
+			goto skip2;
+		}
+	}
+
+	if ( !begin_tri_biand(&trb) ) goto fat_err;
+	count = 0;	
+	for (;;) {
+		if( !memcmp(dxfg->str,dxf_keys[DXF_VERTEX],6) )  {
+			while (1) {
+				if (!get_group(dxfg)) goto fat_err;
+				switch (dxfg->gr) {
+					case 10:
+						v = dxfg->xyz;
+						continue;
+					case 70:
+						flag_v = dxfg->f;
+						continue;
+					case 0:
+						break;
+					default:
+						continue;
+				}
+				break;
+			}
+			if ((flag & 4) && (flag_v & 16))
+				continue; 
+			memcpy(&v2[count++], &v, sizeof(D_POINT));
+			if (count == m) {
+				count = 0;
+				if (flag & 32) v2[m] = v2[0];
+				if (first && (flag & 1)) {
+					memcpy(sl, v2, m1 * sizeof(D_POINT));
+				}
+				if (!first) {
+					if (!write_sloy(v1, v2, m1, &trb)) goto fat_err;
+				}
+				memcpy(v1, v2, m1 * sizeof(D_POINT));
+				first = 0;
+			}
+			continue;
+		}
+		if (memcmp(dxfg->str,dxf_keys[DXF_SEQEND],6) == 0) {
+			if (flag & 1) {         
+				memcpy(v2, sl, m1 * sizeof(D_POINT));
+				if (!write_sloy(v1, v2, m1, &trb)) goto fat_err;
+			}
+			
+			while (TRUE) {
+				if (!get_group(dxfg)) goto fat_err;
+				if (dxfg->gr == 0) break;
+			}
+			break;
+		}
+		goto fat_err;	
+	}
+	if (v1) SGFree(v1); //nb v1 = NULL;
+	if (v2) SGFree(v2); //nb v2 = NULL;
+	if (sl) SGFree(sl); //nb sl = NULL;
+	save_obj_attrib = obj_attrib;
+	obj_attrib.color = (BYTE)color;
+	obj_attrib.flg_transp	= TRUE;
+	ret = end_tri_biand(&trb, listh);
+	obj_attrib = save_obj_attrib;
+	return ret;
+
+fat_err:
+	save_obj_attrib = obj_attrib;
+	obj_attrib.color = (BYTE)color;
+	obj_attrib.flg_transp	= TRUE;
+	/*nb ret = */end_tri_biand(&trb, listh);
+	obj_attrib = save_obj_attrib;
+	if (v1) SGFree(v1); //nb v1 = NULL;
+	if (v2) SGFree(v2); //nb v2 = NULL;
+	if (sl) SGFree(sl); //nb sl = NULL;
+	skip_vertex();
+	return FALSE;
+}
+
+static BOOL write_sloy(lpD_POINT v1, lpD_POINT v2, int num, lpTRI_BIAND trb)
+{
+	int		i;
+
+	for (i = 0; i < num - 1; i++) {
+		if (!put_face_4(&v1[i], &v1[i+1], &v2[i+1], &v2[i],
+				TRP_APPROCH | (TRP_APPROCH << 2) | (TRP_APPROCH << 4) |
+				(TRP_APPROCH << 6), trb))
+			return FALSE;
+	}
+	return TRUE;
+}

CSG/sgCore/Core/APLICAT/DXF/POL_PATH.cpp

@@ -0,0 +1,231 @@
+#include "../../sg.h"
+
+
+
+BOOL poly_path(sgFloat height, short flag, short type, short color,
+							lpLISTH listh2, BOOL  flag_h, lpD_POINT v, lpD_POINT p10)
+{
+	D_POINT 		first, prev, next, last, min, max, vc, vb, ve, tmp, p0, p1, p01;
+	lpD_POINT		point, pnt;
+	sgFloat 			tang4, save_tang4, r;	//, derivate;
+	sgFloat 			xm, ym, zm, h, ss, cc, xc, yc;
+	short 			ff, closing, flag_v = 0, i;
+	BOOL				ret;
+	LISTH				listh;
+	GEO_LINE		line;
+	GEO_ARC			arc;
+	GEO_PATH		path;
+	GEO_SPLINE	spline;
+	VDIM				vdim;
+	MATR				gcs_pl, pl_gcs;
+	hOBJ				hobj;
+	lpOBJ				obj;
+	int					nump, step, j, k, degree;
+
+	init_listh(&listh);
+	init_vdim(&vdim, sizeof(D_POINT));
+	if (flag & 4) ff = 1; else ff = 0;
+	closing = 0;
+	for (;;) {
+		if(memcmp(dxfg->str,dxf_keys[DXF_SEQEND],6) == 0) {
+			if (flag & 4) break;
+			if (flag & 1) {         
+				closing = 1;
+				memcpy(&next,&first,sizeof(first));
+				goto cls;
+			}
+			break;
+		}
+
+		if( !memcmp(dxfg->str,dxf_keys[DXF_VERTEX],6) )  {
+
+			tang4 = 0.;
+//			derivate = 0;
+			while (1) {
+				if (!get_group(dxfg)) goto err;
+				switch (dxfg->gr) {
+					case 10:
+						next = dxfg->xyz;
+						if (!(flag & 8))
+							next.z = p10->z;	
+						continue;
+					case 0:
+						break;
+					case 42:
+						tang4 = dxfg->v;
+						continue;
+					case 70:
+						flag_v = dxfg->f;
+						continue;
+//					case 50:	
+//						derivate = dxfg->a;
+//						continue;
+					default:
+						continue;
+				}
+				break;
+			}
+			if ((flag & 4) && (flag_v & 8)) 
+				continue;
+			if ( ff == 0) {
+				memcpy(&prev,&next,sizeof(prev));
+				save_tang4 = tang4;
+				memcpy(&first,&prev,sizeof(prev));
+				ff=1;
+				continue;
+			}
+cls:
+			if (flag & 4) {	
+				o_hcncrd(dxfg->ocs_gcs, &next, &prev);
+				if (!vdim.num_elem || !dpoint_eq(&last, &prev, eps_d)) {
+					if (!add_elem(&vdim, &prev)) goto err;
+					last = prev;
+				}
+			} else {	
+				if (save_tang4 == 0.) {
+					o_hcncrd(dxfg->ocs_gcs, &prev, &line.v1);
+					o_hcncrd(dxfg->ocs_gcs, &next, &line.v2);
+					if (!dpoint_eq(&line.v1, &line.v2, eps_d)) {
+						if ( !cr_add_obj(OLINE, color, (lpGEO_SIMPLE)&line,
+														 &listh, NULL, FALSE)) goto err;
+					}
+				} else {
+					if (!dpoint_eq(&prev, &next, eps_d)) {
+						xm = 0.5 * (prev.x + next.x);
+						ym = 0.5 * (prev.y + next.y);
+						zm = 0.5 * (prev.z + next.z);
+						r  = sqrt((xm-prev.x)*(xm-prev.x) +
+											(ym-prev.y)*(ym-prev.y) +
+											(zm-prev.z)*(zm-prev.z));
+						save_tang4 = 1.0 / save_tang4;
+						h  = 0.5 * r * (save_tang4 * save_tang4 - 1.0) / save_tang4;
+						ss = (prev.y - ym) / r;
+						cc = (prev.x - xm) / r;
+						xc = xm + h * ss;
+						yc = ym - h * cc;
+ //nb						r = sqrt((xc-prev.x)*(xc-prev.x)+(yc-prev.y)*(yc-prev.y));
+						
+						vc.x = xc; vc.y = yc; vc.z = prev.z;
+						o_hcncrd(dxfg->ocs_gcs, &vc, &vc);
+						o_hcncrd(dxfg->ocs_gcs, &prev, &vb);
+						o_hcncrd(dxfg->ocs_gcs, &next, &ve);
+						
+						if (save_tang4 < 0) {
+							tmp = vb; vb = ve; ve = tmp;
+						}
+						
+						o_hcunit(gcs_pl);
+						o_tdtran(gcs_pl, dpoint_inv(&vc, &tmp));
+						o_hcrot1(gcs_pl, v);
+						o_minv(gcs_pl, pl_gcs);
+						o_hcncrd(gcs_pl, &vc, &vc);
+						o_hcncrd(gcs_pl, &vb, &vb);
+						o_hcncrd(gcs_pl, &ve, &ve);
+						
+						if (!arc_b_e_c(&vb, &ve, &vc,
+													 TRUE, FALSE, FALSE, &arc)) goto err2;
+						
+						o_hcncrd(pl_gcs, &arc.vc, &arc.vc);
+						o_hcncrd(pl_gcs, &arc.vb, &arc.vb);
+						o_hcncrd(pl_gcs, &arc.ve, &arc.ve);
+						arc.n = *v;
+						if ( !cr_add_obj(OARC, color, (lpGEO_SIMPLE)&arc,
+														 &listh, NULL, FALSE)) goto err;
+						
+						if (save_tang4 < 0) {
+							hobj = listh.htail;
+							obj = (lpOBJ)hobj;
+							obj->status |= ST_DIRECT;
+						}
+					}
+				}
+			}
+			if (closing) break;
+			memcpy(&prev,&next,sizeof(prev));
+			save_tang4 = tang4;
+			continue;
+		}
+		if (!get_group(dxfg)) goto err;
+	}
+	if (flag & 4) {
+		degree = (type == 5) ? 2 : 3;
+		if (vdim.num_elem == 2) {	
+			if (!read_elem(&vdim, 0, &p0)) goto err;
+			if (!read_elem(&vdim, 1, &p1)) goto err;
+			dpoint_parametr(&p0, &p1, 0.5, &p01);
+			if (!add_elem(&vdim, &p1)) goto err;
+			if (!write_elem(&vdim, 1, &p01)) goto err;
+		}
+		if (vdim.num_elem < degree + 2) {
+			degree = (short)vdim.num_elem - 2;
+			if (degree < 1) goto err2;	
+		}
+		spline.type = SPLY_NURBS | SPLY_APPR;
+		spline.degree = degree;
+		if (flag & 1) {
+			spline.type |= SPLY_CLOSE;
+			if (!read_elem(&vdim, 0, &p0)) goto err;
+			if (!read_elem(&vdim, vdim.num_elem - 1, &p1)) goto err;
+			if (!dpoint_eq(&p0, &p1, eps_d)) {
+				if (!add_elem(&vdim, &p0)) goto err;
+			}
+		}
+		nump = (short)vdim.num_elem;
+		if (nump > MAX_POINT_ON_SPLINE) {
+			step = (nump - 1) / MAX_POINT_ON_SPLINE + 1;
+			j = nump / step;
+			if (1 + j * step > nump) j--;
+			if (1 + j * step < nump) j++;
+			nump = j + 1;
+		} else step = 1;
+		spline.nump = nump;
+		spline.numd = 0;
+		if ((spline.hpoint = SGMalloc(sizeof(D_POINT)*nump)) == NULL) goto err;
+		spline.hderivates = 0;
+		if (!begin_rw(&vdim, 0)) {
+err4:
+			SGFree(spline.hpoint);
+			goto err;
+		}
+		point = (lpD_POINT)spline.hpoint;
+		for (i = 0, j = 0, k = 0; i < vdim.num_elem; i++) {
+			if ((pnt = (D_POINT*)get_next_elem(&vdim)) == NULL) {
+				end_rw(&vdim);
+				goto err4;
+			}
+			if (!j || i == vdim.num_elem - 1) {
+				if (k < nump)	point[k++] = *pnt;
+			}
+			j++;
+			if (j == step) j = 0;
+		}
+		end_rw(&vdim);
+		ret = dxf_extrude(OSPLINE, color, (lpGEO_SIMPLE)&spline, listh2,
+											flag_h, v, height, FALSE);
+		if (!ret) goto err;
+	} else {
+		if (!listh.num) goto err2;
+		memset(&path, 0, sizeof(path));
+		o_hcunit(path.matr);
+		path.listh = listh;
+		hobj = listh.hhead;
+		path.min.x = path.min.y =  path.min.z =  GAB_NO_DEF;
+		path.max.x = path.max.y =  path.max.z = -GAB_NO_DEF;
+		while (hobj) {
+			if (!get_object_limits(hobj, &min, &max)) goto err;
+			union_limits(&min, &max, &path.min, &path.max);
+			get_next_item(hobj, &hobj);
+		}
+		ret = dxf_extrude(OPATH, color, (lpGEO_SIMPLE)&path, listh2,
+											flag_h, v, height, FALSE);
+	}
+	goto ex;
+err:
+	ret = FALSE;
+	goto ex;
+err2:
+	ret = TRUE;
+ex:
+	free_vdim(&vdim);
+	return ret;
+}

CSG/sgCore/Core/APLICAT/DXF/PUTDXFGR.cpp

@@ -0,0 +1,91 @@
+#include "../../sg.h"
+
+
+#define DG_UNK   0
+#define DG_STR   1
+#define DG_DBL   2
+#define DG_INT   3
+
+static short   dxf_gr_bnum[] =
+  {0,      10,     60,     140,    170,    210,    999,    1010,   1060};
+static short   dxf_gr_enum[] =
+  {9,      59,     79,     147,    175,    239,    1009,   1059,   1079};
+static UCHAR dxf_gr_type[] =
+  {DG_STR, DG_DBL, DG_INT, DG_DBL, DG_INT, DG_DBL, DG_STR, DG_DBL, DG_INT};
+
+extern bool dxf_binary_flag;
+
+BOOL put_vertex_to_dxf(lpBUFFER_DAT bd, int gr_num, lpD_POINT p)
+
+{
+short    i;
+sgFloat *d = (sgFloat*)p;
+  for(i = 0; i < 3; i++, gr_num += 10)
+    if(!put_dxf_group(bd, gr_num, &d[i])) return FALSE;
+  return TRUE;
+}
+
+BOOL put_dxf_group(lpBUFFER_DAT bd, int GrNum, void *par)
+
+{
+char   buf[MAX_sgFloat_STRING];
+char   pk[2]  = {'\r','\n'};
+short    j, gr_type = DG_UNK;
+char   *c;
+short    *i;
+sgFloat *d;
+UCHAR  ng = 255;
+short gr_num;
+
+  gr_num = (short)GrNum;
+
+	if(dxf_binary_flag){
+		if(gr_num == 999) return TRUE;
+		if(gr_num >  255){
+			if(!story_data(bd, sizeof(UCHAR), &ng)) return FALSE;
+			if(!story_data(bd, sizeof(short), &gr_num)) return FALSE;
+		}
+		else{
+			ng = (BYTE)gr_num;
+			if(!story_data(bd, sizeof(UCHAR), &ng)) return FALSE;
+		}
+	}
+	else{
+		sprintf(buf, "%3d", gr_num);
+		if(!story_data(bd, strlen(buf), buf)) return FALSE;
+		if(!story_data(bd, 2, pk))            return FALSE;
+	}
+
+
+	for(j = 0; j < sizeof(dxf_gr_bnum)/sizeof(short); j++)
+		if(gr_num >= dxf_gr_bnum[j] && gr_num <= dxf_gr_enum[j]){
+			gr_type = dxf_gr_type[j];
+			break;
+		}
+
+	switch(gr_type){
+		case DG_STR:
+			c = (char*)par;
+			if(dxf_binary_flag) return story_data(bd, strlen(c) + 1, c);
+			if(!story_data(bd, strlen(c), c)) return FALSE;
+			break;
+		case DG_INT:
+			i = (short*)par;
+			if(dxf_binary_flag) return story_data(bd, sizeof(short), i);
+			sprintf(buf, "%6d", *i);
+			if(!story_data(bd, strlen(buf), buf)) return FALSE;
+			break;
+		case DG_DBL:
+			d = (sgFloat*)par;
+			if(dxf_binary_flag) return story_data(bd, sizeof(sgFloat), d);
+      sgFloat_to_text_for_export(buf, *d);
+			if(!story_data(bd, strlen(buf), buf)) return FALSE;
+			break;
+		default:
+			put_message(INTERNAL_ERROR, "DXFOUT", 0);
+			return FALSE;
+	}
+	if(!story_data(bd, 2, pk)) return FALSE;
+
+	return TRUE;
+}

CSG/sgCore/Core/APLICAT/DXF/PUT_FACE.cpp

@@ -0,0 +1,87 @@
+#include "../../sg.h"
+
+
+static BOOL put_tri2(lpTRI_BIAND trb,
+										 lpD_POINT p1, lpD_POINT p2, lpD_POINT p3,
+										 int f1, int f2, int f3);
+
+BOOL put_face_4(lpD_POINT p1, lpD_POINT p2, lpD_POINT p3, lpD_POINT p4,
+								int flag_v, lpTRI_BIAND trb)
+{
+	D_POINT s1, s2, s3, s4, e12, e13, e14, e23, e24;
+	sgFloat 	r1, r2, r3, r4, c1, c2, eps_d2 = eps_d * eps_d;
+	BOOL		ret = TRUE;
+	int			f1, f2, f3, f4;
+	BOOL 		l1, l2, l3, l4;
+
+	f1 = flag_v        & 3;
+	f2 = (flag_v >> 2) & 3;
+	f3 = (flag_v >> 4) & 3;
+	f4 = (flag_v >> 6) & 3;
+	dpoint_sub(p2, p1, &e12);
+	dpoint_sub(p3, p1, &e13);
+	dpoint_sub(p4, p1, &e14);
+	dvector_product(&e12, &e13, &s1);
+	r1 = dskalar_product(&s1, &s1);
+	dvector_product(&e13, &e14, &s2);
+	r2 = dskalar_product(&s2, &s2);
+	dpoint_sub(p3, p2, &e23);
+	dpoint_sub(p4, p2, &e24);
+	dvector_product(&e12, &e14, &s3);
+	r3 = dskalar_product(&s3, &s3);
+	dvector_product(&e23, &e24, &s4);
+	r4 = dskalar_product(&s4, &s4);
+	dnormal_vector(&s1);
+	dnormal_vector(&s2);
+	dnormal_vector(&s3);
+	dnormal_vector(&s4);
+	c1 = dskalar_product(&s1, &s2);
+	c2 = dskalar_product(&s3, &s4);
+	l1 = (fabs(r1) < eps_d2) ? FALSE : TRUE;
+	l2 = (fabs(r2) < eps_d2) ? FALSE : TRUE;
+	l3 = (fabs(r3) < eps_d2) ? FALSE : TRUE;
+	l4 = (fabs(r4) < eps_d2) ? FALSE : TRUE;
+	if (l1 && l2 && c1 <= 0) l1 = l2 = FALSE;
+	if (l3 && l4 && c2 <= 0) l3 = l4 = FALSE;
+	if ((!l1 && !l2) && (!l3 && !l4))
+		return TRUE;	
+	if ((!l1 || !l2) && (l3 && l4)) {
+		ret = put_tri2(trb, p1, p2, p4, f1, TRP_DUMMY, f4);
+		if (ret) ret = put_tri2(trb, p2, p3, p4, f2, f3, TRP_DUMMY);
+	} else if ((!l3 || !l4) && (l1 && l2)) {
+		ret = put_tri2(trb, p1, p2, p3, f1, f2, TRP_DUMMY);
+		if (ret) ret = put_tri2(trb, p1, p3, p4, TRP_DUMMY, f3, f4);
+	} else if (l1 && l2 & l3 & l4) { 
+		r1 = min(r1, r2);
+		r3 = min(r3, r4);
+		if (r1 < r3) {
+			ret = put_tri2(trb, p1, p2, p4, f1, TRP_DUMMY, f4);
+			if (ret) ret = put_tri2(trb, p2, p3, p4, f2, f3, TRP_DUMMY);
+		} else {
+			ret = put_tri2(trb, p1, p2, p3, f1, f2, TRP_DUMMY);
+			if (ret) ret = put_tri2(trb, p1, p3, p4, TRP_DUMMY, f3, f4);
+		}
+	} else if(l2 && l4) {		// p1 == p2
+		ret = put_tri2(trb, p2, p3, p4, f2, f3, f4);
+	} else if (l2 && l3) {	// p2 == p3
+		ret = put_tri2(trb, p1, p2, p4, f1, f3, f4);
+	} else if (l1 && l3) { 	// p3 == p4
+		ret = put_tri2(trb, p1, p2, p3, f1, f2, f4);
+	} else if (l1 && l4) { 	// p1 == p4
+		ret = put_tri2(trb, p1, p2, p3, f1, f2, f3);
+	}
+	return ret;
+}
+
+static BOOL put_tri2(lpTRI_BIAND trb,
+										 lpD_POINT p1, lpD_POINT p2, lpD_POINT p3,
+										 int f1, int f2, int f3)
+{
+	NPTRP		trp;
+
+	trp.constr = (UCHAR)(f1 | (f2 << 2) | (f3 << 4));
+	trp.v[0] = *p1;
+	trp.v[1] = *p2;
+	trp.v[2] = *p3;
+	return put_tri(trb, &trp);
+}