17_Framework (Transform, PerFrame, Renderer)

Transform.cpp, h

#include "Framework.h"
#include "Transform.h"
 
Transform::Transform()
{
	D3DXMatrixIdentity(&bufferDesc.World);
}
 
Transform::Transform(Shader * shader)
{
	D3DXMatrixIdentity(&bufferDesc.World);
	SetShader(shader);
}
 
Transform::~Transform()
{
	SafeDelete(buffer);
}
 
void Transform::Set(Transform * transform)
{
	position = transform->position;
	scale = transform->scale;
	rotation = transform->rotation;
 
	UpdateWorld();
}
 
void Transform::SetShader(Shader * shader)
{
	this->shader = shader;
	buffer = new ConstantBuffer(&bufferDesc, sizeof(BufferDesc));
	sBuffer = shader->AsConstantBuffer("CB_World");
 
}
 
void Transform::Position(float x, float y, float z)
{
	Position(Vector3(x, y, z));
}
 
void Transform::Position(Vector3 & vec)
{
	position = vec;
	UpdateWorld();
}
 
void Transform::Position(Vector3 * vec)
{
	*vec = position;
}
 
void Transform::Scale(float x, float y, float z)
{
	Scale(Vector3(x, y, z));
}
 
void Transform::Scale(Vector3 & vec)
{
	scale = vec;
	UpdateWorld();
}
 
void Transform::Scale(Vector3 * vec)
{
	*vec = scale;
}
 
void Transform::Rotation(float x, float y, float z)
{
	Rotation(Vector3(x, y, z));
}
 
void Transform::Rotation(Vector3 & vec)
{
	rotation = vec;
	UpdateWorld();
}
 
void Transform::Rotation(Vector3 * vec)
{
	*vec = rotation;
}
 
void Transform::RotationDegree(float x, float y, float z)
{
	RotationDegree(Vector3(x, y, z));
}
 
void Transform::RotationDegree(Vector3 & vec)
{
	Vector3 temp;
	temp.x = Math::ToRadian(vec.x);
	temp.y = Math::ToRadian(vec.y);
	temp.z = Math::ToRadian(vec.z);
 
	Rotation(temp);
}
 
void Transform::RotationDegree(Vector3 * vec)
{
	Vector3 temp;
	temp.x = Math::ToDegree(rotation.x);
	temp.y = Math::ToRadian(rotation.y);
	temp.z = Math::ToRadian(rotation.z);
 
	*vec = temp;
}
 
Vector3 Transform::Forward()
{
	return Vector3(bufferDesc.World._31, bufferDesc.World._32, bufferDesc.World._33);
}
 
Vector3 Transform::Up()
{
	return Vector3(bufferDesc.World._21, bufferDesc.World._22, bufferDesc.World._33);
}
 
Vector3 Transform::Right()
{
	return Vector3(bufferDesc.World._11, bufferDesc.World._12, bufferDesc.World._13);
}
 
void Transform::World(Matrix & matrix)
{
	Math::MatrixDecompose(matrix, scale, rotation, position);
	bufferDesc.World = matrix;
}
 
void Transform::UpdateWorld()
{
	Matrix S, R, T;
	D3DXMatrixScaling(&S, scale.x, scale.y, scale.z);
	D3DXMatrixRotationYawPitchRoll(&R, rotation.y, rotation.x, rotation.z);
	D3DXMatrixTranslation(&T, position.x, position.y, position.z);
 
	Matrix world = S * R* T;
	bufferDesc.World = world;
 
}
 
void Transform::Update()
{
}
 
void Transform::Render()
{
	if (shader == NULL) return;
	buffer->Render();
	sBuffer->SetConstantBuffer(buffer->Buffer());
}

 

#pragma once
//월드 관리 클래스
class Transform
{
public:
	Transform();
	Transform(Shader* shader);
	~Transform();
 
	//자기와 같은 타입 들어오면 위치, 회전, 크기 셋팅
	void Set(Transform* transform);
 
	void SetShader(Shader* shader);
 
	void Position(float x, float y, float z);
	void Position(Vector3& vec);
	void Position(Vector3* vec);
 
	void Scale(float x, float y, float z);
	void Scale(Vector3& vec);
	void Scale(Vector3* vec);
 
	void Rotation(float x, float y, float z);
	void Rotation(Vector3& vec);
	void Rotation(Vector3* vec);
 
	void RotationDegree(float x, float y, float z);
	void RotationDegree(Vector3& vec);
	void RotationDegree(Vector3* vec);
 
	//벡터값들
	Vector3 Forward();
	Vector3 Up();
	Vector3 Right();
 
	void World(Matrix& matrix);
	Matrix& World() { return bufferDesc.World; }
 
private:
	void UpdateWorld();
 
public:
	void Update(); //나중 인스텅싱
	void Render();
 
private:
	struct BufferDesc{
		Matrix World;
	} bufferDesc;
 
private:
	Shader* shader = NULL;
 
