/***************************************************************************
 *                                                             <210493.1436>
 *    PROJECT:      dVS
 *    SUBSYSTEM:    VCTools.
 *    MODULE:       VC Object definitions.
 *
 ***************************************************************************
 *
 *    File:         $RCSfile: vcobject.h,v $
 *    Revision:     $Revision: 1.1 $
 *    Date:         $Date: 95/05/18 10:24:17 $
 *    Author:       $Author: john $
 *    RCS Ident:    $Id: vcobject.h,v 1.1 1995/03/10 14:52:46 john Exp $
 *    Creator:      Jon Green.
 *
 * 
 *
 **************************************************************************
 *                                                                        *
 * Copyright (c) 1992,1993,1994,1995 Division Ltd.                        *
 *                                                                        *
 * All Rights Reserved.                                                   *
 *                                                                        *
 * This Document may not, in whole  or in part, be copied, photocopied,   *
 * reproduced, translated,  or  reduced  to  any  electronic  medium or   *
 * machine readable  form without  prior written  consent from Division   *
 * Ltd.                                                                   *
 *                                                                        *
 *************************************************************************/

/*---	Include Definitions */

#ifndef	_VCOBJECT_H
#define	_VCOBJECT_H	1

/* Spin functions */
#define VCEntity_SpinX(e,a)    VCEntity_Spin(e,VC_X,a)
#define VCEntity_SpinY(e,a)    VCEntity_Spin(e,VC_Y,a)
#define VCEntity_SpinZ(e,a)    VCEntity_Spin(e,VC_Z,a)

int  	 VCEntity_Rotate (VCEntity *e, dmPoint centre, int axis, float angle);
int	 VCEntity_RotateX (VCEntity *e, float angle);
int	 VCEntity_RotateY (VCEntity *e, float angle);
int 	 VCEntity_RotateZ (VCEntity *e, float angle);


int	 VCEntity_Spin (VCEntity *e, int axis, float angle);
int	 VCEntity_Scale (VCEntity *e, float sx, float sy, float sz);
int	 VCEntity_Resize (VCEntity *entity, float sx, float sy, float sz);
int	 VCEntity_Translate (VCEntity *e, float dx, float dy, float dz);


VCAttribute 	*VCVisual_Create 	(char *visual_name, VCDynamicVisual *dynamicVIsual, uint32 mode, char *lod,
                                         char *frontMaterial, char *backMaterial, 
                                         uint32 intersectMask);
int		 VCVisual_Set 		(VCAttribute *attribute, char *visual_name, VCDynamicVisual *dynamicVisual,
                                         uint32 setMode, uint32 clearMode, char *lod, char *frontMaterial, 
                                         char *backMaterial, uint32 setIntersectMask,
                                         uint32 clearIntersectMask);
int		 VCVisual_Get 		(VCAttribute *attribute, char **visual_name,
                                         VCDynamicVisual **dynamicVisual,
                                         uint32 *mode, char **lod, char **frontMaterial, char **backMaterial,
                                         uint32 *intersectMask);
VCAttribute 	*VCVisual_CreateData	(VCVisualData *visualData);
int		 VCVisual_SetData 	(VCAttribute *attribute,VCVisualData *visualData);
int		 VCVisual_GetData 	(VCAttribute *attribute, VCVisualData *visualData);

VCAttribute	*VCEntity_AddVisual 	(VCEntity *entity, char *visual_name, VCDynamicVisual *DynamicVisual,
                                         uint32 mode, char *lod,
                                         char *frontMaterial, char *backMaterial, uint32 intersectMask);
