/* $XConsortium: ddpex.h,v 5.14 94/04/17 20:35:53 rws Exp $ */

/***********************************************************

Copyright (c) 1989, 1990, 1991  X Consortium

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.

Copyright (c) 1989, 1990, 1991 by Sun Microsystems, Inc.

                        All Rights Reserved

Permission to use, copy, modify, and distribute this software and its 
documentation for any purpose and without fee is hereby granted, 
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in 
supporting documentation, and that the names of Sun Microsystems,
and the X Consortium, not be used in advertising or publicity 
pertaining to distribution of the software without specific, written 
prior permission.  

SUN MICROSYSTEMS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT 
SHALL SUN MICROSYSTEMS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.

******************************************************************/

#ifndef DDPEX_H
#define DDPEX_H

#include "X.h"
#include "PEX.h"
#include "pixmapstr.h"
#include "dix.h"
#include "Xprotostr.h"

/* Basic data types */
/* Many of the typdefs in this file look like the protocol structures 
 * This is intentional.  The protocol structures specify bit fields
 * and the SI ddpex does not use bit fields.  Therefore, ddpex uses its
 * own data definitions, not the ones used by the protocol.
 ****************************************************************************
 * THE SIZE AND ALIGNMENT OF THESE STRUCTURES IS EXPECTED MATCH THE PROTOCOL
 ****************************************************************************
 * This is VERY important.  Although ddpex does not use bit fields, it does
 * assume that short ints are 16 bits, int/long ints are 32 bits.  Pads and
 * unused fields have been kept in the ddpex structures so that they match
 * the protocol structures exactly, allowing type casting and fast copies
 * between the structures.  
 * ddFLOAT is for server internal floating point representations
 */

typedef char    ddCHAR;
typedef short   ddSHORT;
typedef long    ddLONG;
typedef float   ddFLOAT;

typedef unsigned char   ddUCHAR;
typedef unsigned short  ddUSHORT;
typedef unsigned long   ddULONG;

typedef unsigned char    *ddPointer;
typedef unsigned char   ddBYTE;
typedef unsigned char   ddBOOL;

/* Let the default font that gets opened up be Monospaced Roman */
#define DEFAULT_PEX_FONT_NAME	"Roman_M"

/* Resource structures passed between dipex and ddpex. Most of the resources
 * data is kept in dd structures which are opaque to dipex.  Info needed by
 * dipex is kept visible to it in these structures
 */
typedef struct {
	XID	id;
	ddPointer	deviceData;
} ddWKSResource;

typedef struct {
	XID	id;
	ddUSHORT	lutType;
	ddPointer	deviceData;
} ddLUTResource;

typedef ddWKSResource ddStructResource;
typedef ddWKSResource ddNSResource;
typedef ddWKSResource ddFontResource;
typedef ddWKSResource ddPMResource;

#define GetNSId(HANDLE) HANDLE->id

#define GetLUTId(HANDLE) HANDLE->id

typedef ddWKSResource		*diWKSHandle;
typedef ddLUTResource		*diLUTHandle;
typedef ddStructResource	*diStructHandle;
typedef ddNSResource		*diNSHandle;
typedef ddFontResource		*diFontHandle;
typedef ddPMResource		*diPMHandle;
typedef ddPointer		diResourceHandle;

/* PEXprotost.h equivalents */

typedef ddULONG		ddBitmask;
typedef	ddUSHORT	ddBitmaskShort;
typedef	ddSHORT		ddEnumTypeIndex;
typedef	XID		ddResourceId;
typedef	ddBYTE		ddSwitch;
typedef	ddUSHORT	ddTableIndex;

typedef struct {
    ddFLOAT	x;
    ddFLOAT	y;
} ddVector2D;

typedef struct {
    ddFLOAT	x;
    ddFLOAT	y;
    ddFLOAT	z;
} ddVector3D;

typedef struct {
    ddFLOAT	x;
    ddFLOAT	y;
} ddCoord2D;

typedef struct {
    ddLONG	x;
    ddLONG	y;
} ddCoord2DL;

typedef xPoint ddCoord2DS; /* must be the same type for compiler's sake */
/* typedef struct { ddSHORT x; ddSHORT y; } ddCoord2DS; */

typedef struct {
    ddFLOAT	x;
    ddFLOAT	y;
    ddFLOAT	z;
} ddCoord3D;

typedef struct {
    ddLONG	x;
    ddLONG	y;
    ddLONG	z;
} ddCoord3DL;

