● 언리얼 엔진으로 만든 뮤직 비쥬얼라이저

※ 지극히 개인적인 일상 메모와 기록을 위한 곳입니다.

● DirectXTex 사용

※ 지극히 개인적인 일상 메모와 기록을 위한 곳입니다.

깃허브에 공개된 소스를 다운 받아 이용한다

github.com/microsoft/directxtex 접속하여 코드파일을 ZIP으로 다운로드 한다.

압축을 풀고 DirectXTex_Desktop_2022.sln 솔루션 파일을 비주얼 스튜디오로 열고 빌드를 해준다.

빌드가 잘 끝나면 위의 폴더에서 DirectXTex.lib 파일을 이용을 할 건데..

 

여기에 복사를 해주고

헤더 파일을 복사해서..

Include 폴더를 만들어서 복사해 주었다

엔진 속성에서 DLL과 LIB 파일을 불어올 파일을 설정해주고..

폴더 경로 설정도 해준다

속성에서 C/C++은 헤더 파일을 연결, 포함해줄 디렉터리를 설정해 준다

C/C++ 설정은 헤더파일, 링커는 dll. lib 연결 설정.

프로젝트에 포함 시킬 때는 마우스로 파일을 끌어다가 비주얼 스튜디오 폴더 트리 창에 드래그&드롭도 가능하다.

텍스쳐 파일을 이용하기 위한 ID3D11ShaderResourceView 이용을 할 수 있다.

코드 예제.

//by JSHong CodeBlock//
#include "Core.h"
#include "TextureLoader.h"
#include <DirectXTex.h>
#include <Utility/STLException.h>

namespace STL
{
	std::unordered_map<std::wstring, ID3D11ShaderResourceView*> TextureLoader::textureMap;

	ID3D11ShaderResourceView* TextureLoader::CreateShaderResourceView(ID3D11Device* device, const std::wstring& filename)
	{
		auto search = textureMap.find(filename);
		if (search != textureMap.end())
		{
			return search->second;
		}

		std::wstring extension = filename.substr(filename.find_last_of(TEXT(".")) + 1);
		std::transform(extension.begin(), extension.end(), extension.begin(), tolower);

		static auto basePath = std::filesystem::current_path().parent_path();

		auto finalPath = basePath;
		finalPath /= "Content\\Textures";
		finalPath /= filename;

		DirectX::ScratchImage image;
		HRESULT hr = E_FAIL;
		if (extension == TEXT("tga") || extension == TEXT("targa"))
		{
			hr = DirectX::LoadFromTGAFile(
				finalPath.c_str(),
				nullptr,
				image
			);
		}
		else
		{
			hr = DirectX::LoadFromWICFile(
				finalPath.c_str(),
				DirectX::WIC_FLAGS_NONE,
				nullptr,
				image
			);
		}

		ThrowIfFailed(hr, "Failed to load scratch image.");

		ID3D11Texture2D* texture = nullptr;
		hr = DirectX::CreateTexture(
			device,
			image.GetImages(),
			image.GetImageCount(),
			image.GetMetadata(),
			reinterpret_cast<ID3D11Resource**>(&texture)
		);

		ThrowIfFailed(hr, "Failed to create texture.");

		D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
		memset(&srvDesc, 0, sizeof(srvDesc));
		srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
		srvDesc.Texture2D.MipLevels = 1;
		srvDesc.Format = image.GetMetadata().format;

		ID3D11ShaderResourceView* shaderResourceView = nullptr;
		hr = device->CreateShaderResourceView(
			texture,
			&srvDesc,
			&shaderResourceView
		);

		SafeRelease(texture);
		ThrowIfFailed(hr, "Failed to shader resource view.");

		textureMap.insert({ filename, shaderResourceView });

		return shaderResourceView;
	}

	void TextureLoader::Release()
	{
		for (auto pair : textureMap)
		{
			SafeRelease(pair.second);
		}
	}
}

# 셰이더 프로그래밍 입문 책 (http://www.yes24.com/Product/Goods/7366949)

● 깃허브 공부해보기

※ 지극히 개인적인 일상 메모와 기록을 위한 곳입니다.

# TDD 테스트 주도 개발

# DDD 도메인 주도 개발(설계)

    - 예전에 인기였다가 사장되다가 다시 떠오르는 방식

# 깃허브 무료 강좌 (https://www.inflearn.com/course/30%EB%B6%84-%EC%8B%9C%EC%A6%8C4-%EA%B9%83%ED%97%88%EB%B8%8C)

#한빛 전자책 https://www.hanbit.co.kr/realtime/

● 깃허브 첫 사용

※ 지극히 개인적인 일상 메모와 기록을 위한 곳입니다.

# MS의 COM구조는 멀티 플랫폼에서 통일화를 위해서 만들어진 것.

