ShipEditor

OLM

• ObjectOriented-Lowpoly-Modeller
• Prism Based -> enhanced Interior Detection and Mesh-Management

Headers

class iSmartPointable {
	public:
	void RegisterSmartPtr	(SmartPtr<_T>* p);
	void UnregisterSmartPtr	(SmartPtr<_T>* p);
	SmartPtr<_T>* GetSmartPtr (iSmartPtrListener* listener);
	
	protected:
	std::List*>	smartPointers;
	iSmartPointable();							// empty, protected (must inherit)
	~iSmartPointable();							// calls NotifyDestroy() of all smartPointers
	void NotifySmartPtrChange(const int code);	// calls NotifyChange() of all smartPointers (idea)
}

class iSmartPtrListener {
	public :
	virtual void	NotifySmartPtrDestroy	(SmartPtr<_T>* sp);
	virtual void	NotifySmartPtrChange	(SmartPtr<_T>* sp,const int code);
}

class SmartPtr {
	public :
	SmartPtr	(_T* target=0,iSmartPtrListener<_T>* listener=0);  // target=0 possible !!!  (register)
	~SmartPtr 	();  						//  (unregister)
	void	SetTarget		(_T* target)	// unregister old + register new
	void	NotifyDestroy	();				// calls listener->NotifyDestroy()
	_T& operator = (_T* cmp)				// test for equality
	_T& operator = (SmartPtr<_T> cmp)		// test for equality
	_T& operator * ()						// todo : lookup syntax for (*smartptr), something like (int dummy)
	_T& operator -> ()
	
	private :
	_T*					target; // _T must be iSmartPointable, can be 0
	iSmartPtrListener*	listener; // can be 0
}

class iEditable { 
	public :
	virtual void	Move	(Vec3 v); 
	virtual void	Scale	(Vec3 v,Vec3 o = gVec3Zero); //  might not operate on vertices !
	virtual void	Rotate	(Vec3 v,Vec3 o = gVec3Zero);
	virtual void	Rotate	(Quaternion q,Vec3 o = gVec3Zero);
	// void transform(matrix m) ?  might not operate on vertices (cockpit-component is iEditable)
}

class iMeshLike : public iEditable { 
	public :
	virtual Vec3&	EditVertex		(const int i); // throws exception if index out of bounds
	virtual int		CountVertices	();
	Vec3	GetBoundsMin	();
	Vec3	GetBoundsMax	();
	Vec3	GetBoundsCenter	();
	Vec3	GetPivot		();
	
	// todo : readonly lists or complete management in this class ?
	// usecase :  ship-frame(readwrite) cockpit(readonly:just one dockable side, and move/rotatable for complete object)
	list	GetLinkedSides(SideNum);
	list	GetLinkedVertices(VertexNum);
	list	GetLinkedEdges(EdgeNum);
	list	GetSideVertices(SideNum);
	list	GetEdgeVertices(EdgeNum);
	vertex,side,edge enumeration and access
	editable functions
	position+rotation access -> coordinate conversion + align rotation.
	flags for lock vertices, lock pos/rot...
		cockpit is model with one designated side for docking,
			vertices cannot be changed, but position+rotation change is possible
		framecomponent does not need to use rotation, as the vertices are usualle freely movable
		when docked to cockpit, and moving the docked side, try to rotate/move the cockpit
			as closely as possible, then readjust vertices
		also otpional "lock form/vertices" for completed frame components (only rotate/position)
			-> behave similar to cockpit
	// visual feedback(side/edge/face hilighting, gizmos...) implemented in this class ??
}

class cComponent {
	public:
	SmartPtr parent; // =0 for top, frame:group,maschine:frame,...
	position,rotation
	GetBounds()
	GenBluePrint(tex,axis,offset,scale,colors)
	Cast2Group()
	Cast2Frame()
	ComponentType*	type;
	// emissions for sensors....
	// blueprint status display : functionality and damage
	NotifyDamage(); // Section (groupname) has been hit..
	GetDescription();
	// also baseclass for inner-maschinery etc...
	// coordinate translation ! (rotation)
	//intersection,inclusion-calc
}

class cFrameComponent : public iMeshLike {
	public:
	list		top;
	list		bot;
	int				flags;
	EditComponent	GetEditComponent	(); // null or overridden
}

class cModuleComponent : public iMeshLike { 
	public:
	list>	sides;
	// throws exceptions on illegal edit
	// cockpit, solarpanel...
	// ??? iMeshLike -> iEditable outside editor (deform from hit ??)
}

class cComponentType {
	public:
	// SteelFrame,TitanFrame,Cockpit...
}

class cEditComponent {
	public:
	// lists for selected vertices,edges,sides and whole FrameComponent
}