typedef struct {
    ddSHORT	x;
    ddSHORT	y;
    ddSHORT	z;
} ddCoord3DS;

typedef struct {
    ddFLOAT	x;
    ddFLOAT	y;
    ddFLOAT	z;
    ddFLOAT	w;
} ddCoord4D;

typedef struct {
	ddSHORT		x;
	ddSHORT 	y;
	ddFLOAT 	z;
} ddDeviceCoord;

typedef struct {
	ddSHORT		xmin;
	ddSHORT		ymin;
	ddSHORT		xmax;
	ddSHORT		ymax;
} ddDeviceRect;

typedef struct {
        ddFLOAT         xmin;
        ddFLOAT         ymin;
        ddFLOAT         zmin;
        ddFLOAT         wmin;
        ddFLOAT         xmax;
        ddFLOAT         ymax;
        ddFLOAT         zmax;
        ddFLOAT         wmax;
} ddListBounds;

typedef struct {
    ddSHORT		approxMethod;
    ddUSHORT		unused;
    ddFLOAT		tolerance;
} ddCurveApprox;

typedef struct {
    ddSHORT		approxMethod;
    ddUSHORT		unused;
    ddFLOAT		uTolerance;
    ddFLOAT		vTolerance;
} ddSurfaceApprox;

typedef struct {
    ddUSHORT		vertical;
    ddUSHORT		horizontal;
} ddTextAlignmentData;

typedef struct {
    ddDeviceCoord	minval;
    ddDeviceCoord	maxval;
    ddUCHAR		useDrawable;
    ddBYTE		pad[3];
} ddViewport;

typedef struct {
    ddCoord2DS      position;
    ddFLOAT         distance;
} ddDC_HitBox;

typedef struct {
    ddCoord3D	minval;
    ddCoord3D	maxval;
} ddNpcSubvolume;

typedef  ddNpcSubvolume ddNPC_HitVolume;

typedef struct {
	ddUSHORT	clipFlags;
	ddUSHORT	unused;
	ddNpcSubvolume	clipLimits;
	ddFLOAT		orientation[4][4];
	ddFLOAT		mapping[4][4];
} ddViewEntry;

typedef struct {
	ddUSHORT	definableEntries;
	ddUSHORT	numPredefined;
	ddUSHORT	predefinedMin;
	ddUSHORT	predefinedMax;
} ddTableInfo;


typedef struct {
        diStructHandle    structure;	/* the structure id is replaced with */
        ddULONG         offset;		/* the handle */
} ddElementRef;

typedef struct {
        ddCoord4D       orig_point;	/* original PEX ref point */
        ddCoord4D       point;
        ddVector3D      orig_vector;	/* original PEX ref vector*/	
        ddVector3D      vector;		/* normalized vector */
	ddFLOAT		dist;		/* Hessian form distance func */
} ddHalfSpace; 				

typedef struct {
        diStructHandle    structure;	/* the structure id is replaced with the */
        ddULONG         offset;		/* handle by diPEX */
        ddULONG         pickid;
} ddPickPath;

typedef struct {
    ddULONG		sid;
    ddULONG             offset;
    ddULONG             pickid;
} ddPickElementRef;

typedef struct {
      ddUSHORT        pickType;
      union {
	  ddDC_HitBox        DC_HitBox;
	  ddNPC_HitVolume    NPC_HitVolume;
      } hit_box;
} ddPickRecord;

typedef struct {
	ddUSHORT	elementType;
	ddUSHORT	length;
} ddElementInfo;

/* Colour structures */
typedef struct {
    ddFLOAT	red;
    ddFLOAT	green;
    ddFLOAT	blue;
} ddRgbFloatColour;

typedef struct {
    ddFLOAT	hue;
    ddFLOAT	saturation;
    ddFLOAT	value;
} ddHsvColour;

typedef struct {
    ddFLOAT	hue;
    ddFLOAT	lightness;
    ddFLOAT	saturation;
} ddHlsColour;

typedef struct {
    ddFLOAT	x;
    ddFLOAT	y;
    ddFLOAT	z;
} ddCieColour;

typedef struct {
    ddUCHAR	red;
    ddUCHAR	green;
    ddUCHAR	blue;
    ddUCHAR	pad;
} ddRgb8Colour;

typedef struct {
    ddUSHORT	red;
    ddUSHORT	green;
    ddUSHORT	blue;
    ddUSHORT	pad;
} ddRgb16Colour;

typedef struct {
    ddUSHORT		index;
    ddUSHORT		pad;
} ddIndexedColour;

