simpcomp.h

hl2 source code. Do not use it illegal.

/**********************************************************************
 *<
	FILE: simpcomp.h

	DESCRIPTION:  A sample composite/leaf pair.

	CREATED BY: John Hutchinson

	HISTORY: created 8/24/98

 *>	Copyright (c) 1994, All Rights Reserved.
 **********************************************************************/
#ifndef _COMP_OBJ
#define _COMP_OBJ

#define _CACHING

#include "compbase.h"
#include "iparamb.h"
#ifdef _CACHING
#include "shape.h"
#endif

class PickMember;
class MoveModBoxCMode;
class RotateModBoxCMode;
class UScaleModBoxCMode;
class NUScaleModBoxCMode;
class SquashModBoxCMode;
class SelectModBoxCMode;

extern TCHAR *GetString(int id);
extern HINSTANCE hInstance;

#define BEGIN_EDIT_SKIP_SO_REGISTRATION		(1<<7)

class SimpleComposite : public CompositeBase
{
	friend class SimpleCompositeIterator;
	friend class UiUpdateRestore;
	friend class OpSelectionRestore;
	friend class ToggleHiddenRestore;

	enum { kobjectarray, kcontrolarray };

	//object list (references that we make)
	Tab<Object*> m_objlist;
	//controller list
	Tab<RefTargetHandle> m_ctllist;

protected://JH 1/13/99 let derived classes get at this stuff
	NameTab m_opName;
	BitArray selbits;//bit array to store the selection state of the components
	BitArray hidebits;//array to store the hidden state
#define EXPAND_BITS 64 //the chunk size for resizing the bit array

	bool m_creating;
//	int iSelLevel; //JH 5/31/99 moving to base class
	CoreExport static SimpleComposite* editObj;

	Matrix3 m_AmbientTM;
	Interval ivalid;

#ifdef _CACHING
protected:
	Mesh meshcache;
	BezierShape bezcache;
	Interval meshvalid;
	Interval shapevalid;
#endif
	int mOpContentFlags; // a cached value; if flag is zero, it is not up-to-date
	enum
	{
		kFlagsValid = 1,
		kContainsBaseMesh = 2,
		kContainsBaseShape = 4,
		kContainsEvalMesh = 8,
		kContainsEvalShape = 16,
	};
	bool mContentUpdateInProgress;

	class CompositeDeleteKeyUser : public EventUser
	{
	private:
		Object* m_composite_obj;
	public:
		//local methods
		CompositeDeleteKeyUser(){m_composite_obj = NULL;}
		void SetObject(Object* o){m_composite_obj = o;}

		//from Eventuser
		void Notify();
	}
	m_delete_user;

public:	//Class variables
	//miscellaneous
	CoreExport static IObjParam *ip;			//Access to the interface
	CoreExport static HWND hParams1;			// the object level dialog
	CoreExport static HWND hParams2;			// the subobject dialog
	static PickMember pickCB;
	static bool BlockExtract;
	CoreExport static Class_ID m_classid;

	//subobject modes
	CoreExport static MoveModBoxCMode *moveMode;
	CoreExport static RotateModBoxCMode *rotMode;
	CoreExport static UScaleModBoxCMode *uscaleMode;
	CoreExport static NUScaleModBoxCMode *nuscaleMode;
	CoreExport static SquashModBoxCMode *squashMode;
	CoreExport static SelectModBoxCMode *selectMode;

public: //methods
	// Constructor/Destructor
	CoreExport SimpleComposite();
	CoreExport ~SimpleComposite();

	// From Animatable
	CoreExport virtual void DeleteThis(){delete this;}
	CoreExport virtual void BeginEditParams(IObjParam  *ip, ULONG flags, Animatable *prev);
	CoreExport virtual void EndEditParams(IObjParam *ip, ULONG flags, Animatable *next);
	CoreExport virtual Class_ID ClassID() { return m_classid; }
	CoreExport virtual void FreeCaches();
	CoreExport virtual void* GetInterface(ULONG id);
	CoreExport virtual void GetClassName(TSTR& s) { s = _T("SimpleComposite"); }


