10_Sampler

TextureSamplerDemo.cpp, h

 

#include "stdafx.h"
#include "TextureSamplerDemo.h"

void TextureSamplerDemo::Initialize()
{
	Context::Get()->GetCamera()->RotationDegree(0, 0, 0);
	Context::Get()->GetCamera()->Position(0, 0, -5);
	((Freedom*)Context::Get()->GetCamera())->Speed(5);

	shader = new Shader(L"10_Sampler.fxo");
	vertices = new Vertex[4];

	vertices[0].Position = Vector3(-0.5f, -0.5f, 0.0f);
	vertices[1].Position = Vector3(-0.5f, +0.5f, 0.0f);
	vertices[2].Position = Vector3(+0.5f, -0.5f, 0.0f);
	vertices[3].Position = Vector3(+0.5f, +0.5f, 0.0f);

	vertices[0].Uv = Vector2(0, 2);
	vertices[1].Uv = Vector2(0, 0);
	vertices[2].Uv = Vector2(2, 2);
	vertices[3].Uv = Vector2(2, 0);

	//Create VertexBuffer
	{
		D3D11_BUFFER_DESC desc;
		ZeroMemory(&desc, sizeof(D3D11_BUFFER_DESC));
		desc.ByteWidth = sizeof(Vertex) * 4;
		desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;

		D3D11_SUBRESOURCE_DATA data = { 0 };
		data.pSysMem = vertices;

		Check(D3D::GetDevice()->CreateBuffer(&desc, &data, &vertexBuffer));
	}

	indices = new UINT[6]{ 0, 1, 2, 2, 1, 3 };

	//Create IndexBuffer
	{
		D3D11_BUFFER_DESC desc;
		ZeroMemory(&desc, sizeof(D3D11_BUFFER_DESC));
		desc.ByteWidth = sizeof(UINT) * 6;
		desc.BindFlags = D3D11_BIND_INDEX_BUFFER;

		D3D11_SUBRESOURCE_DATA data = { 0 };
		data.pSysMem = indices;

		Check(D3D::GetDevice()->CreateBuffer(&desc, &data, &indexBuffer));
	}

	SafeDelete(vertices);
	SafeDelete(indices);

	texture = new Texture(L"Box.png");
}

void TextureSamplerDemo::Destroy()
{
	SafeDelete(shader);
	SafeDelete(texture);

	SafeRelease(vertexBuffer);
	SafeRelease(indexBuffer);
}

void TextureSamplerDemo::Update()
{
	//Open FileDialog
	if (ImGui::Button("Load Texture"))
	{
		function<void(wstring)> f = bind(&TextureSamplerDemo::LoadTexture, this, placeholders::_1); //중요
		Path::OpenFileDialog(L"", Path::ImageFilter, L"../../_Textures/", f, D3D::GetDesc().Handle);
	};

	//SamplerState Filter Test
	{
		static UINT Filter = 0;
		ImGui::InputInt("Filter", (int*)&Filter);
		Filter %= 2;
		shader->AsScalar("Filter")->SetInt(Filter);
	}

	//SamplerState Address Test
	{
		static UINT Address = 0;
		ImGui::InputInt("Addres", (int*)&Address);
		Address %= 4;
		shader->AsScalar("Addres")->SetInt(Address);
	}
	
	Matrix world;
	D3DXMatrixIdentity(&world);

	shader->AsMatrix("World")->SetMatrix(world);
	shader->AsMatrix("View")->SetMatrix(Context::Get()->View());
	shader->AsMatrix("Projection")->SetMatrix(Context::Get()->Projection());
}

void TextureSamplerDemo::Render()
{
	UINT stride = sizeof(Vertex);
	UINT offset = 0;

	D3D::GetDC()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	D3D::GetDC()->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
	D3D::GetDC()->IASetIndexBuffer(indexBuffer, DXGI_FORMAT_R32_UINT, 0);

	//Texture 정보를 hlsl에 넘겨줌
	shader->AsSRV("DiffuseMap")->SetResource(texture->SRV());

	shader->DrawIndexed(0, 1, 6);
}

void TextureSamplerDemo::LoadTexture(wstring name)
{
	SafeDelete(texture);
	texture = new Texture(name);

	/* C++에서 보내는 방식
	ID3D11SamplerState* state;
	D3D11_SAMPLER_DESC desc;
	desc.AddressU = 0;
	D3D::GetDevice()->CreateSamplerState(&desc, &state);
	shader->AsSampler("Samp")->SetSampler(0, state);
	*/
}

 