# 숙제 Effective Modern C++ 항목 2 (매주 금요일 발표)

# GitHub 레포지터리 설정 및 동기화

    - GitHub Desktop 설치 및 설정

    - 프로젝트 관리

    - .gitignore 파일 수정

● 7월 25일 월요일

※ 지극히 개인적인 일상 메모와 기록을 위한 곳입니다.

# 언리얼 빌드 툴 (https://docs.unrealengine.com/4.27/ko/ProductionPipelines/BuildTools/)

    - 빌드 툴 공부해서 오브젝트 만들어 볼 수 있음

# c++ unicode (텍스트 인코딩)

https://www.youtube.com/watch?v=tOHnXt3Ycfo

#비쥬얼 스튜디오 코드 (에디터) 사용해 볼까?

https://code.visualstudio.com/

# 솔루션 설정

    - 'STL_RenderEngineV2'이란 이름으로 솔루션 생성을 해주고

    - 'Game'과 'Engine'이란 이름으로 프로젝트 생성을 해주었다.

    - Game 및 Engine 프로젝트 속성에서 [구성 속성]-[일반] 속성에서 '출력 디렉터리'와 '중간 디렉터리' 설정을 해주었다

    - Engine 프로젝트 속성에서는 [일반]-[구성 형식] 에서 '실행파일'을 '동적 라이브러리'로 변경해준다

    - Engine 프로젝트 속성에서 [구성속성]-[C/C++]-[전처리기] 전처리기 정의에 ENIGNE_BUILD_DLL;를 추가해준다

    - Game이란 프로젝트와 Engine이란 프로젝트를 만들었다

    - Engine에는 Source폴더를 만들고 Core 폴더와 Device 폴더를 만들었다 (이때 필터가 아니라 실제 로컬 폴더를 생성해야 함 주의!)

    - Core에는 Core.cpp 와 Core.h 코드를 생성하고

    - Device에는 Window.cpp와 Window.h 코드를 생성하였다

    - 이때 Device 우클릭 후 클래스 추가로 'Widnows'를 입력하여 생성하고

    - Windows.cpp 파일과 Windows.h 파일은 마우스로 끌어다가 Device 폴더로 옮겨주었다

    - Lib 연동을 위해 '설정'을 해주고

    - Game 속성에서는 참조 추가를 'Engine'으로 해주었다

    - Game 속성 [링크]에서 추가 종속성 설정을 하여 Engine.lib를 명시해주었다

    - Game 속성 [일반]-[추가 포함 디렉토리]에서 '$(SolutionDir)Engine\Source\'를 명시해주었다

# Engine.Lib 파일 구조

    - LoadLibrary("MyDLL") DLL을 불러온다

원래 따로 빌드 해야 하지만 참조 설정을 해주면 자동으로 Engine 빌드 다시 해주고 Game 빌드를 해준다 (자동화)

결과

빌드를 2개 성공했다는 메시지가 나온다!

가끔 실제 오류는 아니지만 'warning'이 귀찮을 때가 있다. 이때 경고 메세지를 꺼준다. (ㅋㅋㅋ)

외부에서 작성된 코드를 프로젝트에 추가할때 마우스로 끌어다 놓아도 되지만 추가 [기존 항목] 기능을 이용하여 파일을 찾아 import를 하는게 안전(!)하다.

허무하지만... 어쨌든 창 하나 달랑 띄우기 성공 ㅠㅠ

# 숙제 '이득우의 게임 수학 블로그' 16번까지 읽어보기

● 비주얼 스튜디오 프로젝트 빌드 설정

※ 지극히 개인적인 일상 메모와 기록을 위한 곳입니다.

 

배치 파일로 만들어서 링커의 역할을 대신 해준다

//빌드 전 이벤트

not exist "$(OutDir)..\Application" mkdir "$(OutDir)..\Application"
if not exist "$(SolutionDir)Lib\Engine\$(Platform)\$(Configuration)" mkdir "$(SolutionDir)Lib\Engine\$(Platform)\$(Configuration)"

//빌드 후 이벤트
copy "$(OutDir)Engine.dll" "$(Outdir)..\Application\"
copy "$(OutDir)Engine.lib" "$(SolutionDir)Lib\Engine\$(Platform)\$(Configuration)\"



Engine.vcxproj 파일(xml)을 열어서 메모장에서 수정해줘도 된다.

● 비주얼 스튜디오 알수 없는 에러 날때?

※ 지극히 개인적인 일상 메모와 기록을 위한 곳입니다.

Application 

    - Pixelshder.hlsl 만들고

    - VertexShader.hlsl 만들고

Engine

    - Test.h 만들고

    - Test.cpp 만들고

