[DirectX11] 018 Texture Sampler

matrix World;
matrix View;
matrix Projection;
Texture2D Map;
 
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 Samp;
float4 PS(VertexOutput input) : SV_Target
{
    return Map.Sample(Samp, input.Uv);
}
 
uint Filter;
 
SamplerState Sampler_Filter_Point
{
    Filter = MIN_MAG_MIP_POINT;
};
 
SamplerState Sampler_Filter_Linear
{
    Filter = MIN_MAG_MIP_POINT;
};
 
float4 PS_Filter(VertexOutput input) : SV_Target
{
    if (Filter == 0)
        return Map.Sample(Sampler_Filter_Point, input.Uv);
    
    if (Filter == 1)
        return Map.Sample(Sampler_Filter_Linear, input.Uv);
 
    return Map.Sample(Samp, input.Uv);
}
 
uint Address;
 
SamplerState Sampler_Address_Wrap
{
    AddressU = Wrap;
    AddressV = Wrap;
};
 
SamplerState Sampler_Address_Mirror
{
    AddressU = Mirror;
    AddressV = Mirror;
};
 
SamplerState Sampler_Address_Clamp
{
    AddressU = Clamp;
    AddressV = Clamp;
};
 
SamplerState Sampler_Address_Border
{
    AddressU = Border;
    AddressV = Border;
 
    BorderColor = float4(0, 0, 1, 1);
};
 
float4 PS_Address(VertexOutput input) : SV_Target
{
    if (Address == 0)
        return Map.Sample(Sampler_Address_Wrap, input.Uv);
    
    if (Address == 1)
        return Map.Sample(Sampler_Address_Mirror, input.Uv);
 
    if (Address == 2)
        return Map.Sample(Sampler_Address_Clamp, input.Uv);
    
    if (Address == 3)
        return Map.Sample(Sampler_Address_Border, input.Uv);
 
    return Map.Sample(Samp, input.Uv);
}
 
technique11 T0
{
    pass P0
    {
        SetVertexShader(CompileShader(vs_5_0, VS()));
        SetPixelShader(CompileShader(ps_5_0, PS()));
    }
 
    pass P1
    {
        SetVertexShader(CompileShader(vs_5_0, VS()));
        SetPixelShader(CompileShader(ps_5_0, PS_Filter()));
    }
 
    pass P2
    {
        SetVertexShader(CompileShader(vs_5_0, VS()));
        SetPixelShader(CompileShader(ps_5_0, PS_Address()));
    }
}

#pragma once
#include "Systems/IExecute.h"
 
class TextureSamplerDemo : public IExecute
{
public:
	virtual void Initialize() override;
	virtual void Ready() 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:
	Shader* shader;
 
	VertexTexture vertices[6];
	ID3D11Buffer* vertexBuffer;
 
	UINT indices[6] = { 0, 1, 2, 2, 1, 3 };
	ID3D11Buffer* indexBuffer;
 
	Matrix world;
	Texture* texture = NULL;
};

#include "stdafx.h"
#include "TextureSamplerDemo.h"
 
void TextureSamplerDemo::Initialize()
{
	Context::Get()->GetCamera()->Position(0, 0, -0.5f);
 
	shader = new Shader(L"18_TextureSampler.fx");
	
	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, 1);
	vertices[1].Uv = Vector2(0, 0);
	vertices[2].Uv = Vector2(1, 1);
	vertices[3].Uv = Vector2(1, 0);
*/
	/*vertices[0].Uv = Vector2(0.0f, 1.0f);
	vertices[1].Uv = Vector2(0.0f, 0.0f);
	vertices[2].Uv = Vector2(0.5f, 1.0f);
	vertices[3].Uv = Vector2(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 Vertex Buffer
	{
		D3D11_BUFFER_DESC desc;
		ZeroMemory(&desc, sizeof(D3D11_BUFFER_DESC));
		desc.ByteWidth = sizeof(VertexTexture) * 4;
		desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
 
		D3D11_SUBRESOURCE_DATA subResource = { 0 };
		subResource.pSysMem = vertices;
 
		Check(D3D::GetDevice()->CreateBuffer(&desc, &subResource, &vertexBuffer));
	}
 
	//Create Index Buffer
	{
		D3D11_BUFFER_DESC desc;
		ZeroMemory(&desc, sizeof(D3D11_BUFFER_DESC));
		desc.ByteWidth = sizeof(UINT) * 6;
		desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
 
		D3D11_SUBRESOURCE_DATA subResource = { 0 };
		subResource.pSysMem = indices;
 
		Check(D3D::GetDevice()->CreateBuffer(&desc, &subResource, &indexBuffer));
	}
 
 
	D3DXMatrixIdentity(&world);
 
	texture = new Texture(L"Box.png");
}
 
void TextureSamplerDemo::Destroy()
{
	SafeDelete(shader);
 
	SafeRelease(vertexBuffer);
	SafeRelease(indexBuffer);
 
	SafeDelete(texture);
}
 
void TextureSamplerDemo::Update()
{
	static UINT filter = 0;
	ImGui::InputInt("Filter", (int*)&filter);
	filter %= 2;
 
	shader->AsScalar("Filter")->SetInt(filter);
 
 
	static UINT address = 0;
	ImGui::InputInt("Address", (int*)&address);
	address %= 4;
 
	shader->AsScalar("Address")->SetInt(address);
}
 
void TextureSamplerDemo::Render()
{
	shader->AsMatrix("World")->SetMatrix(world);
	shader->AsMatrix("View")->SetMatrix(Context::Get()->View());
	shader->AsMatrix("Projection")->SetMatrix(Context::Get()->Projection());
 
	shader->AsSRV("Map")->SetResource(texture->SRV());
 
 
	UINT stride = sizeof(VertexTexture);
	UINT offset = 0;
 
	D3D::GetDC()->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
	D3D::GetDC()->IASetIndexBuffer(indexBuffer, DXGI_FORMAT_R32_UINT, 0);
	D3D::GetDC()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 
	//shader->DrawIndexed(0, 0, 6);
	//shader->DrawIndexed(0, 1, 6); //Filter
	shader->DrawIndexed(0, 2, 6);  //Address
}