public override ActorComponent MakeInstance(Actor resetActor)
{
JellyComponent instanceNode = new JellyComponent();
instanceNode.Copy(this, resetActor);
return(instanceNode);
}
public void Copy(JellyComponent node, Actor resetActor)
{
base.Copy(node, resetActor);
m_EaseIn = node.m_EaseIn;
m_EaseOut = node.m_EaseOut;
m_ScaleIn = node.m_ScaleIn;
m_ScaleOut = node.m_ScaleOut;
m_InTargetIdx = node.m_InTargetIdx;
m_OutTargetIdx = node.m_OutTargetIdx;
}
public static JellyComponent Read(Actor actor, BinaryReader reader, JellyComponent node = null)
{
if (node == null)
{
node = new JellyComponent();
}
ActorComponent.Read(actor, reader, node);
node.m_EaseIn = reader.ReadSingle();
node.m_EaseOut = reader.ReadSingle();
node.m_ScaleIn = reader.ReadSingle();
node.m_ScaleOut = reader.ReadSingle();
node.m_InTargetIdx = reader.ReadUInt16();
node.m_OutTargetIdx = reader.ReadUInt16();
return(node);
}
private void ReadComponentsBlock(BlockReader block)
{
int componentCount = block.ReadUInt16();
m_Components = new ActorComponent[componentCount + 1];
m_Components[0] = m_Root;
// Guaranteed from the exporter to be in index order.
BlockReader nodeBlock = null;
int componentIndex = 1;
m_NodeCount = 1;
while ((nodeBlock = block.ReadNextBlock()) != null)
{
ActorComponent component = null;
if (Enum.IsDefined(typeof(BlockTypes), nodeBlock.BlockType))
{
BlockTypes type = (BlockTypes)nodeBlock.BlockType;
switch (type)
{
case BlockTypes.ActorNode:
component = ActorNode.Read(this, nodeBlock);
break;
case BlockTypes.ActorBone:
component = ActorBone.Read(this, nodeBlock);
break;
case BlockTypes.ActorRootBone:
component = ActorRootBone.Read(this, nodeBlock);
break;
case BlockTypes.ActorImage:
m_ImageNodeCount++;
component = ActorImage.Read(this, nodeBlock, makeImageNode());
if ((component as ActorImage).TextureIndex > m_MaxTextureIndex)
{
m_MaxTextureIndex = (component as ActorImage).TextureIndex;
}
break;
case BlockTypes.ActorIKTarget:
component = ActorIKTarget.Read(this, nodeBlock);
break;
case BlockTypes.ActorEvent:
component = ActorEvent.Read(this, nodeBlock);
break;
case BlockTypes.CustomIntProperty:
component = CustomIntProperty.Read(this, nodeBlock);
break;
case BlockTypes.CustomFloatProperty:
component = CustomFloatProperty.Read(this, nodeBlock);
break;
case BlockTypes.CustomStringProperty:
component = CustomStringProperty.Read(this, nodeBlock);
break;
case BlockTypes.CustomBooleanProperty:
component = CustomBooleanProperty.Read(this, nodeBlock);
break;
case BlockTypes.ActorColliderRectangle:
component = ActorColliderRectangle.Read(this, nodeBlock);
break;
case BlockTypes.ActorColliderTriangle:
component = ActorColliderTriangle.Read(this, nodeBlock);
break;
case BlockTypes.ActorColliderCircle:
component = ActorColliderCircle.Read(this, nodeBlock);
break;
case BlockTypes.ActorColliderPolygon:
component = ActorColliderPolygon.Read(this, nodeBlock);
break;
case BlockTypes.ActorColliderLine:
component = ActorColliderLine.Read(this, nodeBlock);
break;
case BlockTypes.ActorNodeSolo:
component = ActorNodeSolo.Read(this, nodeBlock);
break;
case BlockTypes.ActorJellyBone:
component = ActorJellyBone.Read(this, nodeBlock);
break;
case BlockTypes.JellyComponent:
component = JellyComponent.Read(this, nodeBlock);
break;
case BlockTypes.ActorIKConstraint:
component = ActorIKConstraint.Read(this, nodeBlock);
break;
case BlockTypes.ActorDistanceConstraint:
component = ActorDistanceConstraint.Read(this, nodeBlock);
break;
case BlockTypes.ActorTranslationConstraint:
component = ActorTranslationConstraint.Read(this, nodeBlock);
break;
case BlockTypes.ActorScaleConstraint:
component = ActorScaleConstraint.Read(this, nodeBlock);
break;
case BlockTypes.ActorRotationConstraint:
component = ActorRotationConstraint.Read(this, nodeBlock);
break;
case BlockTypes.ActorTransformConstraint:
component = ActorTransformConstraint.Read(this, nodeBlock);
break;
}
}
if (component is ActorNode)
{
m_NodeCount++;
}
m_Components[componentIndex] = component;
if (component != null)
{
component.Idx = (ushort)(componentIndex);
}
componentIndex++;
}
m_ImageNodes = new ActorImage[m_ImageNodeCount];
m_Nodes = new ActorNode[m_NodeCount];
m_Nodes[0] = m_Root;
// Resolve nodes.
int imgIdx = 0;
int anIdx = 0;
ActorComponent[] components = m_Components;
for (int i = 1; i <= componentCount; i++)
{
ActorComponent c = components[i];
// Nodes can be null if we read from a file version that contained nodes that we don't interpret in this runtime.
if (c != null)
{
c.ResolveComponentIndices(components);
}
ActorImage ain = c as ActorImage;
if (ain != null)
{
m_ImageNodes[imgIdx++] = ain;
}
ActorNode an = c as ActorNode;
if (an != null)
{
m_Nodes[anIdx++] = an;
}
}
for (int i = 1; i <= componentCount; i++)
{
ActorComponent c = components[i];
if (c != null)
{
c.CompleteResolve();
}
}
SortDependencies();
}
public override void Update(byte dirt)
{
ActorBone bone = m_Parent as ActorBone;
ActorBone parentBone = bone.Parent as ActorBone;
JellyComponent parentBoneJelly = parentBone == null ? null : parentBone.m_Jelly;
Mat2D inverseWorld = new Mat2D();
if (!Mat2D.Invert(inverseWorld, bone.WorldTransform))
{
return;
}
if (m_InTarget != null)
{
Vec2D translation = m_InTarget.GetWorldTranslation(new Vec2D());
Vec2D.TransformMat2D(m_InPoint, translation, inverseWorld);
Vec2D.Normalize(m_InDirection, m_InPoint);
}
else if (parentBone != null)
{
if (parentBone.FirstBone == bone && parentBoneJelly != null && parentBoneJelly.m_OutTarget != null)
{
Vec2D translation = parentBoneJelly.m_OutTarget.GetWorldTranslation(new Vec2D());
Vec2D localParentOut = Vec2D.TransformMat2D(new Vec2D(), translation, inverseWorld);
Vec2D.Normalize(localParentOut, localParentOut);
Vec2D.Negate(m_InDirection, localParentOut);
}
else
{
Vec2D d1 = new Vec2D(1.0f, 0.0f);
Vec2D d2 = new Vec2D(1.0f, 0.0f);
Vec2D.TransformMat2(d1, d1, parentBone.WorldTransform);
Vec2D.TransformMat2(d2, d2, bone.WorldTransform);
Vec2D sum = Vec2D.Add(new Vec2D(), d1, d2);
Vec2D.TransformMat2(m_InDirection, sum, inverseWorld);
Vec2D.Normalize(m_InDirection, m_InDirection);
}
m_InPoint[0] = m_InDirection[0] * m_EaseIn * bone.Length * CurveConstant;
m_InPoint[1] = m_InDirection[1] * m_EaseIn * bone.Length * CurveConstant;
}
else
{
m_InDirection[0] = 1.0f;
m_InDirection[1] = 0.0f;
m_InPoint[0] = m_InDirection[0] * m_EaseIn * bone.Length * CurveConstant;
}
if (m_OutTarget != null)
{
Vec2D translation = m_OutTarget.GetWorldTranslation(new Vec2D());
Vec2D.TransformMat2D(m_OutPoint, translation, inverseWorld);
Vec2D tip = new Vec2D(bone.Length, 0.0f);
Vec2D.Subtract(m_OutDirection, m_OutPoint, tip);
Vec2D.Normalize(m_OutDirection, m_OutDirection);
}
else if (bone.FirstBone != null)
{
ActorBone firstBone = bone.FirstBone;
JellyComponent firstBoneJelly = firstBone.m_Jelly;
if (firstBoneJelly != null && firstBoneJelly.m_InTarget != null)
{
Vec2D translation = firstBoneJelly.m_InTarget.GetWorldTranslation(new Vec2D());
Vec2D worldChildInDir = Vec2D.Subtract(new Vec2D(), firstBone.GetWorldTranslation(new Vec2D()), translation);
Vec2D.TransformMat2(m_OutDirection, worldChildInDir, inverseWorld);
}
else
{
Vec2D d1 = new Vec2D(1.0f, 0.0f);
Vec2D d2 = new Vec2D(1.0f, 0.0f);
Vec2D.TransformMat2(d1, d1, firstBone.WorldTransform);
Vec2D.TransformMat2(d2, d2, bone.WorldTransform);
Vec2D sum = Vec2D.Add(new Vec2D(), d1, d2);
Vec2D.Negate(sum, sum);
Vec2D.TransformMat2(m_OutDirection, sum, inverseWorld);
Vec2D.Normalize(m_OutDirection, m_OutDirection);
}
Vec2D.Normalize(m_OutDirection, m_OutDirection);
Vec2D scaledOut = Vec2D.Scale(new Vec2D(), m_OutDirection, m_EaseOut * bone.Length * CurveConstant);
m_OutPoint[0] = bone.Length;
m_OutPoint[1] = 0.0f;
Vec2D.Add(m_OutPoint, m_OutPoint, scaledOut);
}
else
{
m_OutDirection[0] = -1.0f;
m_OutDirection[1] = 0.0f;
Vec2D scaledOut = Vec2D.Scale(new Vec2D(), m_OutDirection, m_EaseOut * bone.Length * CurveConstant);
m_OutPoint[0] = bone.Length;
m_OutPoint[1] = 0.0f;
Vec2D.Add(m_OutPoint, m_OutPoint, scaledOut);
}
UpdateJellies();
}
