INSHAPE 3D Modeler & Shader


Dateiformat - Object

(c)1990-93 by Roald Christesen



Diese Formatbeschreibung soll es Ihnen ermglichen, Programme zu schreiben,
die Objekte im InShape Format lesen und/oder schreiben. Es werden nachein-
ander die bentigten Datentypen, Konstanten und Datenstrukturen erlutert.
Es folgt eine Beschreibung des Datei-Aufbaus. Am Ende wird Schrittweise 
aufgezeigt, wie eine Datei geschrieben wird.



/********
 *
 *	DATENTYPEN
 *
 ********/


Bezeichn.	Speicherbedarf											PureC-Typ
----------------------------------------------------------------------------
CHAR			signed 8 Bit											char
BYTE			signed 8 Bit											char
UBYTE			unsigned 8 Bit											unsigned char
INT			signed 16 Bit											int
UINT			unsigned 16 Bit										unsigned int
LONG			signed 32 Bit											long
ULONG			unsigned 32 Bit										unsigned long
FLOAT			floating point 32 Bit, single precision		float
REAL			floating point 80 Bit, double precision		double



/********
 *
 *	KONSTANTEN
 *
 ********/


/* Layer Flags */
#define LAYER_DISP			0x1	/* Layer wird angezeigt */
#define LAYER_EDIT			0x2	/* Layer ist editierbar */

/* Surface Flags */
#define SRF_IMAGE				0x1	/* Bild verwenden (Image-Mapping) */
#define SRF_NOSHADOW			0x2	/* Surface wirft keine Schatten */
#define SRF_RFILTER			0x4	/* Reflektionen filtern */
#define SRF_TFILTER			0x8	/* Transparenz  filtern */

/* Surface Refraction */
#define SRF_REFR_AIR			0
#define SRF_REFR_WATER		1
#define SRF_REFR_GLASS		2
#define SRF_REFR_CRYSTAL	3
#define SRF_REFR_DIAMOND	4

/* Image Projektionstyp */
#define IMG_PROJ_PLANE		0	/* Ebenen-Projektion */
#define IMG_PROJ_OCYLINDER	1	/* Zylinder-Projektion auen */
#define IMG_PROJ_ICYLINDER	2	/* Zylinder-Projektion innen */



/********
 *
 *	STRUKTUREN
 *
 ********/


V3S
	3D Vektor im float Format (single precision).

typedef struct
{
	FLOAT		x, y, z;
} V3S;


V3D
	3D Vektor im double Format (double precision).

typedef struct
{
	REAL		x, y, z;
} V3D;


V3L
	3D Vektor im long Format

typedef struct
{
	LONG	x, y, z;
} V3L;


LAYER
	Die Layer-Struktur enthlt alle Angaben eines Layers aus einem Objekt.
	Diese Struktur ist in der Objekt-Datei 16-fach vorhanden.

typedef struct
{
	CHAR		name[17];	/* Layer Name (Nullterminierter String) */
	INT		flags;		/* siehe unten */
	LONG		pnt_n;		/* Anzahl Punkte */
	LONG		pln_n;		/* Anzahl Flchen */
} LAYER;

Fr flags knnen folgende Konstanten verknpft werden:

	LAYER_DISP	-	Kennzeichnet, ob das Layer im Objekteditor angezeigt
						werden soll (Checkbox im Layer-Formular).

	LAYER_EDIT	-	Kennzeichnet, ob das Layer im Objekteditor editierbar
						ist (Checkbox im Layer-Formular).



SRF
	Oberflchenbeschreibung (Surface).

typedef struct
{
	CHAR		name[21];	/* Surface Name (Nullterminierter String) */
	SRF_MAT	mat1;			/* Grund-Material (siehe Surface Material) */
	SRF_MAT	mat2;			/* Zweit-Material (bei Verwendung eines 		
					   			Pattern's */
	UBYTE		ptrn_id;		/* Pattern Nummer (0 - 29) */
	UBYTE		ptrn_dir;	/* Richtung (0 - 3) */
	FLOAT		ptrn_scale;	/* Skalierung (0.0001 - 1000.0) */
	UBYTE		bump_id;		/* Bumpmap Nummer (0 - 8) */
	FLOAT		bump_amount;/* Intensitt (0.0001 - 1.0) */
	FLOAT		bump_scale;	/* Skalierung (0.0001 - 1000.0) */
	UBYTE		flags;		/* siehe unten */
} SRF;

