private void TryConnectPivotToObject(BuildableObject _otherObject, PivotObject _pivot)
{
if (_otherObject)
{
ConnectPivotToObject(_otherObject, _pivot);
}
}
public void FitForPercent(PivotObject obj, float p)
{
Vector2 size = obj.size;
if (obj.pivot == PivotObject.PIVOT_POSITION.LEFT)
{
obj.uvRect = new Rect(0, 0, p, 1);
size.x = p;
}
if (obj.pivot == PivotObject.PIVOT_POSITION.RIGHT)
{
obj.uvRect = new Rect(1 - p, 0, p, 1);
size.x = 1 - p;
}
if (obj.pivot == PivotObject.PIVOT_POSITION.BOTTOM)
{
obj.uvRect = new Rect(0, 0, 1, p);
size.y = p;
}
if (obj.pivot == PivotObject.PIVOT_POSITION.TOP)
{
obj.uvRect = new Rect(0, 1 - p, 1, p);
size.y = 1 - p;
}
obj.size = size;
}
public void FitForPercent(PivotObject obj, float p)
{
Vector2 size = obj.size;
if (obj.pivot == PivotObject.PIVOT_POSITION.LEFT)
{
obj.uvRect = new Rect(0, 0, p, 1);
size.x = p;
}
if (obj.pivot == PivotObject.PIVOT_POSITION.RIGHT)
{
obj.uvRect = new Rect(1 - p, 0, p, 1);
size.x = 1 - p;
}
if (obj.pivot == PivotObject.PIVOT_POSITION.BOTTOM)
{
obj.uvRect = new Rect(0, 0, 1, p);
size.y = p;
}
if (obj.pivot == PivotObject.PIVOT_POSITION.TOP)
{
obj.uvRect = new Rect(0, 1 - p, 1, p);
size.y = 1 - p;
}
obj.size = size;
}
public override void ConnectPivotToObject(BuildableObject _otherObject, PivotObject _pivot)
{
base.ConnectPivotToObject(_otherObject, _pivot);
joint = _otherObject.gameObject.AddComponent <FixedJoint2D>();
joint.connectedBody = rb;
joint.anchor = _otherObject.transform.InverseTransformPoint(_pivot.transform.position);
}
public void AddObject(PivotObject newObject, bool needUpdate = true)
{
if(needUpdate)
newObject.Update();
newObject.behaviourmodel.Enable();
_objects.Add(newObject);
_sceneGraph.AddObject(newObject);
}
public void OnEnable()
{
po = target as PivotObject;
po.InitInfos();
uv = po.uvRect;
size = po.size;
pivot = po.pivot;
}
public void OnEnable()
{
po = target as PivotObject;
po.InitInfos();
uv = po.uvRect;
size = po.size;
pivot = po.pivot;
}
public override void DisconnectPivot(PivotObject _pivot)
{
base.DisconnectPivot(_pivot);
if (joint)
{
Destroy(joint);
}
}
public void CasheObject(string __name,
Matrix? __deltaMatrix,
bool __needMouseCast,
bool __needBulletCast,
PivotObject __parentObject = null,
PivotObjectDependType __dependType = PivotObjectDependType.Body)
{
PivotObject newObject = GameEngine.LoadObject(__name, __deltaMatrix, __needMouseCast, __needBulletCast, __dependType);
_cashedObjects.Add(__name, newObject);
}
public override void ConnectPivotToObject(BuildableObject _otherObject, PivotObject _pivot)
{
base.ConnectPivotToObject(_otherObject, _pivot);
joint = _otherObject.gameObject.AddComponent <FixedJoint2D>();
joint.connectedBody = rb;
joint.anchor = _otherObject.transform.InverseTransformPoint(_pivot.transform.position);
joint.autoConfigureConnectedAnchor = false;
joint.breakForce = breakingForce;
}
public virtual void ConnectPivotToObject(BuildableObject _otherObject, PivotObject _pivot)
{
if (_pivot.connectedBody)
{
DisconnectPivot(_pivot);
}
_pivot.connectedBody = _otherObject;
spriteR.sortingOrder = selectionPriority = _otherObject.selectionPriority + 1;
print("Connecting " + gameObject.name + " to " + _otherObject.gameObject.name);
}
public override void ConnectPivotToObject(BuildableObject _otherObject, PivotObject _pivot)
{
base.ConnectPivotToObject(_otherObject, _pivot);
_pivot.joint = _otherObject.gameObject.AddComponent <WheelJoint2D>();
WheelJoint2D wheelJoint = _pivot.joint as WheelJoint2D;
wheelJoint.connectedBody = rb;
wheelJoint.autoConfigureConnectedAnchor = false;
wheelJoint.anchor = _otherObject.transform.InverseTransformPoint(_pivot.transform.position);
wheelJoint.connectedAnchor = transform.InverseTransformPoint(_pivot.transform.position);
}
public override void ConnectPivotToObject(BuildableObject _otherObject, PivotObject _pivot)
{
base.ConnectPivotToObject(_otherObject, _pivot);
wheelJoint = _otherObject.gameObject.AddComponent <WheelJoint2D>();
wheelJoint.connectedBody = rb;
wheelJoint.autoConfigureConnectedAnchor = false;
wheelJoint.anchor = _otherObject.transform.InverseTransformPoint(_pivot.transform.position);
wheelJoint.breakForce = breakingForce;
wheelJoint.suspension = new JointSuspension2D()
{
frequency = frquency, dampingRatio = dampening
};
}
public void CalcParameters(PivotObject __parent)
{
if (!_onLevel || _locatedAtLastFrame)
{
_locatedAtLastFrame = false;
return;
}
if (_object._needCalcAcxis)
{
Vector3 axis = Vector3.UnitY;
if(__parent != null)
axis = Vector3.TransformNormal(Vector3.UnitY, __parent.transform);
else
axis = Vector3.TransformNormal(Vector3.UnitY, _object.transform);
_object._objectConstrAxis = axis;
}
}
public static void CreatePivotObject()
{
Mesh mesh = new Mesh();
const float h = 1, w = 1;
Vector3[] vertices = new Vector3[4];
vertices[0] = new Vector3(-w / 2, h / 2, 0);
vertices[1] = new Vector3(w / 2, h / 2, 0);
vertices[2] = new Vector3(-w / 2, -h / 2, 0);
vertices[3] = new Vector3(w / 2, -h / 2, 0);
int[] triangles = new int[] {
0, 1, 3,
0, 3, 2
};
Rect r = new Rect(0, 0, 1, 1);
Vector2[] uvs = new Vector2[4];
uvs[0] = new Vector2(r.x, r.y + r.height);
uvs[1] = new Vector2(r.x + r.width, r.y + r.height);
uvs[2] = new Vector2(r.x, r.y);
uvs[3] = new Vector2(r.x + r.width, r.y);
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.uv = uvs;
mesh.RecalculateBounds();
mesh.RecalculateNormals();
GameObject g = new GameObject("PivotObject");
g.AddComponent <MeshFilter>().sharedMesh = mesh;
g.AddComponent <MeshRenderer>();
PivotObject p = g.AddComponent <PivotObject>();
p.pivot = PivotObject.PIVOT_POSITION.CENTER;
}
public override void ConnectPivotToObject(BuildableObject _otherObject, PivotObject _pivot)
{
base.ConnectPivotToObject(_otherObject, _pivot);
rb.bodyType = RigidbodyType2D.Static;
if (targetA == null)
{
targetA = _otherObject.rb;
joint = _otherObject.gameObject.AddComponent <SpringJoint2D>();
joint.anchor = _otherObject.transform.InverseTransformPoint(_pivot.transform.position);
joint.enableCollision = true;
joint.autoConfigureDistance = joint.autoConfigureConnectedAnchor = false;
joint.breakForce = breakingForce;
}
else
{
targetB = _otherObject.rb;
joint.connectedBody = targetB;
joint.connectedAnchor = _otherObject.transform.InverseTransformPoint(_pivot.transform.position);
joint.distance = retractedDistance = Vector2.Distance(targetA.transform.TransformPoint(joint.anchor), _pivot.transform.position);
}
}
public virtual void SetParentObject(PivotObject __object)
{
}
public abstract void Update(PivotObject __object);
public static void UnloadPivotObject(
PivotObject theobject)
{
LevelObject gobject = theobject as LevelObject;
if (gobject == null)
return;
ConsoleWindow.TraceMessage("Content loader: Unloading object: " + theobject.editorAspect.DescriptionName);
System.Drawing.Point p = new System.Drawing.Point();
ResourceCollector.PackContent pc = ResourceCollector.PackList.Instance.findobject(theobject.editorAspect.DescriptionName, ref p);
ResourceCollector.Content.LevelObjectDescription description = pc as ResourceCollector.Content.LevelObjectDescription;
if (description != null)
{
description.Enginereadedobject.RemoveAt(description.Enginereadedobject.Count - 1);
//unload ro
ResourceCollector.Content.RenderObjectDescription rod = ResourceCollector.PackList.Instance.findobject(description.RODName, ref p) as ResourceCollector.Content.RenderObjectDescription;
RenderObject obj = rod.Enginereadedobject[rod.Enginereadedobject.Count - 1] as RenderObject;
rod.Enginereadedobject.RemoveAt(rod.Enginereadedobject.Count - 1);
if (rod.Enginereadedobject.Count == 0)
{
XNAevents.Add("disposing render object " + description.RODName);
IDisposable i = obj;
i.Dispose();
}
//unload material
ResourceCollector.Content.Material matd = ResourceCollector.PackList.Instance.findobject(description.matname, ref p) as ResourceCollector.Content.Material;
matd.Enginereadedobject.RemoveAt(matd.Enginereadedobject.Count - 1);
for (int i = 0; i < matd.lodMats.Count; i++)
{
for (int j = 0; j < matd.lodMats[i].mats.Count; j++)
{
ResourceCollector.ImageContent inage = ResourceCollector.PackList.Instance.findobject(matd.lodMats[i].mats[j].DiffuseTextureName, ref p) as ResourceCollector.ImageContent;
Content.EngineTexture tex = inage.Enginereadedobject[inage.Enginereadedobject.Count - 1] as Content.EngineTexture;
inage.Enginereadedobject.RemoveAt(inage.Enginereadedobject.Count - 1);
if (inage.Enginereadedobject.Count == 0)
{
XNAevents.Add("loading texture " + matd.lodMats[i].mats[j].DiffuseTextureName);
tex.Dispose();
}
}
}
if (description.IsRCCMEnabled)
{
//unload raycast
ResourceCollector.Content.CollisionMesh cm = ResourceCollector.PackList.Instance.findobject(description.RCCMName, ref p) as ResourceCollector.Content.CollisionMesh;
cm.Enginereadedobject.RemoveAt(cm.Enginereadedobject.Count - 1);
}
}
gobject.deleted = true;
}
public void AddObjectWithoutId(PivotObject newObject)
{
objects.Add(newObject);
sceneGraph.AddObject(newObject);
}
public override void DisconnectPivot(PivotObject _pivot)
{
base.DisconnectPivot(_pivot);
}
public void SearchClickedObject()
{
//ищем объект на кот тыкнули
Engine.Logic.PivotObject clickedlo = null;
Vector3 newpoint = MyGame.Instance._mousepoint;
float distance = 10000;
Vector3 camerapos = MyGame.Instance.ray.Position;
_belowMouseObject = null;
foreach (Engine.Logic.PivotObject lo in this.gameScene._visibleObjects)
{
if (!lo._needMouseCast)
continue;
Vector3? point = lo.raycastaspect.IntersectionClosest(MyGame.Instance.ray, lo.transform, ref MyGame.Instance._mousepointNormal);
if (point != null)
{
float range = (point.Value - camerapos).Length();
if (range < distance)
{
Vector3 direction = MyGame.Instance.ray.Direction;
direction.Normalize();
clickedlo = lo;
distance = range;
newpoint = point.Value;
newpoint += (direction * 0.3f);
_belowMouseObject = lo;
}
}
}
MyGame.Instance._mousepoint = newpoint;
}
/// <summary>
/// TODO - TEST
/// </summary>
/// <param name="__oldObject"></param>
/// <param name="__newObject"></param>
/// <param name="__recalculate"></param>
public bool SwapObjects(PivotObject __oldObject, PivotObject __newObject, bool __recalculate)
{
bool finded = false;
foreach(PivotObject obj in _objects)
if (obj == __oldObject)
{
finded = true;
break;
}
if (!finded)
{
__newObject.behaviourmodel.Enable();
_objects.Add(__newObject);
_sceneGraph.AddObject(__newObject);
return false;
}
List<MyContainer<PivotObject>.MyContainerRule> rules = _objects.FindAllRulesForObject(__oldObject);
foreach (MyContainer<PivotObject>.MyContainerRule rule in rules)
{
if (rule.firstObject == __oldObject)
{
rule.firstObject = __newObject;
rule.secondObject.behaviourmodel.SetParentObject(__newObject);
}
else if (rule.secondObject == __oldObject)
rule.secondObject = __newObject;
}
__newObject.behaviourmodel.Enable();
__oldObject.behaviourmodel.Disable();
_objects.Swap(__oldObject, __newObject, false);
_sceneGraph.SwapObjects(__oldObject, __newObject, __recalculate);
return true;
}
// удаление единичного объекта
public void ObjectDeleted(PivotObject curObject)
{
}
public void RemoveObject(PivotObject deletingobjects)
{
_objects.Remove(deletingobjects);
_sceneGraph.RemoveObject(deletingobjects);
deletingobjects.behaviourmodel.Disable();
// счетчик идов будет начинать все делать с 0
if (_objects.Count == 0)
{
IdGenerator.ClearIdsCounter();
}
}
public void CasheObject(string __name,
Matrix? __deltaMatrix,
bool __needMouseCast,
bool __needBulletCast,
PivotObject __parentObject = null,
PivotObjectDependType __dependType = PivotObjectDependType.Body)
{
_cashe.CasheObject(__name, __deltaMatrix, __needMouseCast, __needBulletCast, __parentObject, __dependType);
}
public override void ConnectPivotToObject(BuildableObject _otherObject, PivotObject _pivot)
{
base.ConnectPivotToObject(_otherObject, _pivot);
}
public void AddObject(PivotObject newObject)
{
newObject.editorAspect.id = idgenertor.NewId();
objects.Add(newObject);
sceneGraph.AddObject(newObject);
}
public virtual void DisconnectPivot(PivotObject _pivot)
{
_pivot.connectedBody = null;
}
private void AddObjectToScene(PivotObject __object, PivotObject __parentObject = null)
{
LevelObject loNew = __object as LevelObject;
if (loNew == null)
return;
if (loNew.renderaspect.isanimated)
{
Render.AnimRenderObject ro = loNew.renderaspect as Render.AnimRenderObject;
AnimationManager.AnimationManager.Manager.AddAnimationUserEnd(ro);
}
gameScene.AddObject(__object);
if (__parentObject != null)
{
__object.behaviourmodel.SetParentObject(__parentObject);
gameScene._objects.AddRule(__parentObject, __object);
}
}
public abstract void SetGlobalPose(Matrix GlobalPoseMatrix, object Additionaldata, PivotObject __parent = null);
public bool SearchPoint(Microsoft.Xna.Framework.Ray __ray, float __distance, out Vector3 __resultPoint, out PivotObject __resultObject, out Vector3 __pointNormal)
{
Engine.Logic.PivotObject clickedlo = null;
Vector3 newpoint = new Vector3();
Vector3 normal = new Vector3();
float distance = __distance;
bool finded = false;
foreach (Engine.Logic.PivotObject lo in this._intersectedObjects)
{
if (!lo._needBulletCast)
continue;
Vector3? point = lo.raycastaspect.IntersectionClosest(__ray, lo.transform, ref normal);
if (point != null)
{
StatisticContainer.Instance().UpdateParameter("totalBulletFaces", lo.raycastaspect.RCCM.Indices.Length / 3);
float range = (point.Value - __ray.Position).Length();
if (range < distance)
{
clickedlo = lo;
distance = range;
newpoint = point.Value;
finded = true;
}
}
}
__pointNormal = normal;
__resultObject = clickedlo;
__resultPoint = newpoint;
return finded;
}
public override void SetGlobalPose(Matrix GlobalPoseMatrix, object Additionaldata, PivotObject __parent)
{
CurrentPosition = GlobalPoseMatrix;
}
public void RemoveObjectFromScene(PivotObject __object)
{
LevelObject loNew = __object as LevelObject;
if (loNew == null)
return;
if (loNew.renderaspect.isanimated)
{
Render.AnimRenderObject ro = loNew.renderaspect as Render.AnimRenderObject;
AnimationManager.AnimationManager.Manager.RemoveUser(ro);
}
gameScene.RemoveObject(__object);
}
/// <summary>
/// ПОЛЬЗУЙСЯ ИМ!!!!!!!!!!!!!!
/// </summary>
/// <param name="newobject"></param>
public void AddObject(PivotObject newobject)
{
objectstoadd.Add(newobject);
}
public void ObjectAdded(PivotObject newObject)
{
Console.WriteLine("ObjectAdded");
levelform.AddObject(newObject.editorAspect.id.ToString(), newObject.editorAspect.DescriptionName, newObject.editorAspect.objtype.ToString(), newObject.editorAspect.isActive);
}
public override void SetGlobalPose(Matrix GlobalPoseMatrix, object Additionaldata, PivotObject __parent)
{
this.globalpose = GlobalPoseMatrix;
_actor.GlobalPose = GlobalPoseMatrix.toPhysicM();
}
public static BuildableObject CheckForConnection(PivotObject _pivot, GameObject _ignore = null) => CheckForConnection(_pivot.transform.position, _ignore);
