Patoke-4JLibs/Windows_Libs/Dev/Render/RendererMatrix.cpp

#pragma once
#include "Renderer.h"

#include <cstring>

const float* Renderer::MatrixGet(int type)
{
	Context& context = this->getContext();
	const int depth = context.matrixStackDepth[type];
	return reinterpret_cast<const float*>(&context.matrixStacks[type][depth]);
}

void Renderer::MatrixMode(int type)
{
	Context& context = this->getContext();
	context.matrixModeType = type;
}

void Renderer::MatrixMult(float* mat)
{
	DirectX::XMMATRIX matrix;
	std::memcpy(&matrix, mat, sizeof(matrix));
	this->MultWithStack(matrix);
}

void Renderer::MatrixOrthogonal(float left, float right, float bottom, float top, float zNear, float zFar)
{
	const DirectX::XMMATRIX matrix = DirectX::XMMatrixOrthographicOffCenterRH(left, right, bottom, top, zNear, zFar);
	this->MultWithStack(matrix);
}

void Renderer::MatrixPerspective(float fovy, float aspect, float zNear, float zFar)
{
	const float fovRadians = fovy * (3.14159274f / 180.0f);
	const DirectX::XMMATRIX matrix = DirectX::XMMatrixPerspectiveFovRH(fovRadians, aspect, zNear, zFar);
	this->MultWithStack(matrix);
}

void Renderer::MatrixPop()
{
	Context& context = this->getContext();
	const int mode = context.matrixModeType;
	--context.matrixStackDepth[mode];
	context.matrixDirty[mode] = true;
}

void Renderer::MatrixPush()
{
	Context& context = this->getContext();
	const int mode = context.matrixModeType;
	const int depth = context.matrixStackDepth[mode];
	context.matrixStacks[mode][depth + 1] = context.matrixStacks[mode][depth];
	++context.matrixStackDepth[mode];
}

void Renderer::MatrixRotate(float angle, float x, float y, float z)
{
	const DirectX::XMVECTOR axis = DirectX::XMVectorSet(x, y, z, 0.0f);
	const DirectX::XMMATRIX matrix = DirectX::XMMatrixRotationAxis(axis, angle);
	this->MultWithStack(matrix);
}

void Renderer::MatrixScale(float x, float y, float z)
{
	const DirectX::XMMATRIX matrix = DirectX::XMMatrixScaling(x, y, z);
	this->MultWithStack(matrix);
}

void Renderer::MatrixSetIdentity()
{
	Context& context = this->getContext();
	const int mode = context.matrixModeType;
	const int depth = context.matrixStackDepth[mode];
	context.matrixStacks[mode][depth] = DirectX::XMMatrixIdentity();
	context.matrixDirty[mode] = true;
}

void Renderer::MatrixTranslate(float x, float y, float z)
{
	const DirectX::XMMATRIX matrix = DirectX::XMMatrixTranslation(x, y, z);
	this->MultWithStack(matrix);
}

void Renderer::MultWithStack(DirectX::XMMATRIX matrix)
{
	Context& context = this->getContext();
	const int mode = context.matrixModeType;
	const int depth = context.matrixStackDepth[mode];
	DirectX::XMMATRIX& current = context.matrixStacks[mode][depth];
	current = DirectX::XMMatrixMultiply(matrix, current);
	context.matrixDirty[mode] = true;
}

void Renderer::Set_matrixDirty()
{
	Context& context = this->getContext();
	const DirectX::XMMATRIX identity = DirectX::XMMatrixIdentity();

	context.matrixStacks[0][0] = identity;
	context.matrixStacks[1][0] = identity;
	context.matrixStacks[2][0] = identity;
	context.matrixStacks[3][0] = identity;

	context.matrixDirty[0] = true;
	context.matrixDirty[1] = true;
	context.matrixDirty[2] = true;
	context.matrixDirty[3] = true;

	activeVertexType = 0xFFFFFFFFu;
	activePixelType = 0xFFFFFFFFu;
}