typedef struct {
    ddSHORT       colourType;
    ddSHORT       unused;
    union {
	ddIndexedColour        indexed;
	ddRgb8Colour           rgb8;
	ddRgb16Colour          rgb16;
	ddRgbFloatColour           rgbFloat;
	ddCieColour            cieFloat;
	ddHlsColour            hlsFloat;
	ddHsvColour            hsvFloat;
    }  colour;
} ddColourSpecifier;

typedef union {
	ddRgb8Colour           rgb8;
	ddRgb16Colour          rgb16;
	ddRgbFloatColour           rgbFloat;
	ddCieColour            cieFloat;
	ddHlsColour            hlsFloat;
	ddHsvColour            hsvFloat;
}  ddDirectColour;

typedef struct {
    ddFLOAT		ambient;
    ddFLOAT		diffuse;
    ddFLOAT		specular;
    ddFLOAT		specularConc;
    ddFLOAT		transmission;  /* 0.0 = opaque, 1.0 = transparent */
    ddColourSpecifier  specularColour;	    
} ddReflectionAttr;

/* end of PEXprotost.h equivalent structures */

/* error return values */
typedef int ddpex4rtn;
typedef int ddpex43rtn;
typedef int ddpex3rtn;
typedef int ddpex2rtn;
typedef int ddpex1rtn;

/* ddBuffer is used to pass variable length data from ddpex to dipex 
 * there is a utility called miBuffRealloc which can be used by either
 * dipex or ddpex to reallocate space in the buffer.
 * The buffer itself is just an array of bytes.  The beginning of the
 * buffer is pointed to by pHead.  ddpex copies the info into the
 * buffer beginning at the location pointed to by pBuf.  This allows
 * dipex to control where in the buffer the data is located.  dipex
 * sets pBuf, pHead and bufSize before calling the ddpex procedure.
 * ddpex copies data into the buffer starting at pBuf and puts the
 * number of bytes of data copied into dataSize.  ddpex does not change
 * pHead, pBuf, or data Size (pBuf continues pointing to the beginning
 * of the info ddpex copies to the buffer).  ddpex MUST check that the
 * buffer is large enough to hold the data (macro DD_BUF_TOO_SMALL is
 * useful for this) and should call miBufRealloc to increase the buffer
 * size if it's too small.  pHead, pBuf and bufSize will be adjusted
 * for the realloc correctly in that procedure.
 */
typedef struct {
    ddULONG	bufSize;	/* number of total bytes in buffer */
    ddULONG	dataSize;	/* number of bytes used by the new data */
    ddPointer   pBuf;		/* pointer to buffer where new data starts */
    ddPointer   pHead;		/* pointer to true head of buffer */
} ddBuffer, *ddBufferPtr;

/* lists of objects are needed in several places in the SI server.  The following
 * data structure are intended to be used for those lists. The enum type defines
 * what the possible objects in a list are.  listofObj defines the list itself.
 * The list is an array of objects.  Procedures for doing operations on these
 * lists are provided in server/dipex/utilities.  Declarations of the procedures and
 * useful macros are defined in server/include/pexUtils.h.
 * dipex and ddpex both use these lists.  The lists are not intended
 * to be opaque.  dipex and ddpex can use them directly, although we've tried
 * to use the macros and procedures as much as possible.  
 * More info is given with the procedures.
 */
typedef enum {
        DD_ELEMENT_REF=0,
        DD_HALF_SPACE=1,
        DD_PICK_PATH=2,
        DD_RENDERER=3,
        DD_WKS=4,
        DD_NS=5,
	DD_STRUCT=6,
        DD_DEVICE_RECT=7,
	DD_NAME=8,
	DD_INDEX=9,
        DD_LIST_OF_LIST=10,
	DD_NUM_TYPES=11
} ddListType;

typedef struct {
        ddListType      type;
        ddLONG     numObj;
        ddLONG     misc;
        ddLONG     maxObj;
        ddPointer  pList;
        /* pList is an array of foos (see ddListType for possible foos)
         * it is allocated as an array of footypes and reallocated as needed
         * in multiples of a defined size.
	 * footypes and array sizes are stated explicitely in
	 * server/dipex/dispatch/pexUtils.c
         * yes, this could be a union, but by using a generic char *,
         * the list can be handled generically and not have to be 
         * specified differently for each type if it isn't necessary
         */
} listofObj;

/* Pipeline Context and Renderer Resource structures: shared by dipex and ddpex */

typedef	struct {
	ddUSHORT	placementType;
	ddUSHORT	numUcurves;
	ddUSHORT	numVcurves;
} ddPSC_IsoparametricCurves;

