2020_1021 Terrain Edit ( Texture Splatting )

201021_DX3D_TextureSplatting.zip

7.16MB

 

 

1. Texture Editor

#pragma once

class TerrainEditor : public Transform
{
private:
	typedef VertexUVNormalTangentAlpha VertexType;
	//
public:
	class BrushBuffer : public ConstBuffer
	{
	public:
		struct Data
		{
			int type;
			Float3 location;
			float range;
			Float3 color;
		}data;
		//
		BrushBuffer() : ConstBuffer(&data, sizeof(Data))
		{
			data.type = 0;
			data.location = Float3(0, 0, 0);
			data.range = 10.0f;
			data.color = Float3(0.0f, 0.5f, 0.0f);
		}
	};
	//
	struct InputDesc
	{
		UINT index;
		Float3 v0, v1, v2;
	};
	//
	struct OutputDesc
	{
		int picked;
		float u, v, distance;
	};
	////////////////////////////////////
	const float MAX_HEIGHT = 30.0f;
	const float MAX_ALPHA = 1.0f;
	////////////////////////////////////
	Material* material;
	Mesh* mesh;
	////////////////////////////////////
	vector<VertexType> vertices;
	vector<UINT> indices;
	////////////////////////////////////
	UINT width, height;
	////////////////////////////////////
	Texture* heightMap;
	//Texture* alphaMap;
	Texture* secondMap;
	Texture* thirdMap;
	Texture* alphaMaps[2];
	////////////////////////////////////
	ComputeShader* computeShader;
	RayBuffer* rayBuffer;
	StructuredBuffer* structuredBuffer;
	InputDesc* input;
	OutputDesc* output;
	//
	UINT size;
	////////////////////////////////////
	BrushBuffer* brushBuffer;
	////////////////////////////////////
	bool isRaise;
	float adjustValue;
	////////////////////////////////////
	bool isPainting;
	float paintValue;
	int selectMap;
	////////////////////////////////////
	char inputHeightFileName[100];
	char inputAlphaFileName[100];
	////////////////////////////////////
public:
	TerrainEditor(UINT width = 100, UINT height = 100);
	~TerrainEditor();
	////////////////////////////////////
	void Update();
	void Render();
	void PostRender();
	////////////////////////////////////
	bool ComputePicking(OUT Vector3* position);
	////////////////////////////////////
	void AdjustY(Vector3 position);
	void PaintBrush(Vector3 position);
	////////////////////////////////////
	void SaveHeight(wstring heightFile);
	void LoadHeight(wstring heightFile);
	void ResetHeight();
	void SaveAlpha(wstring alphaFile, int selectMap);
	void LoadAlpha(wstring alphaFile, int selectMap);
	void ResetAlpha();
	////////////////////////////////////
private:
	void CreateMesh();
	void CreateNormal();
	void CreateTangent();
	void CreateCompute();
};
////////////////////////////////////////////////////////////////////////
#include "Framework.h"
#include "TerrainEditor.h"

TerrainEditor::TerrainEditor(UINT width, UINT height)
	: width(width), height(height),
	isRaise(true), adjustValue(50.0f),
	heightMap(nullptr),
	inputHeightFileName{}, inputAlphaFileName{},
	structuredBuffer(nullptr), rayBuffer(nullptr), output(nullptr),
	isPainting(true), paintValue(5.0f), selectMap(0),
	secondMap(nullptr), thirdMap(nullptr), alphaMaps{} // alphaMap(nullptr)
{
	material = new Material(L"TerrainSplating");
	material->SetDiffuseMap(L"Textures/Landscape/Dirt2.png");
	//
	//alphaMap = Texture::Add(L"Textures/HeightMaps/AlphaMap.png");
	secondMap = Texture::Add(L"Textures/Landscape/Floor.png");
	thirdMap = Texture::Add(L"Textures/Landscape/Stones.png");
	//
	CreateMesh();
	//
	CreateCompute();
	//
	brushBuffer = new BrushBuffer;
}