!!!!!! VIsual Studio에서 Path 설정시 스페이스 인식 오류난다!!! 제길!!!!!!!!

$(SolutionDir)Engine\;$(SolutionDir)Engine\Source\;$(VC_IncludePath);$(WindowsSDK_IncludePath);

;뒤에 한칸 띄면 뒷 부분 인식 못함 ㅋㅋ

# UE 데이터 스미스 (플러그인)

    - 언리얼이 기본적으로 FBX만 지원하지만 데이터스미스를 이용하여 다양한 포맷도 지원 가능하다.

# 비쥬얼 스튜디오 2019, 2022 다 설치 돼서 사용하다가 이상하게 자꾸 오류가 나길래.. 혹시나 해서 2019를 삭제하니까 해결이 되었다

    - 구문 해석 실시간 잘 안되는 현상

    - 이상하게 설정 오류가 나서 include, link가 잘 안돼서 오류 나기도 함

    - 2019 제거하고 2022 하나만 사용하니 깔끔하게 해결이 됨 ㅋㅋㅋ

● 유튜브 비디오 챕터 정보를 갖고 올 수 있을까?

※ 지극히 개인적인 일상 메모와 기록을 위한 곳입니다.

const axios = require('axios').default; // You have to install axios (npm install axios) in order to use this code
const youtubeApiKey = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'; // Your YouTube API Key here

// Function for filtering array elements which don't contain a timestamp
const notText = (array) => {
    const regexTimePattern = /\d:\d/;
    for (let i = 0; i < array.length; i++) {
        let result = regexTimePattern.exec(array[i]);
        if (result === null) {
            array[i] = "";
        }
    }
}

const main = async (videoId) => {
    const videoDataResponse = await axios.get(
        `https://youtube.googleapis.com/youtube/v3/videos?part=snippet&id=${videoId}&key=${youtubeApiKey}`,
        { headers: { 'Accept': 'application/json' } }
    );
    const description = JSON.stringify(videoDataResponse.data.items[0].snippet.description); //DESCRIÇÃO DO VÍDEO

    // Find [number]:[number] pattern in description
    const numberNumberPattern = /\d:\d/gi;
    let descriptionLines = [], numberNumbeResult;
    while ((numberNumbeResult = numberNumberPattern.exec(description))) {
        descriptionLines.push(numberNumbeResult.index);
    }

    let min = [], sec = [], hour = [], chapterTitle = [], chapterStartIndex, chapterEndIndex;

    // Verifies if last [number]:[number] correspondence is in the last description line
    if (description.indexOf("\\n", descriptionLines[descriptionLines.length - 1]) === -1) { //é na última linha
        chapterEndIndex = description.length - 1;
    } else { // not in the last line
        chapterEndIndex = description.indexOf("\\n", descriptionLines[descriptionLines.length - 1]);
    }

    // Verifies if first [number]:[number] correspondence is in the first description line
    switch (descriptionLines[0]) {
        case 1: // it's in the first line ([number]:[number] pattern)
            chapterStartIndex = 1;
            break;
        case 2: // it's in the first line ([number][number]:[number] pattern)
            chapterStartIndex = 2;
            break;
        default: //it's not in the first line
            const auxiliarString = description.substring(descriptionLines[0] - 6);
            chapterStartIndex = auxiliarString.indexOf("\\n") + descriptionLines[0] - 4;
    }

    // get description part with timestamp and titles
    const chapters = description.substring(chapterStartIndex, chapterEndIndex);

    // separete lines
    const notFilteredLine = chapters.split("\\n");

    // filter lines which don't have [number]:[number] pattern
    notText(notFilteredLine);

    // filter empty lines
    const filteredLine = notFilteredLine.filter(Boolean);


    for (let i = 0; i < filteredLine.length; i++) {
        const notNumberOrColonRegex = /[^:\d]/; // not number nor ":"
        const numberRegex = /\d/; // number
        let numberResult = numberRegex.exec(filteredLine[i]);
        filteredLine[i] = filteredLine[i].substring(numberResult.index); // starts line in first number found
        let notNumberOrColonResult = notNumberOrColonRegex.exec(filteredLine[i]);
        let tempo = filteredLine[i].substring(0, notNumberOrColonResult.index); // timestamp end (not number nor ":")
        let tempoSeparado = tempo.split(":"); // split timestamps in each ":"
        switch (tempoSeparado.length) {
            case 2: // doesn't have hour
                hour[i] = 0;
                min[i] = Number(tempoSeparado[0]);
                sec[i] = Number(tempoSeparado[1]);
                break;
            case 3: // has hour
                hour[i] = Number(tempoSeparado[0]);
                min[i] = Number(tempoSeparado[1]);
                sec[i] = Number(tempoSeparado[2]);
                break;
        }
        const numberOrLetterRegex = /[a-z0-9]/i; // number or letter 
        const auxiliarString = filteredLine[i].substring(notNumberOrColonResult.index); // auxiliar string starts when not number nor ":"
        let numberOrLetterResult = numberOrLetterRegex.exec(auxiliarString);

        // chapter title starts in first letter or number found in auxiliarString
        chapterTitle[i] = auxiliarString.substring(numberOrLetterResult.index);
    }
    let chaptersData = [];
    for (let i = 0; i < chapterTitle.length; i++) {
        chaptersData[i] = {
            chapterTitle: chapterTitle[i],
            chapterTimestamp: [hour[i], min[i], sec[i]]
        }
    }
    console.log(chaptersData);
  // chaptersData contains the data we are looking for
  // chaptersData is an array of objects, in the format {chapterTitle: 'chapter title example', chapterTimestamp: [01, 25, 39]}
  // chapterTimestamp is in the format [hour, minute, second]
}