Fr ptrn_id sind folgende Werte mglich:

	 0	OFF (default)
	 1	Marble
	 2	Marble thin
	 3	Marble thick
	 4	Marble turb.
	 5	Granite
	 6	Stone
	 7	Wood massive
	 8	Wood ledges
	 9	Random 1
	10	Random 2
	11	Random 3
	12	Random 4
	13	Stripes 1
	14	Stripes 2
	15	Stripes 3
	16	Stripes 4
	17	Spotted 1
	18	Spotted 2
	19	Dotted 1
	20	Dotted 2
	21	Soap
	22	Turbulent
	23	Spherical
	24	Multi color
	25	Tiles
	26	Tiles shift
	27	Tiles narrow
	28	Checkered
	29	Check. query

Fr ptrn_dir sind folgende Werte mglich:

	0	X (default)
	1	Y
	2	Z
	3	Across

Fr bump_id sind folgende Werte mglich:

	0	OFF (default)
	1	Bumps
	2	Dents
	3	Wrinkles
	4	Corrosion
	5	Wave static
	6	Wave anim
	7	Pyramids
	8	Tiles

Fr flags knnen folgende Konstanten verknpft werden:

	SRF_IMAGE		-	Bild verwenden (Image-Mapping)
	SRF_NOSHADOW	-	Surface wirft keine Schatten
	SRF_RFILTER		-	R-Filter
	SRF_TFILTER		-	T-Filter



SRF_MAT
	Beschreibt die Beleuchtungseigenschaften. Diese Struktur ist fr eine
	Surface zweifach vorhanden (mat1, mat2).

typedef struct
{
	UBYTE		r, g, b;	/* Farbe (0 - 255) */
	UBYTE		lu;		/* Eigenleuchten in Prozent (0 - 100) */
	UBYTE		ca,		/* Ambienter Anteil (0 - 100) */
				cd,		/* Diffuser Anteil (0 - 100) */
				cs;		/* Spekularer Anteil (0 - 100) */
	UBYTE		se;		/* Exponent fr spekularen Anteil (1 - 100) */
	UBYTE		refl;		/* Spiegel-Anteil in Prozent (0 - 100) */
	UBYTE		trns;		/* Transparenter Anteil in Prozent (0 - 100) */
	UBYTE		refr;		/* Brechungsart, siehe unten */
	UBYTE		reserved;
} SRF_MAT;

Fr refr sind folgende Werte mglich (siehe Konstanten):

	SRF_REFR_AIR
	SRF_REFR_WATER
	SRF_REFR_GLASS
	SRF_REFR_CRYSTAL
	SRF_REFR_DIAMOND



VIEW
	Die View-Struktur enhlt Informationen fr die Darstellung im
	Objekteditor.

typedef struct
{
	INT		mode;		/* Projektions-Modus (0 - 7) */
	REAL		zoom;		/* Vergrerung (1.0 - ca. 850000.0) */
	V3S		pos;		/* Position */
	V3S		rot;		/* Rotation */
} VIEW;

Fr  mode sind folgende Werte mglich:

	0	Front
	1	Back
	2	Top
	3	Bottom
	4	Right
	5	Left
	6	Parallel
	7	Central

Der Parameter zoom gibt an, um welchen Faktor die Objektdarstellung im
Objekteditor vergrert wird. Der Defaultwert ist 1.0.

Der Vektor pos beschreibt eine Raumkoordinate relativ zum Objektursprung.
Diese Koordinate des Objektes wird im Zentrum des Arbeitsbereichs angezeigt.
Der Defaultwert von pos ist 0.0, 0.0, 0.0.

Der Vektor rot beschreibt die Rotation der Objektdarstellung in den Modi
Parallel und Central. Die Rotation erfolgt in der Reihenfolge x, y, z;



IMG_MAP
	Die IMG_MAP Struktur enhlt alle Informationen fr das Image Mapping
	in einem Objekt.

