ZFX + Developia

Code: Alles auswählen

/** Recalculates the bones transform matrix */
void Bone::RecalcMatrix(float animationTime)
{
	XMFLOAT3 pos = InterpolatePosition(animationTime);
	XMFLOAT4 rot = InterpolateRotation(animationTime);
	XMFLOAT3 scale = InterpolateScale(animationTime);
	
	XMVECTOR vPos = XMLoadFloat3(&pos);
	XMVECTOR vRot = XMLoadFloat4(&rot);
	XMVECTOR vScale = XMLoadFloat3(&scale);
	XMMATRIX mat;

	
	mat = XMMatrixScalingFromVector(vScale);
	mat *= XMMatrixRotationQuaternion(vRot);
	mat *= XMMatrixTranslationFromVector(vPos);
	

	// Get parents transform
	XMMATRIX parentMat;
	if(Parent)
		parentMat = XMLoadFloat4x4(&Parent->NodeTransform);
	else
		parentMat = XMMatrixIdentity();


	//XMMATRIX invBindPosMat =  XMMatrixInverse(nullptr, XMLoadFloat4x4(&BindPoseMatrix));
	//XMMATRIX bindPoseMatrix = XMLoadFloat4x4(&BindPoseMatrix);
	XMMATRIX offsetMat = XMLoadFloat4x4(&OffsetMatrix);
	

	// Compute this bones transform
	XMMATRIX nodeTrans = parentMat * mat;
	XMMATRIX globalInverseTransform = XMLoadFloat4x4(&GlobalInverseTransform);

	// Store final transformation matrix
	XMStoreFloat4x4(&Matrix, globalInverseTransform * nodeTrans * offsetMat);

	// Store this bones transform for the children
	XMStoreFloat4x4(&NodeTransform, nodeTrans);
	

	// Compute the other transforms
	for(int i=0; i<ChildBones.size();i++)
	{
		ChildBones[i]->RecalcMatrix(animationTime);
	}

}

Code: Alles auswählen

static const int MAX_BONES = 32;

cbuffer ModelViewProjectionConstantBuffer : register(b0)
{
    matrix model;
    matrix view;
    matrix projection;
	float Time;
};

cbuffer ExplosionBuffer : register(b1)
{
	float State;
};

cbuffer BoneBuffer : register(b2)
{
	matrix Bones[MAX_BONES];
};

struct VertexShaderInput
{
    float3 Position : POSITION;
    float3 Normal : NORMAL;
	float2 TexCoord : TEXCOORD0;
	int4 BoneIDs : BONEIDS;
	float4 Weights : WEIGHTS;
};

struct VertexShaderOutput
{
	float2 TexCoord : TEXCOORD0;
	float3 Normal : NORMAL;
    float4 Pos : SV_POSITION;
};

SamplerState DefSampler;

VertexShaderOutput main(VertexShaderInput input)
{
    VertexShaderOutput output;
    float4 pos = float4(input.Position, 1.0f);
	
	/*float nTime = Time;
	float rand = sin(3*(pos.x+Time+pos.y+pos.z));
	
	// Pressure
	float p = min(State,1);
	pos.xyz *= 1 + 0.125 * rand * p;
	
	// Explosion
	float e = max(1,min(State,2))-1;
	pos.xyz *= 1 + (e*(rand + 1.5f));*/

	matrix boneTransform = Bones[input.BoneIDs[0]] * input.Weights[0];
    boneTransform += Bones[input.BoneIDs[1]] * input.Weights[1];
    boneTransform += Bones[input.BoneIDs[2]] * input.Weights[2];
    boneTransform += Bones[input.BoneIDs[3]] * input.Weights[3];
	
   	
    // Transform the vertex position into projected space.
	pos = mul(pos, boneTransform);
    pos = mul(pos, model);
    pos = mul(pos, view);
    pos = mul(pos, projection);
    output.Pos = pos;

    // Pass through the color without modification.
    output.Normal = mul(input.Normal, (float3x3)model);
	//output.Normal = mul(output.Normal, (float3x3)boneTransform);

	output.TexCoord = float2(input.TexCoord.x, input.TexCoord.y * -1);
	output.Normal = input.Weights.rgb;
    return output;
}