// calls main with the ID of the video of interest
main('videoId'); // For example: main('R3WDe7byUXo');

#youtube video chapters API

● 삼각형 그리기

※ 지극히 개인적인 일상 메모와 기록을 위한 곳입니다.

#ifndef UNICODE
#define UNICODE
#endif

#include <windows.h>
#include <tchar.h>
#include <string>
//#include <time.h>
//#include <cmath>

// DX Header
#include <d3d11.h>          // DirectX11 헤더
#include <d3dcompiler.h>    // 쉐이더 컴파일러 기능 제공
#include <comdef.h>

// lib 링킹
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "d3dcompiler.lib")

// 변수
// 전역 변수 <-> 함수 내에 있는 변수는 지역 변수
std::wstring className = TEXT("Sample Window Class");
std::wstring title = TEXT("STL Render Engine");
HINSTANCE hInstance = nullptr;
int width = 1600;
int height = 900;
HWND hwnd = nullptr;

// DX 변수
// DX 장치
ID3D11Device* device = nullptr;
ID3D11DeviceContext* context = nullptr;
IDXGISwapChain* swapChain = nullptr;
ID3D11RenderTargetView* renderTargetView = nullptr;

// 정점 버퍼 관련 변수
unsigned int vertexByteWidth = 0u;
unsigned int vertexCount = 0u;
ID3D11Buffer* vertexBuffer = nullptr;

ID3D11VertexShader* vertexShader = nullptr;
ID3D11PixelShader* pixelShader = nullptr;
ID3D11InputLayout* inputlayout = nullptr;

// DX 장치 초기화
void InitializeDevice();

// 장면 초기화
void InitializeScene();

void Draw();

// 오류 메시지 얻어오는 함수
std::wstring GetErrorMessage(HRESULT hr)
{
    _com_error error(hr);
    return error.ErrorMessage();
}

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

int WINAPI wWinMain(
    _In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ LPWSTR lpCmdLine,
    _In_ int nShowCmd)
{
    // Register the window class.
    ::hInstance = hInstance;        // ::전역 변수를 가리킴

    WNDCLASS wc = { };
    //memset(&wc, 0, sizeof(wc));

    // Invoke
    wc.lpfnWndProc = WindowProc;        // 콜백(Callback) / 위임(Delegate)
    wc.hInstance = hInstance;
    wc.lpszClassName = className.c_str();

    // 창 클래스 이름 등록
    RegisterClass(&wc);

    // Create the window.

    // 창 크기 조정.
    // RECT는 직사각형 구조체, (left, top, right, bottom)
    RECT rect = { 0, 0, static_cast<long>(width), static_cast<long>(height) };
    AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE);

    // 조정된 직사각형 크기로 창 가로/세로 크기 구하기(Window는 좌측 상단이 기준점)
    int windowWidth = rect.right - rect.left;
    int windowHeight = rect.bottom - rect.top;

    // 화면 중심에서 창을 그리기 위한 생성좌표 구하기
    // GetSystemMetrics(SM_CXSCREEN) -> 모니터 가로 크기 구하는 함수
    // GetSystemMetrics(SM_CYSCREEN) -> 모니터 세로 크기 구하는 함수
    int xPosition = (GetSystemMetrics(SM_CXSCREEN) - windowWidth) / 2;
    int yPosition = (GetSystemMetrics(SM_CYSCREEN) - windowHeight) / 2;

    hwnd = CreateWindowEx(
        0,                              // Optional window styles.
        className.c_str(),              // Window class
        title.c_str(),                  // Window text
        WS_OVERLAPPEDWINDOW,            // Window style

        // Size and position (실행 시 위치와 크기)
        //CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
        xPosition, yPosition, windowWidth, windowHeight,

        nullptr,        // Parent window
        nullptr,        // Menu
        hInstance,      // Instance handle
        nullptr         // Additional application data
    );

    if (hwnd == nullptr)
    {
        return 0;
    }

    ShowWindow(hwnd, SW_SHOW);      // window 창 일반적인 상태로 보이기
    UpdateWindow(hwnd);             // 창 업데이트
    // ------ 창 생성 ------ //

    // DX 초기화
    InitializeDevice();

    // 장면 초기화
    InitializeScene();

    // Run the message loop.

    MSG msg = { };      // MSG 구조체에 마우스 클릭 반응 등이 들어있음
    // WM_QUIT 메시지가 아니면 계속 루프 실행
    while (msg.message != WM_QUIT)
    {
        // 윈도우가 메시지 전달하면 실행
        //if (GetMessage(&msg, NULL, 0, 0) > 0)
        if (PeekMessage(&msg, nullptr, 0u, 0u, PM_REMOVE))
        {
            // 윈도우(OS)가 전달한 메시지 해석 및 전달(WindowProc 함수 호출)
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else
        {
            Draw();
            // GameLoop
            // Rendering (DX 작업은 여기서 실행)

            // ProcessInput
            // Update
            // Render
            // PostRender
        }
    }

    // 창 등록 해제
    UnregisterClass(className.c_str(), hInstance);

    return 0;
}