typedef struct
{
	CHAR		fname[81];	/* Pfad fr Image-Mapping (Nullterminiert) */
	BYTE		disp_flag;	/* Projektions Anzeige ein/aus */
	BYTE		proj_mode;	/* Projektionsmodus */
	V3S		crd;			/* Position */
	V3S		rot;			/* Rotation */
	FLOAT		width;		/* Breite */
	FLOAT		radius;		/* Radius */
	FLOAT		angle;		/* Grad */
	INT		w;				/* Bildbreite */
	INT		h;				/* Bildhhe */
} IMG_MAP;

fname			-	Nullterminierter String, der angibt, wo die Bilddatei
					(Bild im IIM-Format) zu suchen ist (z.B. "F:\MAPPING.IIM" ).

disp_flag	-	Gibt an, ob die Projektion im Objekteditor angezeigt werden
					soll. 0 = aus, 1 = an.

proj_mode	-	Projektionsmodus: 0 = Plane, 1 = Cylinder outer,
					2 = Cylinder inner.

crd			-	"Position" aus dem Formular "Image Projection" des
					Objekteditors.

rot			-	"Rotation" aus dem Formular "Image Projection" des
					Objekteditors.

width			-	"Width" aus dem Formular "Image Projection" des
					Objekteditors (nur bei proj_mode == 0).

radius		-	"Radius" aus dem Formular "Image Projection" des
					Objekteditors (nur bei proj_mode != 0).

angle			-	"Angle" aus dem Formular "Image Projection" des
					Objekteditors (nur bei proj_mode != 0).

w				-	Bildbreite in Pixel.

h				-	Bildhhe in Pixel.



/********
 *
 * DATEIAUFBAU
 *
 ********/


Dateikennung:	*.IOB



Anz.	Typ		Beschreibung				Wertebereich oder Inhalt
----------------------------------------------------------------------------
  8	CHAR		Header String				"MD_OBJCT"
 20	CHAR		Object Name
  1	LONG		Anzahl Punkte
  1	LONG		Anzahl Flchen
 16	LAYER		Daten der 16 Layer		siehe struct LAYER
  1	INT		Layer ID						Index des aktiven Layers
 32	SRF		Daten der 32 Surface's	siehe struct SRF		
  1	INT		Surface ID					Index der aktiven Surface
  1	IMG_MAP	Image mapping Daten		siehe struct IMG_MAP
  1	VIEW		Daten fr Viewing			siehe struct VIEW
  1	V3D		Local center
  2	V3D		Rotation Axis


Der folgende Abschnitt beschreibt einen Punkt und ist "Anzahl Punkte" mal
enthalten.

  1	BYTE		Layer ID des Punktes			0 - 15
  1	V3L		Punktkoordinate in
					1/200000 cm						-20000000 bis +20000000

Der folgende Abschnitt beschreibt eine Flche und ist "Anzahl Flchen" mal
enthalten. Die Flche geht durch die Punkte mit den angegebenen Indizes
(Index des 1., 2., 3. und 4. Punktes). Fr Dreiecke werden lediglich die
ersten drei Indizes verwendet. Der vierte Index wird auf -1L gesetzt.

  1	BYTE		Layer ID der Flche			0 - 15
  1	BYTE		Surface ID der Flche		0 - 31
  1	LONG		Index des 1. Punktes			0 - ( Anzahl Punkte - 1 )
  1	LONG		Index des 2. Punktes			0 - ( Anzahl Punkte - 1 )
  1	LONG		Index des 3. Punktes			0 - ( Anzahl Punkte - 1 )
  1	LONG		Index des 4. Punktes
					oder -1L							0 - ( Anzahl Punkte - 1 ) oder -1
  1	BYTE		Flags fr "weiche" Kanten	0x1 erste  Kante
														0x2 zweite Kante
														0x4 dritte Kante
														0x8 vierte Kante



/********
 *
 *	Schreiben einer Object-Datei
 *
 ********/

1. Header String

Der Headerstring besteht immer aus der 8 Zeichen langen Zeichenkette
"MD_OBJCT". Diese kann wie folgt geschrieben werden:


	Fwrite( fhandle, 8L, "MD_OBJCT" );



2. Object Name

Der Objektname kann eine Lnge bis zu 20 Zeichen haben. Bei Namen krzer
als 20 Zeichen mu die Zeichenkette nullterminiert sein.


	CHAR	name[20];

	strncpy( name, "Wohnhaus mit Garage", 20L );
	Fwrite( fhandle, 20L, name );