TerrainEditor::~TerrainEditor()
{
	delete brushBuffer;
	//
	delete material;
	delete mesh;

	delete rayBuffer;
	delete structuredBuffer;

	delete[] input;
	delete[] output;
}

void TerrainEditor::Update()
{
	if (ImGui::GetIO().WantCaptureMouse == false)
	{
		if (KEY_PRESS(VK_LBUTTON))
		{
			if (isPainting == true)
				PaintBrush(brushBuffer->data.location);
			else
				AdjustY(brushBuffer->data.location);
		}
		if (KEY_UP(VK_LBUTTON))
		{
			CreateNormal();
			CreateTangent();
			mesh->UpdateVertex(vertices.data(), vertices.size());
		}
	}
	//
	UpdateWorld();
}

void TerrainEditor::Render()
{
	mesh->IASet();
	worldBuffer->SetVSBuffer(0);
	brushBuffer->SetPSBuffer(10);
	//
	//if(alphaMap != nullptr)
	//	alphaMap->PSSet(10);
	//
	if(secondMap != nullptr)
		secondMap->PSSet(11);
	//
	if(thirdMap != nullptr)
		thirdMap->PSSet(12);
	//
	material->Set();
	//
	DC->DrawIndexed((UINT)indices.size(), 0, 0);
}

void TerrainEditor::PostRender()
{
	/* Debug */
	//if(ImGui::IsWindowFocused())
	//
	Vector3 temp{};
	ComputePicking(&temp);
	brushBuffer->data.location = temp;
	//
	ImGui::Spacing();
	ImGui::Text("[Terrain Editor]");
	ImGui::SliderInt("Type",
		&brushBuffer->data.type, 0, 1);
	ImGui::SliderFloat("Range",
		&brushBuffer->data.range, 1.0f, 50.0f);
	ImGui::ColorEdit3("Color",
		(float*)&brushBuffer->data.color);
	ImGui::Checkbox("Raise", &isRaise);
	//
	ImGui::Checkbox("Painting", &isPainting);
	ImGui::InputInt("SelectMap", &selectMap);
	// Save & Load HeightMap
	ImGui::InputText("HeightFileName", inputHeightFileName, 100);
	wstring heightFile = ToWString(inputHeightFileName);
	if (ImGui::Button("SaveHeight", { 128.0f, 32.0f }))
		SaveHeight(heightFile);
	if (ImGui::Button("LoadHeight", { 128.0f, 32.0f }))
	{
		LoadHeight(heightFile);
		//
		CreateNormal();
		CreateTangent();
		mesh->UpdateVertex(vertices.data(), vertices.size());
	}
	if (ImGui::Button("ResetHeight", { 128.0f, 32.0f }))
		ResetHeight();
	// Save & Load AlphaMap
	ImGui::InputText("AlphaFileName", inputAlphaFileName, 100);
	wstring alphaFile = ToWString(inputAlphaFileName);
	if (ImGui::Button("SaveAlpha", { 128.0f, 32.0f }))
		SaveAlpha(alphaFile, selectMap);
	if (ImGui::Button("LoadAlpha", { 128.0f, 32.0f }))
	{
		LoadAlpha(alphaFile, selectMap);
		//
		mesh->UpdateVertex(vertices.data(), vertices.size());
	}
	if (ImGui::Button("ResetAlpha", { 128.0f, 32.0f }))
		ResetAlpha();
}