void InitializeDevice()
{
    // 장치 생성할 때 전달할 옵션 값
    unsigned int createFlag = 0;

#if _DEBUG
    // Debug 모드인 경우,
    // 장치 생성 과정에서 오류가 방생했을 때 디버깅 정보를 더 많이 전달해달라는 옵션 추가
    createFlag |= D3D11_CREATE_DEVICE_DEBUG;
#endif

    // DX11 버전 지정
    // 상위 버전을 앞에 넣으면 먼저 시도해보고, 지원하지 않으면 다음 버전으로 넘어감
    D3D_FEATURE_LEVEL levels[] =
    {
        D3D_FEATURE_LEVEL_11_1,
        D3D_FEATURE_LEVEL_11_0
    };

    // 스왑체인 생성을 위한 구조체 설정
    DXGI_SWAP_CHAIN_DESC swapChainDesc = {};
    swapChainDesc.BufferCount = 1;              // 백버퍼 개수 설정
    swapChainDesc.BufferDesc.Width = width;     // 프레임(이미지) 가로 크기
    swapChainDesc.BufferDesc.Height = height;   // 프레임(이미지) 세로 크기
    swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;   // 이미지 채널별 포멧
    swapChainDesc.Windowed = true;              // 창(Window) 모드 여부 설정
    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;    // 프레임(이미지)의 용도 (렌더링)
    swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;            // Front <-> Back 버퍼 변경할 때 효과 넣을지 설정
    swapChainDesc.SampleDesc.Count = 1;         // 멀티 샘플링 할지 여부 설정 -> 안함
    swapChainDesc.SampleDesc.Quality = 0;       // 멀티 샘플링 품질 설정 -> 기본 값 (Count - 1)
    swapChainDesc.OutputWindow = hwnd;          // DX가 그릴 창 핸들

    D3D_FEATURE_LEVEL finalFeature;

    // 장치 초기화
    auto result = D3D11CreateDeviceAndSwapChain(
        nullptr,
        D3D_DRIVER_TYPE_HARDWARE,
        nullptr,
        createFlag,
        levels,
        //ARRAYSIZE(levels),
        _countof(levels),
        D3D11_SDK_VERSION,
        &swapChainDesc,
        &swapChain,
        &device,
        &finalFeature,
        &context
    );

    // 실패 여부 확인
    if (FAILED(result))
    {
        //MessageBox(nullptr, L"Failed to create device.", L"Error", MB_OK);
        MessageBox(nullptr, GetErrorMessage(result).c_str(), L"Error", MB_OK);
        exit(-1);
    }

    // 랜더(Render, 그린다, Draw) 타겟 (백버퍼) -> 우리가 이미지를 그릴 버퍼(메모리)
    ID3D11Texture2D* backbuffer = nullptr;

    // 그래픽카드가 가지고 있는 백버퍼 정보를 얻어온다.
    result = swapChain->GetBuffer(
        0,
        __uuidof(ID3D11Texture2D),
        reinterpret_cast<void**>(&backbuffer)
    );

    // 오류 확인
    if (FAILED(result))
    {
        MessageBox(nullptr, GetErrorMessage(result).c_str(), L"Error", MB_OK);
        exit(-1);
    }

    // 렌더 타겟 뷰(RenderTargetView) 생성
    renderTargetView = nullptr;
    result = device->CreateRenderTargetView(
        backbuffer,
        nullptr,
        &renderTargetView
    );

    // 오류 확인
    if (FAILED(result))
    {
        MessageBox(nullptr, GetErrorMessage(result).c_str(), L"Error", MB_OK);
        exit(-1);
    }

    // 백버퍼 해제
    // COM
    backbuffer->Release();

    // 렌더 타켓 뷰 설정
    context->OMSetRenderTargets(1, &renderTargetView, nullptr);

    // 화면(Viewport) 설정
    D3D11_VIEWPORT viewport = {};
    viewport.TopLeftX = 0.0f;
    viewport.TopLeftY = 0.0f;
    viewport.Width = static_cast<float>(width);     // width가 int 이므로 float 로 형변환
    viewport.Height = static_cast<float>(height);   // height가 int 이므로 float 로 형변환
    viewport.MinDepth = 0.0f;
    viewport.MaxDepth = 1.0f;

    // 뷰포트 설정
    context->RSSetViewports(1, &viewport);
}

