//!!!!physics shape
//!!!!triangle index
public ResultItem(Component_ObjectInSpace obj, Vector3?position, double distanceScale, PhysicsRayTestItem.ResultItem testResult = null)
{
Object = obj;
Position = position;
DistanceScale = distanceScale;
RayTestResult = testResult;
}
protected override void OnCreate()
{
base.OnCreate();
if (ObjectInSpace != null)
{
var scene = CreateScene(false);
scene.DisplayPhysicalObjects = true;
instanceInScene = (Component_ObjectInSpace)ObjectInSpace.Clone();
scene.AddComponent(instanceInScene);
scene.Enabled = true;
if (Document != null)
{
Document.UndoSystem.ListOfActionsChanged += UndoSystem_ListOfActionsChanged;
}
if (ObjectOfEditor != null)
{
SelectObjects(new object[] { ObjectOfEditor });
}
}
}
internal void ObjectsInSpace_ObjectRemove(Component_ObjectInSpace obj)
{
if (octree != null && obj.sceneOctreeIndex != -1)
{
octreeObjects[obj.sceneOctreeIndex] = null;
octree.RemoveObject(obj.sceneOctreeIndex);
obj.sceneOctreeIndex = -1;
}
}
void ParentMeshInSpace_GetRenderSceneDataBefore(Component_ObjectInSpace sender, ViewportRenderingContext context, GetRenderSceneDataMode mode)
{
//check need modifiable mesh
bool needModifiableMesh = CheckNeedModifiableMesh();
//check need recreate
if (needRecreateModifiableMesh)
{
if (ParentMeshInSpace.ModifiableMesh_CreatedByObject == this)
{
ParentMeshInSpace.ModifiableMesh_Destroy();
}
needRecreateModifiableMesh = false;
}
//recreate
if (needModifiableMesh)
{
if (ParentMeshInSpace.ModifiableMesh == null)
{
if (CalculateOnCPU)
{
var flags = Component_MeshInSpace.ModifiableMeshCreationFlags.VertexBuffersCreateDuplicate | Component_MeshInSpace.ModifiableMeshCreationFlags.VertexBuffersDynamic;
ParentMeshInSpace.ModifiableMesh_Create(this, flags);
}
//var flags = Component_MeshInSpace.ModifiableMeshCreationFlags.VertexBuffersCreateDuplicate;
//if( CalculateOnCPU )
// flags |= Component_MeshInSpace.ModifiableMeshCreationFlags.VertexBuffersDynamic;
//else
// flags |= Component_MeshInSpace.ModifiableMeshCreationFlags.VertexBuffersComputeWrite;
//ParentMeshInSpace.ModifiableMesh_Create( this, flags );
needRecreateModifiableMesh = false;
}
}
else
{
if (ParentMeshInSpace.ModifiableMesh_CreatedByObject == this)
{
ParentMeshInSpace.ModifiableMesh_Destroy();
needRecreateModifiableMesh = false;
}
}
//update data
if (ParentMeshInSpace.ModifiableMesh_CreatedByObject == this)
{
UpdateModifiableMesh(context);
}
if (DisplaySkeleton)
{
RenderSkeleton(context.Owner);
}
}
/// <summary>
/// Get object to transform. find by reference. must be child of selected object.
/// </summary>
/// <param name="selectedObject"></param>
/// <returns></returns>
public static Component_ObjectInSpace CalculateObjectToTransform(Component_ObjectInSpace selectedObject)
{
Component_ObjectInSpace objectToTransform = null;
//get object to transform. find by reference. must be child of selected object.
//Component_TransformOffset specific
Component current = selectedObject;
while (current != null)
{
//check outside parent
{
bool inside = current == selectedObject || ComponentUtility.IsChildInHierarchy(selectedObject, current);
if (!inside)
{
break;
}
}
//_ObjectInSpace
var objectInSpace = current as Component_ObjectInSpace;
if (objectInSpace != null)
{
//check found result
if (!objectInSpace.Transform.ReferenceSpecified)
{
//found
objectToTransform = objectInSpace;
break;
}
objectInSpace.Transform.GetMember(current, out var outObject, out var outMember);
current = outObject as Component;
continue;
}
//_TransformOffset
var transformOffset = current as Component_TransformOffset;
if (transformOffset != null)
{
if (transformOffset.Source.ReferenceSpecified)
{
transformOffset.Source.GetMember(current, out var outObject, out var outMember);
current = outObject as Component;
continue;
}
}
//stop
break;
}
return(objectToTransform);
}
public void AddBaseObject(Component_ObjectInSpace obj)
{
var groupOfObjects = GetOrCreateGroupOfObjects();
if (groupOfObjects != null)
{
if (!groupOfObjects.BaseObjects.Contains((Component)obj))
{
groupOfObjects.BaseObjects.Add(ReferenceUtility.MakeRootReference <Component>(obj));
}
}
}
public static void ShowBoxAroundObject(Component_ObjectInSpace obj, Viewport viewport)
{
// Find object by the cursor.
//var obj = GetObjectByCursor(viewport);
// Draw selection border.
if (obj != null)
{
viewport.Simple3DRenderer.SetColor(new ColorValue(1, 1, 0));
viewport.Simple3DRenderer.AddBounds(obj.SpaceBounds.CalculatedBoundingBox);
}
}
protected override void OnViewportUpdateBeforeOutput()
{
base.OnViewportUpdateBeforeOutput();
if (ObjectInSpace != null && needRecreateInstance)
{
instanceInScene?.Dispose();
instanceInScene = (Component_ObjectInSpace)ObjectInSpace.Clone();
Scene.AddComponent(instanceInScene);
needRecreateInstance = false;
}
}
public Component_Character2DAITask_MoveToObject MoveTo(Component_ObjectInSpace target, bool run, bool clearTaskQueue = true)
{
if (clearTaskQueue)
{
ClearTaskQueue();
}
var task = CreateComponent <Component_Character2DAITask_MoveToObject>(enabled: false);
task.Target = target;
task.Run = run;
task.Enabled = true;
return(task);
}
public static void Detach(Component_ObjectInSpace objectToDetach, DocumentInstance documentforUndoRedo = null, UndoMultiAction undoMultiAction = null)
{
const string transformOffsetName = "Attach Transform Offset";
var objectInSpace = objectToDetach;
//var objectToTransform = CalculateObjectToTransform( objectInSpace );
//if( objectToTransform != null )
// objectInSpace = objectToTransform;
var transformOffset = objectInSpace.GetComponent(transformOffsetName) as Component_TransformOffset;
if (transformOffset != null)
{
//change Transform
{
//undo action
if (undoMultiAction != null)
{
var property = (Metadata.Property)objectInSpace.MetadataGetMemberBySignature("property:Transform");
var undoItem = new UndoActionPropertiesChange.Item(objectInSpace, property, objectInSpace.Transform, new object[0]);
undoMultiAction.AddAction(new UndoActionPropertiesChange(new UndoActionPropertiesChange.Item[] { undoItem }));
}
//remove reference
objectInSpace.Transform = new Reference <Transform>(objectInSpace.Transform, "");
}
//delete
if (undoMultiAction != null)
{
undoMultiAction.AddAction(new UndoActionComponentCreateDelete(documentforUndoRedo, new Component[] { transformOffset }, false));
}
else
{
transformOffset.Dispose();
}
}
}
/////////////////////////////////////////
internal void ObjectsInSpace_ObjectUpdate(Component_ObjectInSpace obj)
{
if (octree != null)
{
if (obj.sceneOctreeIndex == -1)
{
//add object to the scene graph
obj.sceneOctreeIndex = octree.AddObject(obj.SpaceBounds.CalculatedBoundingBox, 0); // obj.sceneOctreeGroup );
//add to sceneGraphObjects
while (octreeObjects.Count <= obj.sceneOctreeIndex)
{
octreeObjects.Add(null);
}
octreeObjects[obj.sceneOctreeIndex] = obj;
}
else
{
//update
octree.UpdateObject(obj.sceneOctreeIndex, obj.SpaceBounds.CalculatedBoundingBox, 0); // obj.sceneOctreeGroup );
}
}
}
protected virtual bool CalculatePointPosition(Viewport viewport, out Vector3 position, out Component_ObjectInSpace collidedWith)
{
if (!viewport.MouseRelativeMode)
{
var sceneDocumentWindow = DocumentWindow as Component_Scene_DocumentWindow;
if (sceneDocumentWindow != null)
{
var result = sceneDocumentWindow.CalculateCreateObjectPositionUnderCursor(viewport);
if (result.found)
{
position = result.position;
collidedWith = result.collidedWith;
return(true);
}
}
}
position = Vector3.Zero;
collidedWith = null;
return(false);
}
//
public TransformToolObject_ObjectInSpace(Component_ObjectInSpace selectedObject)
: base(selectedObject)
{
this.selectedObject = selectedObject;
//objectToTransform = Component_ObjectInSpace_Utility.CalculateObjectToTransform( this.selectedObject );
}
public static void SetRenderSceneIndex(Component_ObjectInSpace obj, int v)
{
obj._internalRenderSceneIndex = v;
}
/////////////////////////////////////////
//Component_ObjectInSpace
public static int GetRenderSceneIndex(Component_ObjectInSpace obj)
{
return(obj._internalRenderSceneIndex);
}
protected override bool CalculatePointPosition(Viewport viewport, out Vector3 position, out Component_ObjectInSpace collidedWith)
{
var result = base.CalculatePointPosition(viewport, out position, out collidedWith);
if (result)
{
if (collidedWith != null)
{
CreatingObject.AddBaseObject(collidedWith);
}
}
return(result);
}
public static Component_TransformOffset Attach(Component_ObjectInSpace attachTo, Component_ObjectInSpace objectToAttach, DocumentInstance documentforUndoRedo = null, UndoMultiAction undoMultiAction = null)
{
var objectToTransform = CalculateObjectToTransform(objectToAttach);
if (objectToTransform != null)
{
objectToAttach = objectToTransform;
}
//create _TransformOffset
Component_TransformOffset transformOffset;
{
const string transformOffsetName = "Attach Transform Offset";
transformOffset = objectToAttach.CreateComponent <Component_TransformOffset>(enabled: false);
transformOffset.Name = transformOffsetName;
transformOffset.Source = ReferenceUtility.MakeReference <Transform>(null, ReferenceUtility.CalculateThisReference(transformOffset, attachTo, "Transform"));
try
{
var f = attachTo.Transform.Value;
var s = objectToAttach.Transform.Value;
var offset = f.ToMatrix4().GetInverse() * s.ToMatrix4();
offset.Decompose(out Vector3 pos, out Quaternion rot, out Vector3 scl);
transformOffset.PositionOffset = pos;
transformOffset.RotationOffset = rot;
transformOffset.ScaleOffset = scl;
//transformOffset.Matrix = offset;
//var offset = new Mat4( s.Rotation.ToMat3(), s.Position ) * new Mat4( f.Rotation.ToMat3(), f.Position ).GetInverse();
//var f = first.Transform.Value;
//var s = second.Transform.Value;
//var offset = new Mat4( s.Rotation.ToMat3(), s.Position ) * new Mat4( f.Rotation.ToMat3(), f.Position ).GetInverse();
////var offset = second.Transform.Value.ToMat4() * first.Transform.Value.ToMat4().GetInverse();
//offset.Decompose( out Vec3 pos, out Quat rot, out Vec3 scl );
//transformOffset.PositionOffset = pos / f.Scale;// / s.Scale;
//transformOffset.RotationOffset = rot;
//transformOffset.ScaleOffset = s.Scale / f.Scale;
////transformOffset.ScaleOffset = scl;
}
catch { }
transformOffset.Enabled = true;
if (undoMultiAction != null)
{
undoMultiAction.AddAction(new UndoActionComponentCreateDelete(documentforUndoRedo, new Component[] { transformOffset }, true));
}
}
//change Transform
{
//undo action
if (undoMultiAction != null)
{
var property = (Metadata.Property)objectToAttach.MetadataGetMemberBySignature("property:Transform");
var undoItem = new UndoActionPropertiesChange.Item(objectToAttach, property, objectToAttach.Transform, new object[0]);
undoMultiAction.AddAction(new UndoActionPropertiesChange(new UndoActionPropertiesChange.Item[] { undoItem }));
}
//configure reference
objectToAttach.Transform = ReferenceUtility.MakeReference <Transform>(null, ReferenceUtility.CalculateThisReference(objectToAttach, transformOffset, "Result"));
}
return(transformOffset);
}
public static void PerformGetRenderSceneData(Component_ObjectInSpace obj, ViewportRenderingContext context, GetRenderSceneDataMode mode)
{
obj.PerformGetRenderSceneData(context, mode);
}
//!!!!подобное для Brush режима
//public delegate void CalculateCreateObjectPositionUnderCursorEventDelegate( Component_ObjectInSpace objectInSpace, ref bool found, ref Vector3 position );
//public static event CalculateCreateObjectPositionUnderCursorEventDelegate CalculateCreateObjectPositionUnderCursorEvent;
//public class CalculateCreateObjectPositionByRayResult
//{
// public bool Found;
// public Vector3 Position;
// public Component_ObjectInSpace CollidedWith;
// public Vector3F Normal;
//}
public static (bool found, Vector3 position, Component_ObjectInSpace collidedWith) CalculateCreateObjectPositionByRay(Component_Scene scene, Component_ObjectInSpace objectInSpace, Ray ray, bool allowSnap)
{
//var viewport = ViewportControl.Viewport;
//Vector2 mouse;
//if( overrideMouse.HasValue )
// mouse = overrideMouse.Value;
//else
//{
// mouse = viewport.MousePosition;
// if( !new Rectangle( 0, 0, 1, 1 ).Contains( mouse ) )
// mouse = new Vector2( 0.5, 0.5 );
//}
//Ray ray;
//if( overrideRay.HasValue )
// ray = overrideRay.Value;
//else
// ray = viewport.CameraSettings.GetRayByScreenCoordinates( mouse );
//!!!!? clamp max distance
//ray.Direction = ray.Direction.GetNormalize() * 100;
//!!!!можно конвекс форму делать вместо бокса
Bounds localBounds = new Bounds();
if (objectInSpace != null)
{
//particle system specific
if (!(objectInSpace is Component_ParticleSystemInSpace))
{
localBounds = objectInSpace.SpaceBounds.CalculatedBoundingBox - objectInSpace.Transform.Value.Position;
}
}
if (localBounds.GetSize().X < 0.001)
{
localBounds.Expand(new Vector3(0.001, 0, 0));
}
if (localBounds.GetSize().Y < 0.001)
{
localBounds.Expand(new Vector3(0, 0.001, 0));
}
if (localBounds.GetSize().Z < 0.001)
{
localBounds.Expand(new Vector3(0, 0, 0.001));
}
double resultMinScale = 1.01;
Component_ObjectInSpace resultMinScaleCollidedWith = null;
if (objectInSpace != null)
{
//when objectInSpace != null
Plane[] planes;
{
var b1 = localBounds + ray.Origin;
var b2 = b1 + ray.Direction;
var points = CollectionUtility.Merge(b1.ToPoints(), b2.ToPoints());
ConvexHullAlgorithm.Create(points, out planes);
}
var item = new Component_Scene.GetObjectsInSpaceItem(Component_Scene.GetObjectsInSpaceItem.CastTypeEnum.All, null, true, planes);
scene.GetObjectsInSpace(item);
foreach (var resultItem in item.Result)
{
if (objectInSpace != resultItem.Object && !resultItem.Object.GetAllParents(false).Contains(objectInSpace))
{
//mesh in space
if (resultItem.Object is Component_MeshInSpace meshInSpace)
{
Vector3[] verticesFull;
int[] indices;
{
var b1 = localBounds + ray.Origin;
var b2 = b1 + ray.Direction;
var points = CollectionUtility.Merge(b1.ToPoints(), b2.ToPoints());
ConvexHullAlgorithm.Create(points, out verticesFull, out indices);
}
if (meshInSpace._Intersects(verticesFull, indices))
{
double minScale = 1.01;
double currentScale = 0.5;
//!!!!?
const double threshold = 0.00001;
double step = 0.25;
while (step > threshold)
{
Vector3[] vertices = new Vector3[verticesFull.Length];
for (int n = 0; n < vertices.Length; n++)
{
vertices[n] = verticesFull[n] - ray.Direction + ray.Direction * currentScale;
}
//Vector3[] vertices;
//int[] indices;
//{
// var b1 = localBounds + ray.Origin;
// var b2 = b1 + ray.Direction * currentScale;
// var points = CollectionUtility.Merge( b1.ToPoints(), b2.ToPoints() );
// ConvexHullAlgorithm.Create( points, out vertices, out indices );
//}
bool intersects = meshInSpace._Intersects(vertices, indices);
if (!intersects)
{
minScale = currentScale;
}
if (intersects)
{
currentScale -= step;
}
else
{
currentScale += step;
}
step /= 2;
}
if (minScale <= 1 && minScale < resultMinScale)
{
resultMinScale = minScale;
resultMinScaleCollidedWith = meshInSpace;
}
}
}
//!!!!какие еще
}
}
}
else
{
//when objectInSpace == null
var item = new Component_Scene.GetObjectsInSpaceItem(Component_Scene.GetObjectsInSpaceItem.CastTypeEnum.All, null, true, ray);
scene.GetObjectsInSpace(item);
foreach (var resultItem in item.Result)
{
//mesh in space
if (resultItem.Object is Component_MeshInSpace meshInSpace)
{
if (meshInSpace.RayCast(ray, Component_Mesh.CompiledData.RayCastMode.Auto, out var scale, out var triangleIndex))
{
if (scale <= 1 && scale < resultMinScale)
{
resultMinScale = scale;
resultMinScaleCollidedWith = meshInSpace;
//if( triangleIndex != -1 )
//{
//}
}
}
}
//!!!!какие еще
}
}
bool found;
Vector3 pos;
if (resultMinScale <= 1)
{
found = true;
pos = ray.GetPointOnRay(resultMinScale);
}
else
{
found = false;
pos = ray.Origin + ray.Direction.GetNormalize() * Math.Max(localBounds.GetBoundingSphere().Radius, 1) * 20;
}
//snap for 2D mode
if (scene.Mode.Value == Component_Scene.ModeEnum._2D)
{
pos.Z = Math.Ceiling(pos.Z);
}
//snap
if (allowSnap)
{
double snap;
//if( Form.ModifierKeys.HasFlag( Keys.Control ) )
snap = ProjectSettings.Get.SceneEditorStepMovement;
//else
// snap = 0;
if (snap != 0)
{
Vector3 snapVec = new Vector3(snap, snap, snap);
pos += snapVec / 2;
pos /= snapVec;
pos = new Vector3I((int)pos.X, (int)pos.Y, (int)pos.Z).ToVector3();
pos *= snapVec;
}
}
//CalculateCreateObjectPositionUnderCursorEvent?.Invoke( objectInSpace, ref found, ref pos );
return(found, pos, resultMinScaleCollidedWith);
//objectToTransform.Transform = new Transform( pos, objectToTransform.Transform.Value.Rotation, objectToTransform.Transform.Value.Scale );
//}
//else
//{
// var localBounds = objectInSpace.SpaceBounds.CalculatedBoundingBox - objectInSpace.Transform.Value.Position;
// //disable object to disable collisions
// var disable = ContainsPhysicsBodies( objectInSpace );
// if( disable )
// objectInSpace.Enabled = false;
// //!!!!contact group
// PhysicsConvexSweepTestItem castItem = new PhysicsConvexSweepTestItem( Matrix4.FromTranslate( ray.Origin ),
// Matrix4.FromTranslate( ray.Origin + ray.Direction ), 1, -1, PhysicsConvexSweepTestItem.ModeEnum.OneClosest, localBounds );
// Scene.PhysicsConvexSweepTest( new PhysicsConvexSweepTestItem[] { castItem } );
// //restore disabled object
// if( disable )
// objectInSpace.Enabled = true;
// Vector3 pos;
// if( castItem.Result.Length != 0 )
// pos = castItem.Result[ 0 ].Position;
// else
// {
// pos = ray.Origin + ray.Direction.GetNormalize() * Math.Max( localBounds.GetBoundingSphere().Radius, 1 ) * 20;
// }
// objectInSpace.Transform = new Transform( pos, objectInSpace.Transform.Value.Rotation, objectInSpace.Transform.Value.Scale );
//}
}
public static void PerformGetRenderSceneData(Component_ObjectInSpace obj, ViewportRenderingContext context, GetRenderSceneDataMode mode, Component_Scene.GetObjectsInSpaceItem modeGetObjectsItem)
{
obj.PerformGetRenderSceneData(context, mode, modeGetObjectsItem);
}