bool TerrainEditor::ComputePicking(OUT Vector3* position)
{
	Ray ray = CAMERA->ScreenPointToRay(MOUSEPOS);

	rayBuffer->data.position = ray.position;
	rayBuffer->data.direction = ray.direction;
	rayBuffer->data.size = size;
	//
	computeShader->Set();
	rayBuffer->SetCSBuffer(0);
	//
	DC->CSSetShaderResources(0, 1, &structuredBuffer->GetSRV());
	DC->CSSetUnorderedAccessViews(0, 1, &structuredBuffer->GetUAV(), nullptr);

	UINT x = ceil((float)size / 1024.0f);

	DC->Dispatch(x, 1, 1);

	structuredBuffer->Copy(output, sizeof(OutputDesc) * size);

	float minDistance = FLT_MAX;
	int minIndex = -1;

	for (UINT i = 0; i < size; i++)
	{
		OutputDesc temp = output[i];
		if (temp.picked)
		{
			if (minDistance > temp.distance)
			{
				minDistance = temp.distance;
				minIndex = i;
			}
		}
	}

	if (minIndex >= 0)
	{
		*position = ray.position + ray.direction * minDistance;
		return true;
	}

	return false;
}

void TerrainEditor::AdjustY(Vector3 position)
{
	switch (brushBuffer->data.type)
	{
	case 0:
	{
		for (VertexType& vertex : vertices)
		{
			Vector3 p1 = Vector3(vertex.position.x, 0, vertex.position.z);
			Vector3 p2 = Vector3(position.x, 0, position.z);
			//
			float distance = (p2 - p1).Length();
			//
			float cosValue = cos(XM_PIDIV2 * distance / brushBuffer->data.range);
			float temp = adjustValue * max(0, cosValue);
			//
			if (distance <= brushBuffer->data.range)
			{
				if (isRaise)
					vertex.position.y += temp * DELTA;
				else
					vertex.position.y -= temp * DELTA;
				//
				if (vertex.position.y < 0)
					vertex.position.y = 0;
				else if (vertex.position.y > MAX_HEIGHT)
					vertex.position.y = MAX_HEIGHT;
			}
		}
	}
	break;
	case 1:
	{
		for (VertexType& vertex : vertices)
		{
			Vector3 p1 = Vector3(vertex.position.x, 0, vertex.position.z);
			Vector3 p2 = Vector3(position.x, 0, position.z);
			//
			float distX = abs(p2.x - p1.x);
			float distZ = abs(p2.z - p1.z);
			//
			if (distX <= brushBuffer->data.range
				&& distZ <= brushBuffer->data.range)
			{
				if (isRaise)
					vertex.position.y += adjustValue * DELTA;
				else
					vertex.position.y -= adjustValue * DELTA;
			}
		}
	}
	break;
	default:
		break;
	}
	//
	mesh->UpdateVertex(vertices.data(), vertices.size());
}

void TerrainEditor::PaintBrush(Vector3 position)
{
	switch (brushBuffer->data.type)
	{
	case 0:
	{
		for (VertexType& vertex : vertices)
		{
			Vector3 p1 = Vector3(vertex.position.x, 0, vertex.position.z);
			Vector3 p2 = Vector3(position.x, 0, position.z);
			//
			float distance = (p2 - p1).Length();
			//
			float cosValue = cos(XM_PIDIV2 * distance / brushBuffer->data.range);
			float temp = paintValue * max(0, cosValue);
			//
			if (distance <= brushBuffer->data.range)
			{
				if (isRaise)
					vertex.alpha[selectMap] += temp * DELTA;
				else
					vertex.alpha[selectMap] -= temp * DELTA;
				//
				vertex.alpha[selectMap] = Saturate(vertex.alpha[selectMap]);
			}
		}
	}
	break;
	case 1:
	{
		for (VertexType& vertex : vertices)
		{
			Vector3 p1 = Vector3(vertex.position.x, 0, vertex.position.z);
			Vector3 p2 = Vector3(position.x, 0, position.z);
			//
			float distX = abs(p2.x - p1.x);
			float distZ = abs(p2.z - p1.z);
			//
			if (distX <= brushBuffer->data.range
				&& distZ <= brushBuffer->data.range)
			{
				if (isRaise)
					vertex.alpha[selectMap] += paintValue * DELTA;
				else
					vertex.alpha[selectMap] -= paintValue * DELTA;
				//
				vertex.alpha[selectMap] = Saturate(vertex.alpha[selectMap]);
			}
		}
	}
	break;
	}
	//
	mesh->UpdateVertex(vertices.data(), vertices.size());
}

