private bool Visit(ActorComponent n) { if (m_Perm.Contains(n)) { return(true); } if (m_Temp.Contains(n)) { Console.WriteLine("Dependency cycle!"); return(false); } m_Temp.Add(n); IList <ActorComponent> dependents = n.m_Dependents; if (dependents != null) { foreach (ActorComponent d in dependents) { if (!Visit(d)) { return(false); } } } m_Perm.Add(n); m_Order.Insert(0, n); return(true); }
public void Copy(ActorComponent component, Actor resetActor) { m_Name = component.m_Name; m_Actor = resetActor; m_ParentIdx = component.m_ParentIdx; m_Idx = component.m_Idx; }
public virtual void Advance(float seconds) { if ((m_Flags & Flags.IsDirty) != 0) { const int MaxSteps = 100; int step = 0; int count = m_DependencyOrder.Count; while ((m_Flags & Flags.IsDirty) != 0 && step < MaxSteps) { m_Flags &= ~Flags.IsDirty; // Track dirt depth here so that if something else marks dirty, we restart. for (int i = 0; i < count; i++) { ActorComponent component = m_DependencyOrder[i]; m_DirtDepth = (uint)i; byte d = component.m_DirtMask; if (d == 0) { continue; } component.m_DirtMask = 0; component.Update(d); if (m_DirtDepth < i) { break; } } step++; } } if ((m_Flags & Flags.IsImageDrawOrderDirty) != 0) { m_Flags &= ~Flags.IsImageDrawOrderDirty; if (m_ImageNodes != null) { Array.Sort <ActorImage>(m_ImageNodes, sm_ImageDrawOrderComparer); // Mark draw index. for (int i = 0; i < m_ImageNodes.Length; i++) { m_ImageNodes[i].DrawIndex = i; } } } if ((m_Flags & Flags.IsVertexDeformDirty) != 0) { m_Flags &= ~Flags.IsVertexDeformDirty; for (int i = 0; i < m_ImageNodeCount; i++) { ActorImage imageNode = m_ImageNodes[i]; if (imageNode != null && imageNode.IsVertexDeformDirty) { imageNode.IsVertexDeformDirty = false; UpdateVertexDeform(imageNode); } } } }
public static ActorComponent Read(Actor actor, BinaryReader reader, ActorComponent component = null) { component.m_Actor = actor; component.m_Name = Actor.ReadString(reader); component.m_ParentIdx = reader.ReadUInt16(); return(component); }
public static ActorConstraint Read(Actor actor, BinaryReader reader, ActorConstraint component) { ActorComponent.Read(actor, reader, component); component.m_Strength = reader.ReadSingle(); component.m_IsEnabled = reader.ReadByte() == 1; return(component); }
public override void ResolveComponentIndices(ActorComponent[] components) { ActorComponent component = components[ParentIdx]; if (component != null) { component.AddCustomIntProperty(this); } }
public IList <ActorComponent> Sort(ActorComponent root) { m_Order = new List <ActorComponent>(); if (!Visit(root)) { return(null); } return(m_Order); }
public static CustomFloatProperty Read(Actor actor, BinaryReader reader, CustomFloatProperty property = null) { if (property == null) { property = new CustomFloatProperty(); } ActorComponent.Read(actor, reader, property); property.Value = reader.ReadSingle(); return(property); }
public static CustomBooleanProperty Read(Actor actor, BinaryReader reader, CustomBooleanProperty property = null) { if (property == null) { property = new CustomBooleanProperty(); } ActorComponent.Read(actor, reader, property); property.Value = reader.ReadByte() == 1; return(property); }
public static CustomStringProperty Read(Actor actor, BinaryReader reader, CustomStringProperty property = null) { if (property == null) { property = new CustomStringProperty(); } ActorComponent.Read(actor, reader, property); property.Value = Actor.ReadString(reader); return(property); }
public static ActorComponent Read(Actor actor, BinaryReader reader, ActorEvent component = null) { if (component == null) { component = new ActorEvent(); } ActorComponent.Read(actor, reader, component); return(component); }
public override void ResolveComponentIndices(ActorComponent[] components) { base.ResolveComponentIndices(components); if (m_TargetIdx != 0) { m_Target = components[m_TargetIdx]; if (m_Target != null) { m_Actor.AddDependency(m_Parent, m_Target); } } }
public static ActorJellyBone Read(Actor actor, BinaryReader reader, ActorJellyBone node = null) { if (node == null) { node = new ActorJellyBone(); } // The Jelly Bone has a specialized read that doesn't go down the typical node path, this is because majority of the transform properties // of the Jelly Bone are controlled by the Jelly Controller and are unnecessary for serialization. ActorComponent.Read(actor, reader, node); node.m_Opacity = reader.ReadSingle(); node.m_IsCollapsedVisibility = reader.ReadByte() == 1; return(node); }
public bool AddDependency(ActorComponent a, ActorComponent b) { IList <ActorComponent> dependents = b.m_Dependents; if (dependents == null) { b.m_Dependents = dependents = new List <ActorComponent>(); } if (dependents.Contains(a)) { return(false); } dependents.Add(a); return(true); }
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); }
public static ActorNode Read(Actor actor, BinaryReader reader, ActorNode node = null) { if (node == null) { node = new ActorNode(); } ActorComponent.Read(actor, reader, node); Actor.ReadFloat32Array(reader, node.m_Translation.Values); node.m_Rotation = reader.ReadSingle(); Actor.ReadFloat32Array(reader, node.m_Scale.Values); node.m_Opacity = reader.ReadSingle(); if (actor.Version >= 13) { node.m_IsCollapsedVisibility = reader.ReadByte() == 1; } return(node); }
public bool AddDirt(ActorComponent component, byte value, bool recurse = false) { if ((component.m_DirtMask & value) == value) { // Already marked. return(false); } // Make sure dirt is set before calling anything that can set more dirt. byte dirt = (byte)(component.m_DirtMask | value); component.m_DirtMask = dirt; m_Flags |= Flags.IsDirty; component.OnDirty(dirt); // If the order of this component is less than the current dirt depth, update the dirt depth // so that the update loop can break out early and re-run (something up the tree is dirty). if (component.m_GraphOrder < m_DirtDepth) { m_DirtDepth = component.m_GraphOrder; } if (!recurse) { return(true); } IList <ActorComponent> dependents = component.m_Dependents; if (dependents != null) { foreach (ActorComponent d in dependents) { AddDirt(d, value, recurse); } } return(true); }
public void Copy(Actor actor) { m_Animations = actor.m_Animations; m_Flags = actor.m_Flags; m_MaxTextureIndex = actor.m_MaxTextureIndex; m_ImageNodeCount = actor.m_ImageNodeCount; m_NodeCount = actor.m_NodeCount; if (actor.ComponentCount != 0) { m_Components = new ActorComponent[actor.ComponentCount]; } if (m_NodeCount != 0) // This will always be at least 1. { m_Nodes = new ActorNode[m_NodeCount]; } if (m_ImageNodeCount != 0) { m_ImageNodes = new ActorImage[m_ImageNodeCount]; } if (actor.ComponentCount != 0) { int idx = 0; int imgIdx = 0; int ndIdx = 0; foreach (ActorComponent component in actor.Components) { if (component == null) { m_Components[idx++] = null; continue; } ActorComponent instanceComponent = component.MakeInstance(this); m_Components[idx++] = instanceComponent; ActorNode nodeInstance = instanceComponent as ActorNode; if (nodeInstance != null) { m_Nodes[ndIdx++] = nodeInstance; } ActorImage imageInstance = instanceComponent as ActorImage; if (imageInstance != null) { m_ImageNodes[imgIdx++] = imageInstance; } } } m_Root = m_Components[0] as ActorNode; foreach (ActorComponent component in m_Components) { if (m_Root == component || component == null) { continue; } component.ResolveComponentIndices(m_Components); } foreach (ActorComponent component in m_Components) { if (m_Root == component || component == null) { continue; } component.CompleteResolve(); } SortDependencies(); }
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(); }