2020_1007 Render Cube

 

 

[Camera class ]
1. View, Projection 관련 함수

#pragma once

class MatrixBuffer;

class Camera : public Singleton<Camera>
{
private:
	MatrixBuffer* viewBuffer;
	MatrixBuffer* projectionBuffer;

public:
	Camera();
	~Camera();
	//
	bool Init();
	//
	void SetVPBuffer();
	void SetViewport();
	void SetViewProjection();
};
////////////////////////////////////////////////////////////////////////////////////////
#include "Framework.h"

Camera::Camera()
{
}

Camera::~Camera()
{
	delete projectionBuffer;
	delete viewBuffer;
}

bool Camera::Init()
{
	SetViewport();
	SetViewProjection();
	return true;
}

void Camera::SetVPBuffer()
{
	viewBuffer->SetVSBuffer(1);
	projectionBuffer->SetVSBuffer(2);
}

void Camera::SetViewport()
{
	// ndc 공간에서 viewport를 통해 확장
	// 중앙 (0, 0), 좌우(-1 ~ 1), 상하(-1 ~ 1)
	D3D11_VIEWPORT vp;
	vp.Width = WIN_WIDTH;
	vp.Height = WIN_HEIGHT;
	vp.MinDepth = 0.0f;
	vp.MaxDepth = 1.0f;
	vp.TopLeftX = 0;
	vp.TopLeftY = 0;
	//
	DC->RSSetViewports(1, &vp);
}

void Camera::SetViewProjection()
{
	// View Setting (Camera)
	XMVECTOR eye = XMVectorSet(0, 0, -3, 0); // Camera의 위치
	XMVECTOR focus = XMVectorSet(0, 0, 0, 0); // Camera가 바라보는 위치
	XMVECTOR up = XMVectorSet(0, 1, 0, 0); // Camera의 Up Dir
	Matrix view = XMMatrixLookAtLH(eye, focus, up);
	// Projection Setting
	float fovAngle = XM_PIDIV4; // 45도
	float aspectRatio = (float)WIN_WIDTH / WIN_HEIGHT; // 종횡비
	float nearZ = 0.1f;
	float farZ = 1000.0f;
	Matrix projection = XMMatrixPerspectiveFovLH(fovAngle, aspectRatio, nearZ, farZ);
	//
	viewBuffer = new MatrixBuffer;
	projectionBuffer = new MatrixBuffer;
	viewBuffer->Set(view);
	projectionBuffer->Set(projection);
}

 

[Cube Class ]
1. Plane 구조체 선언(6면 사용)
2. 각 Plane에 Vertices 할당하여 Render할 때 VertexBuffer를 Update해서 사용하고, IndexBuffer는 동일하게 재사용

#pragma once

class Cube
{
public:
	struct Plane
	{
		VertexColor vertices[4];
		Float4 color;
	};
private:
	VertexShader* vertexShader;
	PixelShader* pixelShader;
	//
	VertexBuffer* vertexBuffer;
	IndexBuffer* indexBuffer;
	//
	Matrix world;
	MatrixBuffer* worldBuffer;
	//
	Plane planes[6];

public:
	Cube();
	~Cube();
	//
	void Update();
	void Render();
	//
	void SetPlanes(float x, float y, float z);
	void SetPlaneVerts(int planeIdx, VertexColor* vertices, int indexes[4]);
	void SetPlaneColors();
};
////////////////////////////////////////////////////////////////////////////////////////
#include "Framework.h"

Cube::Cube()
{
	vertexShader = Shader::AddVS(L"Cube");
	pixelShader = Shader::AddPS(L"Cube");
	//
	VertexColor vertices[4]{};
	UINT indices[6] = { 0, 1, 2, 2, 1, 3 };
	//
	vertexBuffer = new VertexBuffer(vertices, sizeof(VertexColor), 4);
	indexBuffer = new IndexBuffer(indices, 6);
	worldBuffer = new MatrixBuffer;
	//
	SetPlanes(0.5f, 0.4f, 0.3f); // range ( 0 ~ 1.0f (screenMax) )
}

Cube::~Cube()
{
	delete worldBuffer;
	delete indexBuffer;
	delete vertexBuffer;
}

void Cube::Update()
{
	static float angle = 0.0f;
	angle += 0.005f;
	//world = XMMatrixRotationY(angle);
	world = XMMatrixRotationRollPitchYaw(angle, angle, angle);
	worldBuffer->Set(world);
}

void Cube::Render()
{
	indexBuffer->IASet();
	//
	worldBuffer->SetVSBuffer(0);
	//
	vertexShader->Set();
	pixelShader->Set();
	//
	for (int i = 0; i < 6; ++i)
	{
		for (int j = 0; j < 4; ++j)
			planes[i].vertices[j].color = planes[i].color;
		//
		vertexBuffer->Update(planes[i].vertices, 4);
		vertexBuffer->IASet();
		//
		DC->DrawIndexed(6, 0, 0);
	}
}

void Cube::SetPlanes(float x, float y, float z)
{
	VertexColor planeVerts[4]{};
	VertexColor vertices[8]{};
	//
	vertices[0].position = { -x, +y, -z };
	vertices[1].position = { +x, +y, -z };
	vertices[2].position = { -x, -y, -z };
	vertices[3].position = { +x, -y, -z };
	//
	vertices[4].position = { -x, +y, +z };
	vertices[5].position = { +x, +y, +z };
	vertices[6].position = { -x, -y, +z };
	vertices[7].position = { +x, -y, +z };
	//
	int planeIndexes[6][4] =
	{
		{ 0, 1, 2, 3 }, { 5, 4, 7, 6 },	// front, back
		{ 4, 0, 6, 2 }, { 1, 5, 3, 7 },	// left, right
		{ 4, 5, 0, 1 }, { 2, 3, 6, 7 }	// top, bottom
	};
	for (int i = 0; i < 6; ++i)
		SetPlaneVerts(i, vertices, planeIndexes[i]);
	//
	SetPlaneColors();
}

void Cube::SetPlaneVerts(int planeIdx, VertexColor* vertices, int indexes[4])
{	// bottom
	VertexColor planeVerts[4]{};
	for (int i = 0; i < 4; ++i)
		planeVerts[i] = vertices[indexes[i]];
	memcpy(planes[planeIdx].vertices, planeVerts, sizeof(VertexColor) * 4);
}

void Cube::SetPlaneColors()
{
	Float4 colors[3] = { {1,0,0,1},{0,1,0,1},{0,0,1,1} };
	for (int i = 0; i < 6; ++i)
		planes[i].color = colors[i / 2];
}

 

[Scene]

#pragma once

class CubeScene : public Scene
{
private:
	Cube* cube;
	/////////////////////////////////////////
public:
	CubeScene();
	~CubeScene();
	// Scene을(를) 통해 상속됨
	virtual void Update() override;
	virtual void PreRender() override;
	virtual void Render() override;
	virtual void PostRender() override;
};
////////////////////////////////////////////////////////////////////////////////////////
#include "Framework.h"
#include "CubeScene.h"

CubeScene::CubeScene()
{
	cube = new Cube;
}

CubeScene::~CubeScene()
{
	delete cube;
}

void CubeScene::Update()
{
	cube->Update();
}

void CubeScene::PreRender()
{
}

void CubeScene::Render()
{
	DC->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	CAM->SetVPBuffer();
	cube->Render();
}

void CubeScene::PostRender()
{
}