void TerrainEditor::SaveHeight(wstring heightFile)
{
	UINT size = width * height * 4;
	/* Create Height Map File */
	{
		uint8_t* pixels = new uint8_t[size];
		//
		for (UINT i = 0; i < size / 4; ++i)
		{
			float y = vertices[i].position.y;
			uint8_t height = (y * 255.0f) / MAX_HEIGHT;
			pixels[(i * 4) + 0] = height;
			pixels[(i * 4) + 1] = height;
			pixels[(i * 4) + 2] = height;
			pixels[(i * 4) + 3] = 255;
		}
		//
		Image image;
		image.width = width;
		image.height = height;
		image.pixels = pixels;
		image.format = DXGI_FORMAT_R8G8B8A8_UNORM;
		image.rowPitch = image.width * 4;
		image.slicePitch = size;
		//
		wstring fileName =
			L"Textures/HeightMaps/"
			+ heightFile
			+ L".png";
		//
		SaveToWICFile(image, WIC_FLAGS_FORCE_RGB,
			GetWICCodec(WIC_CODEC_PNG), fileName.c_str());
		//
		delete[] pixels;
	}
	/* Create Binary File
	// Create Filesystem
	HANDLE file;
	DWORD write; // unsigned long
	file = CreateFile(L"MapFiles/mapData.map", GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
	{
		int count = vertices.size();
		V(WriteFile(file, &count, sizeof(int), &write, nullptr));
		//
		Vector3 data{};
		for (int i = 0; i < count; ++i)
		{
			data = vertices[i].position;
			V(WriteFile(file, &data, sizeof(Vector3), &write, nullptr));
		}
	}
	// Save End
	CloseHandle(file);
	*/
}
void TerrainEditor::LoadHeight(wstring heightFile)
{
	delete mesh;
	//
	wstring fileName =
		L"Textures/HeightMaps/"
		+ heightFile
		+ L".png";
	//
	heightMap = Texture::Load(fileName);
	//
	CreateMesh();
	CreateCompute();

	/* Create Binary File
	// Create File System
	HANDLE file;
	DWORD read; // unsigned long
	file = CreateFile(L"MapFiles/mapData.map", GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
	{
		int count{};
		V(ReadFile(file, &count, sizeof(int), &read, nullptr));
		//
		Vector3 data{};
		for (int i = 0; i < count; ++i)
		{
			V(ReadFile(file, &data, sizeof(Vector3), &read, nullptr));
			vertices[i].position = data;
		}
	}
	// Load End
	CloseHandle(file);
	*/
}

void TerrainEditor::ResetHeight()
{
	for (auto& vertex : vertices)
		vertex.position.y = 0;
	//
	CreateNormal();
	CreateTangent();
	mesh->UpdateVertex(vertices.data(), vertices.size());
}

void TerrainEditor::SaveAlpha(wstring alphaFile, int selectMap)
{
	UINT size = width * height * 4;
	/* Create Alpha Map File */
	{
		uint8_t* pixels = new uint8_t[size];
		//
		for (UINT i = 0; i < size / 4; ++i)
		{
			float a = vertices[i].alpha[selectMap];
			uint8_t alpha = (a * 255.0f) / MAX_ALPHA;
			pixels[(i * 4) + 0] = 0;
			pixels[(i * 4) + 1] = 0;
			pixels[(i * 4) + 2] = 0;
			pixels[(i * 4) + 3] = 255;
			//
			pixels[(i * 4) + selectMap] = alpha;
		}
		//
		Image image;
		image.width = width;
		image.height = height;
		image.pixels = pixels;
		image.format = DXGI_FORMAT_R8G8B8A8_UNORM;
		image.rowPitch = image.width * 4;
		image.slicePitch = size;
		//
		wstring fileName =
			L"Textures/AlphaMaps/"
			+ alphaFile
			+ L"_"
			+ to_wstring(selectMap)
			+ L".png";
		SaveToWICFile(image, WIC_FLAGS_FORCE_RGB,
			GetWICCodec(WIC_CODEC_PNG), fileName.c_str());
		//
		delete[] pixels;
	}
}