void InitializeScene()
{
    // 1. 정점(Virtex) 데이터 생성
    struct Vertex
    {
        float x;
        float y;
        float z;
    };

    // 점 데이터
    // NDC-(Viewport)
    Vertex vertices[] =
    {
        {  0.0f,  0.5f, 0.5f },     /*{x, y, z?}*/
        {  0.5f, -0.5f, 0.5f },
        { -0.5f, -0.5f, 0.5f }
    };

    //
    vertexByteWidth = sizeof(Vertex);
    vertexCount = _countof(vertices);

    // 정점 버퍼를 설명하는 구조체
    D3D11_BUFFER_DESC vertexBufferDesc = {};
    vertexBufferDesc.ByteWidth = sizeof(Vertex) * _countof(vertices);
    vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;

    // 정점 배열(데이터)을 담을 구조체
    D3D11_SUBRESOURCE_DATA vertexData = {};
    vertexData.pSysMem = vertices;

    // 정점 버퍼
    //ID3D11Buffer* vertexBuffer = nullptr;

    // 정점 버퍼 생성
    auto result = device->CreateBuffer(
        &vertexBufferDesc,
        &vertexData,
        &vertexBuffer
    );

    // 오류 확인
    if (FAILED(result))
    {
        MessageBox(nullptr, GetErrorMessage(result).c_str(), L"Error", MB_OK);
        exit(-1);
    }

    // 셰이더(Shader-그래픽 카드에서 사용하는 프로그램) 생성 (정점 셰이더 / 픽셀 셰이더)
    // 정점 셰이더 생성
    // 1. 컴파일
    // 2. 컴파일된 이진 파일 로드
    // 3. 셰이더 생성
    ID3DBlob* vertexShaderBuffer = nullptr;
    result = D3DCompileFromFile(
        L"VertexShader.hlsl",
        nullptr,
        nullptr,
        "main",
        "vs_5_0",
        0u,
        0u,
        &vertexShaderBuffer,
        nullptr
    );

    // 오류 확인
    if (FAILED(result))
    {
        MessageBox(nullptr, GetErrorMessage(result).c_str(), L"Error", MB_OK);
        exit(-1);
    }

    // 정점 셰이더 생성
    //ID3D11VertexShader* vertexShader = nullptr;
    result = device->CreateVertexShader(
        vertexShaderBuffer->GetBufferPointer(),
        vertexShaderBuffer->GetBufferSize(),
        nullptr,
        &vertexShader
        );

    // 오류 확인
    if (FAILED(result))
    {
        MessageBox(nullptr, GetErrorMessage(result).c_str(), L"Error", MB_OK);
        exit(-1);
    }

    // 픽셀 셰이더
    ID3DBlob* pixelShaderBuffer = nullptr;
    result = D3DCompileFromFile(
        L"pixelShader.hlsl",
        nullptr,
        nullptr,
        "main",
        "ps_5_0",
        0u,
        0u,
        &pixelShaderBuffer,
        nullptr
    );

    // 오류 확인
    if (FAILED(result))
    {
        MessageBox(nullptr, GetErrorMessage(result).c_str(), L"Error", MB_OK);
        exit(-1);
    }

    // 픽셀 셰이더 생성
    //ID3D11VertexShader* vertexShader = nullptr;
    result = device->CreatePixelShader(
        pixelShaderBuffer->GetBufferPointer(),
        pixelShaderBuffer->GetBufferSize(),
        nullptr,
        &pixelShader
    );

    // 오류 확인
    if (FAILED(result))
    {
        MessageBox(nullptr, GetErrorMessage(result).c_str(), L"Error", MB_OK);
        exit(-1);
    }
    
    // 입력 레이아웃 생성 (입력=정점, 정점의 생김새)
    //ID3D11InputLayout* inputlayout = nullptr;
    //LPCSTR SemanticName;
    //UINT SemanticIndex;
    //DXGI_FORMAT Format;
    //UINT InputSlot;
    //UINT AlignedByteOffset;
    //D3D11_INPUT_CLASSIFICATION InputSlotClass;
    //UINT InstanceDataStepRate;
    D3D11_INPUT_ELEMENT_DESC inputElementDesc[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }
    };
    result = device->CreateInputLayout(
        inputElementDesc,
        _countof(inputElementDesc),
        vertexShaderBuffer->GetBufferPointer(),
        vertexShaderBuffer->GetBufferSize(),
        &inputlayout
    );

    // 오류 확인
    if (FAILED(result))
    {
        MessageBox(nullptr, GetErrorMessage(result).c_str(), L"Error", MB_OK);
        exit(-1);
    }
}

