private ErrorCode LoadAnimations(HelixInternalScene scene)
{
var dict = new Dictionary <string, HxScene.SceneNode>(SceneNodes.Count);
foreach (var node in SceneNodes)
{
if (node is HxScene.GroupNode && !dict.ContainsKey(node.Name))
{
dict.Add(node.Name, node);
}
}
foreach (var node in SceneNodes.Where(x => x is Animations.IBoneMatricesNode)
.Select(x => x as Animations.IBoneMatricesNode))
{
if (node.Bones != null)
{
for (var i = 0; i < node.Bones.Length; ++i)
{
if (dict.TryGetValue(node.Bones[i].Name, out var s))
{
ref var b = ref node.Bones[i];
b.ParentNode = s.Parent;
b.Node = s;
s.IsAnimationNode = true; // Make sure to set this to true
}
}
}
}
private ErrorCode LoadAnimations(HelixInternalScene scene)
{
var dict = new Dictionary <string, HxScene.SceneNode>(SceneNodes.Count);
foreach (var node in SceneNodes)
{
if (node is HxScene.GroupNode && !dict.ContainsKey(node.Name))
{
dict.Add(node.Name, node);
}
}
var nodeIdxDict = new Dictionary <string, int>();
foreach (var node in SceneNodes.Where(x => x is Animations.IBoneMatricesNode)
.Select(x => x as Animations.IBoneMatricesNode))
{
if (node.Bones != null)
{
nodeIdxDict.Clear();
for (var i = 0; i < node.Bones.Length; ++i)
{
nodeIdxDict.Add(node.Bones[i].Name, i);
}
for (var i = 0; i < node.Bones.Length; ++i)
{
if (dict.TryGetValue(node.Bones[i].Name, out var s))
{
ref var b = ref node.Bones[i];
b.ParentNode = s.Parent;
b.Node = s;
b.BoneLocalTransform = s.ModelMatrix;
if (s.Parent != null && nodeIdxDict.TryGetValue(s.Parent.Name, out var idx))
{
b.ParentIndex = idx;
}
s.IsAnimationNode = true; // Make sure to set this to true
}
}
if (Configuration.CreateSkeletonForBoneSkinningMesh &&
node is HxScene.BoneSkinMeshNode sk &&
sk.Parent is HxScene.GroupNodeBase group)
{
var skeleton = sk.CreateSkeletonNode(Configuration.SkeletonMaterial,
Configuration.SkeletonEffects, Configuration.SkeletonSizeScale);
skeleton.Name = "HxSK_" + sk.Name;
group.AddChildNode(skeleton);
}
//Setup bone matrices initially if it's morphable (unable to render w/o bones)
if (node is HxScene.BoneSkinMeshNode sn &&
sn.MorphTargetWeights.Length > 0 &&
sn.BoneMatrices?.Length == 0)
{
sn.UpdateBoneMatrices();
}
}
}
/// <summary>
/// Clears this instance.
/// </summary>
protected virtual void Clear()
{
textureDict.Clear();
SceneNodes.Clear();
Animations.Clear();
MeshIndexForNoName = 0;
MaterialIndexForNoName = 0;
}
private void InitializeDefaults()
{
SceneManagerAssetPath = AssetDatabase.GetAssetPath(SerializedManager.targetObject);
bool wasCreated = false;
AssetFilter assetFilter = AssetDatabaseExtensions.
FindOrCreateSubScriptableObject <AssetFilter>(SceneManagerAssetPath, "SceneFilter", out wasCreated);
if (wasCreated)
{
assetFilter.IncludeIfNoMatch = true;
}
SerializedSceneFilter = new SerializedObject(assetFilter);
SceneHunter sceneHunter = AssetDatabaseExtensions.
GetFirstSubAssetOf <SceneHunter>(SceneManagerAssetPath);
if (sceneHunter == null)
{
sceneHunter = AssetDatabaseExtensions.
CreateSubScriptableObject <UnitySceneHunter>(SceneManagerAssetPath, "SceneHunter");
}
ScenePopulator = new SerializedObject(sceneHunter);
SceneNodes = AssetDatabaseExtensions.
FindOrCreateSubScriptableObject <SceneNodeCollection>(SceneManagerAssetPath, "SceneNodes", out wasCreated);
if (wasCreated)
{
SceneNodes.SceneManager = TargetManager;
}
SceneNodes.PopulateSceneInfos();
SceneNodesObject = new SerializedObject(SceneNodes);
SceneNodesProp = SceneNodesObject.FindProperty("sceneNodes");
if (AssetDatabaseExtensions.GetSubAssetsOfType <SceneVariableContainer>(TargetManager).Count() == 0)
{
TargetManager.SceneVariables.name = "ManagerVariables";
AssetDatabase.AddObjectToAsset(TargetManager.SceneVariables, TargetManager);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(TargetManager));
}
SerializedManager.ApplyModifiedProperties();
ScenesProp = SerializedManager.FindProperty("scenes");
EntrySceneIdProp = SerializedManager.FindProperty("entrySceneId");
AnyScenesProp = SerializedManager.FindProperty("anyScene");
UseOnPlayProp = SerializedManager.FindProperty("useOnPlay");
GoToOnPlay = SerializedManager.FindProperty("goToOnPlay");
SerializedVariables = new SerializedSceneVariableCollection(TargetManager.SceneVariables);
}
/// <summary>
/// Processes the scene nodes.
/// </summary>
/// <param name="root">The root.</param>
/// <returns></returns>
protected virtual ErrorCode ProcessSceneNodes(HxScene.SceneNode root)
{
if (root == null)
{
return(ErrorCode.Failed);
}
SceneNodes.Add(root);
SceneNodes.AddRange(root.Items.PreorderDFT(n => { return(true); }));
return(ErrorCode.Succeed);
}
/// <summary>
/// Initializes a new instance of the <see cref="BackupRecord"/> class.
/// </summary>
/// <param name="backupType">Type of the backup.</param>
/// <param name="world">The world.</param>
/// <param name="citizen">The citizen.</param>
/// <param name="label">The label.</param>
/// <param name="description">The description.</param>
/// <param name="sceneNodes">The scene nodes.</param>
public BackupRecord(BackupType backupType, string world, int citizen, string label, string description, SceneNodes sceneNodes)
{
_world = world;
_id = Guid.NewGuid();
_citizen = citizen;
_label = label;
_description = description;
_date = DateTime.Now;
SceneNodes = sceneNodes;
_backupType = backupType;
}
public void Set(SceneNode referenceNode, IList <SceneNode> nodes, RenderContext context)
{
Reset();
ReferenceNode = referenceNode;
int numberOfNodes = nodes.Count;
for (int i = 0; i < numberOfNodes; i++)
{
var node = nodes[i];
if ((WboitFlags)node.UserFlags == WboitFlags.Transparent)
{
TransparentNodes.Add(node);
}
else
{
SceneNodes.Add(node);
}
}
}
public void Reset()
{
ReferenceNode = null;
SceneNodes.Clear();
TransparentNodes.Clear();
}