void TerrainEditor::LoadAlpha(wstring alphaFile, int selectMap)
{
	wstring fileName =
		L"Textures/AlphaMaps/"
		+ alphaFile
		+ L"_"
		+ to_wstring(selectMap)
		+ L".png";
	//
	alphaMaps[selectMap] = Texture::Load(fileName);
	//
	vector<Float4> pixels = alphaMaps[selectMap]->ReadPixels();
	//
	for (UINT z = 0; z < height; z++)
	{
		for (UINT x = 0; x < width; x++)
		{
			UINT index = width * z + x;
			//
			switch (selectMap)
			{
			case 0:
				vertices[index].alpha[selectMap] = pixels[index].x;
				break;
			case 1:
				vertices[index].alpha[selectMap] = pixels[index].y;
				break;
			default:
				break;
			}
		}
	}
}

void TerrainEditor::ResetAlpha()
{
	for (auto& vertex : vertices)
	{
		vertex.alpha[0] = 0;
		vertex.alpha[1] = 0;
	}
	//
	mesh->UpdateVertex(vertices.data(), vertices.size());
}

void TerrainEditor::CreateMesh()
{
	vertices.clear();
	indices.clear();
	//
	vector<Float4> pixels{};
	if (heightMap != nullptr)
	{
		width = heightMap->Width();
		height = heightMap->Height();
		//Vertices
		pixels = heightMap->ReadPixels();
	}
	//
	for (UINT z = 0; z < height; z++)
	{
		for (UINT x = 0; x < width; x++)
		{
			VertexType vertex;
			vertex.position = Float3((float)x, 0.0f, (float)z);
			vertex.uv = Float2(x / (float)width, 1.0f - z / (float)height);

			UINT index = width * z + x;
			//
			if (index < pixels.size())
				vertex.position.y += pixels[index].x * MAX_HEIGHT;
			//
			vertices.emplace_back(vertex);
		}
	}

	//Indices
	for (UINT z = 0; z < height - 1; z++)
	{
		for (UINT x = 0; x < width - 1; x++)
		{
			indices.emplace_back(width * z + x);//0
			indices.emplace_back(width * (z + 1) + x);//1
			indices.emplace_back(width * (z + 1) + x + 1);//2

			indices.emplace_back(width * z + x);//0
			indices.emplace_back(width * (z + 1) + x + 1);//2
			indices.emplace_back(width * z + x + 1);//3
		}
	}

	size = indices.size() / 3;

	input = new InputDesc[size];
	for (UINT i = 0; i < size; i++)
	{
		UINT index0 = indices[i * 3 + 0];
		UINT index1 = indices[i * 3 + 1];
		UINT index2 = indices[i * 3 + 2];

		input[i].v0 = vertices[index0].position;
		input[i].v1 = vertices[index1].position;
		input[i].v2 = vertices[index2].position;

		input[i].index = i;
	}

	CreateNormal();
	CreateTangent();

	mesh = new Mesh(vertices.data(), sizeof(VertexType), (UINT)vertices.size(),
		indices.data(), (UINT)indices.size());
}

void TerrainEditor::CreateNormal()
{
	for (UINT i = 0; i < indices.size() / 3; i++)
	{
		UINT index0 = indices[i * 3 + 0];
		UINT index1 = indices[i * 3 + 1];
		UINT index2 = indices[i * 3 + 2];

		Vector3 v0 = vertices[index0].position;
		Vector3 v1 = vertices[index1].position;
		Vector3 v2 = vertices[index2].position;

		Vector3 A = v1 - v0;
		Vector3 B = v2 - v0;

		Vector3 normal = Vector3::Cross(A, B).Normal();

		vertices[index0].normal = normal + vertices[index0].normal;
		vertices[index1].normal = normal + vertices[index1].normal;
		vertices[index2].normal = normal + vertices[index2].normal;
	}

	for (VertexType& vertex : vertices)
		vertex.normal = Vector3(vertex.normal).Normal();
}