	// From ReferenceMaker
	CoreExport virtual RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, 
										PartID& partID, RefMessage message);
	CoreExport virtual IOResult Load(ILoad* iload);
	CoreExport virtual IOResult Save(ISave* isave);

	// From ReferenceTarget
	CoreExport virtual RefTargetHandle Clone(RemapDir& remap);

	// From BaseObject
	CoreExport virtual int Display(TimeValue t, INode* inode, ViewExp *vpt, int flags);
	CoreExport virtual int HitTest(TimeValue t, INode* inode, int type, int crossing, int flags, 
									IPoint2 *p, ViewExp *vpt);
	CoreExport virtual void ActivateSubobjSel(int level, XFormModes& modes);
	CoreExport virtual CreateMouseCallBack* GetCreateMouseCallBack();
	CoreExport virtual TCHAR *GetObjectName();
	CoreExport virtual void SelectSubComponent(HitRecord *hitRec, BOOL selected, BOOL all, BOOL invert=FALSE);
	CoreExport virtual void ClearSelection(int selLevel);
	CoreExport virtual void Move( TimeValue t, Matrix3& partm, Matrix3& tmAxis, Point3& val, BOOL localOrigin=FALSE);
	CoreExport virtual void Rotate( TimeValue t, Matrix3& partm, Matrix3& tmAxis, Quat& val, BOOL localOrigin=FALSE);
	CoreExport virtual void Scale( TimeValue t, Matrix3& partm, Matrix3& tmAxis, Point3& val, BOOL localOrigin=FALSE);
	CoreExport virtual void TransformStart(TimeValue t);
	CoreExport virtual int HitTest(TimeValue t, INode* inode, int type, int crossing, int flags, 
									IPoint2 *p, ViewExp *vpt, ModContext* mc);
	//4/12/99 JH
	CoreExport virtual void CloneSelSubComponents(TimeValue t); 
	CoreExport virtual void AcceptCloneSelSubComponents(TimeValue t);


	// From Object
	CoreExport virtual void InitNodeName(TSTR& s);
	CoreExport virtual Interval ObjectValidity(TimeValue t);
	CoreExport virtual int UsesWireColor(){return FALSE;}
	//CoreExport virtual int DoOwnSelectHilite(){return 0;}
	CoreExport virtual int NumPipeBranches();
	CoreExport virtual Object *GetPipeBranch(int i);
	CoreExport virtual INode *GetBranchINode(TimeValue t, INode *node, int i);
	CoreExport virtual int IsRenderable();
	CoreExport virtual BOOL IsShapeObject();

	// From IComponent
	CoreExport virtual void Add(TimeValue t, Object* obj, TSTR objname, Matrix3& oppTm, Matrix3& boolTm, Matrix3& parTM, Control* opCont = NULL);
	CoreExport virtual void Add(TimeValue t,INode *node,Matrix3& boolTm, bool delnode = true);
	CoreExport virtual void Remove(ComponentIterator& i);
	CoreExport virtual void DisposeTemporary();
	CoreExport virtual ComponentIterator * MakeIterator();
	CoreExport virtual ComponentIterator * MakeReverseIterator();
	CoreExport virtual Object* MakeLeaf(Object* o);
	CoreExport virtual bool IsLeaf() const { return false; }
	CoreExport virtual void SelectOp(int which, BOOL selected);
	CoreExport virtual void ClearSelection();
	CoreExport virtual int GetSubSelectionCount();

	// From IRefArray
	CoreExport virtual int NumRefRows() const; // the number of arrays I maintain including inner
	CoreExport virtual void EnlargeAndInitializeArrays(int newsize);
	CoreExport virtual const ReferenceArray& RefRow(int which) const;
	CoreExport virtual ReferenceArray& RefRow(int which);

	// From CompositeBase
	CoreExport virtual ObjectState EvalPipeObj(TimeValue t, Object* obj);
	CoreExport virtual void CombineComponentMeshes(TimeValue t, Mesh& m);
	CoreExport virtual void CombineComponentShapes(TimeValue t, BezierShape& Dest);
	CoreExport virtual void CombineRenderMeshes(TimeValue t, INode *inode, View& view, Mesh& m);
	CoreExport virtual bool HasOnlyShapeOperands(TimeValue t);

	//Local Methods
	CoreExport virtual void GetOpTM(TimeValue t,int which, Matrix3& tm, Interval *iv=NULL) const;
	CoreExport virtual void Invalidate();
	CoreExport virtual void HideOp(int which, BOOL hidden);
	CoreExport virtual bool IsSubObjSelected(int i);
	CoreExport virtual bool IsSubObjHidden(int i);
	CoreExport virtual void ExtractOperands(TimeValue t, INode* node, bool autodelete = true, bool justhide = false);
	CoreExport virtual void SetupUI2();
	CoreExport virtual void DoSubObjSelectionFromList();
	CoreExport virtual void CheckIfShapeIsRenderable(Object *obj){}
	CoreExport virtual void SetName(int i, TCHAR *n){ assert(m_opName.Count() > i); m_opName.SetName(i,n); }
	CoreExport virtual TSTR GetName(int i){ assert(m_opName.Count() > i  &&  m_opName[i]); return m_opName[i]; }

protected:
	CoreExport void Clone(SimpleComposite * newob, RemapDir & remap);
	CoreExport void DisableExtract(bool extract);
	CoreExport void ToggleHidden(const Tab<int>& opset);
	CoreExport void UpdateContentFlags(bool recalc = false);
	CoreExport void EnableDeleteKey(bool OnOff);
};

//FIXME JH
//Consider creating a new class GeomObjectWrapper which encapsulates
//the delegation of the geoobject methods

//SS 4/12/99: Now derives from ShapeObject; if you leaf will only
// reference mesh geometry, override SuperClassID() and IsShapeObject().
class SimpleLeaf : public ShapeObject, public IComponent
{
	friend class SimpleLeafClassDesc;

	static Class_ID m_classid;

protected:
	Object* m_obj;
	bool m_deleteMe;
private:

public:
	// Constructor/Destructor
	CoreExport SimpleLeaf() : ShapeObject(), m_obj(NULL), m_deleteMe(false)
		{}
	CoreExport SimpleLeaf(Object* o, bool dm = true);
	CoreExport ~SimpleLeaf();

	// Static methods for dynamic allocation
	CoreExport static SimpleLeaf* CreateSimpleLeaf(Object *ob, bool dm = true);
	CoreExport static void DeleteSimpleLeaf(SimpleLeaf* l);

	// From Animatable
	CoreExport void DeleteThis()
		{ delete this; }
	CoreExport SClass_ID SuperClassID();
	CoreExport void BeginEditParams( IObjParam  *ip, ULONG flags,Animatable *prev);
	CoreExport void EndEditParams( IObjParam *ip, ULONG flags,Animatable *next);
	CoreExport Class_ID ClassID()
		{ return m_classid; }
	CoreExport virtual void FreeCaches();