3. Anzahl Punkte/Flchen

Anzahl Punkte und Flchen des gesamten Objekts. Diese mssen mit den
Summen der Punkte bzw. Flchen der 16 Layer bereinstimmen.


	LONG		pnt_n,		/* Anzahl Punkte */
				pln_n;		/* Anzahl Flchen */

	pnt_n = 160;
	pln_n = 154;

	Fwrite( fhandle, sizeof( LONG ), &pnt_n );
	Fwrite( fhandle, sizeof( LONG ), &pln_n );



4. Layer

Es werden smtliche Parameter aller 16 Layer gesichert.


	INT		i	
	LAYER		layer[16];		/* 16 Layer Strukturen */

	/*** Defaultwerte setzen ... ***/

	for ( i = 0; i < 16; i++ )
	{
		sprintf( layer[i].name, "Layer %02d", i + 1 );
		layer[i].flags = LAYER_DISP;
		layer[i].pnt_n = 0;
		layer[i].pln_n = 0;
	}

	/*** Verwendete Layer initialisieren ... ***/

	strcpy( layer[0].name, "Wohnhaus" );	/* Achtung, max. 16 Zeichen! */
	layer[0].pnt_n = 90;
	layer[0].pln_n = 80;

	strcpy( layer[1].name, "Garage" );		/* Achtung, max. 16 Zeichen! */
	layer[1].pnt_n = 70;
	layer[1].pln_n = 74;

	/*** Smtliche Layer schreiben ... */

	Fwrite( fhandle, sizeof( LAYER ) * 16, layer );



5. Layer ID

Dies ist der Index des Input-Layer im Objekteditor.


	INT		layer_id;

	layer_id = 0;
	Fwrite( fhandle, sizeof( INT ), &layer_id );



6. Surface

Es werden smtliche Parameter aller 32 Surfaces gesichert.


	INT		i;
	SRF		srf[32], *s;

	/*** Defaultwerte setzen ... ***/

	s = srf;
	for ( i = 0; i < 32; s++, i++  )
	{
		s->name[0] = 0;		/* kein Name */
		s->mat1.r =
		s->mat1.g =
		s->mat1.b = 255;		/* Farbe wei */
		s->mat1.lu = 0;
		s->mat1.ca = 10;
		s->mat1.cd = 90;
		s->mat1.cs = 0;
		s->mat1.se = 1;
		s->mat1.refl = 0;
		s->mat1.trns = 0;
		s->mat1.refr = 0;		/* Air, Void */
		s->mat2 = s->mat1;	/* Material 1 und 2 identisch */
		s->ptrn_id = 0;		/* OFF */
		s->ptrn_dir = 0;		/* X */
		s->ptrn_scale = 1.0;
		s->bump_id = 0;		/* OFF */
		s->bump_amount = 0.5;
		s->bump_scale = 1.0;
		s->flags = 0x0;
	}

	/*** Verwendete Surfaces initialisieren ... ***/

	s = &srf[5];
	strcpy( s->name, "Beton" );
	s->mat1.r = 100;
	s->mat1.g = 100;
	s->mat1.b = 95;
	s->mat1.lu = 0;
	s->mat1.ca = 10;
	s->mat1.cd = 90;
	s->mat1.cs = 0;
	s->mat1.se = 1;
	s->mat1.refl = 0;
	s->mat1.trns = 0;
	s->mat1.refr = 0;		/* Air, Void */
	s->mat2 = s->mat1;	/* Material 1 und 2 bis auf die Farbe 		
					 				identisch ... */
	s->mat2.r = 90;
	s->mat2.g = 90;
	s->mat2.b = 85;
	s->ptrn_id = 5;		/* Granite */
	s->ptrn_dir = 0;		/* X */
	s->ptrn_scale = 2.0;
	s->bump_id = 0;		/* OFF */
	s->bump_amount = 0.5;
	s->bump_scale = 1.0;
	s->flags = SRF_NOSHADOW;

	Fwrite( fhandle, sizeof( SRF ) * 32, srf );



7. Surface ID

Dies ist die aktive Surface im Objekteditor.


	INT		srf_id;

	srf_id = 0;
	Fwrite( fhandle, sizeof( INT ), &srf_id );