void Draw()
{
    // 배경 지우기
    float color[] = { 0.2f, 0.4f, 0.6f, 1.0f };     // red, green, blue 순서
    context->ClearRenderTargetView(renderTargetView, color);
    
    // 그리기
    // 데이터/셰이더 설정
    // 순서 상관 없음

    // 점을 연결해서 면을 만들 때 기준이되는 방식을 지정함
    context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

    static unsigned int stride = vertexByteWidth;   // static을 사용하면 드로우 콜 할때 변수를 한 번만 생성해서 공유한다.
    static unsigned int offset = 0u;

    // 정점 버퍼 설정
    context->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
    context->IASetInputLayout(inputlayout);

    // 셰이더 설정
    context->VSSetShader(vertexShader, nullptr, 0);
    context->PSSetShader(pixelShader, nullptr, 0);

    // 드로우 콜
    context->Draw(vertexCount, 0);
    
    swapChain->Present(1u, 0u);     // 1을 넣으면 모니터와 프레임 동기화, 0을 넣으면 모니터와 프레임 동기화를 하지 않음.

    // BeginRender  -> 배경 지우기
    // Render       -> 정면 그리기
    // EndRender    -> 스왑체인 교환
}

// 창 구현
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case WM_DESTROY:        // 창이 닫히는 경우 프로그램 종료
        PostQuitMessage(0);
        return 0;

    case WM_PAINT:      // 그리는 기능을 사용
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hwnd, &ps);

        // All painting occurs here, between BeginPaint and EndPaint.

        FillRect(hdc, &ps.rcPaint, (HBRUSH)(COLOR_WINDOW + 1));

        EndPaint(hwnd, &ps);
    }
    return 0;

    case WM_KEYDOWN:
    {
        // ESC 키가 눌리면
        if (wParam == VK_ESCAPE)
        {
            // 메시지 상자 띄우기
            // 예/아니요 버튼을 제공하는 메시지 상자를 띄우고, "예"를 선택하면 창 삭제
            if (MessageBox(nullptr, TEXT("Quit?"), TEXT("Quit Engine"), MB_YESNO/*디자인*/) == IDYES/*YES를 누르면 실행*/)
            {
                // 창 핸들 삭제 -> 창 삭제
                DestroyWindow(hwnd);
            }
        }
    }
    return 0;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
} 

● 7월 21일 DX 수업 2일차

※ 지극히 개인적인 일상 메모와 기록을 위한 곳입니다.

이득우의 게임 수학 블로그

https://blog.naver.com/destiny9720/221408760120

숙제 : 13번까지 읽어보기

#아핀공간

#동차좌표계

# 정점버퍼

https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=atom723&logNo=190302142

#버텍스 쉐이더, 픽셀 쉐이더

그래픽 파이프라인

● 무슨 부귀 영화를 누리겠다고 새로운 공부를 시작하는 걸까? ㅎㅎ

※ 지극히 개인적인 일상 메모와 기록을 위한 곳입니다.

가끔 내 자신이 조금 불쌍해(?)질 때가 있다

좀 더 편하게 살아도 되는데 왜 이리 빡시게 사는걸까? ㅋㅋ

물론 '빡셈'을 판단하는 기준에 따라 사람마다 다르게 생각할 수는 있다.

나이가 들어서도 하루 종일 책상이나 컴퓨터 앞에 앉아 공부만 하는 사람을 힘들겠다고 보는 사람도 있고, 하루 종일 공사 현장에서 일을 하는 사람을 보며 힘들 것이라 보는 사람들도 있다.

둘 다 힘든 건 맞는 것 같다. 다만 어느쪽이 더 힘드냐 우열을 가리자면 그건 사람마다 다르고 좀 애매해지는 것 같다.

도서관에서 10시간 앉아서 공부하는 사람을 보며 "어휴 나 같으면 그냥 나가서 일을 하지 저렇게 공부 못해 너무 힘들어서" 라고 말을 하는 사람도 있는 반면 "밖에서 땀 흘리며 힘 쓰는 일은 너무 힘들어서 못 할 것 같아. 차라리 하루 종일 책상 앞에 앉아서 공부하는게 덜 힘들어"라고 말을 하는 사람도 있다.