void TerrainEditor::CreateTangent()
{
	for (UINT i = 0; i < indices.size() / 3; i++)
	{
		UINT index0 = indices[i * 3 + 0];
		UINT index1 = indices[i * 3 + 1];
		UINT index2 = indices[i * 3 + 2];

		VertexType vertex0 = vertices[index0];
		VertexType vertex1 = vertices[index1];
		VertexType vertex2 = vertices[index2];

		Vector3 p0 = vertex0.position;
		Vector3 p1 = vertex1.position;
		Vector3 p2 = vertex2.position;

		Float2 uv0 = vertex0.uv;
		Float2 uv1 = vertex1.uv;
		Float2 uv2 = vertex2.uv;

		Vector3 e0 = p1 - p0;
		Vector3 e1 = p2 - p0;

		float u0 = uv1.x - uv0.x;
		float u1 = uv2.x - uv0.x;
		float v0 = uv1.y - uv0.y;
		float v1 = uv2.y - uv0.y;

		Vector3 tangent = (v1 * e0 - v0 * e1);

		vertices[index0].tangent = tangent + vertices[index0].tangent;
		vertices[index1].tangent = tangent + vertices[index1].tangent;
		vertices[index2].tangent = tangent + vertices[index2].tangent;
	}

	for (VertexType& vertex : vertices)
	{
		Vector3 t = vertex.tangent;
		Vector3 n = vertex.normal;

		Vector3 temp = (t - n * Vector3::Dot(n, t)).Normal();

		vertex.tangent = temp;
	}
}

void TerrainEditor::CreateCompute()
{
	computeShader = Shader::AddCS(L"ComputePicking");
	//
	if (structuredBuffer != nullptr)
		delete structuredBuffer;
	//
	structuredBuffer
		= new StructuredBuffer(input, sizeof(InputDesc), size,
			sizeof(OutputDesc), size);
	//
	if (rayBuffer == nullptr)
		rayBuffer = new RayBuffer;
	//
	if (output != nullptr)
		delete[] output;
	output = new OutputDesc[size];
}

 

2. Terrain Splating Shader

# Header.hlsli

//VertexShaderBuffer
cbuffer World : register(b0)
{
    matrix world;
}

cbuffer View : register(b1)
{
    matrix view;
    matrix invView;
}

cbuffer Projection : register(b2)
{
    matrix projection;
}

//PixelShaderBuffer
cbuffer Light : register(b0)
{
    float3 lightDirection;
}

cbuffer Material : register(b1)
{
    float3 mDiffuse;
    float padding1;
    
    float3 mSpecular;
    float padding2;
    
    float3 mAmbient;
    float padding3;
    
    float shininess;
    
    int hasDiffuseMap;
    int hasSpecularMap;
    int hasNormalMap;
}

SamplerState samp : register(s0);

Texture2D diffuseMap : register(t0);
Texture2D specularMap : register(t1);
Texture2D normalMap : register(t2);

//VertexLayouts
struct Vertex
{
    float4 pos : Position;    
};

struct VertexUV
{
    float4 pos : Position;
    float2 uv : UV;    
};

struct VertexUVNormal
{
    float4 pos : Position;
    float2 uv : UV;
    float3 normal : Normal;
};

struct VertexUVNormalTangent
{
    float4 pos : Position;
    float2 uv : UV;
    float3 normal : Normal;
    float3 tangent : Tangent;
};
struct VertexUVNormalTangentAlpha
{
    float4 pos : Position;
    float2 uv : UV;
    float3 normal : Normal;
    float3 tangent : Tangent;
    float4 alpha : Alpha;
};

# TerrainSplatting Shader