class cSelection : iEditable {
	public:
	// Selection != Group, as selection can be mutliple vertices/faces/lines...
}

class cComponentGroup {
	public:
	std::string	name;
	std::list elements;
}

class EditComponentGroup {
	public:
	// type of elements = EditComponent, use Component->GetEditComponent()
}

class cMouseMode {
public :
	// activate (=constructor),deactivate(=destructor)
	// step(=draw gizmos, active child as param ???),
	// abort(by rightclick, activates parent if set)
	// child-functions ??
	// hold SmartPtr to "cGizmo"s, and abort/selfkill on NotifyDestroy ?
}

class cGizmo {
	public:
	bool MouseOver(Vec3 o,Vec3 v);
	// click+drag // TODO : Research : CEGUI click+drag handling
	// drawing, scaling from + -
	// move,scale,rot : smartptr to iEditable, selfkill on NotifyDestroy
}

class cGrid {
	public:
	// snapping support (iSnappable ??)
	// 
}

Diagrams

digraph G { 
cGizmo -> cAxisGizmo -> { cMoveGizmo, cScaleGizmo };
cGizmo -> cRotateGizmo;
}

digraph G { 
cFrameComponent -> cComponent;
cGameComponent -> cComponent;
cGameFrameComponent -> cFrameComponent;
cEditFrameComponent -> {cFrameComponent,iMeshLike};
cSelection -> iEditable;
cComponentGroup -> cComponent;
cEditComponentGroup -> {cComponentGroup,iEditable}
}

use cases

start first spaceship frame

• select create-frame tool
• click and drag from corner A (somewhere on grid) to corner B of the bottom side
• release mouse and move up/down to place the top side
• click to finish

extrude or bevel single side

• select extrude or bevel tool
• click on side (not in selection) and drag to bevel/extrude this one side
• if extrude
  • release to finish
• elseif bevel
  • release starts scaling the extruded face
  • click to finish

bevel/extrude selection

• select pointer/selection tool
• select face mode from mode tool (vertex/edge/face/component/group)
• click + drag to select everything within rectangular area (rect-gizmo)
• shift : add to selection, ctrl : remove from selection : change cursor
• shift-click on single faces to add them to the selection
• select extrude/bevel tool
• click on side (in selection) and drag to bevel/extrude the selected faces together
• if extrude
  • release to finish
• elseif bevel
  • release starts scaling the extruded face
  • click to finish

todo's

• TODO : NameSpace for Editor ? (or just for whole project)
• TODO : Research : Multiple Inheritance : Con-/Destructor Calling and Order
• TODO : Research : Multiple Inheritance : automatic casting ??? or static_cast<Type>(ptr)
• TODO : Research : Trac : auto-generate tickets from doxygen TODOs
• TODO : Research : Exceptions
• TODO : Research : Decorator : editor for framecomponent
• TODO : Research : Python for Editor ?
• TODO : Research : DesignPattern : Memento for Create/Destroy-Command
• Todo : Research : DesignPattern : Builder -> ComponentBuilder

notes/ideas

Intuitive Behavior

• esc,rightclick : cancel mousemode
• backspace=back_to_parent, return=show_detail
• remove(delete) : kill/remove/collapse selected

StackTracer/Profile

• see sfz-wiki : std:uncaught_exception()
• macro : can be declared empty for release-compile
• macro at beginning of function
• creates object, which runs out of scope as the function exits -> exception-safe
• pass "path"("cBaseClass::MyMethod"),file,line to constructor
• use (const char*)path pointer instead of string compare
• profile : measure time from constructor to destructor

Custom-Assert

• keep gui intact if possible
• write report to file
• print stacktrace
• offer options : ignore,abort,debug,throw-exception

Linking

• Link Sides from different components
• throw exception when trying to move/scale/rotate link when locked
• throw exception when trying to change form of link when locked

Locking

• lock form(edge-count,connections,NOT SIZE/POS), size(rotate allowed ??), position
• beware of linking !

Face/Edge/Vertex Indexing

• prism based -> use positive for top, negative for bottom
• keep numbering if possible if only one half is changed
• smartptr-change notify usage ? (integrated listener pattern)

Symetry

• operates on list<component/sides/edges>:mutli-selection?, keeps binding, operator Source.
• mirror-plane + center-merger-plane gizmo : <[]> <[I]>

Editing

• All Operations use the Command Pattern, to support Undo/Redo
• Uses Mnemonic/Inner State Pattern for Create/Destroy
• Python Support ??
• Commands bindable to Buttons, Keys/KeyCombos, MenuItems, Right-Click Menu....

Move,Scale,Rotate