	ConstantBuffer* buffer = NULL;
	ID3DX11EffectConstantBuffer* sBuffer;
 
	Vector3 position = Vector3(0,0,0);
	Vector3 scale = Vector3(1, 1, 1);
	Vector3 rotation = Vector3(0, 0, 0);
};

---

PerFrame.cpp, h

#include "Framework.h"
#include "PerFrame.h"
 
PerFrame::PerFrame(Shader * shader)
	:shader(shader)
{
	buffer = new ConstantBuffer(&desc, sizeof(Desc));
	sBuffer = shader->AsConstantBuffer("CB_PerFrame");
}
 
PerFrame::~PerFrame()
{
	SafeDelete(buffer);
}
 
void PerFrame::Update()
{
	desc.Time = Time::Get()->Running();
 
	desc.View = Context::Get()->View();
	D3DXMatrixInverse(&desc.ViewInverse, NULL, &desc.View);
 
	desc.Projection = Context::Get()->Projection();
 
	desc.VP  = desc.View * desc.Projection;
 
}
 
void PerFrame::Render()
{
	buffer->Render();
	sBuffer->SetConstantBuffer(buffer->Buffer());
}

#pragma once
 
//프레임 조절용
class PerFrame
{
public:
	PerFrame(Shader* shader);
	~PerFrame();
 
	void Update();
	void Render();
 
private:
	struct Desc
	{
		Matrix View;
		Matrix ViewInverse; //View값을 역행렬값
		Matrix Projection;
		Matrix VP; // View * Projection 결과값
 
		Plane Culling[4];
		Plane Clipping;
 
		float Time;
		float Padding[3];
	}desc;
 
 
private:
 
	Shader* shader;
	ConstantBuffer* buffer;
	ID3DX11EffectConstantBuffer* sBuffer;
};

---

Renderer.cpp, h

#include "Framework.h"
#include "Renderer.h"
 
Renderer::Renderer(Shader * shader)
	:shader(shader), bCreateShader(false)
{
	Initialize();
}
 
Renderer::Renderer(wstring shaderFile)
	: bCreateShader(true)
{
	shader = new Shader(shaderFile);
	Initialize();
}
 
void Renderer::Initialize()
{
	preFrame = new PerFrame(shader);
	transform = new Transform(shader);
}
 
Renderer::~Renderer()
{
	SafeDelete(preFrame);
	SafeDelete(transform);
	
	SafeDelete(vertexBuffer);
	SafeDelete(indexBuffer);
 
	//이 클래스에서 만들었을 경우만 삭제
	if (bCreateShader == true)
		SafeDelete(shader);
}
 
void Renderer::Update()
{
	preFrame->Update();
	transform->Update();
}
 
void Renderer::Render()
{
	if (vertexBuffer != NULL)
	{
		vertexBuffer->Render();
 
		if (indexBuffer != NULL)
			indexBuffer->Render();
	}
 
	D3D::GetDC()->IASetPrimitiveTopology(topology);
 
	preFrame->Render();
	transform->Render();
}

#pragma once
 
class Renderer
{
public:
	Renderer(Shader* shader);
	Renderer(wstring shaderFile);
	virtual ~Renderer();
 
	Shader* GetShader() { return shader; }
	
	UINT& Pass() { return pass; }
 
	void Pass(UINT val) { pass = val; }
 
	virtual void Update();
	virtual void Render();
 
	Transform* GetTransform() { return transform; }
 
private:
	void Initialize();
 
private:
	void Topology(D3D11_PRIMITIVE_TOPOLOGY val) { topology = val; }
 
protected:
	Shader* shader;
 
	Transform* transform;
	VertexBuffer* vertexBuffer = NULL;
	IndexBuffer* indexBuffer = NULL;
 
	UINT vertexCount = 0;
	UINT indexCount = 0;
 
private:
	bool bCreateShader = false;
 
	D3D11_PRIMITIVE_TOPOLOGY topology = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
	UINT pass = 0;
 
	PerFrame* preFrame;
};

---

보충 내용

 

PerFrame : CBuffer 값을 쉐이더에 넘겨 주는 클래스 (쉐이더 출력용)

Transform : 월드 관리 클래스 (월드 출력용)

각각 버퍼를 따로 받아서 출력함

Renderer : PerFrame , Transform을 가지고 있고 Mesh class 같은 객체에서 더 쉽게 사용 하기 위한 클래스

 

예)

변경전 클래스

 

변경후 클래스

 

보기와 같이 변경전에는 엄청나게 헤더에 선언하고 cpp에 정의 했던 내용들을 변경후 클래스

처럼 확 줄여버리고 쉽게 관리 

 

그림

왼쪽은 기존에 Mesh 같은 클래스를 선언하면 위치, 쉐이더값을 넘겨주는 값을 일일이 선언해서

길어졌다면 오른쪽 같은 경우는 Renderer 클래스를 상속 받아서 한번에 관리 해버리는 형태로 변경