446 lines
15 KiB
C++
446 lines
15 KiB
C++
#include "DefaultRenderer.h"
|
|
#include "Resources.h"
|
|
#include "../Definitions/GraphicalDefinition.h"
|
|
#include "../Model/ModelInfo.h"
|
|
#include "../DllInterfaces/GFXAPI.h"
|
|
#include <map>
|
|
#include <vector>
|
|
|
|
namespace Oyster
|
|
{
|
|
namespace Graphics
|
|
{
|
|
namespace Render
|
|
{
|
|
Definitions::Pointlight pl;
|
|
|
|
/********************************************************
|
|
* Private Prototype Methods
|
|
********************************************************/
|
|
void AnimateRelativeBones( const Model::ModelInfo &info, Model::AnimationData &anim, Math::Matrix relativeBuffer[] );
|
|
void MergeAnimatedBones
|
|
(
|
|
const Model::Bone raw[], int numBones, Math::Float interpolation, // comparable raw bone data and interpolation value
|
|
const Math::Matrix animatedBoneSourceA[], // relative bone animations
|
|
Math::Matrix animatedBoneSourceB_Target[] // relative bone animations and targetbuffer
|
|
);
|
|
int AnimateAbsoluteBones
|
|
(
|
|
const Model::ModelInfo &info, Math::Float deltaTime,
|
|
Model::AnimationData &anim,
|
|
Math::Matrix SkinTransformBuffer[],
|
|
Math::Matrix BoneAnimationBuffer_Relative[],
|
|
Math::Matrix BoneAnimationBuffer_Absolute[]
|
|
);
|
|
int AnimateAbsoluteBones
|
|
(
|
|
const Model::ModelInfo &info, Math::Float deltaTime,
|
|
Model::AnimationData anim[], int numAnimations,
|
|
Math::Matrix SkinTransformBuffer[],
|
|
Math::Matrix BoneAnimationBuffer_Relative[],
|
|
Math::Matrix BoneAnimationBuffer_Absolute[]
|
|
);
|
|
|
|
/********************************************************
|
|
* Public Method Implementations
|
|
********************************************************/
|
|
|
|
void DefaultRenderer::NewFrame(Oyster::Math::Float4x4 View, Oyster::Math::Float4x4 Projection, Definitions::Pointlight* Lights, int numLights)
|
|
{
|
|
Preparations::Basic::ClearBackBuffer(Oyster::Math::Float4(0,0,0,0));
|
|
Preparations::Basic::ClearDepthStencil(Resources::Gui::depth);
|
|
Preparations::Basic::ClearRTV(Resources::GBufferRTV,Resources::GBufferSize,Math::Float4(0,0,0,0));
|
|
Lights[1];
|
|
|
|
void* data;
|
|
|
|
Definitions::LightConstants lc;
|
|
lc.InvProj = Projection.GetInverse();
|
|
lc.Pixels = Core::resolution;
|
|
lc.Lights = numLights;
|
|
lc.View = View;
|
|
lc.Proj = Projection;
|
|
lc.SSAORadius = 3;
|
|
|
|
data = Resources::Light::LightConstantsData.Map();
|
|
memcpy(data, &lc, sizeof(Definitions::LightConstants));
|
|
Resources::Light::LightConstantsData.Unmap();
|
|
|
|
data = Resources::Light::PointLightsData.Map();
|
|
Definitions::Pointlight* plData = (Definitions::Pointlight*)data;
|
|
for(int i=0; i < numLights; ++i)
|
|
{
|
|
plData[i].Pos = (View * Math::Float4(Lights[i].Pos,1)).xyz;
|
|
plData[i].Radius = Lights[i].Radius;
|
|
plData[i].Color = Lights[i].Color;
|
|
plData[i].Bright = Lights[i].Bright;
|
|
}
|
|
//memcpy(data, Lights, sizeof(Definitions::Pointlight) * numLights);
|
|
Resources::Light::PointLightsData.Unmap();
|
|
|
|
for(auto i = Render::Resources::RenderData.begin(); i != Render::Resources::RenderData.end(); i++ )
|
|
{
|
|
(*i).second->Models=0;
|
|
}
|
|
|
|
Core::PipelineManager::SetRenderPass(Resources::Gather::AnimatedPass);
|
|
}
|
|
|
|
void DefaultRenderer::RenderScene(Model::Model* models, int count, Math::Matrix View, Math::Matrix Projection, float deltaTime)
|
|
{
|
|
for(int i = 0; i < count; ++i)
|
|
{
|
|
if(&models[i] == NULL || !models[i].Visible)
|
|
continue;
|
|
|
|
Model::ModelInfo* info = models[i].info;
|
|
if(!info->Animated && models[i].Instanced)
|
|
{
|
|
Definitions::RenderInstanceData rid;
|
|
Math::Float3x3 normalTransform;
|
|
normalTransform = Math::Float3x3(models[i].WorldMatrix.v[0].xyz, models[i].WorldMatrix.v[1].xyz, models[i].WorldMatrix.v[2].xyz);
|
|
normalTransform.Transpose().Invert();
|
|
Math::Matrix m = Math::Matrix(Math::Vector4(normalTransform.v[0],0.0f), Math::Vector4(normalTransform.v[1],0.0f), Math::Vector4(normalTransform.v[2],0.0f), Math::Vector4(0.0f));
|
|
rid.WV = View * m;
|
|
rid.WVP = Projection * View * models[i].WorldMatrix;
|
|
|
|
rid.Tint = models[i].Tint;
|
|
rid.GTint = models[i].GlowTint;
|
|
|
|
Resources::RenderData[info]->rid[Resources::RenderData[info]->Models++] = rid;
|
|
}
|
|
else
|
|
{
|
|
Definitions::PerModel pm;
|
|
Math::Float3x3 normalTransform;
|
|
normalTransform = Math::Float3x3(models[i].WorldMatrix.v[0].xyz, models[i].WorldMatrix.v[1].xyz, models[i].WorldMatrix.v[2].xyz);
|
|
normalTransform.Transpose().Invert();
|
|
Math::Matrix m = Math::Matrix(Math::Vector4(normalTransform.v[0],0.0f), Math::Vector4(normalTransform.v[1],0.0f), Math::Vector4(normalTransform.v[2],0.0f), Math::Vector4(0.0f));
|
|
pm.WV = View * m;
|
|
pm.WVP = Projection * View * models[i].WorldMatrix;
|
|
|
|
Model::ModelInfo* info = models[i].info;
|
|
|
|
// Bone animation buffers
|
|
Math::Matrix SkinTransform[100];
|
|
Math::Matrix BoneAnimated[100];
|
|
Math::Matrix BoneAbsAnimated[100];
|
|
|
|
pm.Animated = AnimateAbsoluteBones
|
|
(
|
|
*info, deltaTime,
|
|
models[i].Animation,
|
|
::Utility::StaticArray::NumElementsOf( models[i].Animation ),
|
|
SkinTransform, BoneAnimated, BoneAbsAnimated
|
|
);
|
|
|
|
void* data = Resources::Gather::ModelData.Map();
|
|
memcpy(data,&(pm),sizeof(pm));
|
|
Resources::Gather::ModelData.Unmap();
|
|
|
|
Definitions::TintData td;
|
|
td.GlowTint = models[i].GlowTint;
|
|
td.Tint = models[i].Tint;
|
|
td.PAD = 0;
|
|
td.PAD2 = 0;
|
|
int s = sizeof(Definitions::TintData);
|
|
|
|
data = Render::Resources::Color.Map();
|
|
memcpy(data,&td,sizeof(Definitions::TintData));
|
|
Render::Resources::Color.Unmap();
|
|
|
|
if(info->Material.size())
|
|
{
|
|
Core::deviceContext->PSSetShaderResources(0,(UINT)info->Material.size(),&(info->Material[0]));
|
|
}
|
|
|
|
|
|
info->Vertices->Apply();
|
|
if(info->Indexed)
|
|
{
|
|
info->Indecies->Apply();
|
|
Oyster::Graphics::Core::deviceContext->DrawIndexed(info->IndexCount,0,0);
|
|
}
|
|
else
|
|
{
|
|
Oyster::Graphics::Core::deviceContext->Draw(info->VertexCount,0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void BlurGlow()
|
|
{
|
|
Definitions::BlurrData bd;
|
|
bd.BlurMask = Math::Float4(1,1,1,1);
|
|
bd.StopX = (UINT)Core::resolution.x/2;
|
|
bd.StopY = (UINT)Core::resolution.y;
|
|
bd.StartX = 0;
|
|
bd.StartY = (UINT)Core::resolution.y/2;
|
|
|
|
void* data = Resources::Blur::Data.Map();
|
|
memcpy(data,&bd,sizeof(Definitions::BlurrData));
|
|
Resources::Blur::Data.Unmap();
|
|
|
|
Core::PipelineManager::SetRenderPass(Resources::Blur::HorPass);
|
|
Core::deviceContext->Dispatch((UINT)((Core::resolution.x/2 + 127U) / 128U), (UINT)(Core::resolution.y/2), 1);
|
|
|
|
Core::PipelineManager::SetRenderPass(Resources::Blur::VertPass);
|
|
Core::deviceContext->Dispatch((UINT)(Core::resolution.x/2), (UINT)((Core::resolution.y/2 + 127U) / 128U), 1);
|
|
}
|
|
|
|
void BlurSSAO()
|
|
{
|
|
Definitions::BlurrData bd;
|
|
bd.BlurMask = Math::Float4(0,0,0,1);
|
|
bd.StopX = (UINT)Core::resolution.x/2;
|
|
bd.StopY = (UINT)Core::resolution.y/2;
|
|
bd.StartX = 0;
|
|
bd.StartY = 0;
|
|
|
|
void* data = Resources::Blur::Data.Map();
|
|
memcpy(data,&bd,sizeof(Definitions::BlurrData));
|
|
Resources::Blur::Data.Unmap();
|
|
|
|
Core::PipelineManager::SetRenderPass(Resources::Blur::HorPass);
|
|
Core::deviceContext->Dispatch((UINT)((Core::resolution.x/2 + 127U) / 128U), (UINT)(Core::resolution.y/2), 1);
|
|
|
|
Core::PipelineManager::SetRenderPass(Resources::Blur::VertPass);
|
|
Core::deviceContext->Dispatch((UINT)(Core::resolution.x/2), (UINT)((Core::resolution.y/2 + 127U) / 128U), 1);
|
|
}
|
|
|
|
void RenderModel(Model::ModelInfo* info, Definitions::RenderInstanceData* rid , int count)
|
|
{
|
|
if(count < 1)
|
|
return;
|
|
if(info->Material.size())
|
|
{
|
|
Core::deviceContext->PSSetShaderResources(0,(UINT)info->Material.size(),&(info->Material[0]));
|
|
}
|
|
info->Vertices->Apply();
|
|
if(info->Indexed)
|
|
{
|
|
info->Indecies->Apply();
|
|
}
|
|
|
|
void* data = Resources::Gather::InstancedData.Map();
|
|
memcpy(data, rid, sizeof(Definitions::RenderInstanceData)*count);
|
|
Resources::Gather::InstancedData.Unmap();
|
|
|
|
if(info->Indexed)
|
|
{
|
|
Core::deviceContext->DrawIndexedInstanced(info->IndexCount,count,0,0,0);
|
|
//Core::deviceContext->DrawIndexed(info->IndexCount,0,0);
|
|
}
|
|
else
|
|
{
|
|
Core::deviceContext->DrawInstanced(info->VertexCount,count,0,0);
|
|
//Core::deviceContext->Draw(info->VertexCount,0);
|
|
}
|
|
}
|
|
|
|
|
|
void DefaultRenderer::EndFrame()
|
|
{
|
|
Core::PipelineManager::SetRenderPass(Graphics::Render::Resources::Gather::InstancedPass);
|
|
Resources::Gather::InstancedData.Apply(1);
|
|
|
|
for(auto i = Render::Resources::RenderData.begin(); i != Render::Resources::RenderData.end(); i++ )
|
|
{
|
|
RenderModel((*i).first,(*i).second->rid, (*i).second->Models);
|
|
}
|
|
|
|
Core::PipelineManager::SetRenderPass(Resources::Light::Pass);
|
|
|
|
Core::deviceContext->Dispatch((UINT)((Core::resolution.x + 15U) / 16U), (UINT)((Core::resolution.y + 15U) / 16U), 1);
|
|
|
|
BlurGlow();
|
|
|
|
BlurSSAO();
|
|
|
|
Core::PipelineManager::SetRenderPass(Resources::Post::Pass);
|
|
|
|
Core::deviceContext->Dispatch((UINT)((Core::resolution.x + 15U) / 16U), (UINT)((Core::resolution.y + 15U) / 16U), 1);
|
|
|
|
Core::swapChain->Present(0,0);
|
|
}
|
|
|
|
/********************************************************
|
|
* Private Prototype Method Implementations
|
|
********************************************************/
|
|
|
|
void AnimateRelativeBones( const Model::ModelInfo &info, Model::AnimationData &anim, Math::Matrix relativeBuffer[] )
|
|
{
|
|
for( int i = 0; i < info.BoneCount; ++i )
|
|
{
|
|
Model::Bone Bone = info.bones[i];
|
|
relativeBuffer[i] = Bone.Relative;
|
|
}
|
|
|
|
const Model::Animation &A = *anim.AnimationPlaying;
|
|
|
|
while( anim.AnimationTime > A.duration && anim.LoopAnimation )
|
|
anim.AnimationTime -= (float)A.duration;
|
|
|
|
float position = anim.AnimationTime;
|
|
for( int i = 0; i < A.Bones; ++i )
|
|
{
|
|
//find current frame
|
|
int nrOfFrames = A.Frames[i];
|
|
Model::Frame PFrame = A.Keyframes[i][nrOfFrames-1];
|
|
Model::Frame NFrame = A.Keyframes[i][nrOfFrames-1];
|
|
bool FrameFound = false;
|
|
|
|
for (int j = 0; j < nrOfFrames; j++)
|
|
{
|
|
if(position < A.Keyframes[i][j].time)
|
|
{
|
|
PFrame = A.Keyframes[i][j-1];
|
|
NFrame = A.Keyframes[i][j];
|
|
break;
|
|
}
|
|
}
|
|
|
|
float denominator = (float)(NFrame.time - PFrame.time);
|
|
|
|
if( denominator != 0.0f )
|
|
{
|
|
float inter = (float)((position - PFrame.time) / denominator);
|
|
Math3D::InterpolateOrientation_UsingNonRigidNlerp( PFrame.bone.Relative,NFrame.bone.Relative, inter, relativeBuffer[PFrame.bone.Parent] );
|
|
}
|
|
else
|
|
{
|
|
relativeBuffer[PFrame.bone.Parent] = PFrame.bone.Relative;
|
|
}
|
|
}
|
|
}
|
|
|
|
enum Conflict
|
|
{
|
|
Conflict_detected,
|
|
Conflict_useA,
|
|
Conflict_useB
|
|
};
|
|
|
|
Conflict DetectBoneAnimationConflict( const Model::Bone &raw, const Math::Matrix &animBoneA, const Math::Matrix &animBoneB );
|
|
|
|
void MergeAnimatedBones( const Model::Bone raw[], int numBones, Math::Float interpolation, const Math::Matrix *animatedBoneSourceA, Math::Matrix animatedBoneSourceB_Target[] )
|
|
{
|
|
for( int i = 0; i < numBones; ++i )
|
|
{
|
|
switch( DetectBoneAnimationConflict(raw[i], animatedBoneSourceA[i], animatedBoneSourceB_Target[i]) )
|
|
{
|
|
case Conflict_detected:
|
|
Math3D::InterpolateOrientation_UsingNonRigidNlerp( animatedBoneSourceA[i], animatedBoneSourceB_Target[i], interpolation, animatedBoneSourceB_Target[i] );
|
|
break;
|
|
case Conflict_useA:
|
|
animatedBoneSourceB_Target[i] = animatedBoneSourceA[i];
|
|
break;
|
|
default: case Conflict_useB: break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Conflict DetectBoneAnimationConflict( const Model::Bone &raw, const Math::Matrix &animBoneA, const Math::Matrix &animBoneB )
|
|
{
|
|
if( animBoneA == raw.Relative )
|
|
return Conflict_useB;
|
|
|
|
if( animBoneB == raw.Relative )
|
|
return Conflict_useA;
|
|
|
|
return Conflict_detected;
|
|
}
|
|
|
|
int AnimateAbsoluteBones( const Model::ModelInfo &info, Math::Float deltaTime, Model::AnimationData &anim, Math::Matrix SkinTransformBuffer[], Math::Matrix BoneAnimationBuffer_Relative[], Math::Matrix BoneAnimationBuffer_Absolute[] )
|
|
{
|
|
if( !info.Animated || (anim.AnimationPlaying == nullptr) )
|
|
{ // no animation
|
|
return 0;
|
|
}
|
|
|
|
anim.AnimationTime += deltaTime;
|
|
AnimateRelativeBones( info, anim, BoneAnimationBuffer_Relative );
|
|
|
|
for( int i = 0; i < info.BoneCount; ++i )
|
|
{
|
|
Model::Bone Bone = info.bones[i];
|
|
SkinTransformBuffer[i] = Bone.Absolute.GetInverse();
|
|
BoneAnimationBuffer_Absolute[i] = Bone.Absolute;
|
|
}
|
|
|
|
Definitions::AnimationData am;
|
|
|
|
for( int i = 0; i < info.BoneCount; ++i )
|
|
{
|
|
//calculate Absolute Animation Transform
|
|
BoneAnimationBuffer_Absolute[i] = BoneAnimationBuffer_Absolute[info.bones[i].Parent] * BoneAnimationBuffer_Relative[i];
|
|
|
|
//write data to am
|
|
am.AnimatedData[i] = (BoneAnimationBuffer_Absolute[i] * SkinTransformBuffer[i]);
|
|
}
|
|
|
|
void *data = Resources::Gather::AnimationData.Map();
|
|
memcpy( data, &am, sizeof(Definitions::AnimationData) );
|
|
Resources::Gather::AnimationData.Unmap();
|
|
|
|
return 1;
|
|
}
|
|
|
|
int AnimateAbsoluteBones( const Model::ModelInfo &info, Math::Float deltaTime, Model::AnimationData anim[], int numAnimations, Math::Matrix SkinTransformBuffer[], Math::Matrix BoneAnimationBuffer_Relative[], Math::Matrix BoneAnimationBuffer_Absolute[] )
|
|
{
|
|
if( !info.Animated || (numAnimations < 1) )
|
|
{ // no animation
|
|
return 0;
|
|
}
|
|
int isAnimated = 0;
|
|
|
|
// for each animation
|
|
for( int i = 0; i < numAnimations; ++i )
|
|
{
|
|
if( anim[i].AnimationPlaying != nullptr )
|
|
{
|
|
anim[i].AnimationTime += deltaTime;
|
|
if( isAnimated )
|
|
{
|
|
AnimateRelativeBones( info, anim[i], BoneAnimationBuffer_Absolute ); // Borrowing BoneAnimationBuffer_Absolute as interim buffer
|
|
MergeAnimatedBones( info.bones, info.BoneCount, 0.5f, BoneAnimationBuffer_Absolute, BoneAnimationBuffer_Relative );
|
|
}
|
|
else
|
|
{
|
|
isAnimated = 1;
|
|
AnimateRelativeBones( info, anim[i], BoneAnimationBuffer_Relative );
|
|
}
|
|
}
|
|
}
|
|
|
|
if( isAnimated )
|
|
{
|
|
for( int i = 0; i < info.BoneCount; ++i )
|
|
{
|
|
Model::Bone Bone = info.bones[i];
|
|
SkinTransformBuffer[i] = Bone.Absolute.GetInverse();
|
|
BoneAnimationBuffer_Absolute[i] = Bone.Absolute;
|
|
}
|
|
|
|
Definitions::AnimationData am;
|
|
|
|
for( int i = 0; i < info.BoneCount; ++i )
|
|
{
|
|
//calculate Absolute Animation Transform
|
|
BoneAnimationBuffer_Absolute[i] = BoneAnimationBuffer_Absolute[info.bones[i].Parent] * BoneAnimationBuffer_Relative[i];
|
|
|
|
//write data to am
|
|
am.AnimatedData[i] = (BoneAnimationBuffer_Absolute[i] * SkinTransformBuffer[i]);
|
|
}
|
|
|
|
void *data = Resources::Gather::AnimationData.Map();
|
|
memcpy( data, &am, sizeof(Definitions::AnimationData) );
|
|
Resources::Gather::AnimationData.Unmap();
|
|
}
|
|
|
|
return isAnimated;
|
|
}
|
|
}
|
|
}
|
|
} |