typedef	struct {
	ddCoord3D	origin;
	ddVector3D	direction;
	ddUSHORT	numberIntersections;
	ddFLOAT 	*pPoints;
} ddPSC_LevelCurves;

typedef struct {
	ddEnumTypeIndex		type;
	union {
		char				none;
		char				impDep;
		ddPSC_IsoparametricCurves	isoCurves;	
		ddPSC_LevelCurves		mcLevelCurves;	
		ddPSC_LevelCurves		wcLevelCurves;
	} data;
} ddPSurfaceChars;

	
typedef struct {
	ddEnumTypeIndex		markerType;
	ddFLOAT			markerScale;
	ddColourSpecifier	markerColour;
	ddUSHORT		markerIndex;
	ddUSHORT		textFont;
	ddUSHORT		textPrecision;
	ddFLOAT			charExpansion;
	ddFLOAT			charSpacing;
	ddColourSpecifier	textColour;
	ddFLOAT			charHeight;
	ddVector2D		charUp;
	ddUSHORT		textPath;
	ddTextAlignmentData	textAlignment;
	ddFLOAT			atextHeight;
	ddVector2D		atextUp;
	ddUSHORT		atextPath;
	ddTextAlignmentData	atextAlignment;
	ddEnumTypeIndex		atextStyle;
	ddUSHORT		textIndex;
	ddEnumTypeIndex		lineType;
	ddFLOAT			lineWidth;
	ddColourSpecifier	lineColour;
	ddCurveApprox		curveApprox;
	ddEnumTypeIndex		lineInterp;
	ddUSHORT		lineIndex;
	ddEnumTypeIndex		intStyle;
	ddSHORT			intStyleIndex;
	ddColourSpecifier	surfaceColour;
	ddReflectionAttr	reflAttr;
	ddEnumTypeIndex		reflModel;
	ddEnumTypeIndex		surfInterp;
	ddEnumTypeIndex		bfIntStyle;
	ddSHORT			bfIntStyleIndex;
	ddColourSpecifier	bfSurfColour;
	ddReflectionAttr	bfReflAttr;
	ddEnumTypeIndex		bfReflModel;
	ddEnumTypeIndex		bfSurfInterp;
	ddSurfaceApprox		surfApprox;
	ddUSHORT		cullMode;
	ddBOOL			distFlag;
	ddCoord2D		patternSize;
	ddCoord3D		patternRefPt;
	ddVector3D		patternRefV1;
	ddVector3D		patternRefV2;
	ddUSHORT		intIndex;
	ddUSHORT		edges;
	ddEnumTypeIndex		edgeType;
	ddFLOAT			edgeWidth;
	ddColourSpecifier	edgeColour;
	ddUSHORT		edgeIndex;
	ddFLOAT			localMat[4][4];
	ddFLOAT			globalMat[4][4];
	ddUSHORT		modelClip;
	listofObj		*modelClipVolume;
	ddUSHORT		viewIndex;
	listofObj		*lightState;
	ddUSHORT		depthCueIndex;
	ddUSHORT		colourApproxIndex;
	ddSHORT			rdrColourModel;
	ddPSurfaceChars		psc;
	ddULONG			asfs;
	ddULONG			pickId;
	ddULONG			hlhsrType;
	diNSHandle		pCurrentNS;	/* handle to name set */
} ddPCAttr;

typedef struct {
	ddULONG			PCid;
	listofObj		*rendRefs;
	ddPCAttr		*pPCAttr;
} ddPCStr, *ddPCPtr;

/*	Output Command Procedure Vector	used in renderer */
/*	The index of a procedure is the output command number	*/
#define OCTABLE_LENGTH (PEXMaxOC+1)
#define SEPROC_VECTOR_LENGTH (PEXMaxOC+1)

typedef	ddpex2rtn	(*ocTableType)();

typedef struct {
	ddBYTE		type;	/* drawable type: pixmap, window, undrawable_window? */
	ddBYTE		class;	
	ddBYTE		depth;	
	ddBYTE		bitsPerPixel;	
	ddBYTE		rootDepth;
	ddULONG		rootVisual;
} ddDrawableInfo;

typedef enum {
	DD_HIGH_INCL_NS=0,
	DD_HIGH_EXCL_NS=1,
	DD_INVIS_INCL_NS=2,
	DD_INVIS_EXCL_NS=3,
	DD_PICK_INCL_NS=4,
	DD_PICK_EXCL_NS=5,
	DD_MAX_FILTERS=6
} ddNSFilters; 