#pragma once
#include "Systems/IExecute.h"

class TextureSamplerDemo : public IExecute
{
public:
	virtual void Initialize() override;
	virtual void Destroy() override;
	virtual void Update() override;
	virtual void PreRender() override {};
	virtual void Render() override;
	virtual void PostRender() override {};
	virtual void ResizeScreen() override {};

private:
	struct Vertex
	{
		Vector3 Position;
		Vector2 Uv;
	};

private:
	void LoadTexture(wstring name); 

private:
	Shader* shader;

	Vertex* vertices;
	ID3D11Buffer* vertexBuffer;

	UINT* indices;
	ID3D11Buffer* indexBuffer;

	Texture* texture = NULL;
};

---

10_Sampler.fx

matrix World, View, Projection;
Texture2D DiffuseMap;

struct VertexInput
{
    float4 Position : Position;
    float2 Uv : Uv;
};

struct VertexOutput
{
    float4 Position : SV_Position;
    float2 Uv : Uv;
};

VertexOutput VS(VertexInput input)
{
    VertexOutput output;
    output.Position = mul(input.Position, World);
    output.Position = mul(output.Position, View);
    output.Position = mul(output.Position, Projection);
        
    output.Uv = input.Uv;

    return output;
}

//SamplerState(Filter)
SamplerState PointSampler{ Filter = MIN_MAG_MIP_POINT; };
SamplerState LinearSampler{ Filter = MIN_MAG_MIP_LINEAR; };

//Imgui통해서 Sampler 조절
uint Filter;
float4 PS_Filter(VertexOutput input) : SV_Target
{
    if (Filter == 0)
        return DiffuseMap.Sample(PointSampler, input.Uv);
     
    return DiffuseMap.Sample(LinearSampler, input.Uv);
}

//SamplerState(ADDRESS)
SamplerState WarpSampler //복사
{
    AddressU = WRAP;
    AddressV = WRAP;
};

SamplerState MirrorSampler //거울복사
{
    AddressU = MIRROR;
    AddressV = MIRROR;
};

SamplerState ClampSampler //마지막 픽셀로 출력
{
    AddressU = CLAMP;
    AddressV = CLAMP;
};

SamplerState BorderSampler //빈공간 특정색으로 지정해서 출력
{
    AddressU = BORDER;
    AddressV = BORDER;

    BorderColor = float4(0, 0, 1, 1);
};

uint Addres;
float4 PS_Address(VertexOutput input) : SV_Target
{
    if (Addres == 0)  return DiffuseMap.Sample(WarpSampler, input.Uv);
    if (Addres == 1)  return DiffuseMap.Sample(MirrorSampler, input.Uv);
    if (Addres == 2)  return DiffuseMap.Sample(ClampSampler, input.Uv);
    if (Addres == 3)  return DiffuseMap.Sample(BorderSampler, input.Uv);
     
    return DiffuseMap.Sample(PointSampler, input.Uv);
}



technique11 T0
{
    pass P0
    {
        SetVertexShader(CompileShader(vs_5_0, VS()));
        SetPixelShader(CompileShader(ps_5_0, PS_Filter()));
    }

    pass P1
    {
        SetVertexShader(CompileShader(vs_5_0, VS()));
        SetPixelShader(CompileShader(ps_5_0, PS_Address()));
    }
}

---

실행

 

---

Sampler 구조체

여기서 Filter 옵션

 

공통 :

MIN : 축소

MAG : 확대

사용 모드 :

POINT : 인접 픽셀을 복사해서 축소 및 확대 했을때 빈공간을 채움

LINEAR : 인접 픽셀의 선형보간 해서 축소 및 확대 했을때 빈공간을 채움 

 

POINT 방식은 선명한 대식 확대하면 도트형식으로

LINEAR 방식은 부드럽지만 주변 확대하면 흐림 형식으로

 

기본적인 Sampler 구조체 기본값

---

Sampler에서 발달한 기술이 FXAA , SMAA 이고 대각선 처리기법 관련이고 D3D11_FILTER_ANISOTROPIC를 사용

추후 COMPARISON(깊이)를 이용해서 그림자 기법 사용할때 사용