#include "Header.hlsli"

cbuffer Brush : register(b10)
{
    int type; // 원형, 사각형
    float3 location;
    float range;
    float3 color;
}

struct PixelInput
{
    float4 pos : SV_Position;
    float2 uv : UV;
    float3 normal : Normal;
    float3 tangent : Tangent;
    float3 binormal : Binormal;
    float3 viewDir : ViewDir;
    float3 worldPos : Position;
    float4 alpha : Alpha;
};

float3 BrushColor(float3 pos)
{
    if (type == 0)
    {
        float x = pos.x - location.x;
        float z = pos.z - location.z;
        //
        float distance = sqrt(x * x + z * z);
        //
        if (distance <= range)
            return color;
    }
    else if (type == 1)
    {
        float x = pos.x - location.x;
        float z = pos.z - location.z;
        //
        float distX = abs(x);
        float distZ = abs(z);
        //
        if (distX <= range && distZ <= range)
            return color;
    }
    //
    return float3(0, 0, 0);
}

PixelInput VS(VertexUVNormalTangentAlpha input)
{
    PixelInput output;
    //
    output.pos = mul(input.pos, world);
    //
    float3 camPos = invView._41_42_43;
    output.viewDir = normalize(output.pos.xyz - camPos);
    //
    output.worldPos = output.pos.xyz;
    //
    output.pos = mul(output.pos, view);
    output.pos = mul(output.pos, projection);
    //
    output.normal = mul(input.normal, (float3x3) world);
    output.tangent = mul(input.tangent, (float3x3) world);
    output.binormal = cross(output.normal, output.tangent);
    
    output.uv = input.uv;
    output.alpha = input.alpha;
    
    return output;
}
//
//Texture2D alphaMap : register(t10);
Texture2D secondMap : register(t11);
Texture2D thirdMap : register(t12);
//
float4 PS(PixelInput input) : SV_Target
{
    float4 albedo = float4(1, 1, 1, 1);
    if (hasDiffuseMap)
        albedo = diffuseMap.Sample(samp, input.uv);
    //
    //float4 alpha = alphaMap.Sample(samp, input.uv);
    float4 second = secondMap.Sample(samp, input.uv);
    float4 third = thirdMap.Sample(samp, input.uv);
    //
    albedo = lerp(albedo, second, input.alpha.r);
    albedo = lerp(albedo, third, input.alpha.g);
    //
    float3 light = normalize(lightDirection);
    
    float3 T = normalize(input.tangent);
    float3 B = normalize(input.binormal);
    float3 N = normalize(input.normal);
    
    float3 normal = N;
    
    if (hasNormalMap)
    {
        float4 normalMapping = normalMap.Sample(samp, input.uv);
    
        float3x3 TBN = float3x3(T, B, N);
        normal = normalMapping * 2.0f - 1.0f;
        normal = normalize(mul(normal, TBN));
    }
    
    float3 viewDir = normalize(input.viewDir);
    
    float diffuseIntensity = saturate(dot(normal, -light));
    
    float3 specular = 0;
    if (diffuseIntensity > 0)
    {
        /* phong Shading */
        //float3 reflection = normalize(reflect(light, normal));
        //specular = saturate(dot(reflection, -viewDir));

        /* Blinn - Phong Shading */
        float3 halfWay = normalize(viewDir + light);
        specular = saturate(dot(-halfWay, normal));
        
        float3 specularIntensity = float3(1, 1, 1);
        if (hasSpecularMap)
            specularIntensity = specularMap.Sample(samp, input.uv).rgb;
        
        specular = pow(specular, shininess) * specularIntensity;
    }
    
    float3 diffuse = albedo.rgb * diffuseIntensity * mDiffuse;
    specular *= mSpecular;
    float3 ambient = albedo.rgb * mAmbient;
    //
    float3 brushColor = BrushColor(input.worldPos);
    
    return float4(diffuse + specular + ambient + brushColor,
    1.0f);
}