bilbo/d3d10
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

basic skinned animation demo

Browse Source
This commit is contained in:
Zack Buhman 2026-01-03 15:48:39 -06:00
parent 532288906d
commit 2477f849c7
6 changed files with 441 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
gltf.h
View File

@ -1,13 +0,0 @@
union Accessor {
DWORD * dw;
float * f;
D3DXVECTOR3 * v3;
D3DXVECTOR4 * v4;
};
struct Mesh {
int position;
int normal;
int texcoord_0;
int indices;
};

61
gltf.hpp Normal file
View File

@ -0,0 +1,61 @@
struct Mesh {
const D3DXVECTOR3 * position;
const DWORD position_size;
const D3DXVECTOR3 * normal;
const DWORD normal_size;
const D3DXVECTOR2 * texcoord_0;
const DWORD texcoord_0_size;
const D3DXVECTOR4 * weights_0;
const DWORD weights_0_size;
const D3DXVECTOR4 * joints_0;
const DWORD joints_0_size;
const DWORD * indices;
const DWORD indices_size;
};
struct Skin;
struct Node {
const Skin * skin; // skin index (global)
const Mesh * mesh; // mesh index (global)
const D3DXVECTOR3 translation;
const D3DXQUATERNION rotation;
const D3DXVECTOR3 scale;
};
struct Skin {
const D3DXMATRIX * inverse_bind_matrices; // accessor
const Node ** joints;
DWORD joints_length;
};
enum AnimationChannelPath {
ACP__WEIGHTS,
ACP__ROTATION,
ACP__TRANSLATION,
ACP__SCALE,
};
struct AnimationSampler {
const float * input; // accessor index, containing keyframe timestamps
const void * output; // accessor index, containing keyframe values (type depends on channel target path)
const int length;
};
struct AnimationChannel {
const AnimationSampler * sampler; // sampler index, this animation
struct {
const Node * node; // node index
const AnimationChannelPath path; // property to animate
} target;
};
//struct Animation {
// const AnimationChannel * channels;
// const AnimationSampler * samplers;
//};

200
main.cpp
View File