/* pick state for Renderer picking */
#define DD_PICK_ONE 1
#define DD_PICK_ALL 2
#define DD_SERVER	1
#define DD_CLIENT	2
#define DD_NEITHER	3

typedef struct {
	ddUSHORT	  state;        /* pick state one or all */
	ddUSHORT	  server;       /* client or server traversal */
	ddSHORT           pick_method;
	ddBOOL            send_event;
	ddULONG           max_hits;
	ddULONG           more_hits;
	ClientPtr         client;       /* need to send the event */
        diStructHandle    strHandle;	/* struct handle for PickOne */
	diPMHandle	  pseudoPM;      /* fake PM for Renderer Pick */
	listofObj	  *list;	/* list of list for pick all */
	listofObj	  *fakeStrlist;	/* list of fake struct handle for
					   picking */
	listofObj	  *sIDlist;	/* list of IDs, struct handles  and
					   offsets for reverse mapping
					   BeginStructures when picking */
} ddRdrPickStr, *ddRdrPickPtr;       /* need to send the event */ 

typedef struct {
	ddULONG 		rendId;		/* renderer id */
	ddPCPtr			pPC;		/* pipeline context handle */
	ddDrawableInfo		drawExample;	/* info from drawable example */
	DrawablePtr		pDrawable;	/* rendering drawable */
	ddULONG			drawableId;	/* id of rendering drawable */
	listofObj		*curPath;	/* current path */
	ddUSHORT		state;		/* renderer state */
	diLUTHandle		lut[PEXMaxTableType+1];/* lookup table handles */
	diNSHandle		ns[DD_MAX_FILTERS];/* name set handles */
	ddSHORT			hlhsrMode;	/* you guessed it */
	ddNpcSubvolume		npcSubvolume;
	ddViewport		viewport;
	listofObj		*clipList;	 /* clip list */
						 /* Begin 5.1 additions */
						 /* pick_inclusion is in ns */
						 /* pick_exclusion is in ns */
	listofObj		*pickStartPath;	 /* pick start path */
	ddColourSpecifier	backgroundColour;
	ddBOOL			clearI;
	ddBOOL			clearZ;
	ddUSHORT		echoMode;
	ddColourSpecifier	echoColour;
						 /* End 5.1 additions */
	ddBitmask		tablesMask;	/* renderer dynamics */
	ddBitmask		namesetsMask;	/* renderer dynamics */
	ddBitmask		attrsMask;	/* renderer dynamics */
	ddBitmask		tablesChanges;	/* changed attributes */
	ddBitmask		namesetsChanges;/* changed attributes */
	ddBitmask		attrsChanges;	/* changed attributes */
	ocTableType		executeOCs[OCTABLE_LENGTH];	
	ddBOOL			immediateMode;
	ddUSHORT		render_mode;
	ddPointer		pDDContext;	/* device dependent attribute context */
	ddRdrPickStr		pickstr;
} ddRendererStr, *ddRendererPtr;

typedef struct {
	ddULONG			numElRefs;	/* number of element refs */
	listofObj		*Path;		/* path */
} ddAccStStr, *ddAccStPtr;

/* render_mode values */
#define	MI_REND_DRAWING 0
#define	MI_REND_PICKING 1
#define	MI_REND_SEARCHING 2

	/* enum type for specifying resources  */
typedef enum { 
	WORKSTATION_RESOURCE=0,
	STRUCTURE_RESOURCE=1,
	PARENT_STRUCTURE_RESOURCE=2,
	CHILD_STRUCTURE_RESOURCE=3,
	SEARCH_CONTEXT_RESOURCE=4,
	PICK_RESOURCE=5,
	LOOKUP_TABLE_RESOURCE=6,
	NAME_SET_RESOURCE=7,
	FONT_RESOURCE=8,
	RENDERER_RESOURCE=9,
	PIPELINE_CONTEXT_RESOURCE=10
} ddResourceType;

typedef enum {
	ADD=0,
	REMOVE=1
} ddAction;

typedef enum {
	X_WINDOW_RESOURCE=0,
	X_DRAWABLE_RESOURCE=1,
	X_FONT_RESOURCE=2,
	X_PIXMAP_RESOURCE=3,
	X_CURSOR_RESOURCE=4,
	X_COLORMAP_RESOURCE=5,
	X_GCONTEXT_RESOURCE=6,
	X_KEYSYM=7
} ddXResourceType;

#endif  /* DDPEX_H */
