public static Matrix4x4 Perspective(float fX, float fY, float zNear, float zFar)
{
var projectionMatrix = new Matrix4x4();
projectionMatrix[3, 2] = -1;
projectionMatrix[0, 0] = fX;
projectionMatrix[1, 1] = fY;
Matrix4x4Utility.SetClipping(ref projectionMatrix, zNear, zFar);
return(projectionMatrix);
}
private void UpdateGlobalConstantBuffers(CommandList commandEncoder, RenderContext context)
{
var cloudShadowView = Matrix4x4.CreateLookAt(
Vector3.Zero,
Vector3.Normalize(new Vector3(0, 0.2f, -1)),
Vector3.UnitY);
var cloudShadowProjection = Matrix4x4.CreateOrthographic(1, 1, 0, 1);
var lightingConstantsVS = new LightingConstantsVS
{
CloudShadowMatrix = cloudShadowView * cloudShadowProjection
};
if (context.Scene != null)
{
var cameraPosition = Matrix4x4Utility.Invert(context.Camera.View).Translation;
_globalConstantBufferShared.Value.CameraPosition = cameraPosition;
_globalConstantBufferShared.Value.TimeInSeconds = (float)context.GameTime.TotalGameTime.TotalSeconds;
_globalConstantBufferShared.Update(commandEncoder);
_globalConstantBufferVS.Value.ViewProjection = context.Camera.View * context.Camera.Projection;
_globalConstantBufferVS.Update(commandEncoder);
void updateLightingBuffer(
ConstantBuffer <LightingConstantsVS> bufferVS,
ConstantBuffer <LightingConstantsPS> bufferPS,
in LightingConstantsPS constantsPS)
{
bufferVS.Value = lightingConstantsVS;
bufferVS.Update(commandEncoder);
bufferPS.Value = constantsPS;
bufferPS.Update(commandEncoder);
}
updateLightingBuffer(
_globalLightingVSTerrainBuffer,
_globalLightingPSTerrainBuffer,
context.Scene.Lighting.CurrentLightingConfiguration.TerrainLightsPS);
updateLightingBuffer(
_globalLightingVSObjectBuffer,
_globalLightingPSObjectBuffer,
context.Scene.Lighting.CurrentLightingConfiguration.ObjectLightsPS);
}
_globalConstantBufferPS.Value.ViewportSize = new Vector2(context.Game.Viewport.Width, context.Game.Viewport.Height);
_globalConstantBufferPS.Update(commandEncoder);
}
private void UpdateGlobalConstantBuffers(CommandEncoder commandEncoder, RenderContext context)
{
var cameraPosition = Matrix4x4Utility.Invert(context.Camera.View).Translation;
_globalConstantBufferShared.Value.CameraPosition = cameraPosition;
_globalConstantBufferShared.Update();
_globalConstantBufferVS.Value.ViewProjection = context.Camera.View * context.Camera.Projection;
_globalConstantBufferVS.Update();
_globalConstantBufferPS.Value.TimeInSeconds = (float)context.GameTime.TotalGameTime.TotalSeconds;
_globalConstantBufferPS.Value.ViewportSize = context.Camera.Viewport.Size;
_globalConstantBufferPS.Update();
_globalLightingTerrainBuffer.Value = context.Scene.Settings.CurrentLightingConfiguration.TerrainLights;
_globalLightingObjectBuffer.Value = context.Scene.Settings.CurrentLightingConfiguration.ObjectLights;
_globalLightingTerrainBuffer.Update();
_globalLightingObjectBuffer.Update();
}
internal void UpdateBoneTransforms()
{
if (!_hasSkinnedMeshes)
{
return;
}
for (var i = 0; i < Bones.Length; i++)
{
// Bone matrix should be relative to root bone transform.
var rootBoneMatrix = Bones[0].LocalToWorldMatrix;
var boneMatrix = Bones[i].LocalToWorldMatrix;
var boneMatrixRelativeToRoot = boneMatrix * Matrix4x4Utility.Invert(rootBoneMatrix);
boneMatrixRelativeToRoot.ToMatrix4x3(out _skinningBones[i]);
}
SkinningBuffer.SetData(_skinningBones);
}
internal void BuildRenderList(RenderList renderList, MeshComponent mesh)
{
if (Hidden)
{
return;
}
Matrix4x4 world;
if (CameraOriented)
{
var localToWorldMatrix = mesh.Transform.LocalToWorldMatrix;
var viewInverse = Matrix4x4Utility.Invert(mesh.Game.Scene.Camera.View);
var cameraPosition = viewInverse.Translation;
var toCamera = Vector3.Normalize(Vector3.TransformNormal(
cameraPosition - mesh.Transform.WorldPosition,
mesh.Transform.WorldToLocalMatrix));
toCamera.Z = 0;
var cameraOrientedRotation = Matrix4x4.CreateFromQuaternion(QuaternionUtility.CreateRotation(Vector3.UnitX, toCamera));
world = cameraOrientedRotation * localToWorldMatrix;
}
else
{
world = mesh.Transform.LocalToWorldMatrix;
}
ModelComponent modelComponent = null;
if (Skinned)
{
modelComponent = mesh.Entity.GetComponent <ModelComponent>();
}
foreach (var materialPass in MaterialPasses)
{
foreach (var meshPart in materialPass.MeshParts)
{
meshPart.Material.SetSkinningBuffer(modelComponent?.SkinningBuffer);
var renderQueue = meshPart.Material.PipelineState.BlendState.Enabled
? renderList.Transparent
: renderList.Opaque;
renderQueue.AddRenderItemDrawIndexed(
meshPart.Material,
_vertexBuffer,
materialPass.TexCoordVertexBuffer,
CullFlags.None,
mesh,
world,
meshPart.StartIndex,
meshPart.IndexCount,
_indexBuffer);
}
}
}
/// <summary>
/// Updates <see cref="LocalRotation"/> to point towards the specified world space position.
/// </summary>
public void LookAt(Vector3 worldPosition)
{
var matrix = Matrix4x4.CreateLookAt(WorldPosition, worldPosition, Vector3.UnitZ);
LocalRotation = Quaternion.CreateFromRotationMatrix(Matrix4x4Utility.Invert(matrix));
}
public void Update(GraphicsDevice graphicsDevice)
{
NumInstances = 0;
foreach (var instancedRenderable in InstancedRenderables)
{
if (instancedRenderable.Visible)
{
NumInstances += 1;
}
}
if (NumInstances == 0)
{
return;
}
if (Mesh.Skinned)
{
var numElements = (int)(Mesh.NumBones * NumInstances);
if (SkinningBuffer == null || SkinningBuffer.ElementCount < numElements)
{
SkinningBuffer = DynamicBuffer <Matrix4x3> .CreateArray(graphicsDevice, numElements, BufferUsageFlags.None);
_skinningBones = new Matrix4x3[numElements];
}
var boneIndex = 0;
foreach (var instancedRenderable in InstancedRenderables)
{
if (instancedRenderable.Visible)
{
for (var i = 0; i < Mesh.NumBones; i++)
{
// Bone matrix should be relative to root bone transform.
var rootBoneMatrix = instancedRenderable.Bones[0].LocalToWorldMatrix;
var boneMatrix = instancedRenderable.Bones[i].LocalToWorldMatrix;
var boneMatrixRelativeToRoot = boneMatrix * Matrix4x4Utility.Invert(rootBoneMatrix);
boneMatrixRelativeToRoot.ToMatrix4x3(out _skinningBones[boneIndex++]);
}
}
}
SkinningBuffer.UpdateData(_skinningBones);
}
if (WorldBuffer == null || WorldBuffer.ElementCount < NumInstances)
{
WorldBuffer = DynamicBuffer <Matrix4x4> .CreateArray(
graphicsDevice,
(int)NumInstances,
BufferUsageFlags.None);
_worldTransforms = new Matrix4x4[NumInstances];
}
var worldTransformIndex = 0;
foreach (var instancedRenderable in InstancedRenderables)
{
if (instancedRenderable.Visible)
{
_worldTransforms[worldTransformIndex++] = instancedRenderable.Renderable.Transform.LocalToWorldMatrix;
}
}
WorldBuffer.UpdateData(_worldTransforms);
}