하지만 그렇다고 다른 쪽이 쉬워서 덜 힘들어서 선택하는 것은 아니다. 공부를 하고 싶어도 당장 생계 문제가 걸려서 공부를 할 수 없는 상황도 있으며 신체적 결함이나 체력이 너무 약해서 힘쓰는 일을 하고 싶어도 할 수 없는 사람도 있다.

아무튼 어떤 것이 더 힘드냐, 무엇이 힘든 것이냐를 정의하겠다기 보다는 주관적으로 가끔 오는 현타와(나는 무엇 때문에 왜 이러고 있을까?) 객관적으로 주위에서 해주는 말들(그 나이에 굳이 해야겠냐? + 그 나이에도 대단하시네요)로 인해서 가던 길을 잠시 멈추고 싶어 질 때도 있고..

잠깐 멈췄을 때 앞으로 남은 길을 재보기도 하고 뒤를 돌아보며 오는 길을 돌이켜 보면서 '과연 나는 잘 하고 있을까?' '남들 안 가는 길을 가야만 직성이 풀리는 것인가?' '왜 나는 다른 사람들이 갔던 길을 가거나 다른 사람들이 가는 길을 함께 걷지 못하는가?' 생각을 많이 해보게 된다.

그런 생각들을 하면 항상 마지막은 나는 왜 이렇게 살고 있지? 왜 이렇게 힘들게 살고 있을까란 생각이 들며 스스로가 측은해 지기도 한다.

● 머리카락 거름망 구매 (17000원), 하지만 4600원으로 더 행복해짐

※ 지극히 개인적인 일상 메모와 기록을 위한 곳입니다.

텁쉬룸 스테인리스 울트라 욕조 머리카락 거름망 구매

머리카락 때문에 스트레스 ㅎㅎ

머리 감고 날때마다 욕조에 한 웅큼씩 빠져서 잘 걸러줘야 하는데 기존에 쓰던 건 영 별로다. 

그래서 오늘 우연히 검색하다가 평이 너무 좋길래 구매를 해봤다. 쿠팡에서 23880원 하는데 (뭐가 이리 비싸냐 ㅠㅠ 스테인레스 재질에다가 특허권이 있나보다 똑같이 생겼는데 짝퉁 8000원짜리는 재질이 플라스틱이라고 한다 ㅋㅋㅋㅋ) 위메프에서 17000원(무료배송) 혜자스러워서 바로 구매! 

https://front.wemakeprice.com/product/390168156?utm_source=naver_ep&utm_medium=PRICE_af&utm_campaign=null&NaPm=ct%3Dl5f1dbz4%7Cci%3Da07111e23846ac66bef067d387be76405ae93e61%7Ctr%3Dslsl%7Csn%3D197023%7Chk%3Dd09941c60b9e7b1db722d7f287c8003c2f4e5ee4

위메프 최저가!?

쿠팡에서도 17000원!!

일단 질렀음 ㅎㅎ

요건 생긴 건 비슷한데 플라스틱이란다 ㅋ

사용해 보니 정말 머리카락을 잘 걸러준다. 하지만 단점이 있다. 머리카락이 망에 걸러지는 건 좋은데 긴 머리카락들이 칭칭 감겨 있는 걸 휴지로 다시 닦아 내듯이 집어 빼야 하는데 금속 재질이라 단단해서 오히려 머리카락을 훔쳐 내기가 쉽지는 않다.

이것이 재질이 좀 말랑말랑하면 휴지로 감싸쥐고 머리카락을 긁어 내기가 더 쉬울텐데.. 그 생각으로 좀 더 검색을 해보니.. 역시나 그런 제품도 있었다. 텁쉬룸이랑 모양은 살짝 다르지만 그 모양새만 봐도 대략 텁쉬룹과 같은 원리로 사용할 수 있겠다란 느낌이 바로 든다.

결국 더 저렴한(4600원) 제품이 실제 사용시 만족도는 더 높다. 이것도 쿠팡에서 최저가로 판매 중인데 색깔도 다양(총 4가지?)하고 2개씩, 4개씩 묶음 판매도 하고 있다. 가정에서는 2개씩 묶음이면 충분하지 않을까 싶다.

욕조 쓸 때만 꽂아서 쓰고 안 씻고 나서는 바로 빼서 물기 말려주니까 거의 반영구적으로 쓸 것 같다.

드디어 긴긴 머리카락 때문에 항상 욕조 막히던 스트레스에서 해방이 되었다. 이게 뭐라고 행복하다냐 ㅋㅋ

#텁쉬룸

#리버그린

#머리카락거름망