VCAttribute 	*VCEntity_AddVisualData(VCEntity *entity, VCVisualData *visualData);
int		 VCVisual_SetGeometry 	(VCAttribute *attribute, char *visual_name);
int		 VCVisual_SetDynamicVisual (VCAttribute *attribute, VCDynamicVisual *dynamicVisual);
int		 VCVisual_SetMode 	(VCAttribute *attribute, uint32 mode);
int 		 VCVisual_ModifyMode 	(VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int		 VCVisual_SetFrontMaterial (VCAttribute *attribute, char *frontMaterial);
int		 VCVisual_SetBackMaterial (VCAttribute *attribute, char *backMaterial);
int		 VCVisual_SetLod 	(VCAttribute *attribute, char *lod);
int		 VCVisual_SetIntersectMask (VCAttribute *attribute, uint32 intersectMask);
int		 VCVisual_ModifyIntersectMask (VCAttribute *attribute, uint32 setIntersectMask,
                                               uint32 clearIntersectMask);

int		 VCVisual_GetGeometry 	(VCAttribute *attribute, char **visual_name);
int		 VCVisual_GetDynamicVisual (VCAttribute *attribute, VCDynamicVisual **dynamicVisual);
int		 VCVisual_GetMode 	(VCAttribute *attribute, uint32 *mode);
int		 VCVisual_GetFrontMaterial (VCAttribute *attribute, char **frontMaterial);
int		 VCVisual_GetBackMaterial (VCAttribute *attribute, char **backMaterial);
int		 VCVisual_GetLod 	(VCAttribute *attribute, char **lod);
int		 VCVisual_GetIntersectMask (VCAttribute *attribute, uint32 *intersectMask);

#define VCEntity_AddVisualGeometry(e,g) VCEntity_AddVisual(e, g, NULL, VC_VISIBLE | VC_RMODE_POLYGONAL, NULL, NULL, NULL, 0xffffffff)
#define VCEntity_DetachVisual(e,a) VCEntity_DetachAttribute(e,a)
#define VCVisual_CreateGeometry(g) VCVisual_Create( g, NULL, VC_VISIBLE|VC_RMODE_POLYGONAL, NULL, NULL, NULL, NULL)
#define VCVisual_Delete(a) VCAttribute_Delete(a)


VCAttribute 	*VCBodyPart_Create 	(char *bodyPart_name, uint32 actorId);
VCAttribute 	*VCBodyPart_CreateData 	(VCBodyPartData *bodyPart);
VCAttribute 	*VCEntity_AddBodyPartData(VCEntity *entity, VCBodyPartData *data);
VCAttribute	*VCEntity_AddBodyPart 	(VCEntity *entity, char *bodyPart_name, uint32 actorId);
int		 VCBodyPart_Set		(VCAttribute *attribute, char *bodyPart_name,
                                         uint32 *actorId);
int		 VCBodyPart_SetData	(VCAttribute *attribute, VCBodyPartData *bodyPart);
int		 VCBodyPart_SetName	(VCAttribute *attribute, char *name);
int		 VCBodyPart_Get		(VCAttribute *attribute, char **bodyPart_name,
                                         uint32 *actorId);
int		 VCBodyPart_GetData	(VCAttribute *attribute, VCBodyPartData *bodyPart);
int		 VCBodyPart_GetName	(VCAttribute *attribute, char **name);
int		 VCBodyPart_GetActorId	(VCAttribute *attribute, uint32 *actorId);

#define VCEntity_DetachBodyPart(e,a) VCEntity_DetachAttribute(e, a)
#define VCBodyPart_Delete(a) VCAttribute_Delete(a)

VCAttribute     *VCPickObject_Create	(VCEntity *entity, uint32 mode, uint32 actorId);
VCAttribute 	*VCPickObject_CreateData (VCPickObjectData *pickData);
int		 VCPickObject_Set 	(VCAttribute *attribute, VCEntity *entity,
                                         uint32 setMode, uint32 clearMode, uint32 *actorId);
int		 VCPickObject_SetData (VCAttribute *attribute, VCPickObjectData *pickData);
int		 VCPickObject_Get 	(VCAttribute *attribute, VCEntity **entity,
                                         uint32 *mode, uint32 *actorId);
int		 VCPickObject_GetData (VCAttribute *attribute, VCPickObjectData *pickData);
VCAttribute 	*VCEntity_AddPickObjectData(VCEntity *entity, VCPickObjectData *data);
VCAttribute	*VCEntity_AddPickObject (VCEntity *entity, VCEntity *pickingEntity, uint32 mode,
                                         uint32 pickActorId);

#define VCEntity_DetachPickObject(e,a) VCEntity_DetachAttribute(e,a)
#define VCPickObject_Delete(a) VCAttribute_Delete(a)



int		 VCPickObject_SetMode		(VCAttribute *attribute, uint32 mode);
int		 VCPickObject_ModifyMode	(VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int 		 VCPickObject_SetPickingEntity	(VCAttribute *attribute, VCEntity *entity);
int 		 VCPickObject_SetActorId	(VCAttribute *attribute, uint32 actorId);
int		 VCPickObject_GetMode		(VCAttribute *attribute, uint32 *mode);
int 		 VCPickObject_GetPickingEntity	(VCAttribute *attribute, VCEntity **entity);
int 		 VCPickObject_GetActorId	(VCAttribute *attribute, uint32 *actorId);


VCAttribute	*VCBoundary_Create 	(char *geometry, VCDynamicVisual *dynamicVisual, float32 bounds[VC_BOUND_SIZE], 
                                         uint32 mode, char *lod , int numCollisions);
VCAttribute	*VCBoundary_CreateData 	(VCBoundaryData *boundaryData);
int		 VCBoundary_Set 	(VCAttribute *attribute, char *geometry, VCDynamicVisual *dynamicVisual,
                                         float32 bounds[VC_BOUND_SIZE], uint32 setMode, uint32 clearMode, char *lod ,
                                         int32 *numberCollisions);
int		 VCBoundary_SetData 	(VCAttribute *attribute, VCBoundaryData *boundaryData);
int		 VCBoundary_Get		(VCAttribute *attribute, char **geometry, VCDynamicVisual **dynamicVisual,
                                         float32 bounds[VC_BOUND_SIZE], uint32 *mode, char **lod, int32 *numberCollisions,
                                         VCCollision **collision);
int		 VCBoundary_GetData	(VCAttribute *attribute, VCBoundaryData *boundaryData);
VCAttribute 	*VCEntity_AddBoundaryData(VCEntity *entity, VCBoundaryData *data);
VCAttribute	*VCEntity_AddBoundary	(VCEntity *entity, char *geometry, VCDynamicVisual *dynamicVisual, 
                                         float32 bounds[VC_BOUND_SIZE], uint32 mode, char *lod, int numCollisions );
int		 VCBoundary_Delete(VCAttribute *attribute);

#define VCEntity_DetachBoundary(e,a) VCEntity_DetachAttribute(e, a)
#define VCBoundary_CreateBbox(g) VCBoundary_Create(g,NULL,NULL, VC_COLLISION_ENABLE | VC_COLLISION_BBOX, NULL, 1)
#define VCBoundary_CreateRadius(g) VCBoundary_Create(g,NULL,NULL, VC_COLLISION_ENABLE | VC_COLLISION_RADIUS, NULL, 1)
#define VCBoundary_CreateGeometry(g) VCBoundary_Create(g,NULL,NULL, VC_COLLISION_ENABLE | VC_COLLISION_GEOMETRY, NULL, 1)
#define VCEntity_AddBoundaryBbox(e,g) VCEntity_AddBoundary(e,g,NULL,NULL, VC_COLLISION_ENABLE | VC_COLLISION_BBOX, NULL, 1)
#define VCEntity_AddBoundaryRadius(e,g) VCEntity_AddBoundary(e, g,NULL,NULL, VC_COLLISION_ENABLE | VC_COLLISION_RADIUS, NULL, 1)
#define VCEntity_AddBoundaryGeometry(e,g) VCEntity_AddBoundary(e, g,NULL,NULL, VC_COLLISION_ENABLE | VC_COLLISION_GEOMETRY, NULL, 1)


int	VCBoundary_ModifyMode(VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int	VCBoundary_SetGeometry(VCAttribute *attribute, char *geometry);
int	VCBoundary_SetDynamicVisual(VCAttribute *attribute, VCDynamicVisual *dynamicGeometry);
int	VCBoundary_SetBounds(VCAttribute *attribute, float32 bounds[VC_BOUND_SIZE]);
int	VCBoundary_SetMode(VCAttribute *attribute, uint32 mode);
int	VCBoundary_SetLod(VCAttribute *attribute, char *lod);
int	VCBoundary_SetNumberCollisions(VCAttribute *attribute, int32 numberCollisions);
int	VCBoundary_GetGeometry(VCAttribute *attribute, char **geometry);
int	VCBoundary_GetBounds(VCAttribute *attribute, float32 bounds[VC_BOUND_SIZE]);
int	VCBoundary_GetMode(VCAttribute *attribute, uint32 *mode);
int	VCBoundary_GetLod(VCAttribute *attribute, char **lod);
int	VCBoundary_GetNumberCollisions(VCAttribute *attribute, int32 *numberCollisions);
int	VCBoundary_GetCollision(VCAttribute *attribute, VCCollision **collision);
int	VCBoundary_GetDynamicVisual(VCAttribute *attribute, VCDynamicVisual **dynamicGeometry);
void 	*VCBoundary_AttachCollisionCreateCallback(VCAttribute *boundary, VCCollision_Func func, void *data);
void 	*VCBoundary_AttachCollisionUpdateCallback(VCAttribute *boundary, VCCollision_Func func, void *data);
void 	*VCBoundary_AttachCollisionDeleteCallback(VCAttribute *boundary, VCCollision_Func func, void *data);
int		VCBoundary_DetachCollisionCreateCallback(VCAttribute *boundary, void *callbackHandle);
int		VCBoundary_DetachCollisionUpdateCallback(VCAttribute *boundary, void *callbackHandle);
int		VCBoundary_DetachCollisionDeleteCallback(VCAttribute *boundary, void *callbackHandle);

VCAttribute 	*VCLight_Create		(uint32 mode, VCColour colour, float exponent, float theta);
VCAttribute 	*VCLight_CreateData	(VCLightData *lightData);
int		 VCLight_Get 		(VCAttribute *attribute, uint32 *mode, VCColour colour,
                                         float *exponent, float *theta);
int		 VCLight_GetData	(VCAttribute *attribute, VCLightData *lightData);
VCAttribute 	*VCEntity_AddLightData(VCEntity *entity, VCLightData *data);
VCAttribute 	*VCEntity_AddLight	(VCEntity *entity, uint32 mode, float32 *colour,
                                         float exponent, float theta);
int		 VCLight_Set 		(VCAttribute *attribute, uint32 setMode, uint32 clearMode,
                                         VCColour colour, float *exponent, float *theta);
int		 VCLight_SetData	(VCAttribute *attribute, VCLightData *lightData);
int 		 VCLight_SetMode 	(VCAttribute *attribute, uint32 mode);
int		 VCLight_ModifyMode 	(VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int 		 VCLight_SetColour 	(VCAttribute *attribute, VCColour colour);
int 		 VCLight_SetUmbra 	(VCAttribute *attribute, float32 exponent, float theta);

int		 VCLight_GetMode	(VCAttribute *attribute, uint32 *mode);
int		 VCLight_GetColour	(VCAttribute *attribute, VCColour colour);
int		 VCLight_GetUmbra	(VCAttribute *attribute, float32 *exponent, float32 *theta);

#define VCEntity_DetachLight(e,a) VCEntity_DetachAttribute(e,a)
#define VCLight_Delete(a) VCAttribute_Delete(a)
#define VCLight_SetColor(a,c) VCLight_SetColour(a,c)
#define VCLight_GetColor(a,c) VCLight_GetColour(a,c)

#define VCEntity_AddLightDirectional(e,c) VCEntity_AddLight(e, VC_LIGHT_ENABLE | VC_LIGHT_MODE_DIRECTIONAL, c, 0.0f, 0.0f)
#define VCEntity_AddLightAmbient(e,c) VCEntity_AddLight(e, VC_LIGHT_ENABLE | VC_LIGHT_MODE_AMBIENT, c, 0.0f, 0.0f)
#define VCEntity_AddLightPoint(e,c) VCEntity_AddLight(e, VC_LIGHT_ENABLE | VC_LIGHT_MODE_POINT, c, 0.0f, 0.0f)
#define VCEntity_AddLightSpot(e,c,x,t) VCEntity_AddLight(e, VC_LIGHT_ENABLE | VC_LIGHT_MODE_SPOT, c, x, t)

#define VCLight_CreateDirectional(c) VCLight_Create(VC_LIGHT_ENABLE | VC_LIGHT_MODE_DIRECTIONAL, c, 0.0f, 0.0f)
#define VCLight_CreateAmbient(c) VCLight_Create(VC_LIGHT_ENABLE | VC_LIGHT_MODE_AMBIENT, c, 0.0f, 0.0f)
#define VCLight_CreatePoint(c) VCLight_Create(VC_LIGHT_ENABLE | VC_LIGHT_MODE_POINT, c, 0.0f, 0.0f)
#define VCLight_CreateSpot(c,x,t) VCLight_Create(VC_LIGHT_ENABLE | VC_LIGHT_MODE_SPOT, c, x, t)

VCAttribute 	*VCAudio_Create 	(char *voice, float32 gain, uint8 velocity,
                                         uint32 mode, int32 loopCnt, int8 priority,
                                         char *radiatorName, char *radiatorFileName);
VCAttribute 	*VCEntity_AddAudioData(VCEntity *entity, VCAudioData *data);
VCAttribute	*VCEntity_AddAudio	(VCEntity *entity, char *voice, float32 gain, uint8 velocity,
                                         uint32 mode, int32 loopCnt, int8 priority,
                                         char * radiatorName, char *radiatorFileName);
int		 VCAudio_Set 		(VCAttribute *attribute, char *voice,
                                         float32 *gain, uint8 *velocity, uint32 setMode,
                                         uint32 clearMode, uint8 play, int32 *loopCnt, int8 *priority, 
                                         char *radiatorName, char *radiatorFileName);
int		 VCAudio_Get 		(VCAttribute *attribute, char **voice,
                                         float32 *gain, uint8 *velocity, uint32 *mode,
                                         int32 *loopCnt, int8 *priority, 
                                         char **radiatorName, char **radiatorFileName);
VCAttribute	*VCAudio_CreateData 	(VCAudioData *audioData);
int		 VCAudio_GetData 	(VCAttribute *attribute, VCAudioData *audioData);
int		 VCAudio_SetData 	(VCAttribute *attribute, VCAudioData *audioData);

int		 VCAudio_SetVoice 	(VCAttribute *attribute, char *voice);
int		 VCAudio_SetMode	(VCAttribute *attribute, uint32 mode);
int		 VCAudio_ModifyMode 	(VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int		 VCAudio_SetGain 	(VCAttribute *attribute, float32 gain);
int		 VCAudio_SetVelocity 	(VCAttribute *attribute, uint8 velocity);
int		 VCAudio_SetLoopCount	(VCAttribute *attribute, int32 loopCnt);
int		 VCAudio_SetPriority 	(VCAttribute *attribute, int8 priority);
int		 VCAudio_SetRadiatorName(VCAttribute *attribute, char *radiator);
int		 VCAudio_SetRadiatorFile(VCAttribute *attribute, char *radiator);
int		 VCAudio_Start 		(VCAttribute *attribute);
int		 VCAudio_Stop 		(VCAttribute *attribute);

int		 VCAudio_GetVoice	(VCAttribute *attribute, char **voice);
int		 VCAudio_GetMode	(VCAttribute *attribute, uint32 *mode);
int		 VCAudio_GetGain	(VCAttribute *attribute, float32 *gain);
int		 VCAudio_GetVelocity	(VCAttribute *attribute, uint8 *velocity);
int		 VCAudio_GetLoopCount	(VCAttribute *attribute, int32 *loopCount);
int		 VCAudio_GetPriority	(VCAttribute *attribute, int8 *priority);
int		 VCAudio_GetRadiatorName(VCAttribute *attribute, char **radiator);
int		 VCAudio_GetRadiatorFile(VCAttribute *attribute, char **radiator);


#define VCEntity_AddAudioVoice(e,v) VCEntity_AddAudio(e, v, 0, 80, 0, 1, 0, NULL, NULL)
#define VCEntity_DetachAudio(e,a) VCEntity_DetachAttribute(e,a)
#define VCAudio_CreateVoice(v) VCAudio_Create(  v, 0, 80, 0, 1, 0, NULL, NULL)
#define VCAudio_Delete(a) VCAttribute_Delete(a)

VCAttribute 	*VCConstraints_Create 	(uint32 mode, uint32 flags, float32 points[6],
                                         float32 rotation[6]);
VCAttribute 	*VCConstraints_CreateData (VCConstraintsData *constraintsData);
int		 VCConstraints_Get	(VCAttribute *attribute, uint32 *mode, uint32 *flags, 
                                         float32 points[6], float32 rotation[6]);
int		 VCConstraints_GetData (VCAttribute *attribute, VCConstraintsData *constraintsData);

VCAttribute 	*VCEntity_AddConstraintsData(VCEntity *entity, VCConstraintsData *data);
VCAttribute	*VCEntity_AddConstraints(VCEntity *entity, uint32 mode, uint32 flags,
                                         float32 points[6], float32 rotation[6]);
int		 VCConstraints_Set 	(VCAttribute *attribute, uint32 setMode, 
                                         uint32 clearMode, uint32 setFlags, uint32 clearFlags,
                                         float32 points[6], float32 rotation[6]);
int		 VCConstraints_SetData (VCAttribute *attribute, VCConstraintsData *constraintsData);

int	VCConstraints_SetMode 		(VCAttribute *attribute, uint32 mode);
int	VCConstraints_ModifyMode 	(VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int	VCConstraints_ModifyFlags 	(VCAttribute *attribute, uint32 setFlags, uint32 clearFlags);
int	VCConstraints_SetFlags 		(VCAttribute *attribute, uint32 flags);
int	VCConstraints_SetPoint 		(VCAttribute *attribute, float32 point[6]);
int 	VCConstraints_SetRotation 	(VCAttribute *attribute, float32 rotation[6]);
int		 VCConstraints_GetMode (VCAttribute *attribute, uint32 *mode);
int		 VCConstraints_GetFlags (VCAttribute *attribute, uint32 *flags);
int		 VCConstraints_GetPoint (VCAttribute *attribute, float32 point[6]);
int		 VCConstraints_GetRotation (VCAttribute *attribute, float32 rotation[6]);





VCAttribute	*VCEntity_AddConstraintsHinge(VCEntity *entity, uint32 axis, float32 min, float32 max);
VCAttribute	*VCEntity_AddConstraintsHingeX(VCEntity *entity, float32 min, float32 max);
VCAttribute	*VCEntity_AddConstraintsHingeY(VCEntity *entity, float32 min, float32 max);
VCAttribute	*VCEntity_AddConstraintsHingeZ(VCEntity *entity, float32 min, float32 max);

VCAttribute 	*VCEntity_AddConstraintsTranslate(VCEntity *entity, uint32 axis, float32 min, float32 max);
VCAttribute	*VCEntity_AddConstraintsTranslateX(VCEntity *entity, float32 min, float32 max);
VCAttribute	*VCEntity_AddConstraintsTranslateY(VCEntity *entity, float32 min, float32 max);
VCAttribute	*VCEntity_AddConstraintsTranslateZ(VCEntity *entity, float32 min, float32 max);

VCAttribute 	*VCEntity_AddConstraintsRotate(VCEntity *entity, uint32 axis, float32 min, float32 max);
VCAttribute	*VCEntity_AddConstraintsRotateX(VCEntity *entity, float32 min, float32 max);
VCAttribute	*VCEntity_AddConstraintsRotateY(VCEntity *entity, float32 min, float32 max);
VCAttribute	*VCEntity_AddConstraintsRotateZ(VCEntity *entity, float32 min, float32 max);

VCAttribute *VCConstraints_CreateHinge(uint32 axis, float32 min, float32 max);
VCAttribute *VCConstraints_CreateHingeX(float32 min, float32 max);
VCAttribute *VCConstraints_CreateHingeY(float32 min, float32 max);
VCAttribute *VCConstraints_CreateHingeZ(float32 min, float32 max);
VCAttribute *VCConstraints_CreateTranslate(uint32 axis, float32 min, float32 max);
VCAttribute *VCConstraints_CreateTranslateX(float32 min, float32 max);
VCAttribute *VCConstraints_CreateTranslateY(float32 min, float32 max);
VCAttribute *VCConstraints_CreateTranslateZ(float32 min, float32 max);
VCAttribute *VCConstraints_CreateRotate(uint32 axis, float32 min, float32 max);
VCAttribute *VCConstraints_CreateRotateX(float32 min, float32 max);
VCAttribute *VCConstraints_CreateRotateY(float32 min, float32 max);
VCAttribute *VCConstraints_CreateRotateZ(float32 min, float32 max);

#define VCEntity_DetachConstraints(e,a) VCEntity_DetachAttribute(e,a)
#define VCConstraints_Delete(a) VCAttribute_Delete(a)

VCAttribute 	*VCVisualResource_Create	(char *name, uint32 mode, float32 frameRate, float32 iod,
                                                 float32 convergence, VCColour backGround,
                                                 float32 nearClip, float32 farClip, VCColour fogColour,
                                                 float32 nearFlog, float32 farFog, float32 lodScale,
                                                 uint32 actorId);
VCAttribute 	*VCVisualResource_CreateData 	(VCVisualResourceData *visualResource);
int		 VCVisualResource_Get		(VCAttribute *attribute, char **name, uint32 *mode,
                                                 float32 *frameRate, float32 *iod, float32 *convergence,
                                                 VCColour backGround, float32 *nearClip, float32 *farClip,
                                                 VCColour fogColour, float32 *nearFog, float32 *farFog,
                                                 float32 *lodScale, uint32 *actorId);
int		 VCVisualResource_GetData 	(VCAttribute *attribute, VCVisualResourceData *visualResource);
int		 VCVisualResource_Set 		(VCAttribute *attribute, uint32 setMode,
                                                 uint32 clearMode, float32 *frameRate, float32 *iod,
                                                 float32 *convergence, VCColour backGround,
                                                 float32 *nearClip, float32 *farClip, VCColour fogColour, 
                                                 float32 *nearFog, float32 *farFog, float32 *lodScale);
int		 VCVisualResource_SetData 	(VCAttribute *attribute, VCVisualResourceData *visualResource);
VCAttribute 	*VCEntity_AddVisualResourceData(VCEntity *entity, VCVisualResourceData *data);
VCAttribute	*VCEntity_AddVisualResource	(VCEntity *entity, char *name, uint32 mode,
                                                 float32 frameRate, float32 iod, float32 convergence,
                                                 VCColour backGround, float32 nearClip, float32 farClip,
                                                 VCColour fogColour, float32 nearFlog, float32 farFog,
                                                 float32 lodScale, uint32 actorId);

#define VCEntity_DetachVisualResource(e,a) VCEntity_DetachAttribute(e,a)
#define VCVisualResource_Delete(a) VCAttribute_Delete(a)

int 		VCVisualResource_SetMode  	(VCAttribute *attribute, uint32 mode);
int 		VCVisualResource_ModifyMode  	(VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int 		VCVisualResource_SetFrameRate  	(VCAttribute *attribute, float32 frameRate);
int 		VCVisualResource_SetIod  	(VCAttribute *attribute, float32 iod);
int 		VCVisualResource_SetConvergence (VCAttribute *attribute, float32 convergence);
int 		VCVisualResource_SetBackground  (VCAttribute *attribute, VCColour backGround);
int 		VCVisualResource_SetNearClip  	(VCAttribute *attribute, float32 nearClip);
int 		VCVisualResource_SetFarClip  	(VCAttribute *attribute, float32 farClip);
int 		VCVisualResource_SetFogColour 	(VCAttribute *attribute, VCColour fogColour);
int		VCVisualResource_SetNearFog  	(VCAttribute *attribute, float32 nearFog);
int 		VCVisualResource_SetFarFog  	(VCAttribute *attribute, float32 farFog);
int 		VCVisualResource_SetLodScale 	(VCAttribute *attribute, float32 lodScale);
int	VCVisualResource_GetName (VCAttribute *attribute, char **name);
int	VCVisualResource_GetMode (VCAttribute *attribute, uint32 *mode);
int	VCVisualResource_GetFrameRate (VCAttribute *attribute, float32 *frameRate);
int	VCVisualResource_GetIod (VCAttribute *attribute, float32 *iod);
int	VCVisualResource_GetConvergence (VCAttribute *attribute, float32 *convergence);
int	VCVisualResource_GetBackground (VCAttribute *attribute, VCColour backGround);
int	VCVisualResource_GetNearClip (VCAttribute *attribute, float32 *nearClip);
int	VCVisualResource_GetFarClip (VCAttribute *attribute, float32 *farClip);
int	VCVisualResource_GetFogColour (VCAttribute *attribute, VCColour fogColour);
int	VCVisualResource_GetNearFog (VCAttribute *attribute, float32 *nearFog);
int	VCVisualResource_GetFarFog (VCAttribute *attribute, float32 *farFog);
int	VCVisualResource_GetLodScale(VCAttribute *attribute, float32 *lodScale);
int	VCVisualResource_GetActorId(VCAttribute *attribute, uint32 *actorId);

#define VCVisualResource_SetFogColor(a,c) VCVisualResource_SetFogColour(a,c)
#define VCVisualResource_GetFogColor(a,c) VCVisualResource_GetFogColour(a,c)

VCAttribute 	*VCAudioResource_Create 	(char *name,  uint32 mode, float32 iad, float32 volume,
                                                 float32 spreadingRollOff, float32 atmosAbsorb,char *hrtf,
                                                 char *resourceFileName);
VCAttribute 	*VCAudioResource_CreateData 	(VCAudioResourceData *audioData);
VCAttribute 	*VCEntity_AddAudioResourceData(VCEntity *entity, VCAudioResourceData *data);
VCAttribute 	*VCEntity_AddAudioResource 	(VCEntity *entity, char *name, uint32 mode, float32 iad, 
                                                 float32 volume, float32 spreadingRollOff, float32 atmosAbsorb,
                                                 char *hrtf, char *resourceFileName);
int		 VCAudioResource_Set 		(VCAttribute *attribute, uint32 setMode,
                                                 uint32 clearMode, float32 *iad, float32 *volume,
                                                 float32 *spreadingRollOff, float32 *atmosphericAbsorption,
                                                 char *hrtf, char *resourceFileName);
int		 VCAudioResource_SetData 	(VCAttribute *attribute,VCAudioResourceData *audioData);
int		 VCAudioResource_Get 		(VCAttribute *attribute, char **name, uint32 *mode,
                                                 float32 *iad, float32 *volume,
                                                 float32 *spreadingRollOff, float32 *atmosphericAbsorption,
                                                 char **hrtf, char **resourceFileName);
int		 VCAudioResource_GetData 	(VCAttribute *attribute,VCAudioResourceData *audioData);
#define VCEntity_DetachAudioResource(e,a) VCEntity_DetachAttribute(e,a)
#define VCAudioResource_Delete(a) VCAttribute_Delete(a)

int		 VCAudioResource_SetIad 	(VCAttribute *attribute, float32 iad);
int		 VCAudioResource_SetMode (VCAttribute *attribute, uint32 mode);
int		 VCAudioResource_ModifyMode (VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int		 VCAudioResource_SetVolume 	(VCAttribute *attribute, float32 volume);
int		 VCAudioResource_SetHrtf 	(VCAttribute *attribute, char *hrtf);
int		 VCAudioResource_SetResourceFileName (VCAttribute *attribute, char *resourceName);
int		 VCAudioResource_SetSpreadingRollOff (VCAttribute *attribute, float32 spreadingRollOff);
int		 VCAudioResource_SetAtmosphericAbsorption (VCAttribute *attribute,
                                                           float32 atmosphericAbsorption);

int		 VCAudioResource_GetName 	(VCAttribute *attribute, char **name);
int		 VCAudioResource_GetMode (VCAttribute *attribute, uint32 *mode);
int		 VCAudioResource_GetIad 	(VCAttribute *attribute, float32 *iad);
int		 VCAudioResource_GetVolume 	(VCAttribute *attribute, float32 *volume);
int		 VCAudioResource_GetHrtf 	(VCAttribute *attribute, char **hrtf);
int		 VCAudioResource_GetResourceFileName (VCAttribute *attribute, char **resourceName);
int 		 VCAudioResource_GetSpreadingRollOff (VCAttribute *attribute, 
                                                      float32 *spreadingRollOff);
int		 VCAudioResource_GetAtmosphericAbsorption (VCAttribute *attribute,
                                                           float32 *atomsphericAbsorption);



VCAttribute 	*VCInputResource_Create 	(char *name, uint32 mode, VCInput *input);
VCAttribute 	*VCInputResource_CreateData 	(VCInputResourceData *inputData);
VCAttribute 	*VCEntity_AddInputResourceData(VCEntity *entity, VCInputResourceData *data);
VCAttribute 	*VCEntity_AddInputResource 	(VCEntity *entity, char *name, uint32 mode, VCInput *input);
int		 VCInputResource_Set 		(VCAttribute *attribute, uint32 setMode,
                                                 uint32 clearMode, VCInput *input);
int		 VCInputResource_SetData 	(VCAttribute *attribute, VCInputResourceData *inputData);
int		 VCInputResource_Get 		(VCAttribute *attribute, char **name,
                                                 uint32 *mode, VCInput **input);
int		 VCInputResource_GetData 	(VCAttribute *attribute, VCInputResourceData *inputData);
int		 VCInputResource_SetMode 	(VCAttribute *attribute, uint32 mode);
int		 VCInputResource_ModifyMode 	(VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int		 VCInputResource_GetName 	(VCAttribute *attribute, char **name);
int		 VCInputResource_GetMode 	(VCAttribute *attribute, uint32 *mode);
int		 VCInputResource_GetInput 	(VCAttribute *attribute, VCInput **input);


#define VCEntity_DetachInputResource(e,a) VCEntity_DetachAttribute(e,a)
#define VCInputResource_Delete(a) VCAttribute_Delete(a)

VCAttribute 	*VCSensorResource_Create (char *name, uint32 mode, VCTracker *tracker, uint32 sensorId,
                                          float32 scaleTranslate[3], float32 scaleRotate[3],
                                          float32 translationCurveOrder[3], float32 rotationCurveOrder[3],
                                          dmPoint prePosition, dmPoint postPosition, dmEuler preEuler,
                                          dmEuler postEuler, float32 relativeSphere[6], VCPosition *position,
                                          VCConstraintsData *constraints);
VCAttribute 	*VCSensorResource_CreateData (VCSensorResourceData *sensorData);
VCAttribute 	*VCEntity_AddSensorResourceData(VCEntity *entity, VCSensorResourceData *data);
VCAttribute 	*VCEntity_AddSensorResource (VCEntity *entity, char *name, uint32 mode, VCTracker *tracker,
                                             uint32 sensorId, float32 scaleTranslate[3],
                                             float32 scaleRotate[3],float32  translationCurveOrder[3],
                                             float32 rotationCurveOrder[3], dmPoint prePosition, 
                                             dmPoint postPosition, dmEuler preEuler, dmEuler postEuler,
                                             float32 relativeSphere[6], 
                                             VCPosition *position, VCConstraintsData *constraints);

int		 VCSensorResource_Set (VCAttribute *attribute, uint32 setMode, uint32 clearMode,
                                       float32 scaleTranslate[3],
                                       float32 scaleRotate[3], float32 translationCurveOrder[3],
                                       float32 rotationCurveOrder[3], dmPoint prePosition,
                                       dmPoint postPosition, dmEuler preEuler, dmEuler postEuler,
                                       float32 relativeSphere[6], VCPosition *position,
                                       VCConstraintsData *constraints);
int		 VCSensorResource_SetData (VCAttribute *attribute, VCSensorResourceData *sensorData);
int		 VCSensorResource_Get (VCAttribute *attribute, char **name,
                                       uint32 *mode, VCTracker **tracker, uint32 *sensorId,
                                       float32 scaleTranslate[3], float32 scaleRotate[3],
                                       float32 translationCurveOrder[3], float32 rotationCurveOrder[3],
                                       dmPoint prePosition, dmPoint postPosition, dmEuler preEuler,
                                       dmEuler postEuler, float32 relativeSphere[6], 
                                       VCPosition **position, VCConstraintsData *constraints);
int		 VCSensorResource_GetData (VCAttribute *attribute, VCSensorResourceData *sensorData);


#define VCEntity_DetachSensorResource(e,a) VCEntity_DetachAttribute(e,a)
#define VCSensorResource_Delete(a) VCAttribute_Delete(a)

int	VCSensorResource_ModifyMode(VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int	VCSensorResource_SetMode(VCAttribute *attribute, uint32 mode);
int	VCSensorResource_SetTranslationScale(VCAttribute *attribute, float32 scaleTranslate[3]);
int	VCSensorResource_SetRotationScale(VCAttribute *attribute, float32 scaleRotate[3]);
int	VCSensorResource_SetTranslationCurveOrder(VCAttribute *attribute, float32 curveOrder[3]);
int	VCSensorResource_SetRotationCurveOrder(VCAttribute *attribute, float32 curveOrder[3]);
int	VCSensorResource_SetPrePosition(VCAttribute *attribute, dmPoint prePosition);
int	VCSensorResource_SetPostPosition(VCAttribute *attribute, dmPoint postPosition);
int	VCSensorResource_SetPreEuler(VCAttribute *attribute, dmEuler preEuler);
int	VCSensorResource_SetPostEuler(VCAttribute *attribute, dmEuler postEuler);
int	VCSensorResource_SetRelativeSphere(VCAttribute *attribute, float32 relativeSphere[6]);
int	VCSensorResource_SetPosition(VCAttribute *attribute, VCPosition *pos);
int	VCSensorResource_SetConstraints(VCAttribute *attribute, VCConstraintsData *constraints);
int	VCSensorResource_GetName(VCAttribute *attribute, char **name);
int	VCSensorResource_GetMode(VCAttribute *attribute, uint32 *mode);
int	VCSensorResource_GetTracker(VCAttribute *attribute, VCTracker **tracker);
int	VCSensorResource_GetSensorId(VCAttribute *attribute, uint32 *sensorId);
int	VCSensorResource_GetTranslationScale(VCAttribute *attribute, float32 scaleTranslate[3]);
int	VCSensorResource_GetRotationScale(VCAttribute *attribute, float32 scaleRotate[3]);
int	VCSensorResource_GetTranslationCurveOrder(VCAttribute *attribute, float32 curveOrder[3]);
int	VCSensorResource_GetRotationCurveOrder(VCAttribute *attribute, float32 curveOrder[3]);
int	VCSensorResource_GetPrePosition(VCAttribute *attribute, dmPoint prePosition);
int	VCSensorResource_GetPostPosition(VCAttribute *attribute, dmPoint postPosition);
int	VCSensorResource_GetPreEuler(VCAttribute *attribute, dmEuler preEuler);
int	VCSensorResource_GetPostEuler(VCAttribute *attribute, dmEuler postEuler);
int	VCSensorResource_GetRelativeSphere(VCAttribute *attribute, float32 relativeSphere[6]);
int	VCSensorResource_GetPosition(VCAttribute *attribute, VCPosition **pos);
int	VCSensorResource_GetConstraints(VCAttribute *attribute, VCConstraintsData *constraints);


VCAttribute 	*VCVectorIntersect_Create 	(uint32 mode, float32 length, uint32 mask,
                                                 int32 numIntersections);
VCAttribute 	*VCVectorIntersect_CreateData 	(VCVectorIntersectData *intersectData);

VCAttribute 	*VCEntity_AddVectorIntersectData(VCEntity *entity, VCVectorIntersectData *data);
VCAttribute	*VCEntity_AddVectorIntersect 	(VCEntity *entity, uint32 mode, float32 length,
                                                 uint32 mask, int32 numIntersections);
int		 VCVectorIntersect_Set 		(VCAttribute *attribute, uint32 setMode, 
                                                 uint32 clearMode, float32 *length, uint32 setMask,
                                                 uint32 clearMaks, int32 *numIntersections);
int		 VCVectorIntersect_SetData 	(VCAttribute *attribute, VCVectorIntersectData *intersectData);
int		 VCVectorIntersect_Get 		(VCAttribute *attribute, uint32 *mode,
                                                 float32 *length, uint32 *mask, int32 *numIntersections,
                                                 VCIntersection **intersection);
int		 VCVectorIntersect_GetData (VCAttribute *attribute, VCVectorIntersectData *intersectData);
int		 VCVectorIntersect_Delete(VCAttribute *attribute);
#define VCEntity_DetachVectorIntersect(e,a) VCEntity_DetachAttribute(e,a)


int		VCVectorIntersect_SetMode 	(VCAttribute *attribute, uint32 mode);
int		VCVectorIntersect_ModifyMode 	(VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int		VCVectorIntersect_SetLength 	(VCAttribute *attribute, float32 kength);
int		VCVectorIntersect_SetIntersectMask (VCAttribute *attribute, uint32 mask);
int		VCVectorIntersect_ModifyIntersectMask (VCAttribute *attribute, uint32 setMask, 
                                                        uint32 clearMask);
int		VCVectorIntersect_SetNumberIntersections (VCAttribute *attribute, int32 numIntersections);
int		VCVectorIntersect_SetIntersection (VCAttribute *attribute, VCIntersection *intersection);

int		VCVectorIntersect_GetMode (VCAttribute *attribute, uint32 *mode);
int		VCVectorIntersect_GetLength (VCAttribute *attribute, float32 *length);
int		VCVectorIntersect_GetIntersectMask (VCAttribute *attribute, uint32 *mask);
int		VCVectorIntersect_GetNumberIntersections (VCAttribute *attribute, int32 numIntersections);
int		VCVectorIntersect_GetIntersection (VCAttribute *attribute, VCIntersection **intersection);
void 		*VCVectorIntersect_AttachIntersectionCreateCallback(VCAttribute *intersect,
                                                                    VCIntersection_Func func, void *data);
void 		*VCVectorIntersect_AttachIntersectionUpdateCallback(VCAttribute *intersect,
                                                                    VCIntersection_Func func, void *data);
void 		*VCVectorIntersect_AttachIntersectionDeleteCallback(VCAttribute *intersect,
                                                                    VCIntersection_Func func, void *data);

int		VCVectorIntersect_DetachIntersectionCreateCallback(VCAttribute *intersect, void *callbackHandle);
int		VCVectorIntersect_DetachIntersectionUpdateCallback(VCAttribute *intersect, void *callbackHandle);

int		VCVectorIntersect_DetachIntersectionDeleteCallback(VCAttribute *intersect, void *callbackHandle);






VCAttribute 	*VCVisualEffect_Create		(uint32 mode, uint32 type, dmPoint offset, float32 *data,
                                                 char *texture);
VCAttribute 	*VCVisualEffect_CreateData	(VCVisualEffectData *visEffectData);
VCAttribute 	*VCEntity_AddVisualEffectData(VCEntity *entity, VCVisualEffectData *data);
VCAttribute	*VCEntity_AddVisualEffect 	(VCEntity *entity, uint32 mode, uint32 type,
                                                 dmPoint offset, float *data, char *texture);
int		 VCVisualEffect_Set		(VCAttribute *attribute, uint32 setMode, uint32 clearMode,
                                                 uint32 *type, dmPoint offset, float data[72], char *texture);
int		 VCVisualEffect_SetData		(VCAttribute *attribute,VCVisualEffectData *visEffectData);
int		 VCVisualEffect_Get 		(VCAttribute *attribute, uint32 *mode, uint32 *type,
                                                 dmPoint offset, float32 data[72], char **texture);
int		 VCVisualEffect_GetData		(VCAttribute *attribute,VCVisualEffectData *visEffectData);
#define VCEntity_DetachVisualEffect(e,a) VCEntity_DetachAttribute(e,a)
#define VCVisualEffect_Delete(a) VCAttribute_Delete(a)
#define VCEntity_AddVisualEffectExplosion(e,t,o,te) VCEntity_AddVisualEffect(e,VC_VISUALEFFECT_MODE_EXPLOSION,t,o,NULL,te)
#define VCVisualEffect_CreateExplosion(t,o,te) VCVisualEffect_Create(VC_VISUALEFFECT_MODE_EXPLOSION,t,o,NULL,te)
#define VCVisualEffect_StartExplosion(a,o) VCVisualEffect_Set(a,VC_VISUALEFFECT_ENABLE,0,NULL,o,NULL,NULL)

int		 VCVisualEffect_SetMode		(VCAttribute *attribute, uint32 mode);
int		 VCVisualEffect_ModifyMode 	(VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int		 VCVisualEffect_SetType		(VCAttribute *attribute, uint32 type);
int		 VCVisualEffect_SetOffset 	(VCAttribute *attribute, dmPoint offset);
int		 VCVisualEffect_SetInfo		(VCAttribute *attribute, float32 info[72]);
int		 VCVisualEffect_SetTexture 	(VCAttribute *attribute, char *texture);

int		 VCVisualEffect_GetMode		(VCAttribute *attribute, uint32 *mode);
int		 VCVisualEffect_GetType		(VCAttribute *attribute, uint32 *type);
int		 VCVisualEffect_GetOffset 	(VCAttribute *attribute, dmPoint offset);
int		 VCVisualEffect_GetInfo		(VCAttribute *attribute, float32 info[72]);
int		 VCVisualEffect_GetTexture 	(VCAttribute *attribute, char **texture);


VCAttribute 	*VCDynamics_Create 	(uint32 mode, float32 imass, float32 gmass, dmPoint centre,
                                         float32 *iTensor, float32 spring, float32 damper,
                                         float32 sFriction, float32 dFriction);
VCAttribute 	*VCDynamics_CreateData 	(VCDynamicsData *dynamicData);
int		 VCDynamics_Get 	(VCAttribute *attribute, uint32 *mode, float32 *imass, 
                                         float32 *gmass, dmPoint centre, float32 itensor[6],
                                         float32 *spring, float32 *damper, float32 *sFriction,
                                         float32 *dFricition);
int		 VCDynamics_GetData 	(VCAttribute *attribute, VCDynamicsData *dynamicData);
VCAttribute 	*VCEntity_AddDynamicsData(VCEntity *entity, VCDynamicsData *data);
VCAttribute 	*VCEntity_AddDynamics	(VCEntity *entity, uint32 mode, float32 imass, float32 gmass,
                                         dmPoint centre, float32 *iTensor, float32 spring,
                                         float32 damper, float32 sFriction, float32 dFriction);
int		 VCDynamics_Set 	(VCAttribute *attribute, uint32 setMode, 
                                         uint32 clearMode, float32 *imass, float32 *gmass,
                                         dmPoint centre, float32 *iTensor, float32 *spring,
                                         float32 *damper, float32 *sFriction, float32 *dFriction);
int		 VCDynamics_SetData 	(VCAttribute *attribute, VCDynamicsData *dynamicData);
#define VCEntity_DetachDynamics(e,a) VCEntity_DetachAttribute(e,a)
#define VCDynamics_Delete(a) VCAttribute_Delete(a)

int		 VCDynamics_SetMode	(VCAttribute *attribute, uint32 mode);
int		 VCDynamics_ModifyMode 	(VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int		 VCDynamics_SetImass 	(VCAttribute *attribute, float32 imass);
int		 VCDynamics_SetGmass 	(VCAttribute *attribute, float32 gmass);
int		 VCDynamics_SetCentre 	(VCAttribute *attribute, dmPoint centre);
int		 VCDynamics_SetItensor 	(VCAttribute *attribute, float32 *itensor);
int		 VCDynamics_SetSpring 	(VCAttribute *attribute, float32 spring);
int		 VCDynamics_SetDamper 	(VCAttribute *attribute, float32 damper);
int		 VCDynamics_SetStaticFriction 	(VCAttribute *attribute, float32 sFriction);
int		 VCDynamics_SetDynamicFriction 	(VCAttribute *attribute, float32 dFriction);
int		 VCDynamics_GetMode 	(VCAttribute *attribute, uint32 *mode);
int		 VCDynamics_GetImass 	(VCAttribute *attribute, float32 *imass);
int		 VCDynamics_GetGmass 	(VCAttribute *attribute, float32 *gmass);    
int		 VCDynamics_GetCentre 	(VCAttribute *attribute, dmPoint centre);
int		 VCDynamics_GetItensor 	(VCAttribute *attribute, float32 itensor[6]);
int		 VCDynamics_GetSpring 	(VCAttribute *attribute, float32 *spring);
int		 VCDynamics_GetDamper 	(VCAttribute *attribute, float32 *damper);
int		 VCDynamics_GetStaticFriction 	(VCAttribute *attribute, float32 *sFriction);
int		 VCDynamics_GetDynamicFriction 	(VCAttribute *attribute, float32 *dFriction);


VCAttribute 	*VCForce_Create 	(uint32 mode, dmVector force, dmPoint point);
VCAttribute 	*VCForce_CreateData 	(VCForceData *forceData);
int		 VCForce_Get		(VCAttribute *attribute, uint32 *mode, dmVector force, dmPoint point);
int		 VCForce_GetData 	(VCAttribute *attribute, VCForceData *forceData);
VCAttribute 	*VCEntity_AddForceData(VCEntity *entity, VCForceData *data);
VCAttribute 	*VCEntity_AddForce 	(VCEntity *entity, uint32 mode, dmVector force, dmPoint point);
int		 VCForce_Set		(VCAttribute *attribute, uint32 setMode, 
                                         uint32 clearMode, dmVector force, dmPoint point);
int		 VCForce_SetData 	(VCAttribute *attribute, VCForceData *forceData);



#define VCEntity_DetachForce(e,a) VCEntity_DetachAttribute(e,a)
#define VCForce_Delete(a) VCAttribute_Delete(a)

int		 VCForce_SetMode 	(VCAttribute *attribute, uint32 mode);
int		 VCForce_ModifyMode	 (VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int		 VCForce_SetForce 	(VCAttribute *attribute, dmVector force);
int		 VCForce_SetPoint 	(VCAttribute *attribute, dmPoint point);
int		 VCForce_GetMode (VCAttribute *attribute, uint32 *mode);
int		 VCForce_GetForce (VCAttribute *attribute, dmVector force);
int		 VCForce_GetPoint (VCAttribute *attribute, dmPoint point);



VCAttribute 	*VCZone_Create 		(uint32 mode, uint32 actorMask);
VCAttribute 	*VCZone_CreateData 	(VCZoneData *zoneData);
int		 VCZone_Get 		(VCAttribute *attribute, uint32 *mode, uint32 *actorMask);
int		 VCZone_GetData 	(VCAttribute *attribute, VCZoneData *zoneData);
VCAttribute 	*VCEntity_AddZoneData(VCEntity *entity, VCZoneData *data);
VCAttribute 	*VCEntity_AddZone 	(VCEntity *entity, uint32 mode, uint32 actorMask);
int32		 VCZone_Set 		(VCAttribute *attribute, uint32 setMode, 
                                         uint32 clearMode, uint32 setActorMask, uint32 clearActorMask);
int		 VCZone_SetData 	(VCAttribute *attribute, VCZoneData *zoneData);
#define VCEntity_DetachZone(e,a) VCEntity_DetachAttribute(e,a)
#define VCZone_Delete(a) VCAttribute_Delete(a)

int		VCZone_SetMode 		(VCAttribute *attribute, uint32 mode);
int		VCZone_ModifyMode 	(VCAttribute *attribute, uint32 setMode, uint32 clearMode);
int		VCZone_SetActorMask 	(VCAttribute *attribute, uint32 mask);
int		VCZone_ModifyActorMask 	(VCAttribute *attribute, uint32 setMask, uint32 clearMask);
int		VCZone_GetMode(VCAttribute *attribute, uint32 *mode);
int		VCZone_GetActorMask(VCAttribute *attribute, uint32 *mask);



#endif	/* _VCOBJECT_H */
