mirror of
https://github.com/aharabada/glitchy-engine-beef.git
synced 2026-09-05 21:01:52 +00:00
Updated AnimationClip, Model Loader now loads Nodes into ECS
- SandboxApp: Started basic skinned mesh render system
This commit is contained in:
Simon Lübeß
@@ -4,6 +4,7 @@ using cgltf;
|
||||
using GlitchyEngine.Math;
|
||||
using GlitchyEngine.Renderer;
|
||||
using GlitchyEngine.Renderer.Animation;
|
||||
using GlitchyEngine.World;
|
||||
|
||||
namespace GlitchyEngine.Content
|
||||
{
|
||||
@@ -11,10 +12,11 @@ namespace GlitchyEngine.Content
|
||||
{
|
||||
static readonly Matrix RightToLeftHand = .Scaling(1, 1, -1);
|
||||
|
||||
public static void LoadModel(String filename, GraphicsContext context, Effect validationEffect, List<(Matrix Transform, GeometryBinding Model)> output, out Skeleton skeleton, out AnimationClip clip)
|
||||
public static void LoadModel(String filename, GraphicsContext context, Effect validationEffect, Material material, EcsWorld world,
|
||||
List<(Matrix Transform, GeometryBinding Model)> output, out Skeleton skeleton, out List<AnimationClip> clips)
|
||||
{
|
||||
skeleton = null;
|
||||
clip = null;
|
||||
removeMe___Clips = null;
|
||||
|
||||
CGLTF.Options options = .();
|
||||
CGLTF.Data* data;
|
||||
@@ -26,6 +28,14 @@ namespace GlitchyEngine.Content
|
||||
|
||||
Log.EngineLogger.Assert(result == .Success, "Failed to load buffers");
|
||||
|
||||
for(var node in data.Scenes[0].Nodes)
|
||||
{
|
||||
NodesToEntities(data, node, null, world, context, validationEffect, material);
|
||||
}
|
||||
|
||||
clips = removeMe___Clips;
|
||||
|
||||
|
||||
for(var node in data.Nodes)
|
||||
{
|
||||
if(node.Mesh != null)
|
||||
@@ -45,12 +55,117 @@ namespace GlitchyEngine.Content
|
||||
|
||||
if(node.Skin != null)
|
||||
{
|
||||
AnimationClip clip;
|
||||
(skeleton, clip) = ExtractBonestuff(node.Skin, data);
|
||||
clips.Add(clip);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
CGLTF.Free(data);
|
||||
}
|
||||
|
||||
static List<AnimationClip> removeMe___Clips;
|
||||
|
||||
private static void NodesToEntities(CGLTF.Data* data, CGLTF.Node* node, Entity? parentEntity, EcsWorld world, GraphicsContext context, Effect validationEffect, Material material)
|
||||
{
|
||||
Entity entity = world.NewEntity();
|
||||
|
||||
if(parentEntity.HasValue)
|
||||
{
|
||||
var childParent = world.AssignComponent<ParentComponent>(entity);
|
||||
childParent.Entity = parentEntity.Value;
|
||||
}
|
||||
|
||||
var childTransform = world.AssignComponent<TransformComponent>(entity);
|
||||
|
||||
if(node.HasMatrix)
|
||||
{
|
||||
childTransform.LocalTransform = *(Matrix*)&node.Matrix;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(node.HasTranslation)
|
||||
childTransform.Position = *(Vector3*)&node.Translation;
|
||||
else
|
||||
childTransform.Position = .Zero;
|
||||
|
||||
if(node.HasRotation)
|
||||
childTransform.Rotation = *(Quaternion*)&node.Rotation;
|
||||
else
|
||||
childTransform.Rotation = .Identity;
|
||||
|
||||
if(node.HasScale)
|
||||
childTransform.Scale = *(Vector3*)&node.Scale;
|
||||
else
|
||||
childTransform.Scale = .(1, 1, 1);
|
||||
}
|
||||
|
||||
if(parentEntity == null)
|
||||
childTransform.Scale *= .(1, 1, -1);
|
||||
|
||||
Skeleton skeleton = null;
|
||||
|
||||
if(node.Skin != null)
|
||||
{
|
||||
skeleton = ExtractSkeleton(node.Skin);
|
||||
|
||||
removeMe___Clips = new List<AnimationClip>();
|
||||
LoadAnimationClips(data, node.Skin, skeleton, removeMe___Clips);
|
||||
}
|
||||
|
||||
if(node.Mesh != null)
|
||||
{
|
||||
// If we have only one primitive, add it directly to the entity
|
||||
if(node.Mesh.Primitives.Length == 1)
|
||||
{
|
||||
var mesh = world.AssignComponent<MeshComponent>(entity);
|
||||
mesh.Mesh = ModelLoader.PrimitiveToGeoBinding(context, node.Mesh.Primitives[0], validationEffect);
|
||||
|
||||
if(skeleton == null)
|
||||
{
|
||||
var meshRenderer = world.AssignComponent<MeshRendererComponent>(entity);
|
||||
meshRenderer.Material = material;
|
||||
}
|
||||
else
|
||||
{
|
||||
var meshRenderer = world.AssignComponent<SkinnedMeshRendererComponent>(entity);
|
||||
meshRenderer.Material = material;
|
||||
meshRenderer.Skeleton = skeleton;
|
||||
}
|
||||
}
|
||||
// otherwise one child-entity per primitive
|
||||
else
|
||||
{
|
||||
for(var primitive in node.Mesh.Primitives)
|
||||
{
|
||||
Entity meshEntity = world.NewEntity();
|
||||
|
||||
var meshParent = world.AssignComponent<ParentComponent>(meshEntity);
|
||||
meshParent.Entity = entity;
|
||||
|
||||
var mesh = world.AssignComponent<MeshComponent>(meshEntity);
|
||||
mesh.Mesh = ModelLoader.PrimitiveToGeoBinding(context, node.Mesh.Primitives[0], validationEffect);
|
||||
|
||||
if(skeleton == null)
|
||||
{
|
||||
var meshRenderer = world.AssignComponent<MeshRendererComponent>(entity);
|
||||
meshRenderer.Material = material;
|
||||
}
|
||||
else
|
||||
{
|
||||
var meshRenderer = world.AssignComponent<SkinnedMeshRendererComponent>(entity);
|
||||
meshRenderer.Material = material;
|
||||
meshRenderer.Skeleton = skeleton;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* TODO make awesome stuff */
|
||||
CGLTF.Free(data);
|
||||
for(var child in node.Children)
|
||||
{
|
||||
NodesToEntities(data, child, entity, world, context, validationEffect, material);
|
||||
}
|
||||
}
|
||||
|
||||
public static GeometryBinding PrimitiveToGeoBinding(GraphicsContext context, CGLTF.Primitive primitive, Effect validationEffect)
|
||||
@@ -95,6 +210,9 @@ namespace GlitchyEngine.Content
|
||||
}
|
||||
}
|
||||
|
||||
bool hasNormals = false;
|
||||
bool hasTangents = false;
|
||||
|
||||
// vertices
|
||||
{
|
||||
List<VertexElement> elements = scope .(primitive.Attributes.Length);
|
||||
@@ -103,6 +221,19 @@ namespace GlitchyEngine.Content
|
||||
|
||||
for(var attribute in primitive.Attributes)
|
||||
{
|
||||
{
|
||||
StringView attributeName = StringView(attribute.Name);
|
||||
|
||||
if(attributeName.Equals("NORMAL"))
|
||||
{
|
||||
hasNormals = true;
|
||||
}
|
||||
else if(attributeName.Equals("TANGENT"))
|
||||
{
|
||||
hasTangents = true;
|
||||
}
|
||||
}
|
||||
|
||||
// Get Input Element format
|
||||
Format format = FormatFromVectorComponent(attribute.Data.Type, attribute.Data.ComponentType);
|
||||
Log.EngineLogger.AssertDebug(format != .Unknown, "Vertex element format must not be \"Unknown.\"");
|
||||
@@ -114,7 +245,7 @@ namespace GlitchyEngine.Content
|
||||
// Get vertex buffer
|
||||
{
|
||||
CGLTF.BufferView* bufferView = attribute.Data.BufferView;
|
||||
|
||||
|
||||
// if buffer doesn't exist -> create
|
||||
if(!buffers.TryGetValue(bufferView, out vertexBuffer))
|
||||
{
|
||||
@@ -147,6 +278,7 @@ namespace GlitchyEngine.Content
|
||||
|
||||
StringView strView = .(attribute.Name);
|
||||
|
||||
// Remove number from end of name
|
||||
while((*(strView.EndPtr - 1)).IsDigit)
|
||||
{
|
||||
strView.Length--;
|
||||
@@ -156,36 +288,254 @@ namespace GlitchyEngine.Content
|
||||
elements.Add(element);
|
||||
}
|
||||
|
||||
// Generate normals if missing
|
||||
if(!hasNormals)
|
||||
{
|
||||
CGLTF.Accessor* positions = null;
|
||||
|
||||
// Find position accessor
|
||||
for(var attribute in primitive.Attributes)
|
||||
{
|
||||
if(StringView(attribute.Name).Equals("POSITION"))
|
||||
{
|
||||
positions = attribute.Data;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Log.EngineLogger.AssertDebug(positions != null, "The model appears to have no position data?!");
|
||||
|
||||
Vector3[] normals = new Vector3[positions.Count];
|
||||
|
||||
if(primitive.Indices != null)
|
||||
GenerateNormals(primitive.Indices, positions, normals);
|
||||
else
|
||||
GenerateNormals(positions, normals);
|
||||
|
||||
VertexBuffer vertexBuffer = new VertexBuffer(context, (uint32)sizeof(Vector3), (uint32)normals.Count, .Immutable);
|
||||
vertexBuffer.SetData<Vector3>(normals);
|
||||
|
||||
bindings.Add(vertexBuffer.Binding);
|
||||
|
||||
uint32 bindingSlot = (.)bindings.Count - 1;
|
||||
|
||||
binding.SetVertexBufferSlot(vertexBuffer.Binding, (.)bindingSlot);
|
||||
VertexElement element = .(.R32G32B32_Float, "NORMAL", false, 0, bindingSlot);
|
||||
elements.Add(element);
|
||||
}
|
||||
|
||||
// TODO: validate vertex layout somewhere else
|
||||
|
||||
VertexElement[] vertexElements = new VertexElement[elements.Count];
|
||||
for(int i < elements.Count)
|
||||
{
|
||||
vertexElements[i] = elements[i];
|
||||
}
|
||||
|
||||
// TODO: validate vertex layout somewhere else
|
||||
|
||||
VertexLayout layout = new VertexLayout(context, vertexElements, true, validationEffect.VertexShader);
|
||||
binding.SetVertexLayout(layout..ReleaseRefNoDelete());
|
||||
}
|
||||
|
||||
// TODO: calculate normals if missing
|
||||
// TODO: calculate tangents if missing (MikkTSpace algorithm)
|
||||
// Note: Bitangent = cross(normal, tangent.xyz) * tangent.w
|
||||
|
||||
return binding;
|
||||
}
|
||||
|
||||
/// Generates the normals for one triangle
|
||||
static mixin GenerateTriangleNormals(int index0, int index1, int index2, CGLTF.Accessor* positions, Vector3[] normals)
|
||||
{
|
||||
Vector3 position0 = GetEntry<Vector3>(positions, (.)index0);
|
||||
Vector3 position1 = GetEntry<Vector3>(positions, (.)index1);
|
||||
Vector3 position2 = GetEntry<Vector3>(positions, (.)index2);
|
||||
|
||||
ref Vector3 normal0 = ref normals[(.)index0];
|
||||
ref Vector3 normal1 = ref normals[(.)index1];
|
||||
ref Vector3 normal2 = ref normals[(.)index2];
|
||||
|
||||
Vector3 e0 = position1 - position0;
|
||||
Vector3 e1 = position2 - position0;
|
||||
|
||||
Vector3 normal = Vector3.Cross(e0, e1);
|
||||
|
||||
normal0 += normal;
|
||||
normal1 += normal;
|
||||
normal2 += normal;
|
||||
}
|
||||
|
||||
[Inline]
|
||||
static void NormalizeNormals(Vector3[] normals)
|
||||
{
|
||||
for(int i < normals.Count)
|
||||
{
|
||||
normals[i].Normalize();
|
||||
}
|
||||
}
|
||||
|
||||
/// Generates normals for the given model using indexed geometry
|
||||
static void GenerateNormals(CGLTF.Accessor* indices, CGLTF.Accessor* positions, Vector3[] normals)
|
||||
{
|
||||
/// Enumerate triangle-wise
|
||||
for(uint t = 0; t < indices.Count; t += 3)
|
||||
{
|
||||
int index0 = (.)CGLTF.AccessorReadIndex(indices, t);
|
||||
int index1 = (.)CGLTF.AccessorReadIndex(indices, t + 1);
|
||||
int index2 = (.)CGLTF.AccessorReadIndex(indices, t + 2);
|
||||
|
||||
GenerateTriangleNormals!(index0, index1, index2, positions, normals);
|
||||
}
|
||||
|
||||
NormalizeNormals(normals);
|
||||
}
|
||||
|
||||
/// Generates normals for the given model using nonindexed geometry
|
||||
static void GenerateNormals(CGLTF.Accessor* positions, Vector3[] normals)
|
||||
{
|
||||
/// Enumerate triangle-wise
|
||||
for(int i = 0; i < (.)positions.Count; i += 3)
|
||||
{
|
||||
GenerateTriangleNormals!(i, i + 1, i + 2, positions, normals);
|
||||
}
|
||||
|
||||
NormalizeNormals(normals);
|
||||
}
|
||||
|
||||
static Skeleton ExtractSkeleton(CGLTF.Skin* skin)
|
||||
{
|
||||
Skeleton skeleton = new Skeleton();
|
||||
skeleton.Joints = new Joint[skin.Joints.Length];
|
||||
|
||||
for(int i < skin.Joints.Length)
|
||||
{
|
||||
ref Joint joint = ref skeleton.Joints[i];
|
||||
|
||||
joint.InverseBindPose = GetEntry<Matrix>(skin.InverseBindMatrices, i);
|
||||
|
||||
joint.Name = new String(skin.Joints[i].Name);
|
||||
|
||||
int parentId = skin.Joints.IndexOf(skin.Joints[i].Parent);
|
||||
|
||||
Log.EngineLogger.AssertDebug(parentId < uint8.MaxValue, scope $"A skeleton must not have more than {uint8.MaxValue - 1} bones.");
|
||||
|
||||
if(parentId == -1)
|
||||
joint.ParentID = uint8.MaxValue;
|
||||
else
|
||||
joint.ParentID = (uint8)parentId;
|
||||
}
|
||||
|
||||
return skeleton;
|
||||
}
|
||||
|
||||
static bool AnimationBelongsToSkeleton(CGLTF.Animation animation, CGLTF.Skin* skin)
|
||||
{
|
||||
for(var channel in animation.Channels)
|
||||
{
|
||||
if(skin.Joints.IndexOf(channel.TargetNode) == -1)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static void LoadAnimationClips(CGLTF.Data* data, CGLTF.Skin* skin, Skeleton skeleton, List<AnimationClip> clips)
|
||||
{
|
||||
for(var animation in data.Animations)
|
||||
{
|
||||
if(!AnimationBelongsToSkeleton(animation, skin))
|
||||
continue;
|
||||
|
||||
AnimationClip clip = new AnimationClip(skeleton);
|
||||
clips.Add(clip);
|
||||
clip.IsLooping = true;
|
||||
|
||||
for(var channel in animation.Channels)
|
||||
{
|
||||
int nodeIndex = skin.Joints.IndexOf(channel.TargetNode);
|
||||
|
||||
Log.EngineLogger.AssertDebug(nodeIndex != -1);
|
||||
|
||||
ref JointAnimation jointAnimation = ref clip.JointAnimations[nodeIndex];
|
||||
|
||||
Log.EngineLogger.AssertDebug(channel.Sampler.Input.Count == channel.Sampler.Output.Count);
|
||||
|
||||
int samples = (int)channel.Sampler.Input.Count;
|
||||
|
||||
Log.EngineLogger.AssertDebug(channel.Sampler.Input.ComponentType == .R_32f);
|
||||
Log.EngineLogger.AssertDebug(channel.Sampler.Input.Type == .Scalar);
|
||||
|
||||
InterpolationMode interpolationMode;
|
||||
|
||||
switch(channel.Sampler.Interpolation)
|
||||
{
|
||||
case .Step:
|
||||
interpolationMode = .Step;
|
||||
case .Linear:
|
||||
interpolationMode = .Linear;
|
||||
case .CubicSpline:
|
||||
interpolationMode = .CubicSpline;
|
||||
}
|
||||
|
||||
switch(channel.TargetPath)
|
||||
{
|
||||
case .Translation:
|
||||
jointAnimation.TranslationChannel = new .(samples, interpolationMode);
|
||||
|
||||
Log.EngineLogger.AssertDebug(channel.Sampler.Output.ComponentType == .R_32f);
|
||||
Log.EngineLogger.AssertDebug(channel.Sampler.Output.Type == .Vec3);
|
||||
|
||||
for(int i < samples)
|
||||
{
|
||||
float timeStamp = GetEntry<float>(channel.Sampler.Input, i);
|
||||
Vector3 sample = GetEntry<Vector3>(channel.Sampler.Output, i);
|
||||
|
||||
jointAnimation.TranslationChannel.TimeStamps[i] = timeStamp;
|
||||
jointAnimation.TranslationChannel.Values[i] = sample;
|
||||
}
|
||||
case .Rotation:
|
||||
jointAnimation.RotationChannel = new .(samples, interpolationMode);
|
||||
|
||||
Log.EngineLogger.AssertDebug(channel.Sampler.Output.ComponentType == .R_32f);
|
||||
Log.EngineLogger.AssertDebug(channel.Sampler.Output.Type == .Vec4);
|
||||
|
||||
for(int i < samples)
|
||||
{
|
||||
float timeStamp = GetEntry<float>(channel.Sampler.Input, i);
|
||||
Quaternion sample = GetEntry<Quaternion>(channel.Sampler.Output, i);
|
||||
|
||||
jointAnimation.RotationChannel.TimeStamps[i] = timeStamp;
|
||||
jointAnimation.RotationChannel.Values[i] = sample;
|
||||
}
|
||||
case .Scale:
|
||||
jointAnimation.ScaleChannel = new .(samples, interpolationMode);
|
||||
|
||||
Log.EngineLogger.AssertDebug(channel.Sampler.Output.ComponentType == .R_32f);
|
||||
Log.EngineLogger.AssertDebug(channel.Sampler.Output.Type == .Vec3);
|
||||
|
||||
for(int i < samples)
|
||||
{
|
||||
float timeStamp = GetEntry<float>(channel.Sampler.Input, i);
|
||||
Vector3 sample = GetEntry<Vector3>(channel.Sampler.Output, i);
|
||||
|
||||
jointAnimation.ScaleChannel.TimeStamps[i] = timeStamp;
|
||||
jointAnimation.ScaleChannel.Values[i] = sample;
|
||||
}
|
||||
default:
|
||||
Log.EngineLogger.Error($"Unknown channel target path \"{channel.TargetPath}\"");
|
||||
}
|
||||
|
||||
clip.Duration = Math.Max(clip.Duration, jointAnimation.Duration);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static (Skeleton, AnimationClip) ExtractBonestuff(CGLTF.Skin* skin, CGLTF.Data* data)
|
||||
{
|
||||
Skeleton skeleton = new Skeleton();
|
||||
skeleton.Joints = new Joint[skin.Joints.Length];
|
||||
|
||||
AnimationClip testClip = new AnimationClip();
|
||||
testClip.Skeleton = skeleton;
|
||||
testClip.FramesPerSecond = 0;
|
||||
testClip.JointAnimations = new JointAnimation[skeleton.Joints.Count];
|
||||
//testClip.Samples = new AnimationSample[1];
|
||||
//testClip.Samples[0].JointPose = new JointPose[skeleton.Joints.Count];
|
||||
AnimationClip testClip = new AnimationClip(skeleton);
|
||||
testClip.IsLooping = true;
|
||||
|
||||
for(int i < skin.Joints.Length)
|
||||
@@ -323,6 +673,16 @@ namespace GlitchyEngine.Content
|
||||
CGLTF.AccessorReadFloat(accessor, (uint)index, (float*)&result, 4);
|
||||
case typeof(Matrix):
|
||||
CGLTF.AccessorReadFloat(accessor, (uint)index, (float*)&result, 16);
|
||||
case default:
|
||||
uint8* data = (uint8*)accessor.BufferView.Buffer.Data;
|
||||
|
||||
data += accessor.BufferView.Offset;
|
||||
|
||||
data += accessor.Offset;
|
||||
|
||||
data += accessor.Stride * (uint)index;
|
||||
|
||||
result = *(T*)data;
|
||||
}
|
||||
|
||||
return result;
|
||||
|
||||
Reference in New Issue
Block a user