private static IHierarchyElement ReadHieraerchyElement(UnsafeReader reader)
{
switch (reader.ReadInt32())
{
case 0:
return(GameObjectHierarchy.Read(reader));
case 1:
return(ComponentHierarchy.Read(reader));
case 2:
return(PrefabInstanceHierarchy.Read(reader));
case 3:
return(ScriptComponentHierarchy.Read(reader));
case 4:
return(StrippedHierarchyElement.Read(reader));
case 5:
return(TransformHierarchy.Read(reader));
default:
throw new InvalidOperationException("Unknown type");
}
}
private void FireBullet()
{
Debug.Assert(Entity != null, nameof(Entity) + " != null");
Debug.Assert(Entity.Scene != null, "Entity.Scene != null");
var entity = new Entity();
Entity.Scene.AddEntity(entity);
var transform = TransformHierarchy.Calculate2DTransformationMatrix(Entity);
entity.AddComponent(new Transform2DComponent
{
Translation = (transform * new Vector2(0, 20).Homogeneous).ToVector2(),
Rotation = 0,
Scale = Vector2.One
});
Debug.Assert(Random != null, nameof(Random) + " != null");
entity.AddComponent(new EllipseRendererComponent
{
Color = Color.FromArgb(1, Random.NextDouble(), Random.NextDouble(), Random.NextDouble()),
Radius = 5,
FillInterior = true,
OrderInLayer = 2
});
entity.AddComponent(new BulletBehaviorComponent {
Velocity = _cannonRotorTransform.VectorY * 200
});
}
private static void Write(UnsafeWriter writer, AssetDocumentHierarchyElement value)
{
writer.Write(value.myOtherBoxedElements.Count);
writer.Write(value.myGameObjectHierarchies.Count);
writer.Write(value.myTransformElements.Count);
writer.Write(value.myScriptComponentElements.Count);
writer.Write(value.myComponentElements.Count);
foreach (var v in value.myOtherBoxedElements)
{
WriteHierarchyElement(writer, v);
}
foreach (var v in value.myGameObjectHierarchies)
{
GameObjectHierarchy.Write(writer, v);
}
foreach (var v in value.myTransformElements)
{
TransformHierarchy.Write(writer, v);
}
foreach (var v in value.myScriptComponentElements)
{
ScriptComponentHierarchy.Write(writer, v);
}
foreach (var v in value.myComponentElements)
{
ComponentHierarchy.Write(writer, v);
}
}
public InitHeadJoint(Transform target,
Transform myTransform,
TransformHierarchy targetDoll,
SkinnedMeshRenderer mesh) : base(target, myTransform)
{
m_TargetDoll = targetDoll;
m_Mesh = mesh;
}
public void Calculate2DTransformationMatrix_ShouldReturnTransformOfEntity_GivenEntityIsRoot()
{
// Arrange
var rootTransform2DComponent = CreateRandomTransform2DComponent();
var expected = rootTransform2DComponent.ToMatrix();
var rootEntity = new Entity();
rootEntity.AddComponent(rootTransform2DComponent);
// Act
var transformationMatrix = TransformHierarchy.Calculate2DTransformationMatrix(rootEntity);
// Assert
Assert.That(transformationMatrix, Is.EqualTo(expected).Using(Matrix3x3Comparer));
}
// ############################
public void SerializeBodies(Dictionary <Transform, Transform> targetToDoll, TransformHierarchy targetsHierachy)
{
SerializedObject so = new SerializedObject(this);
so.FindProperty("Hips").objectReferenceValue = targetToDoll[targetsHierachy.Hips].GetComponent <ActiveRagDollBone>();
so.FindProperty("Spine").objectReferenceValue = targetToDoll[targetsHierachy.Spine].GetComponent <ActiveRagDollBone>();
so.FindProperty("Head").objectReferenceValue = targetToDoll[targetsHierachy.Head].GetComponent <ActiveRagDollBone>();
so.FindProperty("UpperArm1").objectReferenceValue = targetToDoll[targetsHierachy.UpperArm1].GetComponent <ActiveRagDollBone>();
so.FindProperty("UpperArm2").objectReferenceValue = targetToDoll[targetsHierachy.UpperArm2].GetComponent <ActiveRagDollBone>();
so.FindProperty("LowerArm1").objectReferenceValue = targetToDoll[targetsHierachy.LowerArm1].GetComponent <ActiveRagDollBone>();
so.FindProperty("LowerArm2").objectReferenceValue = targetToDoll[targetsHierachy.LowerArm2].GetComponent <ActiveRagDollBone>();
so.FindProperty("UpperLeg1").objectReferenceValue = targetToDoll[targetsHierachy.UpperLeg1].GetComponent <ActiveRagDollBone>();
so.FindProperty("UpperLeg2").objectReferenceValue = targetToDoll[targetsHierachy.UpperLeg2].GetComponent <ActiveRagDollBone>();
so.FindProperty("LowerLeg1").objectReferenceValue = targetToDoll[targetsHierachy.LowerLeg1].GetComponent <ActiveRagDollBone>();
so.FindProperty("LowerLeg2").objectReferenceValue = targetToDoll[targetsHierachy.LowerLeg2].GetComponent <ActiveRagDollBone>();
so.ApplyModifiedProperties();
}
// ############################
public static BoxColliderParams CalculateBoxColliderParams(Vector3 lowerBoundPos,
Vector3 upperBoundPos,
Transform subject,
TransformHierarchy targetDoll)
{
Vector3 headPos = targetDoll.Head.position;
Vector3 armPos1 = targetDoll.UpperArm1.position;
Vector3 armPos2 = targetDoll.UpperArm2.position;
Vector3 spinePos = targetDoll.Spine.position;
Vector3 legPos = targetDoll.UpperLeg1.position;
int upDownDirIndex = Utils.GetDirectionIndex(subject, (headPos - spinePos).normalized);
int leftRightDirIndex = Utils.GetDirectionIndex(subject, (armPos1 - armPos2).normalized);
int forwardDirIndex = Enumerable.Range(0, 3).Where(x => (x != upDownDirIndex) && (x != leftRightDirIndex)).First();
Vector3[] directionsByIndex = new Vector3[] { subject.right, subject.up, subject.forward };
float upperBoundLocalHeight = Vector3.Dot(upperBoundPos - subject.position, directionsByIndex[upDownDirIndex]) / subject.lossyScale[upDownDirIndex];
float lowerBoundLocalHeight = Vector3.Dot(lowerBoundPos - subject.position, directionsByIndex[upDownDirIndex]) / subject.lossyScale[upDownDirIndex];
float requiredHeight = upperBoundLocalHeight - lowerBoundLocalHeight;
float requiredUpDownPos = (upperBoundLocalHeight + lowerBoundLocalHeight) / 2.0f;
float halfArmSpan = Mathf.Abs(Vector3.Dot(armPos1 - subject.position, directionsByIndex[leftRightDirIndex]) / subject.lossyScale[leftRightDirIndex]);
float requiredWidth = 2.0f * halfArmSpan;
float armsLocalforward = Vector3.Dot(armPos1 - subject.position, directionsByIndex[forwardDirIndex]) / subject.lossyScale[forwardDirIndex];
float legsLocalForward = Vector3.Dot(legPos - subject.position, directionsByIndex[forwardDirIndex]) / subject.lossyScale[forwardDirIndex];
float requiredForwardPos = (armsLocalforward + legsLocalForward) / 2.0f;
Vector3 centre = Vector3.zero;
centre[upDownDirIndex] = requiredUpDownPos;
centre[forwardDirIndex] = requiredForwardPos;
Vector3 size = Vector3.one;
size[upDownDirIndex] = requiredHeight;
size[leftRightDirIndex] = requiredWidth;
size[forwardDirIndex] = requiredWidth;
return(new BoxColliderParams(centre, size));
}
public void ProcessPhysics(Scene scene)
{
var entities = scene.AllEntities.Where(e => e.HasComponent <Transform2DComponent>() && e.HasComponent <Collider2DComponent>()).ToArray();
_colliders.Clear();
_transforms.Clear();
foreach (var entity in entities)
{
var collider2D = entity.GetComponent <Collider2DComponent>();
_transforms.Add(TransformHierarchy.Calculate2DTransformationMatrix(entity));
_colliders.Add(collider2D);
collider2D.ClearCollidingEntities();
}
for (var i = 0; i < entities.Length; i++)
{
var entity1 = entities[i];
var collider1 = _colliders[i];
var transform1 = _transforms[i];
var shape1 = CreateShapeForCollider(collider1, transform1);
for (var j = i + 1; j < entities.Length; j++)
{
var entity2 = entities[j];
var collider2 = _colliders[j];
var transform2 = _transforms[j];
IShape shape2 = CreateShapeForCollider(collider2, transform2);
if (shape1.Overlaps(shape2))
{
collider1.AddCollidingEntity(entity2);
collider2.AddCollidingEntity(entity1);
}
}
}
}
private static object Read(UnsafeReader reader)
{
var otherCount = reader.ReadInt32();
var gameObjectsCount = reader.ReadInt32();
var transformCount = reader.ReadInt32();
var scriptCount = reader.ReadInt32();
var componentsCount = reader.ReadInt32();
var result = new AssetDocumentHierarchyElement(otherCount, gameObjectsCount, transformCount, scriptCount, componentsCount);
for (int i = 0; i < otherCount; i++)
{
var hierarchyElement = ReadHieraerchyElement(reader);
result.myOtherBoxedElements.Add(hierarchyElement);
}
for (int i = 0; i < gameObjectsCount; i++)
{
result.myGameObjectHierarchies.Add(GameObjectHierarchy.Read(reader));
}
for (int i = 0; i < transformCount; i++)
{
result.myTransformElements.Add(TransformHierarchy.Read(reader));
}
for (int i = 0; i < scriptCount; i++)
{
result.myScriptComponentElements.Add(ScriptComponentHierarchy.Read(reader));
}
for (int i = 0; i < componentsCount; i++)
{
result.myComponentElements.Add(ComponentHierarchy.Read(reader));
}
return(result);
}
public void Calculate2DTransformationMatrix_ShouldReturnProductOfTransformOfEntityAndTransformOfParentEntity_GivenEntityHasParent()
{
// Arrange
var level0Transform2DComponent = CreateRandomTransform2DComponent();
var level1Transform2DComponent = CreateRandomTransform2DComponent();
var expected = level0Transform2DComponent.ToMatrix() * level1Transform2DComponent.ToMatrix();
var level0Entity = new Entity();
level0Entity.AddComponent(level0Transform2DComponent);
var level1Entity = new Entity();
level1Entity.AddComponent(level1Transform2DComponent);
level0Entity.AddChild(level1Entity);
// Act
var transformationMatrix = TransformHierarchy.Calculate2DTransformationMatrix(level1Entity);
// Assert
Assert.That(transformationMatrix, Is.EqualTo(expected).Using(Matrix3x3Comparer));
}
private void RenderEntities(Matrix3x3 cameraTransformationMatrix)
{
foreach (var entity in _renderList)
{
var transformationMatrix = TransformHierarchy.Calculate2DTransformationMatrix(entity);
transformationMatrix = cameraTransformationMatrix * transformationMatrix;
if (entity.HasComponent <SpriteRendererComponent>())
{
var sprite = entity.GetComponent <SpriteRendererComponent>().Sprite;
if (sprite != null)
{
_renderer2D.RenderSprite(sprite, transformationMatrix);
}
}
if (entity.HasComponent <TextRendererComponent>())
{
var textRenderer = entity.GetComponent <TextRendererComponent>();
_renderer2D.RenderText(textRenderer.Text, textRenderer.FontSize, textRenderer.Color, transformationMatrix);
}
if (entity.HasComponent <RectangleRendererComponent>())
{
var rectangleRenderer = entity.GetComponent <RectangleRendererComponent>();
var rectangle = new AxisAlignedRectangle(rectangleRenderer.Dimension);
_renderer2D.RenderRectangle(rectangle, rectangleRenderer.Color, rectangleRenderer.FillInterior, transformationMatrix);
}
if (entity.HasComponent <EllipseRendererComponent>())
{
var ellipseRenderer = entity.GetComponent <EllipseRendererComponent>();
var ellipse = new Ellipse(ellipseRenderer.RadiusX, ellipseRenderer.RadiusY);
_renderer2D.RenderEllipse(ellipse, ellipseRenderer.Color, ellipseRenderer.FillInterior, transformationMatrix);
}
}
}
private static void WriteHierarchyElement(UnsafeWriter writer, IHierarchyElement hierarchyElement)
{
switch (hierarchyElement)
{
case GameObjectHierarchy gameObjectHierarchy:
writer.Write(0);
GameObjectHierarchy.Write(writer, gameObjectHierarchy);
break;
case ComponentHierarchy componentHierarchy:
writer.Write(1);
ComponentHierarchy.Write(writer, componentHierarchy);
break;
case PrefabInstanceHierarchy prefabInstanceHierarchy:
writer.Write(2);
PrefabInstanceHierarchy.Write(writer, prefabInstanceHierarchy);
break;
case ScriptComponentHierarchy scriptComponentHierarchy:
writer.Write(3);
ScriptComponentHierarchy.Write(writer, scriptComponentHierarchy);
break;
case StrippedHierarchyElement strippedHierarchyElement:
writer.Write(4);
StrippedHierarchyElement.Write(writer, strippedHierarchyElement);
break;
case TransformHierarchy transformHierarchy:
writer.Write(5);
TransformHierarchy.Write(writer, transformHierarchy);
break;
}
}
public InitHipsJoint(Transform target, Transform myTransform, TransformHierarchy targetDoll) : base(target, myTransform, targetDoll)
{
}
// ############################
public InitBreastJoint(Transform target,
Transform myTransform,
TransformHierarchy targetDoll) : base(target, myTransform)
{
TargetDoll = targetDoll;
}