• when Tool is active, show the apropriate gizmo in scene
• gizmo acts on Current Selection (iEditable)
• gizmo gives visual MouseOver feedback
• support snapping

Creation

• CreateFrameComponent : Activates a Create-Mode :
• click(first corner) + drag(2d base) + click(3d)
• gizmo gives visual feedback during creation
• support snapping

Selection

• types/smartpointers for vertex,edge,side
• Selection managed as (named)list of those types
• Selection depends on active "type" (vertex,edge,side,FrameComponent,group), no mixing
• select gizmo (rectangle)
• Toggle select on intersect or only on complete containment
• manual selection with shift(add) and control(remove)
• when selection from list, and last selection was manually altered, save last manual selection as named
• undo for selection
• group select : when group is already selected, click selects subgroup
• map<smartptr<comp>,list<num>>

Picking

in popup :

• current selection,
• named selection,
• hierarchy list (groups)
• pick-by-click (current mode : vertex,edge,side,FrameComponent,group)

Tools

• ToolPanel = view, Tool = model(singleton) -> model/view seperation, change-listener
• Tool->CreatePanel()
• Python Support ??
• Tools can "pick" current selection, named selection, groups, or pick-by-click

• Grid Move Gizmo = Axis at left-top
• Grid Centered on Origin, Center of Current Selection, or fixed point
• Grid x,y,z,off (toggle bindable to key)
• Named Selections (depends on current mode (vertex,edge,side,FrameComponent,group)) + Select/Unselect/Show/Hide/Delete
• Mode Selection (vertex,edge,side,FrameComponent,group)
• Tool Selection (Select,Move,Scale,Rotate,Extrude,Bevel,SpinExtrude,SpinBevel)
• Snap (Grid,Vertex,Edge,Face)
• AngleSnap (edit+on/off button + buttons for 20 30 40 45 60 90)
• Name+Group / Ungroup
• Hierarchy-List (also for popup)
• Change Parent (opens hierarchy-list popup)
• Later : Change Type (popup : for compatible types, eg titanframe -> steelframe ??)
• Later : Change Side (point,line,3up,3down,square,penta,[x]:popup)

only for top/bottom, autoconvert if top/bottom <= 4

• Later : Toggle select on intersect or only on complete containment
• Later : QuickCut/Slice (FrameComponent, : DrawLine Gizmo
• Later : Create Adapter : pick operand a,b
• Later : ExtrudeAroundEdge,TurnAroundEdge (pick edge + turn selection)
• Later : SoftSelection (falloff:distance/adjactance,falloff:linear,cubic,curve,falloffdist)
• Later : Dock : move 2 sides together and link them, pick base(not moved) and operand (modifyed)
• Later : Constraints/Links + LockSize (link 2 sides of different FrameComponents, only move, not scale group)
• Later : Prism-Based Subdivide (height/width)
• Later : Hide/Show Selection/All

Gizmos

• scalable with +/-
• mouseovereffekt, areas : axis,area-between

Click / Drag Handling

• TODO : Research : CEGUI

• Tool/Mode/Gizmo can activate "MouseMode", abort on esc,rightclick

and when another MouseMode is activated

Spawning/ObjectCreation

• MouseMode
• Frame/Cockpit :
  • click on side : extrude/bevel
  • click on empty : create in space/ on grid

Inclusion/Intersection Warning

• not possible for space ships, breaks interior-definition,

and enables cheating (ultra compact, multi-dimensional cargo bays)

   ---
  /\X/\
 /  -  \
 -------
 

Blinking/Signal lights

• position on hull, can have limied offset
• choose color, frequency and offset

Sensors

• Heat/Temperature, Radioactivity, Electricity, Mass, Radar(metal), Bio
• spectrum analyzer : distinct materials
• active scanning (radar, detailed materials, freight)
• colors can be customized
• hud element for active scanning : modus (off, manual ping, fade display, ping interval)
• hud element for radar : 2 half-spheres (front and back) or single full sphere
  • FOF-colors customizable, lines to center : distance...
  • alternate : 2d-circle with orthogonal-lines indicating height

ComponentTypes

• implement constraints by inheritance or decorator or callback...
• factory for components ??
  • (could be used to convert component-type if neccessary : steel-titan-frame)
  • editable restraints

SampleComponents

• Frame (different materials, eg steel,titan,...)
• Cockpit/Bridge (different models)
• Scalable Thruster/Engine
• Scalable Solar Panel (rotatable?)
• Mountable Thruster ( mount on wing, like jumbo-jet, can mount missile/rocket-launcher instead)

Naming Scheme

• entity : ship,cargo-box,star,planet...
• entity has components
• system (starsystem) contains entities
• entity has course, pos+vel or pos+orbit(center,elliptic-params)