@ -4,6 +4,9 @@
#include <d3dx10.h>
#include <strsafe.h>
#include "gltf.hpp"
#include "skin.hpp"
HINSTANCE g_hInstance = NULL;
HWND g_hWnd = NULL;
ID3D10Device * g_pd3dDevice = NULL;
@ -15,7 +18,7 @@ ID3D10Effect * g_pEffect = NULL;
ID3D10EffectTechnique * g_pTechniqueRender = NULL;
ID3D10EffectTechnique * g_pTechniqueRenderLight = NULL;
ID3D10InputLayout * g_pVertexLayout = NULL;
ID3D10Buffer * g_pVertexBuffer = NULL;
//ID3D10Buffer * g_pVertexBuffer = NULL;
ID3D10Buffer * g_pIndexBuffer = NULL;
ID3D10Texture2D * g_pTexture = NULL;
@ -24,6 +27,7 @@ ID3D10ShaderResourceView * g_pTextureShaderResourceView = NULL;
ID3D10EffectMatrixVariable * g_pWorldVariable = NULL;
ID3D10EffectMatrixVariable * g_pViewVariable = NULL;
ID3D10EffectMatrixVariable * g_pProjectionVariable = NULL;
ID3D10EffectMatrixVariable * g_pJointVariable = NULL;
ID3D10EffectVectorVariable * g_pLightDirVariable = NULL;
ID3D10EffectVectorVariable * g_pLightColorVariable = NULL;
ID3D10EffectVectorVariable * g_pOutputColorVariable = NULL;
@ -39,15 +43,6 @@ HRESULT InitDirect3DDevice();
void Render();
BOOL Resize();
struct SimpleVertex {
D3DXVECTOR3 Pos;
D3DXVECTOR3 Normal;
D3DXVECTOR2 Texture;
};
#include "gltf.h"
#include "minimal.h"
struct WindowSize {
UINT Width;
UINT Height;
@ -276,6 +271,31 @@ HRESULT InitDirect3DDevice()
return hr;
}
//////////////////////////////////////////////////////////////////////
// rasterizer state
//////////////////////////////////////////////////////////////////////
D3D10_RASTERIZER_DESC RSDesc;
RSDesc.FillMode = D3D10_FILL_SOLID;
//RSDesc.CullMode = D3D10_CULL_BACK;
RSDesc.CullMode = D3D10_CULL_NONE;
RSDesc.FrontCounterClockwise = FALSE;
RSDesc.DepthBias = 0;
RSDesc.SlopeScaledDepthBias = 0.0f;
RSDesc.DepthBiasClamp= 0;
RSDesc.DepthClipEnable = TRUE;
RSDesc.ScissorEnable = FALSE;
RSDesc.AntialiasedLineEnable = FALSE;
RSDesc.MultisampleEnable = FALSE;
ID3D10RasterizerState* pRState = NULL;
hr = g_pd3dDevice->CreateRasterizerState(&RSDesc, &pRState);
if (FAILED(hr))
return hr;
g_pd3dDevice->RSSetState(pRState);
//
InitDirect3DViews();
// texture
@ -342,6 +362,7 @@ HRESULT InitDirect3DDevice()
g_pWorldVariable = g_pEffect->GetVariableByName("World")->AsMatrix();
g_pViewVariable = g_pEffect->GetVariableByName("View")->AsMatrix();
g_pProjectionVariable = g_pEffect->GetVariableByName("Projection")->AsMatrix();
g_pJointVariable = g_pEffect->GetVariableByName("mJoint")->AsMatrix();
g_pLightDirVariable = g_pEffect->GetVariableByName("vLightDir")->AsVector();
g_pLightColorVariable = g_pEffect->GetVariableByName("vLightColor")->AsVector();
g_pOutputColorVariable = g_pEffect->GetVariableByName("vOutputColor")->AsVector();
@ -350,6 +371,8 @@ HRESULT InitDirect3DDevice()
// input layout
D3D10_INPUT_ELEMENT_DESC layout[] = {
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0 , D3D10_INPUT_PER_VERTEX_DATA, 0},
{"TEXCOORD", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 0, D3D10_INPUT_PER_VERTEX_DATA, 0},
{"TEXCOORD", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 2, 0, D3D10_INPUT_PER_VERTEX_DATA, 0},
//{"NORMAL" , 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0},
//{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D10_INPUT_PER_VERTEX_DATA, 0},
};
@ -374,39 +397,70 @@ HRESULT InitDirect3DDevice()
D3D10_SUBRESOURCE_DATA initData;
//////////////////////////////////////////////////////////////////////
// vertex buffer
// vertex buffers
//////////////////////////////////////////////////////////////////////
#define VERTEX_ACCESSOR accessor_1
#define MESH mesh_0
ID3D10Buffer * pVertexBuffers[3];
// position
bd.Usage = D3D10_USAGE_DEFAULT;
bd.ByteWidth = (sizeof (VERTEX_ACCESSOR));
//bd.ByteWidth = (sizeof (SimpleVertex)) * vertices_length;
bd.ByteWidth = MESH.position_size;
bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
initData.pSysMem = VERTEX_ACCESSOR;
//initData.pSysMem = vertices;
hr = g_pd3dDevice->CreateBuffer(&bd, &initData, &g_pVertexBuffer);
initData.pSysMem = MESH.position;
hr = g_pd3dDevice->CreateBuffer(&bd, &initData, &pVertexBuffers[0]);
if (FAILED(hr)) {
print("CreateBuffer\n");
return hr;
}
UINT stride = (sizeof (VERTEX_ACCESSOR[0]));
UINT offset = 0;
g_pd3dDevice->IASetVertexBuffers(0, 1, &g_pVertexBuffer, &stride, &offset);
// weights
bd.Usage = D3D10_USAGE_DEFAULT;
bd.ByteWidth = MESH.weights_0_size;
bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
initData.pSysMem = MESH.weights_0;
hr = g_pd3dDevice->CreateBuffer(&bd, &initData, &pVertexBuffers[1]);
if (FAILED(hr)) {
print("CreateBuffer\n");
return hr;
}
// joints
bd.Usage = D3D10_USAGE_DEFAULT;
bd.ByteWidth = MESH.joints_0_size;
bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
initData.pSysMem = MESH.joints_0;
hr = g_pd3dDevice->CreateBuffer(&bd, &initData, &pVertexBuffers[2]);
if (FAILED(hr)) {
print("CreateBuffer\n");
return hr;
}
UINT stride[] = {
(sizeof (MESH.position[0])),
(sizeof (MESH.weights_0[0])),
(sizeof (MESH.joints_0[0])),
};
UINT offset[] = { 0, 0, 0 };
g_pd3dDevice->IASetVertexBuffers(0, 3, pVertexBuffers, stride, offset);
//////////////////////////////////////////////////////////////////////
// index buffer
//////////////////////////////////////////////////////////////////////
#define INDEX_ACCESSOR accessor_0
bd.Usage = D3D10_USAGE_DEFAULT;
bd.ByteWidth = (sizeof (INDEX_ACCESSOR));
bd.ByteWidth = MESH.indices_size;
//bd.ByteWidth = (sizeof (DWORD)) * indices_length;
bd.BindFlags = D3D10_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
initData.pSysMem = INDEX_ACCESSOR;
initData.pSysMem = MESH.indices;
//initData.pSysMem = indices;
hr = g_pd3dDevice->CreateBuffer(&bd, &initData, &g_pIndexBuffer);
if (FAILED(hr))
@ -416,11 +470,13 @@ HRESULT InitDirect3DDevice()
g_pd3dDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
//////////////////////////////////////////////////////////////////////
// transform matrices
//////////////////////////////////////////////////////////////////////
D3DXMatrixIdentity(&g_World1);
D3DXMatrixIdentity(&g_World2);
D3DXVECTOR3 Eye(0.0f, 0.0f, -2.0f);
D3DXVECTOR3 Eye(0.0f, 0.0f, -3.0f);
D3DXVECTOR3 At(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 Up(0.0f, 1.0f, 0.0f);
D3DXMatrixLookAtLH(&g_View, &Eye, &At, &Up);
@ -478,6 +534,7 @@ BOOL Resize()
return true;
}
/*
void Animate(float t)
{
const float * frames = accessor_2;
@ -514,19 +571,104 @@ void Animate(float t)
D3DXMatrixRotationQuaternion(&g_World1, &rotation);
}
*/
static inline void MatrixTRS(D3DXMATRIX * transform,
const D3DXVECTOR3 * translation,
const D3DXQUATERNION * rotation,
const D3DXVECTOR3 * scaling)
{
D3DXMATRIX mTranslation;
D3DXMatrixTranslation(&mTranslation, translation->x, translation->y, translation->z);
D3DXMATRIX mRotation;
D3DXMatrixRotationQuaternion(&mRotation, rotation);
D3DXMATRIX mScaling;
D3DXMatrixScaling(&mScaling, scaling->x, scaling->y, scaling->z);
D3DXMatrixMultiply(transform, &mRotation, &mTranslation);
D3DXMatrixMultiply(transform, transform, &mScaling);
}
static inline float fract(float f)
{
return f - floor(f);
}
static inline float loop(float f, float n)
{
return fract(f / n) * n;
}
static inline int FindFrame(const float * frames, int length, float t)
{
for (int i = 0; i < length - 1; i++) {
if (frames[i] <= t && frames[i+1] >= t) {
return i;
}
}
return 0;
}
static inline float Lerp(const float * frames, float t, int frame_ix)
{
return (t - frames[frame_ix]) / (frames[frame_ix + 1] - frames[frame_ix]);
}
D3DXMATRIX mJoints[2];
void Animate(float t)
{
t = loop(t, 5.5);
// animation_0__sampler_0
const AnimationSampler * sampler = &animation_0__sampler_0;
const float * input = sampler->input;
const D3DXQUATERNION * output = (D3DXQUATERNION *)sampler->output;
int frame_ix = FindFrame(sampler->input, sampler->length, t);
float lerp = Lerp(sampler->input, t, frame_ix);
D3DXQUATERNION rotation;
D3DXQuaternionSlerp(&rotation,
&output[frame_ix],
&output[frame_ix+1],
lerp);
// joint 1
const Skin * skin = &skin_0;
const Node * node = skin->joints[1];
// T * R * S
D3DXMATRIX global_transform;
MatrixTRS(&global_transform, &node->translation, &rotation, &node->scale);
D3DXMatrixIdentity(&mJoints[0]);
D3DXMatrixIdentity(&mJoints[1]);
const D3DXMATRIX * inverse_bind_matrix = &skin->inverse_bind_matrices[1];
//D3DXMatrixMultiply(&mJoints[1], &global_transform, inverse_bind_matrix);
//D3DXMatrixIdentity(&mJoints[1]);
//g_World1 = global_transform;
D3DXMatrixMultiply(&mJoints[1], inverse_bind_matrix, &global_transform);
//mJoints[1] = global_transform;
//g_World1 = *inverse_bind_matrix;
}
void Render()
{
static float t = 0.0f;
if (1) {
#ifdef _DEBUG
t += (float)D3DX_PI * 0.0125f * 0.5;
} else {
#else
static DWORD dwTimeStart = 0;
DWORD dwTimeCur = GetTickCount();
if (dwTimeStart == 0)
dwTimeStart = dwTimeCur;
t = (dwTimeCur - dwTimeStart) / 1000.0f;
}
#endif
Animate(t);
@ -563,6 +705,8 @@ void Render()
g_pWorldVariable->SetMatrix((float *)&g_World1);
g_pDiffuseVariable->SetResource(g_pTextureShaderResourceView);
g_pJointVariable->SetMatrixArray((float *)mJoints, 0, 2);
// color
g_pOutputColorVariable->SetFloatVector((float *)&vLightColors[0]);
@ -575,7 +719,7 @@ void Render()
g_pTechniqueRender->GetDesc(&techDesc);
for (UINT p = 0; p < techDesc.Passes; p++) {
g_pTechniqueRender->GetPassByIndex(p)->Apply(0);
g_pd3dDevice->DrawIndexed(3, 0, 0);
g_pd3dDevice->DrawIndexed(accessor_0_length, 0, 0);
}
// render the lights

23
main.fx
View File

@ -2,6 +2,8 @@ matrix World;
matrix View;
matrix Projection;
matrix mJoint[2];
float4 vLightDir[2];
float4 vLightColor[2];
float4 vOutputColor;
@ -16,6 +18,8 @@ SamplerState samLinear {
struct VS_INPUT
{
float4 Pos : POSITION;
float4 Weight : TEXCOORD0;
float4 Joint : TEXCOORD1;
//float3 Normal : NORMAL;
//float2 Tex : TEXCOORD;
};
@ -23,6 +27,8 @@ struct VS_INPUT
struct PS_INPUT
{
float4 Pos : SV_POSITION;
float4 Weight : TEXCOORD0;
float4 Joint : TEXCOORD1;
//float3 Normal : TEXCOORD0;
//float2 Tex : TEXCOORD1;
};
@ -30,10 +36,22 @@ struct PS_INPUT
PS_INPUT VS(VS_INPUT input)
{
PS_INPUT output = (PS_INPUT)0;
output.Pos = mul(input.Pos, World);
matrix mSkin
= input.Weight.x * mJoint[int(input.Joint.x)]
+ input.Weight.y * mJoint[int(input.Joint.y)]
+ input.Weight.z * mJoint[int(input.Joint.z)]
+ input.Weight.w * mJoint[int(input.Joint.w)]
;
output.Pos = mul(input.Pos, mSkin);
output.Pos = mul(output.Pos, World);
output.Pos = mul(output.Pos, View);
output.Pos = mul(output.Pos, Projection);
output.Weight = input.Weight;
output.Joint = input.Joint;
//output.Normal = mul(input.Normal, World);
//output.Tex = input.Tex;
return output;
@ -56,7 +74,8 @@ float4 PS(PS_INPUT input) : SV_Target
float4 PSSolid(PS_INPUT input) : SV_Target
{
return vOutputColor;
//return vOutputColor;
return float4(input.Weight.xy, input.Joint.y, 1);
}
technique10 Render

39
minimal.h
View File

@ -1,39 +0,0 @@
const DWORD accessor_0[] = {
2,
1,
0,
};
const int accessor_0_length = (sizeof (accessor_0)) / (sizeof (accessor_0[0]));
const D3DXVECTOR3 accessor_1[] = {
D3DXVECTOR3( 0.000f, 0.000f, 0.000f),
D3DXVECTOR3( 1.000f, 0.000f, 0.000f),
D3DXVECTOR3( 0.000f, 1.000f, 0.000f),
};
const int accessor_1_length = (sizeof (accessor_1)) / (sizeof (accessor_1[0]));
const float accessor_2[] = {
0.0,
0.25,
0.5,
0.75,
1.0,
};
const int accessor_2_length = (sizeof (accessor_2)) / (sizeof (accessor_2[0]));
const D3DXVECTOR4 accessor_3[] = {
D3DXVECTOR4( 0.000f, 0.000f, 0.000f, 1.000f),
D3DXVECTOR4( 0.000f, 0.000f, 0.707f, 0.707f),
D3DXVECTOR4( 0.000f, 0.000f, 1.000f, 0.000f),
D3DXVECTOR4( 0.000f, 0.000f, 0.707f, -0.707f),
D3DXVECTOR4( 0.000f, 0.000f, 0.000f, 1.000f),
};
const int accessor_3_length = (sizeof (accessor_3)) / (sizeof (accessor_3[0]));
const Mesh mesh_0 = {
1, -1, -1, 0,
};

187
skin.hpp Normal file
View File

@ -0,0 +1,187 @@
const DWORD accessor_0[] = {
0,
1,
3,
0,
3,
2,
2,
3,
5,
2,
5,
4,
4,
5,
7,
4,
7,
6,
6,
7,
9,
6,
9,
8,
};
const int accessor_0_length = (sizeof (accessor_0)) / (sizeof (accessor_0[0]));
const D3DXVECTOR3 accessor_1[] = {
D3DXVECTOR3(-0.5000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR3( 0.5000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR3(-0.5000000f, 0.5000000f, 0.0000000f),
D3DXVECTOR3( 0.5000000f, 0.5000000f, 0.0000000f),
D3DXVECTOR3(-0.5000000f, 1.0000000f, 0.0000000f),
D3DXVECTOR3( 0.5000000f, 1.0000000f, 0.0000000f),
D3DXVECTOR3(-0.5000000f, 1.5000000f, 0.0000000f),
D3DXVECTOR3( 0.5000000f, 1.5000000f, 0.0000000f),
D3DXVECTOR3(-0.5000000f, 2.0000000f, 0.0000000f),
D3DXVECTOR3( 0.5000000f, 2.0000000f, 0.0000000f),
};
const int accessor_1_length = (sizeof (accessor_1)) / (sizeof (accessor_1[0]));
const D3DXVECTOR4 accessor_2[] = {
D3DXVECTOR4( 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.0000000f, 0.0000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.0000000f, 1.0000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.0000000f, 1.0000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.0000000f, 1.0000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.0000000f, 1.0000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.0000000f, 1.0000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.0000000f, 1.0000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.0000000f, 1.0000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.0000000f, 1.0000000f, 0.0000000f, 0.0000000f),
};
const int accessor_2_length = (sizeof (accessor_2)) / (sizeof (accessor_2[0]));
const D3DXVECTOR4 accessor_3[] = {
D3DXVECTOR4( 1.0000000f, 0.0000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 1.0000000f, 0.0000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.7500000f, 0.2500000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.7500000f, 0.2500000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.5000000f, 0.5000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.5000000f, 0.5000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.2500000f, 0.7500000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.2500000f, 0.7500000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.0000000f, 1.0000000f, 0.0000000f, 0.0000000f),
D3DXVECTOR4( 0.0000000f, 1.0000000f, 0.0000000f, 0.0000000f),
};
const int accessor_3_length = (sizeof (accessor_3)) / (sizeof (accessor_3[0]));
const D3DXMATRIX accessor_4[] = {
D3DXMATRIX( 1.0000000f, 0.0000000f, 0.0000000f, 0.0000000f,
0.0000000f, 1.0000000f, 0.0000000f, 0.0000000f,
0.0000000f, 0.0000000f, 1.0000000f, 0.0000000f,
0.0000000f, 0.0000000f, 0.0000000f, 1.0000000f),
D3DXMATRIX( 1.0000000f, 0.0000000f, 0.0000000f, 0.0000000f,
0.0000000f, 1.0000000f, 0.0000000f, 0.0000000f,
0.0000000f, 0.0000000f, 1.0000000f, 0.0000000f,
0.0000000f, -1.0000000f, 0.0000000f, 1.0000000f),
};
const int accessor_4_length = (sizeof (accessor_4)) / (sizeof (accessor_4[0]));
const float accessor_5[] = {
0.0,
0.5,
1.0,
1.5,
2.0,
2.5,
3.0,
3.5,
4.0,
4.5,
5.0,
5.5,
};
const int accessor_5_length = (sizeof (accessor_5)) / (sizeof (accessor_5[0]));
const D3DXVECTOR4 accessor_6[] = {
D3DXVECTOR4( 0.0000000f, 0.0000000f, 0.0000000f, 1.0000000f),
D3DXVECTOR4( 0.0000000f, 0.0000000f, 0.3830000f, 0.9240000f),
D3DXVECTOR4( 0.0000000f, 0.0000000f, 0.7070000f, 0.7070000f),
D3DXVECTOR4( 0.0000000f, 0.0000000f, 0.7070000f, 0.7070000f),
D3DXVECTOR4( 0.0000000f, 0.0000000f, 0.3830000f, 0.9240000f),
D3DXVECTOR4( 0.0000000f, 0.0000000f, 0.0000000f, 1.0000000f),
D3DXVECTOR4( 0.0000000f, 0.0000000f, 0.0000000f, 1.0000000f),
D3DXVECTOR4( 0.0000000f, 0.0000000f, -0.3830000f, 0.9240000f),
D3DXVECTOR4( 0.0000000f, 0.0000000f, -0.7070000f, 0.7070000f),
D3DXVECTOR4( 0.0000000f, 0.0000000f, -0.7070000f, 0.7070000f),
D3DXVECTOR4( 0.0000000f, 0.0000000f, -0.3830000f, 0.9240000f),
D3DXVECTOR4( 0.0000000f, 0.0000000f, 0.0000000f, 1.0000000f),
};
const int accessor_6_length = (sizeof (accessor_6)) / (sizeof (accessor_6[0]));
const Mesh mesh_0 = {
accessor_1, // position
(sizeof (accessor_1)),
NULL, // normal
0,
NULL, // texcoord_0
0,
accessor_3, // weights_0
(sizeof (accessor_3)),
accessor_2, // joints_0
(sizeof (accessor_2)),
accessor_0, // indices
(sizeof (accessor_0)),
};
extern const Skin skin_0;
const Node node_0 = {
&skin_0, // skin
&mesh_0, // mesh
D3DXVECTOR3( 0.0000000f, 0.0000000f, 0.0000000f), // translation
D3DXVECTOR4( 0.0000000f, 0.0000000f, 0.0000000f, 1.0000000f), // rotation
D3DXVECTOR3( 1.0000000f, 1.0000000f, 1.0000000f), // scale
};
const Node node_1 = {
NULL, // skin
NULL, // mesh
D3DXVECTOR3( 0.0000000f, 0.0000000f, 0.0000000f), // translation
D3DXVECTOR4( 0.0000000f, 0.0000000f, 0.0000000f, 1.0000000f), // rotation
D3DXVECTOR3( 1.0000000f, 1.0000000f, 1.0000000f), // scale
};
const Node node_2 = {
NULL, // skin
NULL, // mesh
D3DXVECTOR3( 0.0000000f, 1.0000000f, 0.0000000f), // translation
D3DXVECTOR4( 0.0000000f, 0.0000000f, 0.0000000f, 1.0000000f), // rotation
D3DXVECTOR3( 1.0000000f, 1.0000000f, 1.0000000f), // scale
};
const Node * skin_0__joints[] = {
&node_1,
&node_2,
};
const Skin skin_0 = {
accessor_4, // inverse bind matrices
skin_0__joints, // joints
2, // joints length
};
const AnimationSampler animation_0__sampler_0 = {
accessor_5, // input, keyframe timestamps
accessor_6, // output, keyframe values (void *)
accessor_5_length, // length
};
const AnimationChannel animation_0__channels[] = {
&animation_0__sampler_0, // animation sampler
{
&node_2, // target node
ACP__ROTATION, // target path
},
};