8. Image Mapping

Parameter fr das Image Mapping.


	IMG_MAP		img_map;

	strcpy( img_map.fname, "F:\INSHAPE\MAPPING\BILD.IIM" );
	img_map.disp_flag = 1;		/* Darstellung ist eingeschaltet */
	img_map.proj_mode = IMG_PROJ_PLANE;	/* Projektionsmodus */
	img_map.crd.x = 10.0;		/* Position */
	img_map.crd.y = 30.0;
	img_map.crd.z = 25.0;
	img_map.rot.x = 0.0;		/* Rotation */
	img_map.rot.y = 45.0;
	img_map.rot.z = 0.0;
	img_map.width = 100.0;		/* Breite = 100 cm */
	img_map.radius = 0.0;		/* Radius wird bei IMG_PROJ_PLANE		
										   nicht verwendet */
	img_map.angle = 0.0;		/* dito */
	img_map.w = 320;			/* Bildbreite von BILD.IIM in Pixel */
	img_map.h = 240;			/* Bildhhe von BILD.IIM in Pixel */

	Fwrite( fhandle, sizeof( IMG_MAP ), &img_map );



9. Viewing


	VIEW		view;

	view.mode = 7;				/* Projektionsmodus: Central */
	view.zoom = 10.0;			/* 10-fache Vergrerung */
	view.pos.x = 0.0;			/* Position */
	view.pos.y = 0.0;
	view.pos.z = 0.0;
	view.rot.x = 20.0;		/* Rotation */
	view.rot.y = -45.0;
	view.rot.z = 0.0;

	Fwrite( fhandle, sizeof( VIEW ), &view );



10. Local Center


	V3D		local_center;

	local_center.x = 0.0;
	local_center.y = 24.5;
	local_center.z = -10.0;

	Fwrite( fhandle, sizeof( VEC3D ), &local_center );



11. Rotation Axis


	V3D		axis[2];

	axis[0].x = -100.0;
	axis[0].y = -50.0;
	axis[0].z = 0.0;
	axis[1].x = 100.0;
	axis[1].y = 50.0;
	axis[1].z = 0.0;

	Fwrite( fhandle, sizeof( V3D ) * 2, axis );



12. Punkte


	LONG		i;
	BYTE		layer_id;
	V3L		crd;
	LONG		pnt_n;

	pnt_n =		/* von Ihnen zu ergnzen */

	for ( i = 0; i < pnt_n; i++ )
	{
		/* Hier werden die Parameter eines Punktes initialisiert.
		   Diesen Abschnitt mssen Sie vervollstndigen.
		*/

		layer_id =		/* 0 - 15 */
		crd.x =			/* Achtung: Koordinate in 1/200000 cm */
		crd.y = 
		crd.z =

		Fwrite( fhandle, sizeof( BYTE ), &layer_id );
		Fwrite( fhandle, sizeof( V3L ), &crd );
	}



13. Flchen


	LONG		i;
	BYTE		layer_id;
	BYTE		srf_id;
	LONG		pnt_id[4];
	BYTE		smooth;
	LONG		pln_n;

	pln_n =		/* von Ihnen zu ergnzen */

	for ( i = 0; i < pln_n; i++ )
	{
		/* Hier werden die Parameter einer Flche initialisiert.
		   Diesen Abschnitt mssen Sie vervollstndigen.
		*/

		layer_id =		/* 0 - 15 */
		srf_id =			/* 0 - 63 */
		pnt_id[0] =		/* Index des 1. Punktes */
		pnt_id[1] =		/* Index des 2. Punktes */
		pnt_id[2] =		/* Index des 3. Punktes */
		pnt_id[3] =		/* Index des 4. Punktes oder -1L */
		smooth =			/* Kombination aus den Flags 0x1, 0x2, 0x4
							   und 0x8, die kennzeichnen, welche Kanten
							   weich schattiert werden sollen */

		Fwrite( fhandle, sizeof( BYTE ), &layer_id );
		Fwrite( fhandle, sizeof( BYTE ), &srf_id );
		Fwrite( fhandle, sizeof( LONG ) * 4, pnt_id );
		Fwrite( fhandle, sizeof( BYTE ), &smooth );
	}


