CatDarkGames. Game Dev Story

붉은 사막 리뷰 - 붉은사막이 오픈월드로서 왜 재밌게 느껴지는지에 대한 구조 분석

CatDarkGame — Thu, 7 May 2026 20:54:56 +0900

이 글은 붉은사막을 직접 플레이한 뒤 작성한 개인 리뷰입니다.
특정 개발사나 유저를 비난하기 위한 글이 아니며, 한 명의 플레이어이자 게임 개발자의 관점에서 느낀 경험을 작성했습니다
스포일러 주의: 이 글은 엔딩 이후 콘텐츠, 모든 어비스 해금 이후의 대서고 기록, 세계관의 핵심 설정을 언급합니다.

2시간 30분 만의 환불에서 134시간 플레이까지, 실패와 과잉이 만든 오픈월드의 역설

작성 기준: 2026-05-07

처음 붉은사막을 플레이했을 때의 결론은 단순했다. 이 게임은 미완성이라고 판단했다.

플레이 두 시간 반 만에 환불했고, 그 판단에는 이유가 있었다. 초반부의 서사는 설득력이 약했고, 기본 튜토리얼은 충분히 작동하지 않았으며, 오픈월드의 시스템들은 서로 맞물리기보다 흩어져 있었다. 그런데 약 2주 뒤 나는 이 게임을 다시 샀고, 결국 134시간 넘게 플레이했다. 이 모순적인 경험이 붉은사막을 설명하는 가장 정확한 출발점이다.

1. 첫인상: 미완성이라고 판단한 두 시간 반

초반 경험은 강하게 부정적이었다. 구걸하는 NPC에게 돈을 주고 여성 NPC를 구했다는 이유만으로 주인공이 특별취급을 받는 듯한 전개는 낯설었고, 그 낯섦이 의도된 서사적 충격으로 느껴지지 않았다. 플레이어가 세계의 규칙을 충분히 이해하기 전에 사건이 먼저 진행되면서, 인물과 상황을 받아들일 근거가 부족했다.

기본적인 플레이 학습도 부실했다. 퍼즐을 풀기 위해 알아야 할 조작과 규칙이 충분히 안내되지 않았고, 그 결과 실패가 도전으로 느껴지기보다 품질 관리의 누락처럼 느껴졌다. 헤르난드에서 기사 보스전을 치른 뒤 주변 월드를 돌아다녔을 때도 판단은 크게 달라지지 않았다. NPC와의 인터랙션은 엉성했고, 범죄 시스템은 설계 의도가 선명하지 않았으며, 적 NPC와 월드 이벤트는 반복 배치된 콘텐츠처럼 보였다.

그 시점에서 나는 붉은사막은 오픈월드 게임으로서도, 패키지 싱글 게임으로서도 완성되지 않은 결과물로 판단했다. 기술적으로는 야심이 보였지만, 플레이어에게 무엇을 언제 배우게 하고, 어떤 감정선으로 세계를 받아들이게 할지에 대한 기본 설계가 부족했다.

2. 재구매의 계기: 같은 콘텐츠가 반복되지 않는 숏폼의 이상함

그런데 약 2주 뒤 게임을 다시 구매했다. 계기는 인터넷 여론이었다. 특히 쇼츠와 릴스에서 붉은사막 관련 콘텐츠가 계속 등장했는데, 이상하게도 영상들이 서로 같은 내용을 반복하지 않았다. 어떤 영상은 숨겨진 흔적을 보여줬고, 어떤 영상은 예상하지 못한 전투 방법을 보여줬으며, 어떤 영상은 이동, 탈것, 장비 조합, 월드 이벤트의 기묘한 상호작용을 보여줬다.

보통 완성도가 낮은 오픈월드는 단점이 먼저 확산된다. 그런데 붉은사막은 단점과 별개로, 계속 새로운 장면을 만들어내는 힘이 있었다. 그 지점이 다시 확인해볼 가치로 느껴졌다. 첫 플레이에서 내가 본 것이 게임 전체가 아니라, 설명되지 않은 거대한 덩어리의 극히 일부였을 가능성을 인정하게 됐다.

재구매 이후 플레이 시간은 빠르게 늘었다. 약 120시간에 엔딩과 모든 어비스 해금에 도달했고, 이후에도 아직 경험하지 못한 요소가 남아 있어 추가로 14시간 이상을 더 플레이했다. 모든 어비스를 해금한 뒤에는 대서고에서 세계관의 비하인드 스토리까지 읽었다. 그리고 그 순간, 첫 플레이에서 느꼈던 엉성함이 다른 의미로 되돌아왔다.

참고 : https://youtube.com/shorts/ak_SyQlh_6I?si=RCaxa8dG2CBgNEiZ

3. <섭리의 대서고>에서 느낀 이상한 여운

섭리의 대서고는 붉은 사막의 어비스 지역 중 하나이며, 대서고에서 확인할 수 있는 기록은 현재 플레이어가 도달한 시점까지 어떤 일이 반복되었는지를 설명한다. 그 안에는 최종 보스를 물리치기 위해 반복되었던 세계의 실패가 남아 있다. 108번의 타임루프, 계속된 실패, 데미안이라는 인물을 어떻게 해야 할지 모르겠다는 막막함, 클리프의 감정이 사라진 이유, 이번이 마지막이라는 절박함이 기록되어 있다.

나에게 이 내용들이 붉은 사막 개발진들의 개발 과정으로 느껴졌다. 이 내용이 실제로 개발진의 자기 고백으로 의도되었다고 단정할 근거는 없다. 그러나 플레이어인 내 경험에서는 그렇게 읽혔다. 게임을 플레이하며 직접 마주했던 엉성한 온보딩, 과잉된 시스템, 연결되지 않는 테마, 기묘하게 많은 콘텐츠, 완성된 것과 미완성인 것이 한 공간에 공존하는 느낌이 대서고의 실패 기록과 겹쳐졌다. 텍스트는 세계관의 기록이었지만, 동시에 개발 과정의 시행착오와 고민, 고통의 흔적처럼 느껴졌다.

지금까지 플레이한 게임 중에 개발진의 고생이 이렇게 직접적으로 느껴진 게임은 처음이었다. 이것은 게임 디자인적으로 훌륭했다는 뜻이 아니다. 오히려 반대에 가깝다. 붉은사막은 게임 개발자로서 본받아서는 안 되는 방식의 결과물을 많이 보여준다. 그러나 플레이 유저로서 경험한 전체는 이상하게도 하나의 완성된 기억이 되었다. 결함이 사라진 것이 아니라, 결함까지 포함한 경험이 하나의 정서로 굳어진 것이다.

4. 핵심 허들: 기술력과 게임 디자인 경험의 불균형

게임 디자인 관점에서 붉은사막의 핵심 허들은 기술력과 오픈월드 디자인 경험의 불균형으로 보인다. 붉은사막은 레드 데드 리뎀션 2, 젤다 야숨, 고스트 오브 쓰시마, 어쌔신 크리드 등 성공한 싱글 오픈월드 패키지 게임의 문법을 폭넓게 참조한 프로젝트로 읽힌다. 그러나 시스템을 많이 만드는 것과, 그 시스템을 플레이어에게 자연스럽게 학습시키고 의미 있는 선택으로 연결하는 것은 다른 역량이다.

붉은사막은 탐험, 퍼즐, 전투, 생활, 탈것, 장비, 미니게임, 월드 이벤트 등 콘텐츠 카테고리가 매우 넓다. 문제는 이 콘텐츠들을 어떤 순서로, 어떤 맥락에서, 어느 정도의 가이드와 함께 전달할 것인지가 충분히 정리되지 않았다는 점이다. 게임 플레이 경험에서 온보딩이 중요하며, 자유도를 지향하는 이라도 역설적으로 온보딩을 통한 가이드 필요하다. 플레이어가 자유롭게 행동하려면 먼저 세계가 어떤 규칙으로 반응하는지 배워야 한다.

이 지점에서 붉은사막은 계속 충돌했을 가능성이 높다. 방대한 시스템을 만들수록 플레이어에게 알려야 할 규칙은 늘어난다. 하지만 가이드를 늘리면 자유로운 탐험감이 줄어든다. 반대로 가이드를 줄이면 플레이어는 콘텐츠를 찾지 못하고 떠난다. 붉은사막은 이 균형을 정교하게 해결했다기보다, 오랜 개발 과정에서 만들어진 콘텐츠를 어떻게든 하나의 월드 안에 밀어 넣은 결과에 가깝게 느껴졌다.

5. 아이러니하게도, 그 과잉이 탐험의 재미가 되었다

이 게임의 가장 이상한 지점은 바로 여기다. 유저 온보딩, 스토리 전개, 플레이 가이드가 부족한데도, 세계 안에는 수많은 콘텐츠와 시스템이 남아 있다. 일반적인 선형 게임이라면 이것은 단순한 결함으로 끝났을 것이다. 그러나 붉은사막은 오픈월드다. 설명되지 않은 것들이 월드 곳곳에 흩어져 있고, 플레이어는 우연히 그것을 발견한다. 그러면 결함은 때때로 발견의 재미로 바뀐다.

힌트도 충분하지 않고, 아무도 알려주지 않지만, 돌아다니다 보면 예상하지 못한 보상을 얻는다. 새로운 이동 방식, 숨겨진 상호작용, 전투 빌드, 비밀의 흔적이 계속 튀어나온다. 이 구조는 전통적인 의미에서 좋은 튜토리얼 설계는 아니다. 하지만 2026년의 미디어 환경과 결합하면서 다른 방식으로 작동했다.

숏폼 SNS는 붉은사막의 부족한 설명을 외부에서 보완했다. 유저들은 자신이 발견한 장면을 짧은 영상으로 공유했고, 다른 유저들은 그 영상을 보고 다시 게임에 들어가 직접 확인했다. 개발사가 의도적으로 설계한 온보딩은 아니라고 판단하지만, 커뮤니티와 숏폼 플랫폼이 비공식 온보딩처럼 작동한 셈이다. 만약 이런 미디어 환경이 없었다면, 많은 유저는 붉은사막이 가진 콘텐츠의 극히 일부만 보고 게임을 떠났을 것이라고 생각한다.

6. 테마의 난맥상이 오히려 경험의 폭을 넓혔다

붉은사막의 세계관은 중세 판타지를 기본으로 하지만, 그 안에 동양적 요소, 스팀펑크, 기계 장치, 석유 시추소, 로봇, 제트팩 같은 요소가 함께 들어간다. 세계관 디자인 관점에서 보면 이 조합은 매끄럽지 않다. 각각의 테마가 하나의 네러티브 축으로 정교하게 연결된다고 보기 어렵다.

하지만 탐험 경험 관점에서는 이 난맥상이 장점으로도 작동한다. 다음 지역에서 무엇이 나올지 예측하기 어렵고, 그 예측 불가능성이 월드의 기대값을 높인다. 더 중요한 점은 이런 요소들이 배경 장식에 그치지 않는다는 것이다. 플레이어는 로봇을 타고 싸우고, 제트팩으로 날아다니며, 스팀펑크 아머를 입은 드래곤 같은 과격한 이미지를 실제 플레이 경험으로 받아들인다.

이것은 일관성의 승리가 아니라 폭의 승리다. 붉은사막은 세계관을 정교하게 통제하는 대신, 가능한 많은 경험을 월드 안에 밀어 넣었다. 그 결과 네러티브의 연결성은 약해졌지만, 플레이어가 마주하는 장면과 조작의 범위는 크게 넓어졌다. 바로 이 폭이 숏폼으로 확산되기 좋은 장면들을 계속 만들어냈다.

7. 마케팅과 상품 전략 관점에서 본 이례성

마케팅과 상품 전략 관점에서도 붉은사막은 특이한 프로젝트다. 보도 기준으로 개발비만 약 2,000억 원이 언급되는 대형 프로젝트인데, 플레이어 입장에서 체감한 마케팅 접점은 그 규모에 비해 제한적으로 느껴졌다. 물론 실제 마케팅 집행 규모를 외부에서 단정할 수는 없다. 다만 결과물에서 느껴지는 방향성은 명확했다. 이 프로젝트는 시장별 최적화보다 개발물 자체의 밀도와 야심을 우선한 게임처럼 보였다.

게임 내 도박 콘텐츠가 섯다와 도리짓고땡이라는 점은 그 상징적인 사례다. 두 게임 모두 한국 문화권에 익숙한 규칙이며, 특히 도리짓고땡은 국내에서도 대중성이 높은 편이라고 보기 어렵다. 글로벌 유저의 즉각적인 이해를 우선했다면 홀덤처럼 보편성이 높은 룰을 선택하는 편이 자연스럽다. 그런데 붉은사막은 그런 선택을 하지 않았다.

내가 가진 기존 관점은 게임을 디지털 콘텐츠 상품으로 보고, 판매 시장과 고객에 맞춰 서비스와 개발 전략을 세워야 한다는 쪽에 가깝다. 그런 기준에서 보면 붉은사막은 효율적인 상품 설계의 사례가 아니다. 그럼에도 결과적으로 흥행했다. 2026년 4월 15일 기준, 붉은사막은 전 세계 판매량 500만 장을 돌파했다고 발표됐다. 통상적인 효율성의 관점에서는 설명하기 어려운 성과다.

이 성과에는 여러 요인이 겹쳤다. 한국 개발사의 대형 싱글 패키지 게임이라는 희소성, 현시점 최상위권으로 평가할 수 있는 그래픽과 초원경 비주얼, 숏폼에 적합한 예측 불가능한 콘텐츠, 그리고 출시 이후 유저들이 직접 발견을 공유하는 미디어 환경이 맞물렸다. 결과론적으로 보면 붉은사막은 프로덕션과 마케팅의 정석을 따른 게임이라기보다, 시대적 조건과 과잉 생산물이 우연히 결합해 흥행한 사례에 가깝다고 생각한다.

8. 결론: 감사하지만 반복되어서는 안 되는 게임

결과적으로 붉은사막은 재미있었다. 그리고 글로벌 시장에서도 흥행했다. 하지만 나는 이 개발 방식이 앞으로 반복될 수 있는 방식이라고 판단하지 않는다. 개발비와 인건비가 높아진 상황에서, 장기간의 재작업과 개발자의 체력 소모, 출시 후 재평가, 숏폼을 통한 우연한 발견 확산에 기대는 방식은 건강한 지속 가능한 전략이 아니다.

게임 개발자로서 붉은사막은 본받으면 안 되는 지점이 많다. 온보딩은 부족했고, 시스템 통합은 거칠었으며, 서사 전달은 자주 어긋났고, QA 관점에서도 기본적인 플레이 학습 실패가 드러났다. 그러나 플레이어로서의 나는 이 게임을 쉽게 부정할 수 없다. 결함이 많은데도 계속 새로운 장면을 보여줬고, 불친절한데도 계속 돌아다니게 만들었으며, 마지막에는 그 결함마저 세계관의 실패 기록과 겹쳐지는 특이한 여운을 남겼다.

붉은사막은 좋은 프로덕션 모델이 아니다. 하지만 하나의 플레이 경험으로는 이상하게 완성되어 있다. 그것이 이 게임의 가장 큰 모순이자, 내가 2시간 30분 만에 환불했던 게임을 134시간 넘게 플레이하게 된 이유다.

내 결론은 이것이다. 붉은사막은 존중하지만 권장할 수 없는 방식으로 만들어진, 실패와 과잉이 함께 완성한 오픈월드다.

Unity PostProcess 최적화 - TAA

CatDarkGame — Mon, 13 Apr 2026 21:42:01 +0900

1. 개요

이번 포스팅에서는 모바일 프로젝트에서 커스텀 TAA를 도입하여 화질을 개선하고 대역폭 최적화를 달성하기까지의 개발 과정을 소개한다.

문제

오늘날 모바일 게임에서 고품질 3D 렌더링을 구현하기 위해 Bloom, DoF는 물론 Deferred Rendering, SSAO 등 다양한 후처리 효과가 적극적으로 활용되고 있다.

그러나 LPDDR5X 기준 중상급~플래그십 전 구간에서도 메모리 대역폭은 64~85 GB/s 수준에 불과하다. 이 대역폭 병목으로 인해 PBR 렌더링과 고품질 후처리를 사용하면서 성능 안정성을 확보하려면, 렌더 스케일을 60~70% 수준으로 낮추는 것이 현실적인 선택이다.

문제는 렌더 스케일 70% 기준 총 픽셀 수가 네이티브 대비 약 49%로 줄어들며, 단순 Bilinear 업스케일만으로는 화면 흐림과 외곽선 계단 현상을 피할 수 없다는 점이다.

TAA 도입을 통해 업스케일 효과 적용

Temporal Anti-Aliasing(TAA)은 매 프레임 투영 행렬에 서브픽셀 단위의 오프셋(jitter)을 적용하여, 여러 프레임에 걸쳐 서로 다른 서브픽셀 위치를 누적 합성하는 기법이다. 단일 프레임으로는 부족한 해상도를 시간 축의 누적을 통해 복원할 수 있으며, DLSS, FSR 2+ 등 최신 업스케일 기술들도 이 프레임 누적 원리를 기반으로 한다.

2. TAA의 원리와 한계

2.1 기본 동작 원리

TAA의 원리 자체는 단순하다. 매 프레임 투영 행렬에 서브픽셀 단위의 오프셋(jitter)을 적용해 카메라를 미세하게 흔들고, 그 결과를 히스토리 버퍼에 누적 합성한다. 단일 프레임에서는 픽셀 중심 한 점만 샘플링하지만, 수십 프레임이 누적되면 픽셀 내부의 서로 다른 서브픽셀 위치가 커버되어 AA 및 업스케일링 효과가 자연스럽게 발생한다.

오프셋은 Halton 시퀀스(base 2, 3)로 생성하여 [-0.5, +0.5] 픽셀 범위 내에 준-균일하게 분포시킨다. 히스토리 블렌딩은 아래와 같이 이전 누적 결과에 높은 가중치를 부여하는 방식으로 동작한다.

2.2 근본적 한계 — Ghosting과 Disocclusion

원리는 단순하지만, TAA의 실제 기술력은 히스토리 누적 방식에서 발생하는 두 가지 아티팩트를 얼마나 잘 억제하느냐에 집중된다.

Ghosting은 히스토리 버퍼의 이전 정보가 현재 프레임과 불일치할 때 발생하는 잔상이다.

오브젝트가 빠르게 이동하면 이전 위치의 색상이 반투명하게 겹쳐 보인다. 이를 해결하기 위해 Motion Vector로 히스토리를 현재 픽셀 위치로 재투영(reprojection)하고, Color Clamping으로 히스토리 색상이 현재 프레임 이웃 픽셀의 색상 범위를 벗어나면 강제로 끌어온다. 다만 clamping이 과도하면 flickering이 발생하고, 느슨하면 ghosting이 남는 트레이드오프가 존재한다.

Disocclusion은 이전 프레임에서 다른 오브젝트에 가려져 있던 픽셀이 현재 프레임에서 새로 노출되는 픽셀을 의미한다.

depth 차이 기반 감지, velocity 크기 기반 감지 등 다양한 휴리스틱이 사용되지만, 해당 영역이 이전 프레임에서 아예 보이지 않았던 영역이기 때문에 참조할 유효한 히스토리 데이터 자체가 존재하지 않는다는 프레임 누적 방식의 근본적인 한계다.

결국 TAA 구현의 핵심은 Motion Vector, Color Clamping, Disocclusion 감지 휴리스틱을 조합하여 이 아티팩트들을 얼마나 효과적으로 억제하느냐에 달려 있다.

3. URP 내장 TAA — 소개와 한계점

3.1 URP TAA 구조 개요

Unity 6의 URP 17.3.0에는 빌트인 TAA가 포함되어 있다.

MotionVectorRenderPass: Camera MV(풀스크린) + Object MV(RendererList)를 하나의 렌더 패스에서 생성
TemporalAA 정적 클래스: 포스트프로세싱 파이프라인 내부에서 직접 호출되는 TAA 처리
TaaHistory: double buffering 기반 히스토리 관리
Contrast Adaptive Sharpening : TAA 옵션에서 값을 0보다 높게 설정하면 FinalPost Pass에서 처리.

5단계 품질 티어를 제공하며, 각 티어는 알고리즘 파라미터 조합으로 구현된다.

품질	색공간	Clamping	Depth Dilation	History 샘플링	Center Filter
VeryLow	RGB	5탭 min/max	없음	Bilinear	없음
Low	RGB	5탭 min/max	5탭	Bilinear	없음
Medium	YCoCg	9탭 Variance	9탭	Bilinear	없음
High	YCoCg	9탭 Variance	9탭	Bicubic 5탭	없음
VeryHigh	YCoCg	AABB Clip	9탭	Bicubic 5탭	Blackman-Harris

Medium 이상에서는 YCoCg 색공간 변환, Variance Clamping, Perceptual Space 블렌딩(1/(luma+1) Reinhard-like 가중치), Playdead의 AABB Clip 등 학술적으로 검증된 고급 기법들이 적용된다. 이들은 HDRP 구현을 참조하여 URP에 맞게 경량화한 것으로, 많은 프로덕션 타이틀에서 충분히 효과적으로 동작하는 검증된 조합이다.

3.2 URP TAA의 한계점

이론적으로 잘 설계된 URP TAA지만, 모바일 프로젝트에서 사용할 때 몇 가지 한계에 부딪힌다.

① 고정 블렌드 팩터 — Clamping에만 의존하는 Ghosting 제어

URP TAA는 화면 전체에 동일한 블렌드 팩터(_TaaFrameInfluence, 기본 0.1)를 적용한다. 이는 의도적인 설계로, 콘텐츠에 무관하게 안정적이고 예측 가능한 동작을 제공한다는 장점이 있다. 반면, 빠른 움직임이 있는 장면에서도 동일한 히스토리 비율(90%)이 적용되므로, ghosting 제어를 전적으로 Color Clamping의 품질에 의존한다.

Variance Clamping과 AABB Clip은 대부분의 시나리오에서 효과적으로 ghosting을 억제하지만, 고채도 이펙트나 반투명 파티클이 겹치는 극단적 상황에서는 잔상이 완전히 제거되지 않을 수 있다.

② MotionVector 포맷 — 모바일 대역폭 부담

URP는 R16G16_SFloat(4바이트/픽셀) 포맷으로 Motion Vector를 저장한다.

모바일의 제한된 대역폭에서 FHD 기준 약 8.3MB의 추가적인 프레임버퍼 부담이 된다.

③ Disocclusion 감지 로직이 존재하지 않음

URP TAA는 History UV가 화면 밖을 벗어나는 경우를 체크할 뿐, 오브젝트 이동에 의한 일반적 disocclusion을 감지하는 로직이 존재하지 않는다. Depth dilation이 전경/배경 경계에서 올바른 MV를 선택하도록 도와주어 간접적으로 일부 케이스를 완화하지만, disocclusion에 의한 아티펙트를 완벽하게 해결 할 수 없다.

④ Particle System 및 MotionVector 정보 없는 상황 대응 불가

Unity 6000.3.10f1 버전까지도 Particle System에서 렌더링되는 Shader에는 MotionVector 정보가 들어오지 않는다. 또한 UVScroll, Vertex Animation 등, 결과적으로 Ghosting & Disocclusion을 처리할 수 없는 상황에도 URP TAA는 여전히 해당 픽셀에 대해 히스토리와 블렌딩이 동작한다.

4. 커스텀 TAA — History Rejection 중심의 접근

Ghosting의 원인을 분석하면, 대부분 History 정보가 존재하지 않는 Disocclusion 픽셀과 UVScroll, ParticleSystem 등, MotionVector 정보가 존재하지 않는 픽셀에서 발생하며, URP TAA이런 문제 픽셀에 대해서 복잡한 Color Clamping 알고리즘으로 해결하려고 한다.

커스텀 TAA의 핵심 컨셉은 동적 오브젝트에 대한 이전 & 현재 프레임 Mask 정보를 기록하여 TAA Pass에서 Mask 비교를 통해 Disocclusion을 판정 -> History Rejection(히스토리 버퍼 블랜딩 차단)한다.

4.1 MotionMask 구현

ObjectMotionVector 렌더링 시, 두 번째 렌더 타겟(SV_Target1)에 R8 포맷의 MotionMask를 동시에 출력한다.

이를 위해 ObjectMotionVector Shader Pass를 커스텀으로 제작 필요하다.

MotionMask RT는 이전 & 현재 프레임을 스위칭하며 렌더링해야하기 때문에 URP HistoryManager를 통해 관리하도록 해야하며, 커스텀 MotionVectorPass에서 MotionVector RT와 함께 MRT로 렌더링한다.

커스텀 Motion Vector ScriptableRenderPass

ObjectMotionVector Shader에서는 기존 MotionVector(Velocity) 처리와 추가로 Mask 정보를 기록한다.

ObjectMotionVector Pass는 기본적으로 SkinnedMesh는 자동으로 호출되며 Mesh Renderer는 아래 조건으로 호출된다.

1. Transform이 변동됨.

2. Motion Vectors 옵션이 PerObject Motion 혹은 Force No Motion.

MotionVectors 옵션 값은 "unityMotionVectorParams.y" 글로벌 변수로 Shader에서 읽을 수 있으며 MotionMask RT에는 이 값에 따라 아래와 같이 Mask를 기록한다.

MotionMask RT에 기록한 정보는 이후 TAA Pass에서 Disocclusion 감지 및 History Rejection 판정으로 사용된다.

Mask 값	MotionVectors 세팅	의미
0.5	Per-Object Motion	SkinnedMesh, 동적 오브젝트
1.0	Force No Motion	파티클, UV 스크롤 등 MV 기록 불가

4.2 Disocclusion 감지 & History Rejection

TAA Pass에서 현재 & 이전 MotionMask RT를 샘플링하여 History Rejection 판정한다.

이 접근의 핵심은 복잡한 "clamping으로 잘못된 히스토리를 보정하는 것이 아니라, 무효한 히스토리를 아예 사용하지 않는 것"이다. Disocclusion 픽셀 & Force No Motion 픽셀을 히스토리를 즉시 폐기하므로, 해당 영역은 TAA의 History Blending 효과를 받지 못한다.

빠르게 움직이는 오브젝트 및 Particle System, UVScroll 등, MotionVector가 없는 픽셀에서 TAA 누적 효과는 의미 없으며, ghosting이 없는 깨끗한 원본 색상 버퍼 출력이 더 깔끔하게 나온다.

// TemporalAA_AccumulatePass
half currentMask = SAMPLE_TEXTURE2D_LOD(_MotionMaskTexture, sampler_LinearClamp, uvData.depthOffsetUV, 0.0).r;
[branch] if (currentMask > 0.5) 
{
    // History Full Rejection
    return half4(colorData.center.rgb, 1.0);  
}

CalculateReprojectedUV(motionVector, uvData);

half prevMask = SAMPLE_TEXTURE2D_LOD(_PrevMotionMaskTexture, sampler_LinearClamp, uvData.reprojectedUV, 0.0).r;
bool isCurrentStatic = currentMask < CONST_MASK_THRESHOLD; // 현재 프레임 픽셀이 고정(배경) 픽셀
bool isPrevDynamic = prevMask > CONST_MASK_THRESHOLD;      // 이전 프레임 픽셀이 동적 픽셀
    
[flatten]
if (isCurrentStatic && isPrevDynamic)  
{
    // Disocclusion
    // 현재 프레임이 고정 픽셀인데, 이전 프레임이 동적 픽셀 = 이번 프레임에 새로 보이는 픽셀
}
else
{
    // History Blending
}

초록 = History Blending 정상 작동.

빨강 = Disocclusion

파랑 = Force No Motion

4.3 TAA 구현

Color Clamping / Clipping

Color Clamping은 TAA Pass에서 History 색상을 현재 프레임의 이웃 색상 범위로 제한하여 고스팅을 방지하는 기본적인 기법이다. 커스텀 TAA에서는 기본적으로 4방향 ~ 9방향 주변 픽셀 색상 Clamping 처리만 하며, YCoCg 색공간 변환, Playdead ClipToAABB 등, 복잡한 연산의 처리는 하지 않는다.

항목	URP TAA	커스텀 TAA
기본 방식	Min/Max AABB Clamp	Min/Max Clamp
Variance Clamping	Medium 이상 (9-tap, 설정 가능)	High에서만 (9-tap, 고정 gamma=1.25)
고급 Clipping	VeryHigh에서 ClipToAABBCenter (Playdead 방식)	미적용
색공간	YCoCg에서 수행 (더 정확한 색상 범위 계산)	RGB에서 수행
Perceptual Space	Reinhard-style 톤매핑 가중치 적용	미적용

Depth Dilation (Motion Dilation)

가장 가까운 깊이의 이웃 픽셀을 찾아 해당 위치의 MotionVector를 사용하는 기법이다. 배경 픽셀의 MotionVector가 전경 오브젝트 경계를 오염시키는 문제를 방지한다.

Depth Dilation 알고리즘은 URP 내장과 동일하지만, [flatten] 어트리뷰트로 분기를 명시적으로 작성하여, 예상치 못한 branch 컴파일로 인해 GPU 워프 다이버전스 발생을 방지한다.

Color & Depth 이웃 픽셀 UV Vertex Stage에서 계산

Fragment Stage에서 ALU 연산을 최대한 줄이기 위해 주변 픽셀 UV 정보는 Vertex Stage에서 계산하여 Interpolator로 전달한다. 이 UV는 Color & Depth 이웃 픽셀 샘플링에 그대로 사용된다.

History Blending

History Blending 과정은 현재 ColorRT와 History ColorRT의 블랜딩 비율을 결정하는 과정이다. 정적 화면 기준으로 History ColorRT의 비율을 높이면 TAA 효과를 더 많이 받을 수 있지만, 동적 화면에서는 누적 색상 정보가 부족하여 오히려 화면이 흐릿해지는 문제가 있다.

URP TAA는 이 비율 결정을 Camera TAA 설정에서 결정하는 것 외에 TAA Pass에서 따로 처리하지 않는다.

커스텀 TAA는 MotionVector 정보를 기반으로 정적 픽셀과 동적 픽셀의 움직임 강도에 따라 동적으로 제어하도록하여 정적 픽셀을 History Blending 비율을 높이고, 동적 픽셀은 현재 ColorRT의 비율을 높여 흐릿해지는 현상을 크게 완화했다.

URP TAA

커스텀 TAA History Blending 로직

float CalculateMotionBlend(float2 motionVector)
{
    float motionLength = sqrt(dot(motionVector, motionVector));
    motionLength = saturate(motionLength * PARAM_MOTION_SENSITIVE_SCALE);
    float blendRange = PARAM_MOTION_BLENDFACTOR_BASE - PARAM_MOTION_BLENDFACTOR_MOTION;
    return motionLength * blendRange + PARAM_MOTION_BLENDFACTOR_MOTION;
}

half3 historyColor = SampleHistoryColor(uvData.reprojectedUV);
half3 clampedHistory = ClampHistory(historyColor, colorData);
float blendFactor = CalculateMotionBlend(motionVector);
finalColor = lerp(sharpenedColor, clampedHistory, blendFactor);

Specular Flickering 완화

커스텀 TAA는 Color Clamping에 대한 처리가 단순화되고 Perceptual Space Blending 또한 처리하지 않게 되면서, HDR 컬러에서 밝은 픽셀에 대한 블랜딩 완화되지 않아 밝고 작은 Specular에 대한 Flickering 이슈 발생 위험성이 높아지게 된다.

이 이슈는 경량화된 커스텀 TAA의 구조적이 한계점으로, 오브젝트 Shader에 Specular Anti-Aliasing 로직을 추가하여 해결했다.

좌 : Before, 우 : After

Sharpening

TAA는 본질적으로 여러 프레임의 샘플을 블렌딩하므로 결과가 약간 흐릿해지는 경향이 있다. URP는 이를 TAA Pass 이후에 Final Post Pass에서 CAS(Contrast Adaptive Sharpening)로 처리하지만, 커스텀 TAA에서는 TAA Pass 내부에서 Laplacian 기반 샤프닝 처리하도록 했다.

half3 SharpeningFilter(half3 colorCenter, half3 neighborSum, half intensity)
{
    const half avg = TAA_QUALITY_HIGH ? 0.125 : 0.25;  // 8탭 vs 4탭
    half3 laplacian = (colorCenter - (neighborSum * avg)) * intensity;
    half3 sharpened = mad(laplacian, CONST_E_CONSTANT, colorCenter);  
    return min(sharpened, CONST_MAX_COLOR_VALUE);  // 64500.0
}

5. 커스텀 TAA — 대역폭 최적화

MotionMask 방식을 도입하면서 TAA Pass 자체는 경량화되었지만, 기존 MotionVectorsPass에서 MotionVector RT(R16G16_SFloat), MotionVectorDepth RT(D24S8)에서 추가로 MotionMask(R8)가 추가되어 총 3장의 MRT를 사용하게 되고, TAA Pass에서 MotionMask 현재 & 이전 RT 총 2번의 샘플링이 추가되어 대역폭 부담이 매우 커진 상황이다.

따라서 커스텀 TAA 파이프라인에서는 전반적인 대역폭 최적화를 위해 여러 기법을 도입하였다.

MotionVector RG8 인코딩

URP가 R16G16_SFloat(4바이트/픽셀)를 사용하는 것과 달리, R8G8_UNorm(2바이트/픽셀)을 채택했다.

8비트 정밀도로 Motion Vector를 표현하기 위해 비선형 인코딩을 설계했다.

타일 메모리 기준 계산

URP MotionVector : MV(R16G16, 4B) + Depth(D24S8, 4B) = 8B/pixel
커스텀 MotionVector : MV(RG8, 2B) + MotionMask(R8, 1B) + Depth(D24S8, 4B) = 7B/pixel

// 실제 코드: MotionVectorsCommon.hlsl
float2 EncodeMotionVectors(float2 velocity)
{
    float2 compressed = sqrt(abs(velocity));              // 제곱근 압축
    float2 encoded = compressed * sign(velocity) * 0.5 + CONST_ENCODE_BITOFFSET;
    return encoded;  // CONST_ENCODE_BITOFFSET = 0.498039216 (127/255)
}

float2 DecodeMotionVectors(float2 encoded)
{
    float2 shifted = (encoded - CONST_ENCODE_BITOFFSET) * 2.0;
    return sign(shifted) * (abs(shifted) * abs(shifted)); // 제곱 복원
}

인코딩 코드 해석

sqrt : 16비트 정밀도에서 8비트로 줄이면서, 낮아진 정밀도를 조금이라도 개선하기 위해 sqrt 압축을 통해 모든 범위를 균등하게 할당하는 대신 작은 velocity에 더 많은 비트를 집중시킨다. 제곱근 함수는 0 근처에서 기울기가 급격하므로, 서브픽셀~수 픽셀 범위의 작은 motion에 대해 선형 인코딩 대비 더 세밀한 표현이 가능하다. TAA에서 가장 중요한 것은 작은 motion의 정밀한 reprojection이므로, 큰 motion에서의 정밀도 손실은 허용 가능한 트레이드오프다.

127/255 = 0.498039216 오프셋: zero velocity가 정확히 (127, 127)에 매핑되어, 정지 상태의 MV가 8비트 양자화에 의해 미세하게 편향되는 것을 방지한다.

MotionVectorDepth - WriteAll Memoryless 처리

MotionVectorPass 과정에서 ZTest 처리를 위한 MotionVectorDepth RT가 따로 사용된다. 기본적으로 MotionVectorDepth RT는 별도로 사용되는 곳이 없지만, 기본 CameraDepthAttachment를 사용하는 경우, MRT로 묶여있던 CameraColorAttachment까지 MotionVectorPass에서 로드되기 때문에 별도의 MotionVectorDepth를 사용한다.

커스텀 MotionVectorPass에서는 MotionVectorDepth RT가 MV 렌더링 패스 내에서만 사용되고 이후 패스에서는 참조되지 않는다. 이에 따라 RenderGraph RasterPass의 AccessFlags를 WriteAll로 설정하고 GlobalTexture로 등록하지 않도록 구성하여, 해당 리소스가 transient로 처리되도록 했다. 이를 통해 Memoryless 최적화를 적용했다.

단, 이 최적화는 Metal API에서만 지원되며, Vulkan에서는 아직 Memoryless를 지원하지 않는다.

렌더 스케일만한 D24S8 RT가 생성되는게 메모리에 부담스러워서 CameraDepthAttachment를 사용하도록 테스트해봤지만, 오히려 대역폭 사용량이 증가되는 결과가 확인되어, 모바일 환경에서는 메모리를 좀 사용하더라도 대역폭 최적화가 더 중요하기 때문에 MotionVectorDepth를 사용하기로 결정했다.

TAA CopyPass 제거 (조건부)

URP TAA는 항상 TAA Pass 이후, TAA CopyPass를 수행하여 TAA 결과를 복제한다.

이는 TAA Pass 이후에 Color 버퍼가 수정되는 경우, 다음 프레임에 TAA 히스토리 누적에 오류가 생기기 때문에 그렇다.

커스텀 TAA는 TAA Pass 이후에 Color 버퍼를 대상으로 동작하는 RenderPass를 감지하여 CopyPass가 필요 없는 경우, 동작하지 않도록 구현 및 프로젝트 렌더파이프라인 정책으로 필요한 경우가 아니면 TAA Pass 이후에 동작되는 RenderPass가 없도록 가이드했다.

이 최적화가 적용되는 경우, FHD 기준 약 8.3MB(R11G11B10F)의 풀스크린 복사 대역폭을 절약할 수 있다.

// asmref으로 UniversalRenderer : ScriptableRenderer 내부 메소드 생성.
public bool ExistsPassBetweenExclusive(RenderPassEvent start, RenderPassEvent end)
{
    for (int i = 0; i < m_ActiveRenderPassQueue.Count; i++)
    {
        if (m_ActiveRenderPassQueue[i].renderPassEvent > start &&
            m_ActiveRenderPassQueue[i].renderPassEvent < end)
            return true;
    }
    return false;
}

6. 성능 측정 및 비주얼 결과

성능 측정 환경

iPhone12 Pro Max (2778x1284)
Xcode GPU Framecapture

RenderScale / Option	Total GPU Time	MemoryTotal	FS ALU Instructions	Device Memory R/W
0.6 / NoAA	1.72 ms	138.79 MB	536,973,056	34.19 MiB
0.6 / FXAA	2.26 ms	149.89 MB	463,215,616	41.03 MiB
0.6 / URPTAA - Low	3.41 ms	158.57 MB	1,014,621,952	60.61 MiB
0.6 / URPTAA - High	3.97 ms	158.57 MB	1,402,311,168	60.85 MiB
0.6 / CustomTAA - Mobile	2.61 ms	151.98 MB	777,932,800	51.46 MiB
0.6 / CustomTAA - High	2.99 ms	151.98 MB	1,059,408,640	51.63 MiB
1.0 / NoAA	3.41 ms	176.19 MB	834,619,904	60.15 MiB

0.6 / NoAA

0.6 / FXAA

0.6 / TAA

0.6 / NoAA

0.6 / FXAA

0.6 / TAA

Claude Code Skill for Unity URP Development — RenderGraph & RendererFeature Guide

CatDarkGame — Thu, 2 Apr 2026 21:00:35 +0900

https://github.com/CatDarkGame/claude-skill-unity-urp.git

GitHub - CatDarkGame/claude-skill-unity-urp

Contribute to CatDarkGame/claude-skill-unity-urp development by creating an account on GitHub.

github.com

unity-urp-dev는 Unity URP RenderGraph 기반 렌더피쳐 개발 시 Claude Code가 올바른 방향으로 코드를 생성하도록 안내하는 스킬입니다.

이 스킬의 핵심은 두 가지입니다.

1. 고급 렌더링 기법 레퍼런스
references/ 폴더에는 RenderGraph API 패턴, Job System / Burst 컴파일러, Compute Shader, unsafe zero-copy 메모리 전송 등 실전 구현에 필요한 고급 기법이 문서화되어 있습니다. Claude Code가 이 레퍼런스를 직접 읽고 검증된 패턴으로 코드를 작성합니다.

2. URP 버전 인식 코드 생성
스킬은 작업 시작 전 프로젝트의 URP 버전을 자동으로 감지합니다. 감지된 버전에 맞는 공식 Unity Docs와 URP GitHub 소스를 참조하여, 버전별 API 차이로 인한 오류를 사전에 방지합니다.

테스트 샘플

해당 스킬을 활용해서 SSR, RadialBlur을 최소한의 자연어 프롬프트로 제작했습니다.

릴스 광고 수집 데이터셋 시스템

CatDarkGame — Thu, 2 Apr 2026 19:58:12 +0900

UA 소재 트렌드 파악을 위해 인스타 릴스 광고를 꾸준히 모니터링하는데,
레퍼런스 저장하는 과정이 번거로워서 자동화했습니다.

DM으로 릴스 공유 → 자동 다운로드 + 분류 → Notion DB 적재까지 원클릭.

AI를 활용해 Chrome Extension + Python 서버 구조로 만들었고, 오픈소스로 공개했습니다.

https://github.com/CatDarkGame/reels-catcher-extension.git

Unity PostProcess 최적화 - Mipmap Bloom

CatDarkGame — Mon, 23 Mar 2026 20:44:18 +0900

Bloom 소개

Bloom은 밝은 영역에서 빛이 번지는 효과를 시뮬레이션하는 포스트 프로세싱이다. HDR 렌더링 환경에서 시각적 품질을 크게 끌어올리는 핵심 이펙트로, 현대 게임에서 거의 필수적으로 사용된다.

일반적인 Bloom의 처리 흐름은 다음과 같다:

Camera Color → Prefilter(밝기 추출) → DownSample(반복 축소) → Blur(블러) → UpSample(반복 확대) → Composite(합성)

밝은 픽셀을 추출하고, 해상도를 단계적으로 낮추며 블러를 적용한 뒤, 다시 단계적으로 원본 해상도까지 합성해 올라가는 구조다. Unity URP의 기본 Bloom도 이 흐름을 따르며, Progressive DownSample/UpSample 방식으로 최대 16개의 렌더 패스를 사용한다.

모바일에서의 문제: SetRenderTarget의 실제 비용

Bloom은 화면 전체를 대상으로 하는 풀스크린 이펙트다. 해상도에 비례해 비용이 증가하고, 여러 단계의 DownSample/UpSample 과정에서 매 패스마다 SetRenderTarget(SRT)이 호출된다.

SetRenderTarget이란

SetRenderTarget은 GPU가 렌더링 결과를 기록할 대상 텍스처를 전환하는 명령이다. CPU 관점에서는 단순한 상태 변경처럼 보이지만, GPU 내부에서는 훨씬 복잡한 동작이 일어난다.

TBDR 아키텍처에서 SRT의 동작

모바일 GPU(Apple GPU, Mali, Adreno 등)는 Tile-Based Deferred Rendering(TBDR) 아키텍처를 사용한다. TBDR에서 렌더링은 화면을 작은 타일(보통 16×16 ~ 32×32 픽셀)로 분할하여 처리한다. 각 타일은 GPU 코어 내부의 타일 메모리(On-Chip Memory) 에서 렌더링되며, 이 메모리는 시스템 메모리(DRAM)보다 수십 배 빠르고 전력 소모가 적다.

SRT가 호출되면 GPU는 다음 과정을 수행한다:

[현재 렌더 타겟의 타일 메모리]
        ↓ Store (On-Chip → DRAM)
[시스템 메모리에 기록]
        ↓ 렌더 타겟 전환
[새 렌더 타겟의 이전 내용]
        ↓ Load (DRAM → On-Chip)  
[새 렌더 타겟의 타일 메모리에서 렌더링 시작]

Store: 현재 렌더 타겟의 타일 메모리 내용을 시스템 메모리(DRAM)로 기록한다
Load: 새 렌더 타겟의 기존 내용을 시스템 메모리에서 타일 메모리로 읽어온다

이 Store/Load 사이클이 디바이스 메모리 대역폭을 소비하는 핵심 원인이다. 타일 메모리 내에서의 읽기/쓰기는 거의 무비용이지만, DRAM과의 데이터 전송은 높은 전력을 소모하고 대역폭 병목을 유발한다.

왜 대역폭이 중요한가

데스크톱 GPU에서는 대역폭에 여유가 있어 SRT 전환의 비용이 상대적으로 작다. 그러나 모바일에서는 사정이 다르다:

전력 제한: DRAM 접근은 ALU 연산 대비 수십 배의 에너지를 소모한다. 대역폭 증가는 곧 발열과 배터리 소모 증가를 의미한다
서멀 스로틀링: 발열이 임계값을 넘으면 GPU 클럭이 강제로 낮아져 전체 프레임 레이트가 떨어진다
공유 대역폭: 모바일 SoC에서 CPU와 GPU는 동일한 시스템 메모리와 대역폭을 공유한다

URP 기본 Bloom은 DownSample과 UpSample을 합쳐 최대 16번의 SRT 호출이 발생한다. 매 호출마다 Store → Load 사이클이 반복되며, 이 과정에서 소비되는 대역폭은 프레임당 누적된다.

Bloom 최적화가 어려운 이유

Bloom 최적화를 논의할 때 가장 먼저 떠오르는 접근은 블러 알고리즘 자체를 변경하는 것이다. Dual Filter, Kawase Blur 등이 대표적이다. 이들은 적은 샘플 수로 넓은 범위의 블러를 근사하여 연산 비용을 줄인다.

그러나 실제 프로젝트에서 이 접근을 채택하기는 쉽지 않다.

품질 차이.

URP 기본 Bloom은 Progressive Gaussian 기반의 블러를 사용하며, 이미 검증된 시각적 품질을 제공한다. Dual Filter나 Kawase Blur로 전환하면 블러의 특성(falloff, 형태)이 달라지고, 특히 밝은 광원 주변의 번짐 패턴이 눈에 띄게 변한다. 아트 디렉션 관점에서 이 차이를 수용하기 어려운 경우가 많다.

프로젝트 전반에 미치는 영향.

Bloom은 게임의 전체 비주얼 톤을 결정하는 요소 중 하나다. 이미 Bloom 기반으로 라이팅, 이펙트, UI 연출이 세팅된 프로젝트에서 블러 알고리즘을 변경하면 모든 씬의 룩이 달라진다. 프로젝트 초반이 아니라면 사실상 선택지에서 제외된다.

결국 필요한 것은 기존과 동일한 블러 품질을 유지하면서, 렌더링 파이프라인 레벨에서 비용을 줄이는 접근이다.

Mipmap Bloom 접근

Mipmap Bloom의 핵심 아이디어는 단순하다: 여러 해상도의 블러 결과를 별도의 렌더 타겟으로 분리하지 않고, 하나의 렌더 타겟 안에 영역을 나눠 배치하는 것이다.

이 기법의 이름을 "Mipmap Bloom"이라 했지만, 엄밀히 말하면 GPU의 하드웨어 Mipmap(텍스처 LOD 체인)을 사용하는 것은 아니다. 실제 동작은 여러 해상도의 블러 결과를 "하나의 렌더 타겟에 아틀라스"처럼 패킹하는 방식이므로, "Atlas Bloom"이 더 정확한 표현이다. 다만 각 해상도 단계가 점진적으로 축소되는 구조가 Mipmap 체인과 개념적으로 유사하고, DownSample로 만든 여러 해상도 레벨을 다루는 패스를 코드에서 "MipmapBlur"로 명명했기 때문에 Mipmap Bloom이라는 이름을 그대로 사용한다.

URP Bloom vs Mipmap Bloom 구조 비교

URP 기본 Bloom (URP 버전마다 차이 있음) :

[SRT] DownSample 0  →  [SRT] DownSample 1  →  ...  →  [SRT] DownSample 7
                                                              ↓
[SRT] UpSample 7    ←  [SRT] UpSample 6    ←  ...  ←  [SRT] UpSample 0

총 16개 패스, 16번의 SetRenderTarget 호출
매 패스마다 Store → Load 사이클 발생

Mipmap Bloom:

[SRT] Prefilter → [SRT] DownSample ×5 → [SRT] MipmapBlur H → [SRT] MipmapBlur V → [SRT] Composite

총 9개 패스, 9번의 SetRenderTarget 호출
MipmapBlur H/V는 하나의 렌더 타겟 안에서 4개 Mip Level을 SetViewport로 영역 분할하여 렌더링

아틀라스 기반 Mipmap 패킹

핵심은 MipmapBlur 단계에 있다. 4개 Mip Level의 블러를 각각 별도 RT에 그리는 대신, 하나의 RT를 아틀라스처럼 사용한다.

┌─────────────┬───────┐
│             │       │
│   Mip 0     │ Mip 1 │
│  (가장 큼)   │       │
│             ├───┬───┤
│             │M2 │   │
├─────────────┤───┤M3 │
│             │   │   │
└─────────────┴───┴───┘

각 Mip Level은 SetViewport로 렌더링 영역을 제한하여 같은 RT 내 다른 영역에 그린다. 이렇게 하면:

MipmapBlur Horizontal: 1번의 SRT → 4개 Mip Level을 순차적으로 SetViewport로 영역을 바꿔가며 블러
MipmapBlur Vertical: 1번의 SRT → 동일하게 4개 Mip Level을 영역별로 블러
Composite: 아틀라스에서 각 Mip Level의 UV 영역을 계산하여 한 번에 샘플링 & 합산

기존에 Mip Level 수 × 2(H+V) = 8번의 SRT가 필요했던 블러 단계가 단 2번의 SRT로 줄어든다.

URP Bloom vs Mipmap Bloom 비주얼 비교

UV Tiling/Offset과 Constant Buffer 설계

아틀라스 내에서 각 Mip Level의 정확한 위치를 참조하려면 UV 변환 데이터가 필요하다. 이 데이터를 셰이더에 상수로 하드코딩하지 않고 CPU에서 계산하여 Constant Buffer로 전달하는 이유가 있다.

왜 셰이더 상수가 아닌 CPU 전송인가

아틀라스의 UV 레이아웃은 화면 해상도와 품질 설정에 따라 달라진다. Mip Level별 샘플 카운트를 조절하면 블러 품질과 성능 사이의 트레이드오프를 런타임에 제어할 수 있다:

// 품질 설정에 따라 Mip Level별 샘플 수가 달라진다
private static readonly int[] MipmapSampleCounts      = { 4, 4, 8, 12 };     // Normal
private static readonly int[] MipmapSampleCounts_High = { 8, 12, 16, 32 };   // High Quality

해상도 변경, 품질 옵션 전환, 디바이스별 설정 분기 등에 대응하려면 이 데이터가 동적이어야 한다. 셰이더에 상수로 고정하면 이 유연성을 잃는다.

Burst 컴파일을 통한 CPU 연산 최적화

UV Tiling/Offset, Clamp 값, Gaussian 블러의 offset/weight는 매 프레임 계산되는 것은 아니지만, 해상도나 설정이 바뀔 때 재계산이 필요하다. 이 연산을 효율적으로 수행하기 위해 Unity Burst Compiler를 활용한다:

[BurstCompile]
internal static unsafe void GetGaussianUVOffsets(
    float4* refBlurDatas, int startIndex, int sampleCount, int width, int height)
{
    float dx = 1.0f / width;
    float dy = 1.0f / height;
    float half = (sampleCount - 1) * 0.5f;
    for (int i = 0; i < sampleCount; i++)
    {
        float offset = i - half;
        float4 data = refBlurDatas[startIndex + i];
        refBlurDatas[startIndex + i] = new float4(offset * dx, offset * dy, data.z, data.w);
    }
}

[BurstCompile]
internal static unsafe void GetGaussianWeights(
    float4* refBlurDatas, int startIndex, int sampleCount, float sigma)
{
    // Gaussian weight 계산 — Burst로 네이티브 수준 성능
    float twoSigmaSq = 2f * sigma * sigma;
    float sum = 0f;
    float center = (sampleCount - 1) * 0.5f;
    for (int i = 0; i < sampleCount; i++)
    {
        float x = i - center;
        float w = math.exp(-(x * x) / twoSigmaSq);
        float4 data = refBlurDatas[startIndex + i];
        refBlurDatas[startIndex + i] = new float4(data.x, data.y, w, data.w);
        sum += w;
    }
    // 정규화
    for (int i = 0; i < sampleCount; i++)
    {
        float4 data = refBlurDatas[startIndex + i];
        refBlurDatas[startIndex + i] = new float4(data.x, data.y, data.z / sum, data.w);
    }
}

Burst 컴파일은 C# 코드를 LLVM 기반 네이티브 코드로 변환하여, NativeArray를 통한 unsafe 포인터 연산을 C/C++ 수준의 성능으로 처리한다. 계산된 모든 데이터(샘플 카운트, blur offset/weight, UV tiling/offset, UV clamp)는 하나의 ComputeBuffer에 패킹되어 단일 SetGlobalConstantBuffer 호출로 GPU에 전송된다:

cmd.SetGlobalConstantBuffer(
    _mipmapData.ConstantsBuffer, 
    ShaderPropertyId.MipmapDataConstants, 
    0, _mipmapData.ConstantsBufferSize);

GPU 셰이더에서는 이 Constant Buffer를 그대로 참조한다:

CBUFFER_START(MipmapDataConstants)
    uint4  _BloomMipmapSampleCount;                      // Mip Level별 샘플 수
    float4 _BloomMipmapBlurData[MIPMAP_COUNT * 32u];     // Gaussian offset/weight
    float4 _BloomMipmapTilingOffset[MIPMAP_COUNT];       // UV Tiling & Offset
    float4 _BloomMipmapUVClamp[MIPMAP_COUNT];            // UV Clamp 범위
CBUFFER_END

_BloomMipmapTilingOffset: Mip Level 영역의 UV 스케일과 오프셋. Composite 및 Vertical Blur 패스에서 전체 화면 UV를 해당 Mip 영역의 UV로 변환하는 데 사용한다.
_BloomMipmapUVClamp: 텍스처 샘플링 시 인접 Mip 영역의 픽셀을 침범하지 않도록 UV를 제한한다. 아틀라스 패킹의 필수 요소다.

이 구조의 장점은 CPU 연산은 Burst로 최적화, GPU 전송은 단일 Constant Buffer로 최소화, 런타임 품질 조절은 유연하게 유지하는 세 가지를 동시에 달성한다는 점이다.

SetRenderTarget 제거의 효과

이 접근이 효과적인 이유는 앞서 설명한 TBDR 아키텍처의 Store/Load 사이클과 직결된다.

URP BloomMipmap Bloom변화

SetRenderTarget 호출	16회	9회	-43.8%
디바이스 메모리 Read	5.10 MiB	4.30 MiB	-15.7%
디바이스 메모리 Write	2.05 MiB	0.93 MiB	-54.5%
디바이스 메모리 총량 (R+W)	7.15 MiB	5.23 MiB	-26.9%
렌더 패스 수	16	9	-43.8%

측정 환경: Xcode GPU Frame Capture, iPhone 12 Pro Max 2778x1284

SRT 호출이 줄어들면 타일 Store/Load 사이클이 줄고, 이는 디바이스 메모리 Write의 54.5% 감소로 직접 확인된다. 모바일에서 메모리 대역폭은 전력 소모의 주요 원인이므로, 이 감소는 동일한 프레임 예산 내에서 다른 렌더링 작업에 더 많은 여유를 확보해준다.

마이크로 최적화: UV 연산을 Vertex Stage에서 처리

풀스크린 포스트 프로세싱에서 흔히 간과되는 최적화가 있다. Fragment Shader에서 수행하는 UV 관련 연산을 Vertex Shader로 옮기는 것이다.

풀스크린 삼각형은 화면 전체를 덮는 3개의 정점만 사용한다. Fragment Shader는 화면의 모든 픽셀(수십만~수백만 회)에 대해 호출되지만, Vertex Shader는 단 3번만 호출된다. GPU 하드웨어는 Vertex Shader 출력을 Fragment 단계로 넘길 때 자동으로 보간(interpolation)해주므로, 선형 변환(Tiling/Offset 적용 등)은 Vertex에서 처리해도 결과가 동일하다.

Composite 패스 예시:

// Vertex Shader — 3회 호출
Varyings FullscreenVert(Attributes input)
{
    // ...
    // 4개 Mip Level의 UV를 미리 계산하여 varying으로 전달
    output.uv_0.xy = uv * _BloomMipmapTilingOffset[0].xy + _BloomMipmapTilingOffset[0].zw;
    output.uv_0.zw = uv * _BloomMipmapTilingOffset[1].xy + _BloomMipmapTilingOffset[1].zw;
    output.uv_1.xy = uv * _BloomMipmapTilingOffset[2].xy + _BloomMipmapTilingOffset[2].zw;
    output.uv_1.zw = uv * _BloomMipmapTilingOffset[3].xy + _BloomMipmapTilingOffset[3].zw;
    return output;
}

만약 이 연산을 Fragment Shader에서 수행했다면 해상도에 비례하는 횟수(예: 189,120회)만큼 곱셈-덧셈이 반복된다. Vertex로 옮기면 이 연산은 3회로 줄고, 나머지는 하드웨어 보간기가 처리한다.

동일한 패턴이 MipmapBlur Vertical 패스에서도 적용된다:

Varyings FullscreenVert(Attributes input)
{
    // ...
    // Mip Level 영역의 UV Tiling/Offset 적용
    const float4 tilingOffset = _BloomMipmapTilingOffset[_MipmapCount];
    output.uv.xy = output.uv.xy * tilingOffset.xy + tilingOffset.zw;
    // UV Clamp 값도 varying으로 전달
    output.offsetClamp = _BloomMipmapUVClamp[_MipmapCount];
    return output;
}

Bloom 같은 풀스크린 이펙트에서 이 패턴은 Fragment에서 상수 버퍼 접근 + 산술 연산 수십만 회를 Vertex 3회 + 하드웨어 보간으로 대체하는 것이므로, ALU 부하와 버퍼 대역폭 양쪽 모두에서 이득이다.

성능 측정

Xcode GPU Frame Capture를 통해 URP 기본 Bloom과 Mipmap Bloom의 GPU 성능을 비교 측정했다. 주요 지표 두 가지 — GPU 연산 비용(Execution Cost, ALU) 과 디바이스 메모리 대역폭 — 을 중심으로 분석한다.

측정 환경

디바이스: iPhone 12 Pro Max
해상도: 2778×1284 (Native)
측정 도구: Xcode GPU Frame Capture
비교 범위: Bloom + UberPostProcess 전체 (포스트 프로세싱 파이프라인 단위)

측정 지표 설명

Total GPU Time: 해당 구간의 절대 GPU 소요 시간
Execution Cost: 전체 프레임 GPU 시간에서 차지하는 비율
FS ALU Instructions: Fragment Shader에서 실행된 ALU(산술 논리 연산) 명령어 수. 셰이더의 연산 복잡도를 나타낸다

종합 성능 비교 (Bloom + UberPostProcess)

지표URP BloomMipmap Bloom차이

Total GPU Time	3.33 ms	3.01 ms	−0.32 ms (−9.61%)
Execution Cost	34.74%	32.70%	−5.87%
FS ALU Instructions	385,469,696	337,791,232	−47,678,464 (−12.37%)

디바이스 메모리 대역폭 비교

대역폭 비교에는 전송률(GiB/s)이 아닌 DRAM 전송 총량(Bytes Read + Written) 을 사용한다. 전송률은 패스의 실행 시간에 의존하여 합산 시 의미가 왜곡되지만, 총량은 시간과 무관하게 DRAM에 가한 실제 부담을 보여주며 전력 소모와 직접 비례한다.

Bloom 패스만 비교 (SRT 최적화의 직접 효과):

구분URP Bloom (16 pass)Mipmap Bloom (9 pass)차이

Device Memory Read	5.10 MiB	4.30 MiB	−0.80 MiB (−15.7%)
Device Memory Write	2.05 MiB	0.93 MiB	−1.12 MiB (−54.5%)
총 전송량 (R+W)	7.15 MiB	5.23 MiB	−1.92 MiB (−26.9%)

Write 감소가 두드러진다. SRT 호출 16회 → 9회 감소로 타일 Store 횟수가 줄어든 직접적인 결과다.

분석

GPU Time −9.61%. Bloom + UberPostProcess 전체 구간에서 0.32ms가 감소했다. 60fps 기준 프레임 예산 16.67ms에서 약 2%에 해당하는 여유를 확보한 셈이다.

ALU Instructions −12.37%. 약 4,768만 명령어가 줄었다. Mipmap Bloom은 UpSample 체인(8패스)을 제거하고 Composite 1회로 대체했기 때문에, 해당 구간의 연산이 통째로 사라진다. UberPostProcess에서 MipmapBloom 텍스처를 단일 샘플링하는 방식도 ALU 감소에 기여한다.

Bloom Device Memory Write −54.5%. SRT 호출 감소의 가장 직접적인 성과다. TBDR에서 SRT마다 발생하는 타일 Store가 7회분 줄어들면서, Bloom 구간의 DRAM 쓰기 부담이 절반 이하로 감소했다. 모바일에서 DRAM 접근은 전력 소모의 주요 원인이므로, 이 감소는 서멀 마진 확보에 직접 기여한다.

요약

Mipmap Bloom은 GPU Time 9.61% 감소, ALU 12.37% 감소를 달성했다. 대역폭 관점에서는 Bloom 파이프라인 자체의 DRAM 전송량이 26.9% 감소(특히 Write −54.5%)되었으며, 이는 모바일 환경에서 장시간 플레이 시 발열 감소와 배터리 수명 연장에 기여한다.

DrawInstance 테스트

MipmapBlur 패스에서 4개 Mip Level을 SetViewport로 순차 렌더링하는 대신, GPU Instancing으로 1 draw call에 처리하는 방식도 테스트했다.

MipmapBlur 패스에서 SetRenderTarget이 변동되지 않기 때문에 시도할 수 있는 방법이다.

구현 방식

Instanced 모드에서는 DrawProcedural의 인스턴스 카운트를 4로 설정하여 Mip Level마다 하나의 인스턴스를 할당한다:

 using (new ProfilingScope(cmd, ProfilingSamplers.MipmapBlurH))
{
    cmd.SetRenderTarget(data.mipmapHoriTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
    cmd.ClearRenderTarget(false, true, Color.black);    
                            
    cmd.SetGlobalTexture(ShaderPropertyId.MipmapSampleTexture0, data.downSampleTextures[1]);
    cmd.SetGlobalTexture(ShaderPropertyId.MipmapSampleTexture1, data.downSampleTextures[2]);
    cmd.SetGlobalTexture(ShaderPropertyId.MipmapSampleTexture2, data.downSampleTextures[3]);
    cmd.SetGlobalTexture(ShaderPropertyId.MipmapSampleTexture3, data.downSampleTextures[4]);
                            
     cmd.DrawProcedural(Matrix4x4.identity, data.material, PassId.MipmapBlurHori_Instanced, MeshTopology.Quads, 4, ConstParams.MipmapLevel);
}

Vertex Shader에서 SV_InstanceID를 통해 각 인스턴스가 어떤 Mip Level에 해당하는지 판별하고, UV Tiling/Offset을 적용하여 NDC 좌표를 영역별로 배치한다:

Varyings FullscreenVert_Instance(Attributes input, uint instanceID : SV_InstanceID)
{
    const uint mipmapLevel = instanceID;
    const float4 viewportRect = _BloomMipmapTilingOffset[mipmapLevel]; 
    output.positionCS.xy = output.positionCS.xy * viewportRect.xy + viewportRect.zw;
    output.positionCS.xy = output.positionCS.xy * float2(2.0, -2.0) + float2(-1.0, 1.0);
    // ...
}

추가된 비용

Instanced 모드에서는 SetViewport 대신 셰이더 내에서 영역을 결정하므로, 두 가지 추가 비용이 발생한다:

1. 텍스처 선택 분기문.

SetViewport 방식에서는 C# 코드에서 cmd.SetGlobalTexture로 해당 Mip Level의 DownSample 텍스처를 직접 바인딩한다. Instanced 방식에서는 4개 텍스처를 모두 바인딩해두고 Fragment Shader에서 SV_InstanceID에 따라 선택해야 한다:

half3 SampleInputTexture(uint mipmapLevel, float2 uv)
{
    [branch]
    if (mipmapLevel == 0) return SAMPLE_MIPMAP_TEXTURE(_MipmapSampleTexture0);
    else if (mipmapLevel == 1) return SAMPLE_MIPMAP_TEXTURE(_MipmapSampleTexture1);
    else if (mipmapLevel == 2) return SAMPLE_MIPMAP_TEXTURE(_MipmapSampleTexture2);
    else return SAMPLE_MIPMAP_TEXTURE(_MipmapSampleTexture3);
}

이 분기문은 Fragment Shader의 모든 픽셀에서 실행된다. GPU에서 동적 분기는 warp/SIMD 그룹 내 divergence를 유발할 수 있고, 사용하지 않는 텍스처 슬롯까지 바인딩 상태를 유지해야 한다.

2. Viewport 대체 연산.

하드웨어 SetViewport가 무비용으로 처리하던 클리핑과 좌표 변환을 셰이더에서 직접 수행해야 한다.

측정 결과

Instanced 모드를 적용한 별도 캡처에서 Bloom Execution Cost가 SetViewport 방식 대비 상승하는 것을 확인했다. 텍스처 선택 분기와 좌표 변환의 추가 연산이 드로우콜 감소(4→1)의 이점을 상쇄하고도 남는다.

결론: 안 하는 게 낫다

Bloom의 주요 비용 구성을 보면, 드로우콜 오버헤드보다 블러 연산 자체의 ALU 및 텍스처 샘플링 비용이 지배적이다. MipmapBlur 패스의 드로우콜은 SetViewport 방식에서도 Mip Level당 1회씩 총 4회에 불과하다.

GPU Instancing으로 4 draw call → 1 draw call로 줄여봐야 절감되는 드로우콜 오버헤드는 미미한 반면, 텍스처 선택 분기와 좌표 변환 연산이 모든 픽셀에서 추가되어 오히려 전체 비용이 증가한다.

Bloom과 같이 draw call 수가 적고 픽셀당 연산 비용이 높은 풀스크린 이펙트에서는 GPU Instancing의 이점이 거의 없다. 드로우콜 최적화는 수백~수천 개의 메시를 그리는 지오메트리 패스에서 효과적이지, 패스당 풀스크린 삼각형 1장을 그리는 포스트 프로세싱에서는 적용 대상이 아니다.

Unity URP에서 화면 효과를 최적화하는 새로운 접근법

CatDarkGame — Tue, 22 Jul 2025 21:50:57 +0900

개요

많은 게임의 연출에서 이펙트 뿐만아니라 흑백 반전, 집중선 등 화면에 다양한 이펙트 표현을 볼 수 있습니다.

이러한 효과를 구현하는 방법은 여러가지가 있지만 Unity URP 환경에서 일반적으로 FullscreenRendererFeature & VolumeComponent 방식으로 제작한다면 ScriptableRenderPass, Shader를 직접 구현해야 하기 때문에 개발에 필요한 지식이 높고 관리도 어렵습니다.

이번 포스팅은 화면 효과 구현에 대한 다양한 방법과 제가 생각하는 최적의 구현 방법을 소개합니다.

화면 버퍼 복제 효과 - FrameBufferFetch 활용

흑백 반전 효과는 URP OpaqueTexture 혹은 직접 화면 버퍼를 복제해서 FullScreenShader에서 화면 버퍼를 샘플링하는 방식으로 구현됩니다. 많은 이펙트 연출 효과에서 사용되고 구현 원리가 단순하지만 화면 버퍼를 추가로 생성하고 샘플링해야하기 때문에 메모리 비용과 대역폭 부담이 있는 효과입니다.

Unity6에서 FrameBufferFetch 기능을 활용한다면 샘플링에 의한 대역폭 사용 없이 굉장히 가볍게 구현 가능하게 됩니다.

추가 메모리 비용은 플랫폼에 따라 다르지만 FrameBufferFetch를 제대로 지원한다면 복제하는 화면 버퍼는 Memoryless로 생성되어 메모리 부담도 없게 됩니다.

FrameBufferFetch에 대한 자세한 내용은 아래 포스팅을 참고해 주세요.

https://darkcatgame.tistory.com/193

Unity6 RenderGraph 호환 RenderPass 간단 예제 & 주요 포인트 설명

개요Unity6 RenderGraph 호환하기 위한 ScriptableRenderPass 개발 간단 예제입니다.RenderGraph 미지원 & RenderGraph Unsafe & RasterPass + Framebufferfetch 기반으로 간단한 흑백 화면 효과 구현합니다.Unity 6000.1.12f1 버전

darkcatgame.tistory.com

일반 화면 버퍼 샘플링

FrameBufferFetch 활용

1 Pass Blending 활용 효과

https://github.com/MirzaBeig/Anime-Speed-Lines

위 예시와 같이 화면 효과 중에 단순히 화면 위에 블랜딩하거나 덮는 효과는 화면 버퍼 복제 없이, 블랜드 옵션이 활성화된 FullScreen Shader를 활용할 수 있습니다. 반투명 오브젝트를 화면에 렌더링하면 되기 때문입니다.

FullScreenShader에서는 구현하고자하는 효과에 알맞는 Blend 옵션을 설정합니다.

그리고 ScriptableRenderPass에서 SetRenderTarget 함수에 colorLoadAction 옵션을 Load로 세팅하면, 일반적인 알파블랜드 렌더링을 실행하게 됩니다.

FullScreenShader

ScriptableRenderPass

SetRenderTarget 함수는 위와 같이 Execute 함수 혹은 RenderGraph의 UnsafePass 구현할때는 선언 필요하지만, 아래와 같이 RasterPass로 구현한다면 따로 세팅하지 않아도 RenderGraph에서 자동으로 세팅됩니다.

ScriptableRenderPass

위와 같이 구현 결과, 화면 버퍼 복제 과정 없이 FullScreenShader를 화면에 직접 렌더링하게 되어 1 Pass로 처리 및 추가 렌더텍스처 생성하지 않아 메모리까지 최적화됩니다.

추가로 SetRenderTarget LoadAction에 대한 내용은 아래 포스팅 참고해 주세요.

https://darkcatgame.tistory.com/190

Unity RenderBufferLoadAction & StoreAction 옵션 설명

개요Unity 엔진에서 ScriptableRenderPass 등, 커맨드 버퍼에 RenderTarget 설정 할때 RenderBufferLoadAction & StoreAction 옵션에 대한 설명입니다. 해당 옵션은 SetRenderTarget으로 설정한 렌더버퍼에 대한 데이터를

darkcatgame.tistory.com

Mesh를 활용한 픽셀 비용 최적화

일반적으로 FullScreenShader 구현할때 PolarCoordinate 등, UV를 Fragment에서 재구성하는 작업을 흔하게 하게 됩니다.

하지만 이런한 UV 재구성 작업은 높은 연산 부하를 발생하는 이슈가 있습니다.

이런 문제를 해결하고자, FullScreenShader 렌더링에 직접 UV를 세팅한 화면 Mesh를 활용하는 방법을 소개합니다.

UV를 원형으로 재구성하는 PolarCoordinate

Blender 및 3dsMax와 같은 DCC 툴에서 원하는 효과에 알맞는 메쉬를 모델링합니다.

메쉬 사이즈는 유니티 기준 2m X 2m 사이즈에 맞추는 것을 권장합니다.

(Unity Cube는 1m 사이즈)

Axis 축은 유니티 Quad 기준으로 FrontFace가 -Z 방향을 향하도록 합니다.

ScriptableRenderPass에서는 이전까지 사용하던 DrawProcedural이 아닌, DrawMesh 함수를 활용해서 원하는 메쉬를 렌더링 할 수 있도록 합니다.

FullScreenShader 설명입니다. Vertex Stage에서는 positionOS 오브젝트 공간 버텍스 좌표를 그대로 positionCS 클립 스페이스로 보냅니다. 이때 Y 값에 _ProjectionParams.x를 곱하는데 이는 OpenGL & DX와 같이 좌표계가 다른 API를 대응하기 위함입니다. UNITY_UV_STARTS_AT_TOP 디파인 조건문을 통해 UV Y를 뒤집는 방법도 있지만, 평면이 아닌 입체감 있는 메쉬까지 대응하기 위해서는 _ProjectionParams를 활용하는 것을 권장합니다.

Fragment에서는 이미 PolarCoordinate와 같이 UV가 구성된 Mesh UV 정보를 사용하기 때문에 별도의 UV 재구성이 필요 없습니다.

결과 화면입니다.

리소스 최적화 세팅

FullScreenShader에 사용하는 메쉬 및 텍스처에 대한 최적화 세팅 내용입니다. 아래 소개하는 세팅은 제작하는 화면 효과에 따라 권장 세팅이 달라질 수 있습니다.

메쉬는 일반적으로 Normal & Tangent 정보가 필요 없기 때문에 제거합니다.

좌 : Before 우 : After

텍스처는 Mipmap을 비활성화하고, 단일 채널 무압축 포맷으로 세팅해서 용량 대비 품질을 높이도록 합니다.

FullScreenShader에 사용되는 텍스처는 화면에 크게 렌더링되기 때문에 타일링 텍스처를 사용해도 어느 정도 이상 품질이 필요하지만, 이와 같이 단일 채널로 사용한다면 용량 & 품질 둘다 이점 가질 수 있습니다.

결과 화면입니다.

Mesh를 활용한 픽셀 비용 최적화 - ShockWave 이펙트 구현

다음, 실제 게임 이펙트 연출에 사용될 수 있는 ShockWave 화면 이펙트 효과를 구현해봅니다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

화면 메쉬 제작

목표한 효과는 이전에 제작한 Polarcoordinate 형태의 메쉬를 사용해도 되지만, 더 나은 최적화를 위해 가운데를 뚫은 형태의 화면 메쉬를 제작합니다.

추가로 VertexColor 알파 정보를 추가해서 별도 알파 텍스처 없이 화면 가운데에서 투명해지면서 밖으로 퍼질 수 있도록 합니다.

Dissovle Shader 제작

레퍼런스 효과 구현에 알맞는 FullScreenShader 제작합니다.

간단한 Dissolve 효과를 구현했으며 FragmentShader 최적화를 위해 UV Scroll 계산은 Vertex Stage에서 처리합니다.

                half Level(half value, half add, half mul)
                {
                    return saturate(add + (value * mul));
                }

                half Linearstep(half a, half b, half x)
                {
                    return saturate((x - a) / (b - a));
                }

                half Dissolve(half alpha, half alphaProgress, half sharpness)
                {
                    half dissolveWidth = sharpness;
                    half fadeProgress = lerp(-dissolveWidth, 1.0 + dissolveWidth, alphaProgress);
                    return Linearstep(fadeProgress - dissolveWidth, fadeProgress + dissolveWidth, alpha);
                }
                
                Varyings Vert(Attributes input)
                {
                    Varyings output;
                    UNITY_SETUP_INSTANCE_ID(input);
                    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
                    
                    float4 pos = float4(input.positionOS.x, input.positionOS.y * _ProjectionParams.x, 0.0, 1.0);
                    float2 uv = input.texcoord0;

                    float time = fmod(_Time.y, 100.0);
                    output.positionCS = pos;
                    output.color = input.color;
                    output.texcoord.xy = uv * _DissolveMap1_ST.xy + (_DissolveMap1_ST.zw * time);
                    output.texcoord.zw = uv * _DissolveMap2_ST.xy + (_DissolveMap2_ST.zw * time);
                    
                    return output;
                }
                
                half4 Frag(Varyings input) : SV_Target
                {
                    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
                    float2 uv_0 = input.texcoord.xy;
                    float2 uv_1 = input.texcoord.zw;
                    half4 vertexColor = input.color;
                    
                    half dissolve_2 = SAMPLE_TEXTURE2D_X_LOD(_DissolveMap2, sampler_DissolveMap2, uv_1, 0).r;
                    dissolve_2 = Level(dissolve_2, _DissolveMap2_LevelAdd, _DissolveMap2_LevelMul);
                    half dissolve_1 = SAMPLE_TEXTURE2D_X_LOD(_DissolveMap1, sampler_DissolveMap1, uv_0, 0).r;
                    dissolve_1 = Level(dissolve_1, _DissolveMap1_LevelAdd, _DissolveMap1_LevelMul);
                    dissolve_1 *= dissolve_2 * vertexColor.a;
                    
                    half dissolveMask = Dissolve(dissolve_1, _AlphaProgress, _Sharpness);
                    return dissolveMask * _Color;
                }

결과 화면입니다. 사용하는 텍스처, 파라미터 세팅에 따라서 다양한 화면 연출 효과 구현 가능합니다.

VAT 활용한 화면 깨짐 연출 효과 구현

다음은 VAT(Vertex Animation Texture) 기법을 활용한 화면 깨짐 연출 효과를 구현합니다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

VAT 리소스 제작

VAT(Vertex Animation Texture)는 메쉬 애니메이션의 버텍스 정보를 텍스처에 기록해서 Vertex Stage에서 샘플링하는 기법입니다. VAT 리소스 제작은 Blender, 3dsMax, 후디니 등 다양한 방법이 존재하며 저는 Blender를 활용했습니다.

Blender에서 Cell Fracture라는 에드온으로 파괴 시물레이션을 구현했습니다.

참고 : https://www.youtube.com/watch?v=mEMW5elom_4&ab_channel=SILVERPUNK

목표하는 연출에 맞게 파괴 시물레이션 애니메이션 제작 후, VAT 리소스로 추출합니다.

제작하는 효과는 유리 표현을 위해 Fresnel 표현이 필요하기 때문에 Normal정보까지 필요합니다.

VAT Shader 제작

VAT Shader는 이전 Mesh FullScreenShader와 동일하지만, PositionOS에 VAT Position 샘플 데이터를 Offset 처리합니다.

VAT Normal 샘플 데이터는 NormalOS로 그대로 사용합니다.

우선 테스트 삼아, CopyColor 텍스처를 샘플링해서 효과 구현해보면 아래와 같이 화면이 깨지는 효과 구현이 완료됩니다.

유리 깨지는 표현 강화

Shader에서 추가로 Fresnel 효과와 화면 버퍼 샘플링 UV에 Normal 방향으로 Offset 처리해서 유리의 굴절과 반사 효과를 구현해서 유리 재질 표현을 강화합니다.

좌 : Before 우 : After

앞에서 임시로 CopyColor를 샘플링하도록 했지만, Opaque 패스 이후에 복제된 버퍼이기 때문에 Transparnet 패스까지 대응하기 위해 새로 화면 버퍼를 복제합니다.

아래 예시에서는 renderGraph.AddCopyPass 함수를 활용했으며, 해당 함수를 사용하면 FrameBufferFetch로 화면 버퍼를 복제할 수 있습니다.

애니메이션 제작 & 결과 화면

VAT Shader의 파라미터를 제어해서 Animation을 하나 제작합니다.

화면 연출 효과를 위한 Renderer 컴포넌트 제작

앞에서 소개한 화면 연출 효과는 항상 렌더링되는 것이 아닌, 일반 Particle 이펙트와 같이 일시적으로 생성되고 제거되는 용도입니다. 쉽게 말해서 Bloom, SSAO와 같은 Postprocess와 용도 자체가 다릅니다.

하지만 일반적으로 ScriptableRendererFeature에서 렌더패스를 호출하는 방식으로 제작한다면 항상 Universal Renderer에 객체가 유지되고 Volume Componenet 등을 통해서 활성화 여부와 파라미터를 제어할 수 밖에 없는데 이러면 따로 제어하는 시스템을 구현 할 수밖에 없는 비효율이 발생합니다.

이번에 소개할 내용은 ScriptableRendererFeature를 사용하지 않고 ScriptableRenderPass를 직접 호출하는 Monobehaviour 객체를 구현해서 오브젝트로 효과를 관리할 수 있는 방법을 소개합니다.

RenderPipelineManager.beginCameraRendering

RenderPipelineManager.beginCameraRendering 이벤트 함수 등을 활용해서 URP 내부 렌더링 로직 호출 시점에 원하는 로직이 호출 가능합니다. 이를 활용해 scriptableRenderer에 원하는 ScriptableRenderPass 객체를 렌더링 Queue에 등록하는 방식으로 ScriptableRendererFeature 없이 렌더 패스 호출하도록 구현합니다.

아래 코드는 실제 유리 파괴 효과를 렌더링하도록 구현한 예시입니다.

 [ExecuteInEditMode]
    public class GlassBreakFX : MonoBehaviour
    {
        [SerializeField] private RenderPassEvent renderPassEvent = RenderPassEvent.BeforeRenderingPostProcessing;
        [SerializeField] private Camera targetCamera;
        [SerializeField] private Material material;
        [SerializeField] private Mesh mesh;
        [SerializeField] private GlassBreakFXRenderPass.MaterialProperties materialProperties = GlassBreakFXRenderPass.MaterialProperties.Default();
        
        private GlassBreakFXRenderPass _renderPass;
        
        private void OnEnable()
        {
            if(!targetCamera) targetCamera = Camera.main;
            _renderPass = new GlassBreakFXRenderPass();
            RenderPipelineManager.beginCameraRendering += OnBeginCameraRendering;
        }

        private void OnDisable()
        {
            _renderPass?.Dispose();
            _renderPass = null;
            RenderPipelineManager.beginCameraRendering -= OnBeginCameraRendering;
        }

        private void OnBeginCameraRendering(ScriptableRenderContext context, Camera cam)
        {
            if (material == null || mesh==null ||
                targetCamera == null || targetCamera != cam || 
                !targetCamera.isActiveAndEnabled) return;
            
            var cameraData = cam.GetUniversalAdditionalCameraData();
            if (cameraData.renderType != CameraRenderType.Base) return;
            
            _renderPass.renderPassEvent = renderPassEvent;
            _renderPass.material = material;
            _renderPass.mesh = mesh;
            _renderPass.materialProperties = materialProperties;
            cameraData.scriptableRenderer.EnqueuePass(_renderPass);
        }
    }

리소스 관리

Monobehaviour 클래스에서 FullScreenShader의 파라미터를 노출 시키면 이펙트 작업자는 Particle System 등으로 이펙트 제작과 함께 화면 연출 효과 객체를 다룰 수 있으며, Particle System과 함께 Prefab으로 묶어서 관리 가능합니다.

Unity6 RenderGraph 호환 RenderPass 간단 예제 & 주요 포인트 설명

CatDarkGame — Wed, 16 Jul 2025 22:45:23 +0900

개요

Unity6 RenderGraph 호환하기 위한 ScriptableRenderPass 개발 간단 예제입니다.
RenderGraph 미지원 & RenderGraph Unsafe & RasterPass + Framebufferfetch 기반으로 간단한 흑백 화면 효과 구현합니다.
Unity 6000.1.12f1 버전 기준으로 개발되었습니다.
예제 코드에 대한 상세한 설명 대신, RenderGraph 호환 개발에 대한 핵심 포인트만 설명합니다.

샘플 코드

https://github.com/CatDarkGame/UnityRenderGraphSample

GitHub - CatDarkGame/UnityRenderGraphSample: Unity 6000.1.12f1

Unity 6000.1.12f1 . Contribute to CatDarkGame/UnityRenderGraphSample development by creating an account on GitHub.

github.com

RenderGraph 호환 개발 핵심 포인트

1. RenderGraph 활성화 상태에서 Execute 대신, RecordRenderGraph 함수 사용.

기존에 ScriptableRenderPass의 Execute 함수는 ScriptableRenderer.EnqueuePass에 의해서 호출되며 커맨드버퍼 명령 로직을 작성합니다. RenderGraph 활성화 상태에서는 Execute 대신 RecordRenderGraph 함수가 호출됩니다.

RenderGraph 활성화 & 비활성화 환경 둘다 대응하고 싶으면 두 함수 모두 구현해야합니다.

Execute 함수와 같이 RenderGraph 이전에 사용하던 함수에는 [Obsolete] 어트리뷰트를 추가합니다, 왜냐하면 deprecated 예정이라고 경고 메세지가 계속 발생하기 때문입니다.

2. RenderTexture는 RenderGraph 시스템에서 관리, RTHandle 사용하지 않음.

RenderGraph의 방향성은 RenderTexture 객체 데이터를 사용자가 관리하지 않고 RenderGraph 시스템에서 관리하는 것이며 사용자가 RTHandle과 같은 방법으로 RenderTexture 객체 메모리 관리하지 않습니다.

RTHandle 대신, TextureHandle 구조체를 사용해서 RenderGraph에서 관리하는 RenderTexture를 참조합니다.

또한 TextureHandle은 사용자 클래스에 직접 선언해서 관리하지 않고 PassData 컨테이너 클래스를 선언해서 내부에 선언합니다.

3. PassData 컨테이너 클래스

앞에서 설명한 PassData는 RenderGraph 시스템에 전달 & 참조하기 위한 컨테이너 클래스입니다.

TextureHandle & Material 등, 렌더링에 필요한 자료형을 선언합니다. PassData 또한 ScriptableRenderPass에 객체를 선언하지 않고 RecordRenderGraph 함수 내부에서 RenderGraph에 전달 & 참조만 합니다. RenderGraph에서는 PassData 클래스 내용물을 기준으로 메모리를 할당하여 실제 데이터는 RenderGraph 내부에서 관리하는 방식입니다.

4. UnsafePass와 RasterPass

RenderGraph의 SubPass는 UnsafePass와 RasterPass 2가지 방법으로 개발합니다.

UnsafePass는 기존 처럼 CommandBuffer API를 대부분 다 사용 가능합니다, 실제로 RenderGraph 호환 코드로 변경할때 가장 쉬운 선택지입니다.

UnsafePass

RasterPass는 NativeRenderPass로 동작하는 SubPass입니다.

CommandBuffer 클래스가 아닌 RasterCommandBuffer 클래스를 활용해야하며, 기존 CommandBuffer API 사용이 안됩니다. 대표적으로 SetRenderTarget 대신, builder.SetRenderAttachment 함수를 이용해야합니다.

RasterPass

UnsafePass & RasterPass 차이점

RasterPass는 1 SubPass당 1 Drawcall만 가능합니다, 위 예제 처럼 2번 Drawcall해야한다면 SubPass 2개 선언해야합니다.

NativeRenderPass의 Pass 병합 혹은 FrameBufferFetch 사용할게 아니라면 그냥 UnsafePass로 개발해도 성능 차이 없습니다.

5. builder.SetRenderFunc static 람다 함수 호출 권장

builder.SetRenderFunc 함수를 통해 람다 함수를 호출하는 방식으로 구현합니다.

이때 호출하는 람다 함수는 static으로 선언해야 합니다. 왜냐하면 람다 함수가 자신의 외부 스코프에 있는 변수를 "캡처"하면, 컴파일러는 이 변수들을 저장하기 위한 보이지 않는 클래스를 만들고 이 클래스의 인스턴스를 힙(Heap) 메모리에 할당하게 됩니다.

쉽게 말해서 GC 발생 할 수 있다는 것 입니다.

6. FrameBufferFetch 렌더 호출 방법

FrameBufferFetch를 통해 샘플링하기 위해서 아래 조건이 충족되어야 합니다.

GPU & Graphics API가 타일 렌더 기반으로 동작해야함. (Vulkan 지원 급 모바일은 대부분 OK, 그 외 DX 계열은 안됨)
이전 렌더링 화면 버퍼와 Target 버퍼와 해상도, 포맷 등 RenderTexture 속성이 일치해야함.
UV offset 불가능, 렌더링하는 픽셀 위치의 픽셀만 샘플링 가능.

FrameBufferFetch Pass를 렌더링할때 Texture2D가 아닌 SetInputAttachment 함수를 통해 렌더타겟과 인덱스를 설정합니다.

그리고 Shader에서는 렌더텍스처 이름이 아닌, 인덱스로 바인드합니다.

FrameBufferFetch는 좋은가?

FrameBufferFetch는 메모리에 저장된 텍스처가 아닌 타일 메모리에 저장된 픽셀 정보를 바인드하기 때문에 대역폭 사용량이 없고 샘플링 속도가 빠릅니다.

그런데 아직 Unity6에서는 사용하기에는 불안정합니다, 가끔 렌더버퍼 바인드가 오류나는지 이유 없이 무한 튕김 증상이 일어날 때도 있고, Memoryless로 동작해야하는데 아직 iOS Metal API 외에 Vulkan 사용하는 안드로이드 계열에서 메모리에 RenderTexture를 저장하고 있습니다.

https://docs.unity3d.com/6000.1/Documentation/ScriptReference/RenderTexture-memorylessMode.html

Unity PerObjectRenderTexture UI 시스템 개발 과정

CatDarkGame — Tue, 15 Jul 2025 21:59:52 +0900

PerObjectRT 시스템 소개

PerObjectRT 시스템은 3D 월드 렌더러 객체를 별도 RenderTexture에 Atlas 형식으로 렌더링하고 해당 RenderTexture를 UGUI에서 참조해서 렌더링하는 시스템입니다.

주요 목적은 Spine 오브젝트 다수를 UGUI에 한번에 렌더링하기 위해 개발했으며, 그 외에도 파티클 시스템이나, 일반 Mesh Renderer & Skinned Mesh Renderer까지 동일하게 사용 가능합니다.

Spine에서 제공하는 Skeleton Render Texture와 목적은 비슷하지만, PerObjectRT 시스템은 3D 월드에서 Spine에 파티클 시스템 및 기타 Renderer 오브젝트를 합친 결과물을 드로우콜로 한번으로 UGUI에 출력할 수 있는 차이점이 있습니다.

또한 URP 렌더파이프라인이 아닌, 직접 CommandBuffer에 렌더링하는 시스템으로 개발되어, 카메라 없이 단독으로 렌더링 가능합니다. 따라서 불필요한 Culling & Sorting 등 비용이 발생하지 않고 오직 원하는 오브젝트를 RenderTexture에 렌더링하는 비용만 발생합니다.

커스텀 랜더파이프라인

URP 렌더파이프라인은 모두 카메라에서 수집한 정보를 기반으로 동작합니다, 그래서 카메라에서 수행하는 Culling & Sorting 등 비용이 발생하게 되는데, 제작하는 시스템에서는 원하는 오브젝트만 RenderTexture에 렌더링하는 것이기 때문에 이러한 작업은 불필요한 비용 발생입니다.

그래서 URP 렌더파이프라인을 이용하지 않고 직접 커맨드버퍼에 ViewProjection 정보를 세팅하고 메쉬를 드로우하는 시스템 개발을 했습니다.

1. PerObjectRT시스템 메인쓰레드 비용, 2. 기본 카메라 메인쓰레드 비용.

URP 렌더파이프라인을 이용하는 경우, UniversalCameraData로부터 Culling & Sorting 등 처리가 완료된 카메라 프러스텀에 보이는 RendererList가 들어오게 되며, 해당 데이터를 기반으로 렌더링 호출하도록 동작합니다.

이 RendererList나, CullingResult 데이터는 URP 패키지 Internel로 되어 있거나 Unity 블랙박스 코드로 되어 있어 접근 및 수정이 불가능합니다.

직접 커맨드 버퍼로 렌더링 호출하고 싶은 경우, 우선 RenderPipelineManager 렌더링 콜백 함수를 통해 렌더링 호출 이벤트를 받을 수 있으며, 해당 함수 내부에 커맨드 버퍼 명령을 구현합니다.

PerObjectRT 시스템은 사전에 수집한 Renderer 정보를 직접 생성한 RenderTexture에 렌더링하도록 구현했습니다.

이때 카메라가 없기 때문에 View & Projection Matrix를 각 오브젝트가 순차적으로 캡처되도록 해야합니다.

행렬 정보 계산은 다음 파트에서 설명합니다.

PerObject Renderer 객체 정보 수집, Bounds & VP Matrix 계산

Monobehaviour 객체로 Renderer 및 Bounds, Transform을 수집합니다. 해당 Monobehaviour 컴포넌트가 붙은 오브젝트는 PerObjectRT 렌더 시스템에 렌더링하게 됩니다.

수집한 Bounds 및 Transform 정보는 단일 매니저 클래스에 Register(등록)해서 단일 List로 관리됩니다.

등록되는 시점에 LocalBounds와 View & Projection 행렬 정보를 계산합니다.

단일 List로 관리하는 이유는, 다수의 PerObjectRT Renderer 객체들의 OrthoViewProjection 행렬 값을 한번에 병렬 계산하기 위함입니다. 병렬 계산은 Job & BurstCompile을 활용했으며 이를 위해 모든 데이터는 Value 타입을 사용하여 Native 자료형을 사용할 수 있도록 합니다.

일반적으로 Job을 활용할때 Native 임시 객체를 생성하여 값을 복사하는 과정을 거치는데, 저는 unsafe 방식으로 구현해서, 직접 메모리 포인터(주소)값을 참조하도록 하여, 객체 복사 없이 Job을 호출하도록 했습니다.

[BurstCompile]
        private unsafe struct CalculateViewProjJobParallel : IJobParallelFor
        {
            [NativeDisableUnsafePtrRestriction][ReadOnly] public float3* LocalCorners;
            [NativeDisableUnsafePtrRestriction][ReadOnly] public float3* ViewCorners;
            [ReadOnly] public float3 Padding;
            [ReadOnly] public float Distance;
            [ReadOnly] public float NearClipOverride;
            
            [NativeDisableParallelForRestriction] 
            public NativeList<OrthoViewProjData> OrthoViewProjDatas;
            
            public unsafe void Execute(int index)
            {
                OrthoViewProjData data = OrthoViewProjDatas[index];
                CalculateOrthoViewProjection(ref data);
            }
            
            private unsafe void CalculateOrthoViewProjection(ref OrthoViewProjData data)
            {
                float3 extentsWithPadding = new float3(data.BoundsExtents + Padding);
                float3 min = new float3(data.BoundsCenter - extentsWithPadding);
                float3 max = new float3(data.BoundsCenter + extentsWithPadding);
           
                LocalCorners[0] = min.xyz;
                LocalCorners[1] = new float3(min.x, min.y, max.z);
                LocalCorners[2] = new float3(min.x, max.y, min.z);
                LocalCorners[3] = new float3(min.x, max.y, max.z);
                LocalCorners[4] = new float3(max.x, min.y, min.z);
                LocalCorners[5] = new float3(max.x, min.y, max.z);
                LocalCorners[6] = new float3(max.x, max.y, min.z);
                LocalCorners[7] = max.xyz;
        
                float3 localFrontCenter = new float3(data.BoundsCenter.x, data.BoundsCenter.y, max.z);
                float4 localFrontCenter4 = new float4(localFrontCenter, 1.0f);
                float4 worldFrontCenter4 = math.mul(data.LocalToWorldMatrix, localFrontCenter4);
                float3 worldFrontCenter = worldFrontCenter4.xyz / worldFrontCenter4.w;
                
                float3 objForward = math.normalize(math.mul(data.LocalToWorldMatrix, new float4(0, 0, 1, 0)).xyz);
                float3 objUp = math.normalize(math.mul(data.LocalToWorldMatrix, new float4(0, 1, 0, 0)).xyz);
                float3 eye = worldFrontCenter - objForward * Distance;
                float4x4 viewMatrix = float4x4.LookAt(eye, worldFrontCenter, objUp);
              
                for (int i = 0; i < 8; i++)
                {
                    float4 localCorner4 = new float4(LocalCorners[i], 1.0f);
                    float4 worldCorner4 = math.mul(data.LocalToWorldMatrix, localCorner4);
                    float3 worldCorner = worldCorner4.xyz / worldCorner4.w;
                    float4 viewCorner4 = math.mul(viewMatrix, new float4(worldCorner, 1.0f));
                    ViewCorners[i] = viewCorner4.xyz / viewCorner4.w;
                }
                
                float left = float.MaxValue;
                float right = float.MinValue;
                float bottom = float.MaxValue;
                float top = float.MinValue;
                float viewMaxZ = float.NegativeInfinity;
                float viewMinZ = float.PositiveInfinity;
                for (int i = 0; i < 8; i++)
                {
                    left = math.min(left, ViewCorners[i].x);
                    right = math.max(right, ViewCorners[i].x);
                    bottom = math.min(bottom, ViewCorners[i].y);
                    top = math.max(top, ViewCorners[i].y);
                    viewMaxZ = math.max(viewMaxZ, ViewCorners[i].z);
                    viewMinZ = math.min(viewMinZ, ViewCorners[i].z);
                }
                
                float nearPlane = (viewMaxZ < 0.0f) ? -viewMaxZ : NearClipOverride;
                float farPlane = (viewMinZ < 0.0f) ? -viewMinZ : NearClipOverride + 1.0f;
                /*float4x4 projMatrix = new float4x4(
                    new float4(2f / (right - left), 0f, 0f, 0f),
                    new float4(0f, 2f / (top - bottom), 0f, 0f),
                    new float4(0f, 0f, -2f / (farPlane - nearPlane), 0f),//
                    new float4(-(right + left) / (right - left), -(top + bottom) / (top - bottom), 
                              -(farPlane + nearPlane) / (farPlane - nearPlane), 1f));*/
                float4x4 projMatrix = new float4x4(
                    new float4(2f / (right - left), 0f, 0f, 0f),
                    new float4(0f, 2f / (top - bottom), 0f, 0f),
                    new float4(0f, 0f, 2f / (farPlane - nearPlane), 0f), 
                    new float4(-(right + left) / (right - left), -(top + bottom) / (top - bottom), 
                        (farPlane + nearPlane) / (farPlane - nearPlane), 1f)); 
                
                *data.ViewMatrix = viewMatrix;
                *data.ProjMatrix = projMatrix;
            }
        }

위와 같은 구현을 통해 PerObjectRT Renderer 객체는 실시간으로 Renderer의 Bounds 가 변경되어도 Local Bounds 및 ViewProjection 행렬 재구성이 빠른 속도로 가능하며, 대량의 오브젝트 대응도 가능하게 됩니다.

또한 Spine & SkinnedMeshRenderer의 애니메이션에 맞게 동적 Bounds 조절 가능합니다.

RenderTexture Atlas 구성

PerObjectRT 시스템에서 렌더링하는 RenderTexture는 PerObjectRT Renderer 갯수에 따라 동적으로 Atlas 사이즈를 조절합니다. Atlas는 단순하게 Slice(객체 1개) 크기와 최대 RT 사이즈를 지정해서 사이즈 변경이 필요하면 RT 객체 재생성하는 방식으로 제작했습니다.

추후에 Rectangle Packing과 같은 알고리즘을 활용해서 고정된 사각형 Slice가 아닌 적절하게 Atlas 빈공간에 쑤셔 들어가는 방식으로 개선 필요합니다.

참고 : https://github.com/ThomasMiz/RectpackSharp

internal static void CalculateSliceData(int sliceCount, out int slicesPerRow, out Vector2 scaledSliceSize, out Vector2Int atlasResolution)
        {
            if (sliceCount < 1)
            {
                slicesPerRow = 0;
                scaledSliceSize = Vector2.zero;
                atlasResolution = Vector2Int.one;
                return;
            }

            Profiler.BeginSample(ProfilerStrings.CalculateSliceData);
            
            Vector2Int sliceResolution = SliceResolution;
            Vector2Int maxAtlasResolution = AtlasResolution;

            int maxSlicesPerRow = maxAtlasResolution.x / sliceResolution.x;
            int maxRows = maxAtlasResolution.y / sliceResolution.y;
            int maxAllowedSlices = maxSlicesPerRow * maxRows;

            // Slice 개수가 최대치를 초과하는 경우 Slice 크기를 축소
            scaledSliceSize = sliceResolution;
            if (sliceCount > maxAllowedSlices)
            {
                float uvScale = Mathf.Sqrt((float)maxAllowedSlices / sliceCount);
                scaledSliceSize.x = sliceResolution.x * uvScale;
                scaledSliceSize.y = sliceResolution.y * uvScale;
            }
            slicesPerRow = Mathf.FloorToInt(maxAtlasResolution.x / scaledSliceSize.x);
            int rowsNeeded = Mathf.CeilToInt((float)sliceCount / slicesPerRow);

            // Atlas 크기 계산 (Slice 축소가 없다면 최적의 크기, 축소가 있다면 최대 크기 유지)
            atlasResolution = sliceCount > maxAllowedSlices
                ? maxAtlasResolution
                : new Vector2Int(
                    Mathf.CeilToInt(Mathf.Min(sliceCount, slicesPerRow) * scaledSliceSize.x),
                    Mathf.CeilToInt(rowsNeeded * scaledSliceSize.y)
                );
            
            Profiler.EndSample();
        }

PerObjectRT Renderer 2개 & 3개일때 자동으로 Atlas 사이즈 조절.

UGUI에서는 단일 Atlas Texture를 사용하기 때문에 배칭 조건만 된다면 1 드로우콜로 일괄 렌더링 가능합니다.

Tool 사용성 & API

툴 사용성은 매우 단순하게 디자인했습니다.

UGUI에 PerObjectRT Image 컴포넌트 추가해서 PerObjectRT Renderer 컴포넌트를 참조하면 해당 UI Image에 참조한 객체가 렌더링됩니다. 둘 중 하나가 비활성화하면 렌더링되지 않습니다.

다른 스크립트에서 런타임 도중 객체 추가 & 삭제 관리 가능하도록 주요 함수는 public으로 선언되어 있습니다.

한계점

PerObjectRT 시스템은 목적에 맞게 개발되어, 실제 프로젝트에 사용되고 있습니다. (프로젝트는 추후 공개)

하지만 몇가지 큰 한계점이 존재합니다.

SRP Batcher 미지원.
실시간 라이팅 및 UnityPerDraw 상수 버퍼 관련 기능 미지원.
Animator 및 ParticleSystem Camera Culling 미지원.

위 한계점은 전부 Unity & URP 내장 시스템에서 동작하는 기능으로, 커맨드버퍼로 직접 렌더링하는 시스템 특성상 해당 기능을 직접 구현하지 않으면 극복 불가능합니다.

위 기능들을 하나같이 다 규모가 큰 작업으로, 차라리 성능 낭비를 좀 하더라도 URP 렌더파이프라인 기반으로 다시 만드는게 더 나을 것 같습니다.

Unity6 Dynamic Resolution 소개 및 대응 방법

CatDarkGame — Thu, 10 Jul 2025 22:28:26 +0900

개요

Dynamic Resolution은 런타임 중에 렌더링 해상도를 동적으로 제어하는 시스템입니다.
프레임 버퍼 해상도는 유지하고 렌더링하는 영역만 조정하는 동작 방식이며 GPU 픽셀 연산과 대역폭 최적화 효과를 얻을 수 있습니다.
Unity6에서 동작하며, 그 이전 버전에서 옵션은 존재했지만 기본적으로 동작하지 않았습니다.
렌더 패스 및 프레임 버퍼를 활용하는 기능을 개발한다면 Dynamic Resolution 지원하도록 구현해야 합니다.

Dynamic Resolution 기능 사용 방법

Unity6 환경 기준, Camera 컴포넌트에 "UPR Dynamic Resolution" 옵션을 활성화합니다.

Unity6 이전 버전에서는 "Allow Dynamic Resolution" 옵션으로 존재했지만, Unity 2022.3.38f1 버전 기준으로 활성화해도 동작하지 않고 URP 내장 Shader 및 RenderPass에서 기능을 지원하도록 구현되어 있지도 않습니다.

좌 : Unity6000.0.32f1 우 : Unity 2022.3.38f1

Dynamic Resolution 해상도 제어는 스크립트에서 "ScalableBufferManager" 클래스를 통해서 제어할 수 있으며 일반적으로 디바이스 성능 정보를 기준으로 런타임에서 동적으로 조정되도록 구현합니다.

아래는 유니티 도큐먼트 페이지에서 제공하는 샘플 스크립트입니다.

https://docs.unity3d.com/6000.1/Documentation/Manual/DynamicResolution-control.html

Dynamic Resolution 동작 원리와 최적화 이득

기본 상태

Dynamic Resolution 적용

Dynamic Resolution을 통해서 렌더링 해상도를 제어하면 위 예시와 같이, 프레임 버퍼(렌더 텍스처) 해상도는 유지하고 렌더링되는 영역만 조정합니다. 이로서 시스템 메모리에 점유하는 렌더 텍스처 용량은 변하지 않지만, GPU 픽셀 연산과 대역폭 최적화 효과를 얻을 수 있습니다.

Render Scale & Screen.SetResolution 옵션과 차이점

Dynamic Resolution 외에 렌더 해상도 조정 옵션은 추가로 Render Scale & Screen.SetResolution 기능이 존재합니다.

Render Scale 옵션은 실제 프레임 버퍼 (렌더 텍스처) 해상도 자체를 조정하는 옵션이며 Screen.SetResolution은 어플리케이션 해상도 자체를 조정합니다.

Screen.SetResolution과 용도 차이는 RenderScale은 Camera 렌더링 단계에서 프레임 버퍼 해상도를 조정해서 Final Blit 단계에서 다시 원본 해상도로 복구해서 UI를 해상도 조정 영향 받지 않고 선명하게 렌더링 가능하다는 점이 있습니다.

(Screen Space - Overlay UI만 해당됨)

Render Scale 옵션은 URP Renderer Asset 혹은 스크립트에서 제어 가능

Render Scale & Screen.RetResolution 또한 런타임 도중 동적으로 제어 가능하지만 Dynamic Resolution과 다르게 1 프레임 단위로 렌더링 해상도 제어하는 용도가 아닙니다. 왜냐하면 프레임 버퍼 해상도가 변경되면 한 프레임 렌더링에 필요한 모든 렌더 텍스처를 새로 생성해야 하기 때문에 해상도 변경 순간 프레임 히칭 및 GC 발생하여 성능 부하 발생하기 때문입니다.

(원래 렌더 텍스처를 한번 생성해 놓고 재활용하는 방식으로 동작함)

그래서 Dynamic Resolution은 Adaptive Performance와 같이 디바이스 온도나 프레임 레이트 정보를 기반으로 프레임 단위로 렌더링 해상도 제어하는 용도로 사용합니다.

추가로 Dynamic Resolution 또한 Final Blit 단계에서 원본 해상도로 복구하기 때문에 Screen Space - Overlay UI 해상도에 영향주지 않습니다.

Dynamic Resolution Shader & RenderPass 지원 방법

Unity6 버전으로 오면서 내장 Shader 및 Blitter 클래스의 코드가 많이 변화되었으며, 그 중에서 아래와 같이 이름만 봐도 Dynamic Resolution과 연관되어 보이는 변수 & 함수들이 확인됩니다.

Unity 6000.032f1 - Blit.hlsl

Unity 6000.1.9f1 기준, 이와 관련해서 내장 Shader 및 구현 로직을 확인해본 결과.

대부분 UV 처리 관련 코드는 Blitter 클래스 및 Blit.hlsl와 같은 편의성 헬퍼 클래스를 위한 기능으로 확인되며

화면에 꽉차게 그리는 렌더패스 스타일 기준으로 Dynamic Resolution은 애초에 Viewport 자체를 화면 버퍼보다 작게 세팅되기 때문에 별도 대응할 필요 없습니다.

(혹시 제가 모르는 무언가가 있다면 댓글로 알려주시면 감사드립니다.)

다만 Bloom & DoF와 같은 다운샘플링 & 블러 처리하는 효과 구현에서는 보통 _BlitTexture_TexelSize와 같은 RenderTexture 사이즈와 텍셀 정보 데이터를 이용하게되는데, Dynamic Resolution을 사용하는 경우, 실제 Viewport 사이즈만 조절되기 때문에 이에 대한 대응은 필요합니다.

(Unity 6000.0.32f1 기준, URP Bloom이 이 대응이 안되있어서 Dynamic Resolution으로 해상도 낮추면 Blur가 더 퍼짐.)

PostProcessUtils.SetSourceSize 함수를 이용한다면, 내부에서 DynamicResolution의 해상도 값을 통해 _SourceSize라는 변수 명으로 셰이더 글로벌 상수 버퍼로 전달할 수 있습니다. _BlitTexture_TexelSize를 _SourceSize 로 대체하면 다운 샘플링 & 블러 처리에 Dynamic Resolution 대응 가능합니다.

그 외로 Dynamic Resolution은 _GlobalMipBias에도 영향을 주는데, 조정된 렌더 해상도에 알맞는 MipBias가 설정되기 위함으로 보입니다. 일반적인 화면 효과 RenderTexture에는 Mipmap을 생성하지 않아서 신경 안써도 되지만, RenderObject Pass를 제작하는 경우에는 신경써야 합니다.

(Dynamic Resolution으로 절반 해상도로 만들면 MipBias를 -1.0로 Offset 시키는 원리)

Unity RenderBufferLoadAction & StoreAction 옵션 설명

CatDarkGame — Wed, 11 Jun 2025 00:29:19 +0900

개요

Unity 엔진에서 ScriptableRenderPass 등, 커맨드 버퍼에 RenderTarget 설정 할때 RenderBufferLoadAction & StoreAction 옵션에 대한 설명입니다. 해당 옵션은 SetRenderTarget으로 설정한 렌더버퍼에 대한 데이터를 메모리에 Load 옵션과 Store(방출) 옵션을 설정하는 것입니다.

옵션에 따라 메모리 대역폭에 영향을 주기 때문에 구현하는 RenderPass 목적에 따라 알맞게 설정하면 최적화에 도움됩니다.

옵션 설명

RenderBufferLoadAction 옵션

LoadAction.Load
- 기능 : GPU가 렌더링 할 때 기존 프레임 버퍼 내용을 로드합니다.
- 용도 : Blend 처리와 같이 현재 버퍼 내용과 이후 드로우콜 결과물이 합쳐지는 용도로 사용합니다.
- 성능 고려 사항 : 메모리에서 전체 버퍼를 읽어야 하기 때문에 대역폭 비용이 발생합니다.
LoadAction.DontCare
- 기능 : GPU가 렌더링 할 때 기존 프레임 버퍼 내용을 로드하지 않습니다.
- 용도 : 프레임 버퍼 내용을 덮어 쓸 때 사용합니다. (Blend는 안되지만 샘플링은 가능합니다.)
- 성능 고려 사항 : 가장 최적화된 옵션이며, 메모리 대역폭 절약합니다.
LoadAction.Clear
- 기능 : 프레임 버퍼 내용을 지정된 색상으로 초기화합니다, 깊이 버퍼 경우에는 흰색(1.0)으로 초기화됩니다.
- 용도 : 프레임 버퍼를 지우고 새로 그릴 때 사용합니다. 그런데 cmd.ClearRenderTarget 메소드로 동일한 처리 가능해서 왜 있는 옵션인지 모르겠습니다.
- 성능 고려 사항 : 메뉴얼 상에는 Clear 이후 LoadAction.Load로 동작한다고 합니다.

RenderBufferStoreAction 옵션

StoreAction.Store
- 기능 : 렌더링 결과를 메모리에 저장합니다.
- 용도 : 이 렌더 타겟을 다시 사용하거나 화면에 표시할 때 사용합니다. (화면에 그려야 하거나 다음 패스에서 샘플링 필요하면 사용)
- 성능 고려 사항 : 전체 렌더 타겟을 메모리에 쓰므로 대역폭 비용이 발생합니다.
StoreAction.DontCare
- 기능 : 렌더링 결과를 메모리에 저장하지 않습니다.
- 용도 : 일회성 계산이나 중간 결과물로 더 이상 필요하지 않은 렌더 타겟에 사용합니다.
- 성능 고려 사항 : 메모리 쓰기 작업을 수행하지 않으므로 메모리 대역폭을 절약합니다.
StoreAction.Resolve
- 기능 : 멀티샘플 버퍼의 여러 샘플을 통합하여 단일 샘플 텍스처로 변환합니다, 원본 멀티 샘플 버퍼 정보는 유지하지 않습니다.
- 용도 : MSAA 렌더링 후 결과를 샘플링해야 할 때 필요합니다.
- 성능 고려 사항 : 원본 멀티샘플 데이터는 버리므로 메모리 사용량이 줄어듭니다.
StoreAction.StoreAndResolve
- 기능 : 멀티샘플 버퍼를 원본 형태로 저장하고, 동시에 통합된 단일 샘플 버전도 생성합니다.
- 용도 : 멀티샘플 데이터를 계속 유지하면서 동시에 후처리를 위한 단일 샘플 버전이 필요할 때 사용합니다.
- 성능 고려 사항 : 두 형태의 데이터를 모두 저장하므로 메모리 사용량이 두 배로 증가할 수 있습니다.

만약 올바르지 않게 설정하면 발생하는 이슈

이슈 재현 환경은 LoadAction을 DontCare로 설정하고 Blend 셰이더 드로우콜 호출하게 세팅했습니다.

Blend 셰이더가 동작하기 위해서 RenderTarget의 프레임 버퍼 픽셀을 정보가 필요하기 때문에 LoadAction을 Load로 세팅하는 것이 올바른 것 입니다.

Unity 2022 & 6000.032 버전 기준으로 에디터에서는 문제 없이 동작합니다.

문제는 디바이스 빌드에서 발생하며 안드로이드 기준, GPU 칩셋 종류와 Graphics API에 따라 문제 현상이 다르게 발생합니다.

유니티 에디터

Adreno 750(갤럭시z플립6) / Vulkan

Adreno 750(갤럭시z플립6) / OpenGLES

Mali-G76(갤럭시s10e) / Vulkan

Mali-G76(갤럭시s10e) / OpenGLES

결과와 같이 SetRenderTarget 메소드의 RenderBufferLoad & Store 세팅을 올바르지 않게 하면 디바이스 환경에 따라 문제 발생하니 RenderPass 구현 용도에 알맞게 세팅 필요합니다.

	Vulkan	OpenGLES
Adreno 750(갤럭시z플립6)	정상	비정상
Mali-G76(갤럭시s10e)	비정상	정상

이전 문제되는 환경 세팅에서 RenderBufferLoad 옵션을 올바르게 세팅하는 경우 정상 동작합니다.

결론

앞선 설명을 반복해서 RenderBufferLoad & Store 옵션은 용도에 알맞게 세팅해야 합니다.

올바르지 않은 세팅에서 정상 동작되는 상황은 자세한 원인은 Xcode GPU FrameCapture와 같은 GPU 프로파일링 도구를 통해 확인해봐야 겠지만, API 단계에서 자동으로 처리하는 상황으로 보입니다.

스캐니메이션 게임 엔진 테스트

CatDarkGame — Wed, 21 May 2025 22:54:19 +0900

Unity Cubemap Shadow

CatDarkGame — Mon, 28 Apr 2025 20:46:10 +0900

Cubemap Shadow는 Cubemap에 ShadowMask를 캡처해서 밀폐된 실내 공간에서 창문이나 외부 구멍과 같은 외부 조명 그림자를 표현 할 수 있습니다.

위 샘플은 실시간 그림자 없이 그림자 처리한 결과물입니다.

참고 자료

https://community.arm.com/arm-community-blogs/b/mobile-graphics-and-gaming-blog/posts/dynamic-soft-shadows-based-on-local-cubemap

구현 원리

Camera.Rendercubemap API를 통해 Cubemap을 생성하면, 알파채널에 캡처되지 않은 마스크 영역이 기록됩니다.

이 정보를 그림자 마스크로 활용합니다.

Shader에서는 Cubemap 월드 픽셀 좌표와 라이트 좌표의 방향 벡터 정보를 기반으로 Cubemap 샘플링합니다.

CSM과 비교

좌 = CSM, 우 = CubemapShadow

Unity ShaderGraph Custom Lighting Model 활용 테스트

CatDarkGame — Tue, 15 Apr 2025 22:15:20 +0900

이전 포스팅에서 소개한 ShaderGraph Custom Lighting Model 활용 테스트 내용입니다.

https://darkcatgame.tistory.com/186

아래 자료를 참고해서 Universal Target을 유지하고, SubTarget만 커스텀으로 추가하는 방식으로 구현했습니다.

https://github.com/Zallist/unity.zallist.universal-simple-lit-shadergraph-target/tree/main

SubTarget 커스텀 추가를 통해 Skin, Hair 등 원하는 라이팅 모델을 ShaderGraph에서 사용할 수 있는 것이 가능하지만, Shader 코드 작성이 어렵고 엔진 API가 변동되면 에러 발생할 가능성이 매우 높습니다.

Unity ShaderGraph Custom Lighting Model 추가 방법

CatDarkGame — Thu, 10 Apr 2025 21:51:19 +0900

개요

Unity ShaderGraph에 Target 인터페이스를 기반으로 Custom Lighting Model 추가 방법을 소개합니다.

Unity 6000.0.32f1 URP 환경에서 테스트 내용입니다.
흔히 알려진 SubGraph 활용 방식이 아닌, ShaderGraph에서 직접 지원할 수 있게 합니다.

ShaderGraph에 Custom Lighting Model을 추가하고 싶은 이유

ShaderGraph 사용 장점은 통일된 라이팅 모델 기반으로 필요한 Shader를 빠르게 제작 가능한 것입니다.

하지만 ShaderGraph는 라이팅 모델 커스텀을 지원하지 않으며 URP Lit 등, 기본적으로 엔진에서 지원하고 있는 Lighting Model만 사용 가능합니다.

만약 PBR이 아닌 카툰 렌더링과 같이 특수한 라이팅 표현을 하고 싶거나 더 최적화된 PBR Lighting Model을 사용하고 싶다면, ShaderGraph를 사용하지 않고 HLSL 코드 기반으로 셰이더를 제작하거나, ShaderGraph에서 Unlit 기반으로 SubGraph를 활용해 어거지로 커스텀 라이팅 모델이 동작하도록 해야합니다.

참고 SubGraph Custom Lighting Model : https://nedmakesgames.medium.com/creating-custom-lighting-in-unitys-shader-graph-with-universal-render-pipeline-5ad442c27276

저는 프로젝트 맞춤형 Custom Lighting Model을 사용하며 ShaderGraph의 Shader 생산성을 얻고자 R&D 진행했습니다.

ShaderGraph Target 인터페이스 이용

ShaderGraph에 Target 설정 인터페이스가 있습니다, Target RenderPipline을 의미하는 것으로 추측되며 기본적으로 Universal(URP), Built-In, Custom RenderTexture 3가지 존재합니다.

ShaderGraph 패키지에 Universal을 제외한 다른 Target 구현 자료가 있어 해당 자료를 기반으로 Target을 추가하는 방식으로 진행합니다.

Custom Target & SubTarget 추가

UnityEditor.ShaderGraph.Target 클래스를 상속 받아 내용을 구현하면, 간단하게 ShaderGraph에 Target 추가 가능합니다.

대부분 코드는 기존 패키지 스크립트를 복제해서 제작했기 때문에 설명 생략합니다.

다음 SubTarget를 상속받는 클래스를 제작합니다.

Target은 RenderPipeline 개념이고 SubTarget이 Lighting Model이라고 이해합니다.

SubTarget은 ShaderGraph에서 Material 인터페이스에 추가됩니다.

Shader Generator 로직 연동

ShaderGraph는 제작된 노드 정보를 기반으로 Shader 코드 파일을 조립 생성하는 방식으로 동작합니다.

그래서 추가한 커스텀 Target & SubTarget이 원하는 Shader를 생성하기 위해서 재료가되는 Shader 코드 개발 필요합니다.

쉽게 개발하기 위해 ShaderGraph 패키지의 BuiltIn Target을 기반으로 작업합니다.

Generator는 ShaderPass.template 파일을 기준으로 템플릿 기반 코드 생성과 Define 전처리기 셰이더 코드 조립합니다.

조립되는 셰이더 코드는 복잡하고 오류 추적이 까다로우니, 간단한 Unlit부터 제작하면 편합니다.

또한 URP ShaderLibrary를 이용하기보다는 직접 새로 제작하는 것을 권장합니다.
(URP hlsl Include하면 Define 중복 선언 오류 발생하는데 해결 못함)

위에서 제작한 Pass 구조체와 동일하게 SubShaders 구조체까지 제작하고 SubTarget 클래스 Setup 함수에서 추가되도록 합니다.

CustomRPUnlitSubTarget.cs

위에서 제작한 커스텀 SubTarget은 ShaderGraph Generator 클래스에서 코드 생성 호출됩니다.

com.unity.shadergraph\Editor\Generation\Processors\Generator.cs

결과

Unlit Pass를 기반으로 CustomRP 추가 및 정상작동 됩니다.

Unity Stencil Test 학습서

CatDarkGame — Fri, 21 Feb 2025 22:46:52 +0900

Stencil Test란?

Stencil Buffer는 8bit 사이즈의 화면 버퍼이며 Fragment(픽셀)에 0 ~ 255 값을 기록합니다.

Stencil Test는 Stencil Buffer 정보를 기반으로 Fragment Shader를 동작시킬지 검사하는 작업이며 Rasterization 이후, Fragment Shader 전에 동작합니다.

Stencil Test에 통과 못한 Fragment는 Discard(폐기)되어 Fragment Shader 호출되지 않습니다.

(Stencil Test에 통과되지 못하면 Fragment 연산 자체가 안된다는 뜻)

GPU 렌더링 파이프라인

Vertex Stage
Rasterization(Fragment 생성)
Stencil Test
Depth(Z) Test
Fragment Stage
Blending & Color Write (프레임 버퍼 기록)
Depth Write & Stencil Write

Unity URP HLSL 기반 Stencil Shader Sample

Shader "CatDarkGame/StencilSample"
{
   Properties
    { 
        [MainTexture] _BaseMap("Texture", 2D) = "white" {}
        [MainColor] _BaseColor("Color", Color) = (1, 1, 1, 1)
        
        [Header(Cull Face)][Space(5)]
        [Enum(UnityEngine.Rendering.CullMode)] _CullMode("Cull Mode", Float) = 2
        
        [Header(Blend)][Space(5)]
        [Enum(UnityEngine.Rendering.BlendMode)] _SrcFactor("Src Factor", Float) = 1
        [Enum(UnityEngine.Rendering.BlendMode)] _DstFactor("Dst Factor", Float) = 0
        
        [Header(Depth)][Space(5)]
        [Enum(UnityEngine.Rendering.CompareFunction)] _ZTest("Z Test", Float) = 4
        [Enum(Off, 0, On, 1)] _ZWrite("ZWrite", Float) = 1
        
        [Header(Stencil)][Space(5)]
        [IntRange] _StencilRef("Reference", Range(0,255)) = 0
        [IntRange] _StencilReadMask("Read Mask", Range(0,255)) = 255
        [IntRange] _StencilWriteMask("Write Mask", Range(0,255)) = 255
        [Space(5)]
        [Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Comparison", Int) = 8
        [Enum(UnityEngine.Rendering.StencilOp)] _StencilPass("OP-Pass", Int) = 0
        [Enum(UnityEngine.Rendering.StencilOp)] _StencilFail("OP-Fail", Int) = 0
        [Enum(UnityEngine.Rendering.StencilOp)] _ZFail("OP-ZFail", Int) = 0
        /*
        [Enum(UnityEngine.Rendering.CompareFunction)] _StencilCompBack("ComparisonBack", Int) = 8
        [Enum(UnityEngine.Rendering.StencilOp)] _StencilPassBack("OP-PassBack", Int) = 0
        [Enum(UnityEngine.Rendering.StencilOp)] _StencilFailBack("OP-FailBack", Int) = 0
        [Enum(UnityEngine.Rendering.StencilOp)] _ZFailBack("OP-ZFailBack", Int) = 0
        [Space(1)]
        [Enum(UnityEngine.Rendering.CompareFunction)] _StencilCompFront("ComparisonFront", Int) = 8
        [Enum(UnityEngine.Rendering.StencilOp)] _StencilPassFront("OP-PassFront", Int) = 0
        [Enum(UnityEngine.Rendering.StencilOp)] _StencilFailFront("OP-FailFront", Int) = 0
        [Enum(UnityEngine.Rendering.StencilOp)] _ZFailFront("OP-ZFailFront", Int) = 0
        
        */
    }

    SubShader
    {
         Tags
        {
            "RenderType" = "Opaque"
            "RenderPipeline" = "UniversalPipeline"
            "UniversalMaterialType" = "Lit"
            "IgnoreProjector" = "True"
        }

        Pass
        {
            Name  "Forward"
            Tags {"LightMode" = "UniversalForward"}

            Cull [_CullMode]
            ZWrite [_ZWrite]
            ZTest [_ZTest]
            Blend [_SrcFactor] [_DstFactor]
            
            Stencil
            {
                Ref [_StencilRef]
                ReadMask [_StencilReadMask]
                WriteMask [_StencilWriteMask]

                Comp [_StencilComp]
                Pass [_StencilPass]
                Fail [_StencilFail]
                ZFail [_ZFail]
                /*                             
                CompFront [_StencilCompBack]
                PassFront [_StencilPassBack]
                FailFront [_StencilFailBack]
                ZFailFront [_ZFailBack]

                CompBack [_StencilCompFront]
                PassBack [_StencilPassFront]
                FailBack [_StencilFailFront]
                ZFailBack [_ZFailFront]
                */
            }

            HLSLPROGRAM
            #pragma target 4.5
            #pragma exclude_renderers gles d3d9
            
            #pragma vertex vert
            #pragma fragment frag

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            
            CBUFFER_START(UnityPerMaterial)
                float4 _BaseMap_ST;
                half4 _BaseColor;
            CBUFFER_END

            TEXTURE2D(_BaseMap);    SAMPLER(sampler_BaseMap);
            
            struct Attributes
            {
                float4 positionOS    : POSITION;
                float2 uv            : TEXCOORD0;
            };

            struct Varyings
            {
                float4 positionCS    : SV_POSITION;
                float2 uv            : TEXCOORD0;
            }; 
            

            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;

                float4 positionOS = input.positionOS;
                float3 positionWS = TransformObjectToWorld(positionOS.xyz);
                float4 positionCS = TransformWorldToHClip(positionWS);

                output.positionCS = positionCS;
                output.uv = input.uv * _BaseMap_ST.xy + _BaseMap_ST.zw;
                return output;
            }

            half4 frag(Varyings input) : SV_Target
            {
                float2 baseMapUV = input.uv.xy;
                half4 col = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, baseMapUV);
              
                half4 finalColor = col * _BaseColor;
                return finalColor;
            }
            
            ENDHLSL
        }
    }
}

Stencil 커맨드 설명

Stencil {
    Ref 1         // Stencil 비교 기준값 (Reference Value)
    Comp Equal    // Stencil Buffer 값 == Ref(1)일 때 통과
    Pass Keep     // Stencil Test 통과 시, Stencil Buffer 값 변경 없음
    Fail Zero     // Stencil Test 실패 시, Stencil Buffer 값을 0으로 설정
}

Stencil OP 옵션
Keep	기존 Stencil Buffer 값을 유지
Zero	Stencil Buffer 값을 0으로 설정
Replace	Ref 값으로 Stencil Buffer 값을 변
IncrSat	Stencil Buffer 값을 1 증가 (최대 255, 초과 시 255 유지)
DecrSat	Stencil Buffer 값을 1 감소 (최소 0, 이하 시 0 유지)
Invert	Stencil Buffer 비트를 반전
IncrWrap	Stencil Buffer 값을 1 증가 (255 초과 시 0으로 Wrap)
DecrWrap	Stencil Buffer 값을 1 감소 (0 이하 시 255로 Wrap)

Stencil Test 응용 예제 1 - Ref & Comp

	Red	Green	Blue
Render Queue	2000	2001	2002
ZTest	LessEqual	Disable	Disable
Stencil Ref	128	128	128
Stencil Comp	Always	Equal	Equal
StencilOp Pass	Replace	Zero	Keep

해석

Stencil Test는 Pass 별로 동작하기 때문에 Render Queue(렌더 순서)에 영향 받습니다.
Red의 StencilOp Pass는 Replace이기 때문에 Stencil Test에 통과된 픽셀에 Stencil Buffer에 Stencil Ref 값 128을 기록합니다.
Red의 Stencil Comp가 Always이기 때문에 Stencil Test를 항상 통과합니다. 하지만 ZTest가 LessEqual이기 때문에 Red보다 앞에 그려진 픽셀은 렌더링되지 않습니다.
Green과 Blue는 Red 뒤에 위치하기 때문에 ZTest를 비활성화해야 렌더링될 수 있습니다.
Green은 Stencil Comp가 Equal이기 때문에 Green이 렌더링되는 픽셀의 Stencil Buffer가 Stencil Ref 128과 동일해야 Stencil Test 통과됩니다.
Green의 StencilOp Pass가 Zero이기 때문에 Green의 Stencil Test가 통과된 픽셀의 Stencil Buffer 값은 0이됩니다.
Blue는 Green과 Stencil Ref & Comp 값이 동일하지만 Green이 렌더링되면서 Stencil Buffer 값을 0으로 만들었기 때문에 Green이 렌더링되지 않은 픽셀에만 렌더링됩니다.

Stencil Test 응용 예제 2 - Read & Write Mask

	Red	Green	캐릭터	Blue
Render Queue	2000	2001	2002	3000
ZTest	LessEqual	LessEqual	LessEqual	Always
Stencil Ref	128	129	131	15
Stencil Read Mask	255	255	255	1
Stencil Write Mask	255	1	1	255
Stencil Comp	Always	Always	Always	Equal
StencilOp Pass	Replace	Zero	Zero	Keep
StnecilOp ZFail	Replace	Replace	Replace	Keep

Stencil Read & Write Mask 개념

Stencil Comp(비교)는 Integer(정수) 기준으로 연산합니다.

Stencil Read & Write Mask를 Stencil Buffer & Ref 값을 8비트 이진수 Mask 기준으로 처리됩니다.

기본 값이 255이기 때문에 8비트 전부를 기록하지만, 만약 Mask 값을 128로 세팅한다면 0번 비트만 Stencil Buffer에 기록합니다.

위 예시로 캐릭터의 Ref 값은 131이지만 Stencil Write가 1이기 때문에 7번 비트만 Stencil Buffer에 기록하게 되어 Red와 캐릭터가 겹쳐서 렌더링된 픽셀의 Stencil Buffer 값은 131이 아닌 129가 됩니다.

Stencil Test 응용 예제 3 - Stencil Volume Mask

	Yellow	Gray	Red	Green
Render Queue	2000	2001	3000	3001
Cull	Back	Back	Back	Front
ZTest	LessEqual	LessEqual	GreaterEqual	GreaterEqual
Stencil Ref	0	224	1	128
Stencil Read Mask	255	255	255	129
Stencil Write Mask	255	255	1	255
Stencil Comp	Always	Always	Always	Less
StencilOp Pass	Replace	Replace	Keep	Keep
StnecilOp ZFail	Keep	Keep	Replace	Keep

Stencil Volume Mask는 Stencil & Depth Test를 통해 Volume과 겹친 픽셀을 검출하는 기법입니다.

Stencil Deferred Additional Light, Per Object Shadow 등의 기술에 사용됩니다.

Unity GPU Indirect Drawing 구현 가이드 & ISM 시스템 개발 과정

CatDarkGame — Wed, 15 Jan 2025 20:11:15 +0900

개요

유니티 엔진에서 GPU Driven Rendering 시스템 구현을 위한 구조화 버퍼 설계 활용, 셰이더 및 렌더러 구현에 대한 내용을 소개합니다.

주요 내용

드로우콜 원리 설명과 DrawInstanced 이해

GPU에 렌더 호출을 하기 위해 커맨드버퍼에 담는 정보와 유니티 엔진의 드로우콜 최적화 시스템에서 이를 어떻게 최적화하고 있는지를 설명합니다.

InstanceDraw 시스템 구현 튜토리얼

DrawMeshInstanced, DrawMeshInstancedProcedural, DrawMeshInstancedIndirect까지 유니티 엔진에서 제공하는 InstanceDraw API 사용 방법과 DrawInstanced를 위한 구조화 버퍼 설계 및 구현 방법을 설명합니다.

이해하기 쉽도록 만든 샘플 프로젝트 공유합니다.

GPU Driven Rendering 시스템 개발 및 프로젝트 활용 사례

실제 프로젝트에 DrawInstanced 시스템 활용하기 위해 언리얼 엔진의 ISM(Instanced Static Mesh) 시스템과 유사한 GPU Driven Rendering 개발 과정을 소개합니다. 프로젝트에 시스템 도입을 위한 인터페이스 설계와 런타임 성능을 최대한 높이기 위해 어떤 것들이 고려되었는지 알 수 있습니다.

그 외

프로젝트에 도입한 ISM 시스템의 다음 발전 방향을 소개합니다. Cluster Mesh Render와 유사한 방식으로 버텍스 인덱스 버퍼로 여러 메쉬를 1 드로우콜로 처리하는 등, 실험적인 기술 구현 내용을 설명합니다.

구글 슬라이드 : https://docs.google.com/presentation/d/1xxy7ouNLvLhFBdHa1YXj8iWzaMOTPqgT/edit#slide=id.p1

Instanced Static Mesh 시스템 개발 .pptx

Instanced Static Mesh 시스템 개발 유니티 엔진 GPU Instancing Renderer 시스템 오지후 email : dhwlgn12@gmail.com blog : https://darkcatgame.tistory.com/

docs.google.com

GPU Instancing 샘플 프로젝트 : https://github.com/CatDarkGame/GPUInstancingSample

GitHub - CatDarkGame/GPUInstancingSample

Contribute to CatDarkGame/GPUInstancingSample development by creating an account on GitHub.

github.com

붕괴 스타레일 해상도 별 RenderScale 확인

CatDarkGame — Tue, 7 Jan 2025 22:59:58 +0900

스타레일은 해상도 설정은 어플리케이션 해상도는 고정이며 RenderScale만 조정됩니다.
RenderDoc을 통해 파악된 해상도 설정 별로 RenderScale 조정 값을 정리합니다.

어플리케이션 해상도 : 2560x1440

매우 높음 (1494x840) (-41.67%)
높음 (1494x840) (-41.67%)
중간 (1280x720) (-50.0%)
낮음 (1138x640) (-55.56%)
매우 낮음 (960x540) (-62.5%)

Unity EditorWindow SerializedProperty 활용 예제

CatDarkGame — Tue, 17 Dec 2024 20:31:25 +0900

용도

Editor 툴 개발 시, 별도의 EditorWindow를 띄워 툴 조작이 필요한 경우 SerializedProperty 객체를 참조하는 방식으로 구현.

EditorWindow

using UnityEditor;
using UnityEngine;

public class CustomGradientEditorWindow : EditorWindow
{
    public static void Open(SerializedProperty property, Object target)
    {
        CustomGradientEditorWindow window = CreateInstance<CustomGradientEditorWindow>();
        window.titleContent = new GUIContent("CustomGradientEditorWindow");
        window.gradientProperty = property;
        window.targetObject = target;
        
        window.ShowUtility();
    }
    
    private SerializedProperty gradientProperty; 
    private Object targetObject; 

    private void OnGUI()
    {
        if (gradientProperty == null || targetObject == null) return;
        
        EditorGUI.BeginChangeCheck();
        Gradient gradient = gradientProperty.gradientValue;
        gradient = EditorGUILayout.GradientField(gradient);

        if (EditorGUI.EndChangeCheck())
        {
            Undo.RecordObject(targetObject, "Edit Gradient");
            gradientProperty.gradientValue = gradient;
            
            gradientProperty.serializedObject.ApplyModifiedProperties();
            EditorUtility.SetDirty(targetObject);
        }
        
        if (Event.current.keyCode == KeyCode.Escape) 
        {
            Close();
        }
    }
    
    // 다른 Window 클릭 이벤트
    private void OnLostFocus()
    {
        // Close();
    }
}

CustomEditor - Monobehaviour

using System;
using UnityEditor;
using UnityEngine;

[CustomEditor(typeof(GradientObjectSample))]
public class GradientObject_Editor : Editor
{
    private SerializedProperty gradientProperty;
    private void OnEnable()
    {
        gradientProperty = serializedObject.FindProperty("gradient");
    }

    public override void OnInspectorGUI()
    {
        EditorGUILayout.PropertyField(gradientProperty);

        if (GUILayout.Button("Custom Editor"))
        {
            CustomGradientEditorWindow.Open(gradientProperty, target);
        }
    }
}

public class GradientObjectSample : MonoBehaviour
{
    [SerializeField] private Gradient gradient;
    
}

URP 2D Sprite FakeShadow for 2.5d

CatDarkGame — Sat, 14 Dec 2024 00:08:22 +0900

https://github.com/CatDarkGame/URP2DSpriteFakeShadow/blob/main/README.md

URP2DSpriteFakeShadow/README.md at main · CatDarkGame/URP2DSpriteFakeShadow

URP 2D Sprite FakeShadow for 2.5d. Contribute to CatDarkGame/URP2DSpriteFakeShadow development by creating an account on GitHub.

github.com

Unity Screen Space Camera 테스트

CatDarkGame — Wed, 4 Dec 2024 22:20:35 +0900

테스트 이유

UGUI Canvas를 Screen Space Overlay로 처리하면 안되는 경우, 별도 UI 카메라를 추가로 사용해야 합니다.
UI 카메라는 Culling, 각종 Pass 초기화 등 UI에 불필요한 기능이 동작하여 CPU 성능 저하가 발생합니다.
Screen Space Overlay를 사용할 수 없는 상황에 관련 성능 저하를 극복할 수 있는 방법을 테스트했습니다.

테스트 방향

Screen Space Camera에 별도 UI 카메라가 아닌 메인 카메라를 그대로 사용합니다.
Layer Mask를 활용해 UI가 렌더링되지 않도록 합니다.
Render Objects RendererFeature를 활용해 UI가 AfterPostProcess 단계에서 렌더링되도록 합니다.
Unity 2022.3.38f1 환경에서 테스트합니다.

테스트 결과

샘플 프로젝트에서 UI 기능은 문제 없이 동작합니다.
UI 카메라 사용에 의한 불필요한 기능 동작은 발생하지 않습니다. 하지만 Camera Transform 변화로 인한 Cavna Rebuild 발생합니다.
별도 UI 카메라 사용에 비해서 이 테스트가 얼마나 성능 개선이 되는지 검증이 필요합니다.
FXAA와 같이 Final Bilt 단계에서 동작하는 렌더패스가 UI에 영향을 줍니다.
- AfterRendering 단계에서 화면 버퍼에 접근하는 것은 쉽게 되지 않습니다.

테스트 내용

Screen Space - Camera에 메인 카메라 세팅합니다.
Render Objects 렌더 피처 추가 후, 후처리 이벤트 이후에 UI 레이어가 렌더링되록합니다. 이때 Depth Test를 Always로 세팅합니다.

세팅이 완료되면 렌더링은 아래와 같이 동작합니다.
AfterRenderingPostProcessing 단계에서 UI가 렌더링되기 때문에 UI는 후처리 효과 영향 받지 않습니다.

ColorSpace, 블랜딩 오류 검사를 위해 Screen Space Overlay와 비교해봤으며 샘플 프로젝트에서 이슈 없습니다.

카메라 Transform 변화되면 Canvas Rebuild 관련 기능이 동작합니다.
아래 테스트는 에디터에서 진행했으며 실제 타겟 디바이스에서 UI 카메라 사용과 비교해서 얼마나 성능 이득이 생기는지 검증 필요합니다.

Unity Light Probe Group Volume(Multiple Light Probe Group)

CatDarkGame — Thu, 28 Nov 2024 22:29:17 +0900

Custom Volume 시스템 제작, 씬 Lighting Data에서 추출한 SH 정보를 셰이더에 직접 전달 및 연산 처리하는 방법으로 시도했습니다.

기존 유니티는 여러 Light Probe Group을 설치해도 하나의 Light Probe 정보로 씬에 반영되어 오픈 필드에서 사용하는데 이슈가 있습니다.

이 접근 방법으로 씬에 Light Probe를 Volume 단위로 베이킹하여 관리 가능합니다.

문제 현상

https://discussions.unity.com/t/prefab-light-probes/735323

Unity Package Manager My Assets(구매 에셋) 목록 CSV 추출

CatDarkGame — Mon, 14 Oct 2024 23:35:58 +0900

개요

Unity Package Manger에 표시되는 My Assets (구매 에셋) 목록을 CSV 데이터로 일괄 추출하는 스크립트입니다.

기능 동작 검증을 위한 샘플 코드인점 참고 바랍니다. (사용성이 조잡하다는 의미)

사용법

1. 스크립트 제작

아래 코드를 복사해서 프로젝트 내부 Editor 스크립트를 생성합니다.

using UnityEditor;
using UnityEngine;
using System.Reflection;
using System.IO;
using System.Text;

namespace CatDarkGame.Editor
{
    public class PackageManagerHooker : EditorWindow
    {
        private static string k_OutputFileName = "MyAssetsList.csv";
        
        [MenuItem("Tools/PackageManager Hooker/Export MyAssets Info to CSV")]
        public static void ExportAssetStoreProductInfoToCSV()
        {
            var packageManagerWindowType = typeof(UnityEditor.Editor).Assembly.GetType("UnityEditor.PackageManager.UI.PackageManagerWindow");

            if (packageManagerWindowType == null)
            {
                Debug.LogError("먼저 Package Manager를 실행 후, My Assets 리스트를 로드하고 이 기능을 실행하세요.");
                return;
            }
            
            var packageManagerWindow = GetFirstInstance(packageManagerWindowType);
            if (packageManagerWindow == null) return;
            var packageList = GetPackageList(packageManagerWindow);
            if (packageList == null) return;
            var mAssetStoreCache = GetFieldValue(packageList, "m_AssetStoreCallQueue", "m_AssetStoreCache");
            if (mAssetStoreCache == null) return;
            var productInfos = GetFieldValue(mAssetStoreCache, "m_SerializedProductInfos") as object[];
            if (productInfos == null)
            {
                Debug.LogError("m_SerializedProductInfos is null.");
                return;
            }
            
            StringBuilder csvBuilder = new StringBuilder();
            csvBuilder.AppendLine("category,displayName,publisherName,publishedDate,assetStoreLinkUrl");
            foreach (var productInfo in productInfos)
            {
                var data = ExtractProductInfo(productInfo);
                csvBuilder.AppendLine(string.Join(",", data));
            }
            SaveCSV(csvBuilder.ToString());
        }

        private static object GetFirstInstance(System.Type type)
        {
            var instances = Resources.FindObjectsOfTypeAll(type);
            if (instances.Length == 0)
            {
                Debug.LogError("No PackageManagerWindow instance found.");
                return null;
            }
            return instances[0];
        }

        private static object GetPackageList(object window)
        {
            var mRoot = GetFieldValue(window, "m_Root");
            if (mRoot == null) return null;

            var packageListProperty = mRoot.GetType().GetProperty("packageList", BindingFlags.NonPublic | BindingFlags.Instance);
            if (packageListProperty == null)
            {
                Debug.LogError("packageList property not found.");
                return null;
            }

            return packageListProperty.GetValue(mRoot);
        }

        private static object GetFieldValue(object instance, string fieldName, string nestedFieldName = null)
        {
            var field = instance.GetType().GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance);
            if (field == null)
            {
                Debug.LogError($"{fieldName} field not found.");
                return null;
            }

            var value = field.GetValue(instance);
            if (value == null)
            {
                Debug.LogError($"{fieldName} is null.");
                return null;
            }

            if (!string.IsNullOrEmpty(nestedFieldName))
            {
                var nestedField = value.GetType().GetField(nestedFieldName, BindingFlags.NonPublic | BindingFlags.Instance);
                if (nestedField == null)
                {
                    Debug.LogError($"{nestedFieldName} field not found.");
                    return null;
                }
                value = nestedField.GetValue(value);
            }

            return value;
        }

        private static string[] ExtractProductInfo(object productInfo)
        {
            var productInfoType = productInfo.GetType();
            string category = (string)productInfoType.GetField("category").GetValue(productInfo);
            string displayName = (string)productInfoType.GetField("displayName").GetValue(productInfo);
            string publisherName = (string)productInfoType.GetField("publisherName").GetValue(productInfo);
            string publishedDate = (string)productInfoType.GetField("publishedDate").GetValue(productInfo);
            var assetStoreLink = productInfoType.GetField("assetStoreLink").GetValue(productInfo);
            
            string assetStoreLinkUrl = "";
            if (assetStoreLink != null)
            {
                assetStoreLinkUrl = (string)assetStoreLink.GetType().GetField("url").GetValue(assetStoreLink);
            }

            return new string[] { category, displayName, publisherName, publishedDate, assetStoreLinkUrl };
        }
        
        private static void SaveCSV(string csvData)
        {
            string filePath = EditorUtility.SaveFilePanel(
                "Save CSV File",               
                Application.dataPath,                           
                k_OutputFileName,    
                "csv"                        
            );
            
            if (!string.IsNullOrEmpty(filePath))
            {
                File.WriteAllText(filePath, csvData);
                Debug.Log($"CSV export complete: {filePath}");
            
                // 파일을 탐색기에서 선택
                EditorUtility.RevealInFinder(filePath);
            }
            else
            {
                Debug.LogWarning("File save canceled.");
            }
            AssetDatabase.Refresh();
        }
    }
}

2. Package Manager My Assets 목록 로드

Package Manger 실행 후, My Assets 목록을 전부 로드합니다.
Load / All까지 완료되야합니다.

스크롤을 끝까지 천천히해서 로딩 아이콘이 전부 완료되도록 합니다.

3. 아무 파일 선택해서 Reimport

프로젝트에서 아무 파일 선택해서 Reimport 합니다.
이 작업이 되야 PackageManger 리스트에서 정보 참조가 가능합니다.

4. CSV 추출 툴 실행

위 3번 과정 완료 후, Package Manager를 계속 켜 놓습니다.
그리고 Export MyAssets Info to CSV 기능을 실행하면 CSV 파일로 추출됩니다.

기타

CSV 파일은 "," 문자로 Colume을 구분하는데, 따로 예외처리 하지 않아서 CSV 파일 데이터가 이상하게 저장될 수 있습니다.

그 외 다른 Colume 정보

var productInfoType = productInfo.GetType();
                                                            
                                                            string id = (string)productInfoType.GetField("id").GetValue(productInfo);
                                                            string packageName = (string)productInfoType.GetField("packageName").GetValue(productInfo);
                                                            string description = (string)productInfoType.GetField("description").GetValue(productInfo);
                                                            string publisherName = (string)productInfoType.GetField("publisherName").GetValue(productInfo);
                                                            string category = (string)productInfoType.GetField("category").GetValue(productInfo);
                                                            string versionString = (string)productInfoType.GetField("versionString").GetValue(productInfo);
                                                            string versionId = (string)productInfoType.GetField("versionId").GetValue(productInfo);
                                                            string publishedDate = (string)productInfoType.GetField("publishedDate").GetValue(productInfo);
                                                            string displayName = (string)productInfoType.GetField("displayName").GetValue(productInfo);
                                                            string state = (string)productInfoType.GetField("state").GetValue(productInfo);
                                                            string publishNotes = (string)productInfoType.GetField("publishNotes").GetValue(productInfo);
                                                            string firstPublishedDate = (string)productInfoType.GetField("firstPublishedDate").GetValue(productInfo);
                                                            string publisherLink = (string)productInfoType.GetField("publisherLink").GetValue(productInfo);
                                                            
                                                            var assetStoreLinkField = productInfoType.GetField("assetStoreLink");
                                                            var assetStoreLink = assetStoreLinkField.GetValue(productInfo);
                                                            string assetStoreLinkName = "";
                                                            string assetStoreLinkUrl = "";

                                                            if (assetStoreLink != null)
                                                            {
                                                                var assetStoreLinkType = assetStoreLink.GetType();
                                                                assetStoreLinkName = (string)assetStoreLinkType.GetField("name").GetValue(assetStoreLink);
                                                                assetStoreLinkUrl = (string)assetStoreLinkType.GetField("url").GetValue(assetStoreLink);
                                                            }

Unity ShaderGraph Custom Function & Node 제작 가이드

CatDarkGame — Wed, 2 Oct 2024 23:29:05 +0900

개요

Unity ShaderGraph에서 Custom Function & Custom Node 제작 방법을 설명합니다.
Custom Function은 별도 hlsl 텍스트 파일을 참조하는 방식 기반으로 기본적인 네이밍 규칙 및 ShaderGraph와 연동 방법을 설명합니다.
Custom Node은 내장 노드와 같이 별도 노드를 제작하는 방법을 설명합니다.

*Unity 2022.3.38f1 기준 정보입니다.

Custom Function HLSL 제작 및 연동

ShaderGraph에서 Custom Function 노드 생성 후, hlsl 텍스트 파일을 참조 할 수 있습니다.

Custom Function 노드에서 직접 셰이더 코드를 작성 할 수 있지만, 에디터에서 코드 작성하는 것이 편합니다.

hlsl 코드 기본 구조

다음, Custom Function에 사용되는 hlsl 코드 기본 구조입니다.

ifndef 코드는 보통 중복 include 선언 방지용 디파인문입니다, 구지 안써도 상관 없지만 해당 hlsl 파일을 다른 파일에서 include 선언 대응용으로 작성합니다.
함수 네이밍은 "함수이름_half" & "함수이름_float" 2가지를 작성합니다. 함수 네이밍은 자유롭게 작성해도 상관 없습니다, 함수 이름 뒤에 자료형은 반드시 아래 규칙과 동일하게 작성 필요합니다.

함수 자료형은 Custom Function Node의 Precision(정밀도) 메뉴와 연동되는 부분이며 Single로 세팅하는 경우 "함수이름_float" 함수가 호출되는 방식입니다.

일반적으로 2가지 자료형 함수를 전부 작성하기 때문에 아래와 같이 기능 구현 부분을 별도 함수로 분리하면 코드 관리 효율이 증가합니다.
(구현 내용 자료형은 define문으로 관리 가능)

Custom Function 노드에 HLSL 연동하기

다음, Custom Function 노드에 hlsl 연동 과정입니다. 이 부분에서 규칙이 맞지 않으면 에러가 발생하니 참고합니다.

Source 항목에 hlsl 파일을 참조합니다.
Name 항목에 hlsl에 구현한 함수 이름을 작성합니다, 이때 _float & _half 자료형 글자를 제외하고 작성합니다.
Inputs & Outputs 항목에 함수 인자 값과 동일한 자료형으로 세팅합니다.
이름은 자유롭게 작성해도 되지만 자료형은 완벽히 동일해야합니다.

위 과정까지 진행하면 Custom Function이 정상 동작됩니다.

텍스처 샘플링 Custom Function 제작

다음, ShaderGraph가 아닌 Custon Function에서 텍스처 샘플링하는 방법 설명합니다.

기존에 작성하던 hlsl파일에 다른 함수를 추가로 작성해서 사용 가능합니다, CustomFunction에서 Name 항목에 작성한 함수 이름을 호출하는 방식입니다.

hlsl 파일에서는 샘플링을 위한 다른 hlsl 파일을 include 및 샘플링 코드를 작성합니다.

일반적으로 텍스처 파라미터는 Texture2D & TEXTURE2D 자료형을 사용하지만, 위 코드에서는 UnityTexture2D 자료형을 사용합니다. UnityTexture2D 자료형은 Custom Function 노드 파라미터 항목의 Texture2D와 연동되는 구조체 변수입니다.

UnityTexture2D 구조체에는 Texture2D와 SamplerState 변수 등이 포함되어 있어, 텍스처의 샘플러 정보가 같이 전달됩니다. UnityTexture2D.tex & .samplerstate 코드 작성으로 사용 가능합니다.

*변수 이름을 "texture" & "sampler" 문자를 사용하면 에러 발생합니다.

마지막 노드 연동 부분입니다, Custom Function 노드 부분은 앞선 내용과 동일하며, 그 외 텍스처 노드에서 UV 정보를 꺼내서 제작한 노드에 사용합니다.

여기서 언급한 UV 정보는 Material GUI에 보이는 Tile & Offset 값입니다.

텍스처 샘플링 Custom Function 제작 - 별도 샘플러 사용

다음, 앞선 내용과 동일하지만 텍스처 샘플링 정보가 아닌 별도 샘플링 정보를 사용하는 방법입니다.

hlsl 코드는 UnityTexture2D가 아닌 TEXTURE2D & SAMPLER 자료형을 사용합니다.

Custom Function 노드에서는 Bare Texture2D & Bare Sampler State 자료형을 사용합니다.

마지막으로 아래와 같이 노드 연결하면 동작합니다.

Custom Node 제작

Create Node에서 검색되며 활용 가능한 Custom Node 제작 방법 설명합니다.

Custom Function과 같이 노드 제작 후 별도 세팅 필요 없이 내장 노드와 같이 사용 가능 한 것이 장점입니다.

하지만 복잡한 기능은 제작하기 어렵습니다.

Assembly Definition Reference 생성

먼저 Custom Node 제작에 필요한 API는 URP Internal로 구현되어 있어 기본적으로 함수 접근이 되지 않습니다.

그래서 URP 패키지 내부 코드로 인식될 수 있는 Assembly Difinition Reference 기능을 활용합니다.

프로젝트 Assets 폴더 내부에 "Editor" 폴더 생성합니다. (이름 틀리면 안됩니다)
Project탭에서 아래 메뉴를 통해 Assembly Difinition Reference파일을 생성 후 Unity.ShaderGraph.Editor을 선택합니다.
- Project/Create/Assembly Difinition Reference

스크립트 생성 & 기본 구현

"노드이름"+"Node 이름으로 C# 스크립트를 생성합니다.

아래는 Grayscale 커스텀 노드 스크립트입니다. 코드 작성 방법은 매우 까다롭기 때문에 자세한 문법은 생략하고 중요 규칙만 설명합니다. 다른 코드 예제는 URP 패키지를 참고하세요.

클래스 이름 & Node 이름 문자열 규칙이 일치해야합니다.
static string 클래스에서 노드에 표시되는 input & output을 설정합니다.
static string 클래스 return 값은 셰이더 코드 문자열입니다. 즉 이 부분에 문자열로 셰이더 코드를 작성해야합니다.
셰이더 문자열 코드를 ShaderGraph Core부분에서 파싱해서 코드 생성 방식으로 동작합니다.
이곳에 작성하는 셰이더 코드는 문법이 조금 다릅니다. $precision은 float을 의미합니다, $precision3은 float3을 의미합니다.
dot, mul과 같은 기초 연산 함수는 기본적으로 지원하지만, 그외 include가 필요하거나 커스텀 함수 작성은 매우 복잡합니다.

using System.Reflection;
using UnityEngine;

namespace UnityEditor.ShaderGraph
{
    [Title("CustomNode", "GrayscaleColor")]     // Create Node 계층
    class GrayscaleColorNode : CodeFunctionNode
    {
        public GrayscaleColorNode()
        {
            name = "GrayscaleColor";        // Node 이름
        }

        protected override MethodInfo GetFunctionToConvert()
        {
            return GetType().GetMethod("GrayscaleColor", BindingFlags.Static | BindingFlags.NonPublic);
        }

        static string GrayscaleColor(
            [Slot(0, Binding.None)] ColorRGB color,
            [Slot(1, Binding.None)] out Vector1 Out)
        {
            return 
@"
{
    $precision luma = dot(color, $precision3(0.2126729, 0.7151522, 0.0721750));
    Out = luma.x;
}
";
        }
    }
}

[Unity6] GPU Resident Drawer 간단 스펙 확인

CatDarkGame — Mon, 23 Sep 2024 21:50:06 +0900

*Unity 6000.0.20f1 기준으로 작성된 자료입니다.

GPU Resident Drawer

Unity 6에 신규로 추가된 DOTS Instancing 기반 드로우콜 병목 최적화 시스템입니다.
Transform & Mesh 등, 흔히 드로우콜 속성의 렌더 API를 최적화하며, SRP Batcher와 병행해서 사용 가능합니다.
Mesh Renderer에 BatchRendererGroup 시스템이 내장된 것으로 보이며 DOTS Instancing 외에 GPU Culling 시스템까지 내장되어 있습니다.
GPU Occlusion Culling은 Hierarchical-Z Occlusion Culling 시스템 사용하는 것으로 추측됩니다.
Additional Light, SH, Reflection Probe 및 LOD 등 DOTS Instancing 셰이더 API가 이미 구현되어 있어 커스텀 셰이더 개발 시 활용 가능합니다.
Forward+만 지원하며 위 DOTS Instancing 셰이더 API 또한 Forward+ 전용으로 구현되어 있습니다.

확인 & 예상되는 한계점

Forward+만 지원.
Graphics API가 Vulkan 이상 디바이스만 지원. (Compute Shader & 구조화 버퍼 사용 가능해야함)
Mesh Renderer만 지원.
동일한 Mesh & Material의 오브젝트끼리 배칭 가능. 종류가 다양하면 오히려 성능 저하 예상.
모바일 환경에서 GPU Culling 안정성 여부 검증 필요.

개인 평가

기존 SRP Batcher만 사용했을때 많은 오브젝트에 의한 드로우콜 부하를 어느정도 완화 가능하겠지만 동일한 Mesh & Material끼리만 인스턴싱 가능하다는 부분에서 반쪽짜리 인스턴싱 시스템으로 평가함.
- (Material 버퍼 인스턴싱은 추후 업데이트에서 될 가능성 있음)
Mesh Index & Material Property 구조화 버퍼 구현을 통해 커스텀 가능하겠지만 GPU Culling 등 내장 시스템과 연동되지 않을 것이기 때문에 어차피 커스텀 Renderer 구현 필요함.

DOTS 지원 셰이더 샘플

Shader "CatDarkGame/DOTSSample"
{
    Properties
    { 
        [MainTexture] _BaseMap("Texture", 2D) = "white" {}
        [MainColor] _BaseColor("Color", Color) = (1, 1, 1, 1)
    }

    SubShader
    {
        Tags { "RenderType" = "Opaque" "Queue"="Geometry" "RenderPipeline" = "UniversalPipeline" }
        LOD 100

        Pass
        {
            Name  "DOTSSample"
            Tags {"LightMode" = "UniversalForward"}

            HLSLPROGRAM
            #pragma target 4.5

            #pragma vertex vert
            #pragma fragment frag
            
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl"

            CBUFFER_START(UnityPerMaterial)
                float4  _BaseMap_ST;
                half4   _BaseColor;
            CBUFFER_END

            #ifdef UNITY_DOTS_INSTANCING_ENABLED
                UNITY_DOTS_INSTANCING_START(MaterialPropertyMetadata)
                    UNITY_DOTS_INSTANCED_PROP(float4, _BaseColor)   // float 자료형만 지원
                UNITY_DOTS_INSTANCING_END(MaterialPropertyMetadata)

                // DOTS 전용 Static 변수에 값을 복제하여 사용하면 GPU 성능 높일 수 있다고함. (LitInput.hlsl 주석 참고)
                static float4 unity_DOTS_Sampled_BaseColor;
                void SetupDOTSLitMaterialPropertyCaches()  // UNITY_SETUP_INSTANCE_ID 디파인에서 호출됨
                {
                    unity_DOTS_Sampled_BaseColor            = UNITY_ACCESS_DOTS_INSTANCED_PROP_WITH_DEFAULT(float4, _BaseColor);
                }
                #undef UNITY_SETUP_DOTS_MATERIAL_PROPERTY_CACHES
                #define UNITY_SETUP_DOTS_MATERIAL_PROPERTY_CACHES() SetupDOTSLitMaterialPropertyCaches()
            
                #define _BaseColor              unity_DOTS_Sampled_BaseColor
            #endif
            
            TEXTURE2D(_BaseMap);    SAMPLER(sampler_BaseMap);
            
            struct Attributes
            {
                float4 positionOS : POSITION;
                float2 uv : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            }; 
            
            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;
                UNITY_SETUP_INSTANCE_ID(input);
                
                float4 positionOS = input.positionOS;
                float3 positionWS = TransformObjectToWorld(positionOS.xyz);
                float4 positionCS = TransformWorldToHClip(positionWS);

                output.positionCS = positionCS;
                output.uv = input.uv;
                return output;
            }

            float4 frag(Varyings input) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(input);
                float2 baseMapUV = input.uv.xy * _BaseMap_ST.xy + _BaseMap_ST.zw;
                float4 texColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, baseMapUV);
                
                float4 finalColor = texColor * _BaseColor;
                return finalColor;
            }
            
            ENDHLSL
        }
    }
}

참고 자료

Unity 도큐먼트 : https://docs.unity3d.com/6000.0/Documentation/Manual/urp/gpu-resident-drawer.html
GPU ResidentDrawer 정리 자료 : https://kj1241.github.io/graphics_development/UnityGDC24_GPUResidentDrawer

URP 14 - SimplePostBlur

CatDarkGame — Tue, 30 Jul 2024 21:02:20 +0900

개요

모바일 성능을 고려한 블러 포스트프로세싱입니다.
다운 샘플링 방식으로 블러를 표현하여 GPU 성능을 최대한 사용하지 않습니다.
마스킹 텍스처를 활용해 블러 영역 제어 가능합니다.
Unity 2022.3.38f1 / URP 14.0.3 버전 기준으로 제작되었습니다.
- URP 14의 최신 RendererFeature API를 적극 활용했습니다.

https://github.com/CatDarkGame/SimplePostBlur/tree/main?tab=readme-ov-file

GitHub - CatDarkGame/SimplePostBlur

Contribute to CatDarkGame/SimplePostBlur development by creating an account on GitHub.

github.com

사용법

1. RendererFeature 추가

URP Renderer Data에 PostBlurRendererFeature를 추가합니다.

Filter Mode	다운 샘플링 과정에서 RT 필터 모드를 선택합니다. 성능 차이 거의 없으며, 원하는 비주얼에 맞게 세팅합니다.
Sample Count	다운 샘플 드로우콜 횟수를 의미합니다. 숫자가 높을 수록 다운 샘플링 횟수가 많아지며 성능에 좋지 않습니다. 런타임 도중 유동적으로 값을 바꾸는 것은 성능에 좋지 않습니다. 숫자에 따라 비주얼이 느낌이 다르기 때문에 원하는 방향에 맞게 세팅합니다.
Render Pass Event	후처리 실행 구간을 세팅합니다. 일반적으로 기본 값을 사용하지만 프로젝트 상황에 맞게 세팅합니다.

2. Post Volume 추가

씬에 Post Volume 배치 후, Post Blur Component를 추가합니다.

Blur Amount	Blur 효과 반영 수치를 제어합니다, 0으로 세팅하면 후처리 기능이 완전 비활성화됩니다.
Blur Offset	블러 퍼짐 수치를 제어합니다, 원하는 블러 비주얼 방향에 맞게 조절합니다. RendererFeature의 Sample Count와 다르게 런타임에서 유동적으로 값 제어해도 문제 없습니다.
Blur Mask	마스크 텍스처를 통해 블러 영역을 제어 가능합니다. R채널만 사용하기 때문에 싱글 채널 무압축 포맷 사용을 권장합니다. 마스크 텍스처 사이즈는 성능을 위해 최대한 작게 사용을 권장합니다.
Blur Mask Tilling Offset	마스크 텍스처의 Tiling Offset 제어합니다. 응용 예시는 아래 설명합니다.

3. 사용 예제 : TiltShift 세팅

TiltShift 블러를 세팅한 예제는 github 샘플 프로젝트에서 확인 가능합니다.

TiltShift는 화면 위 아래를 블러 처리하여 간단히 표현 가능하며, 주로 Fov가 낮은 미니어처 느낌을 낼때 사용합니다.

사용한 블러 마스크는 8x256 사이즈의 그라디언트 텍스처이며 Wrap Mode를 Mirror로 세팅하여 텍스처 사이즈 대비 더 높은 품질을 내도록 했습니다.

후처리에 사용하는 텍스처 사이즈 관련해서

후처리 특성상 전체 해상도만큼 픽셀 쉐이더가 돌아가야하기 때문에 픽셀 연산 및 샘플링 비용에 민감할 필요가 있습니다.

특히 Shared 메모리를 사용하는 모바일 디바이스 특성상 텍스처 샘플링 캐시 히트율이 낮으면 쉐이더 연산 상관 없이 성능 저하가 쉽게 발생하기 때문에 주의할 필요가 있습니다.

구현 & 원리 설명

1. 쉐이더 구현

1개의 쉐이더의 각 역할이 다른 2개의 Pass가 구현되어 있습니다.

Pass 0 : 최종 블러 결과물 출력을 담당, 블러 처리된 RT와 Lerp 블랜딩 구현됨.
Pass 1 : 다운 & 업 샘플링 Pass이며, 단순히 4방향 Box 블러가 구현됨.

2. RenderPass - RenderTexture 세팅

기본적으로 화면 버퍼 카피(sourceTexture) & 출럭 버퍼(destTexture) RTHandle을 선언합니다.

그리고 다운 샘플링 버퍼를 저장하는 RTHandle을 SampleCount 만큼 배열로 선언합니다.

URP 14에서 한번 메모리에 생성한 버퍼를 재활용하기 때문에 고정 배열 형태로 선언하여 Sample Count가 변하지 않는 이상 추가 동적 할당이 발생하지 않습니다.

RT 생성하는 코드입니다. 다운 샘플링 -> 업 샘플링해야하기 때문에 >> 비트 시프트 연산자로 2배로 줄어들고 2배로 증가하도록 구현했습니다.

다음은 커맨드버퍼에 드로우콜 구현 내용입니다.

URP 14에서 권장하는 Triangles 메쉬로 화면 전체에 출력하는 방식으로 구현되었습니다.

그 외 Material에 값을 직접 세팅하지 않고 MaterialPropertyBlock을 사용했는데, Blitter.BlitTexture 함수를 사용할 때 Material에 직접 값을 세팅해서 사용하면 세팅한 값이 초기화되지 않는 현상이 있어 이와 같이 구현했습니다.

URP 내장 코드에서도 이와 같이 구현된 것을 보면 MaterialPropertyBlock 사용이 권장 사항 같습니다.

3. 결과 & 구현 특징 해설

앞서 설명한대로, 쉐이더에서는 박스 블러 외에 특별한 구현 내용이 없으며, 블러 효과는 다운 & 업 샘플링에 의존도가 높은 것이 특징입니다. 따라서 쉐이더 연산에 의한 GPU 성능보다는 RT 생성 & 드로우콜 처리에 의한 CPU 성능을 더 사용합니다.

최대 장점은 높은 해상도에 의한 성능 저하 부담이 적으며, RenderPass에서 프레임 스킵 구현을 통해 추가 최적화 작업이 가능합니다.

Unity Light Probe with out Lightmap

CatDarkGame — Mon, 22 Jul 2024 22:27:49 +0900

Light Probe는 씬의 GI 정보를 베이킹하는 시스템입니다.

이번 포스팅에서 LightMap 없이 Light Probe만 단독으로 사용 방법에 대한 리서칭 내용을 작성합니다.

라이트 프로브 배치

우선 씬에 Light Probe를 배치합니다, Light Probe를 손으로 일일히 설치하는 방법도 있지만 Magic LightProbe 에셋을 활용하여 자동으로 배치 가능합니다.

(Unity 2023에서부터 APV를 지원하지만 이 포스팅은 2023을 올리지 않는 프로젝트를 위해 작성했습니다.)

(https://unity.com/kr/products/pricing-updates)

라이트 베이킹

Light Probe 베이킹을 동작 시키는 목적이기 때문에 베이킹 속도를 위해 Lightmap 세팅은 최저 옵션으로 합니다.

Lighting Mode는 Shadowmask로 세팅합니다.

샘플 씬에서 URP Lit 쉐이더를 사용했습니다.

유니티 라이트 베이킹하면 Static 오브젝트는 Lightmap에 구워진 GI 정보를 활용합니다.

Dynamic 오브젝트만 LightProbe의 GI 정보를 받게 되어 있습니다.

Lit 쉐이더 수정

Static 오브젝트를 Lightmap 정보를 사용하지 않고 LightProbe GI 정보를 활용 할 수 있도록 쉐이더 수정이 필요합니다.

샘플 프로젝트에서는 URP Lit 쉐이더를 복제하여 수정했습니다.

쉐이더 키워드 중에 LIGHTMAP_ON 키워드를 제거합니다.

그럼 아래와 같이 Lightmap의 GI 정보를 사용하지 않기 때문에 어둡게 나옵니다.

다음 LitForwardPass의 InitializeInputData 함수에서 SAMPLE_GI 디파인 키워드 대신 SampleSH 함수를 직접 호출하게 변경합니다.

(예제에서는 기능 작동 확인을 위해 핵심 코드 수정만 설명드리니, 이 내용 이해를 기반으로 프로젝트에 알맞게 적용하시면 됩니다)

다음 Lightmap 베이킹한 배경 오브젝트를 복제하고 원본은 비활성화합니다.

기존 원본 오브젝트는 Lightmap 베이킹 모드로 전환되는지, 쉐이더 수정해도 반영되지 않습니다.

하지만 복제되어 새로 생성된 오브젝트는 Lightmap이 아닌 LightProbe GI 정보를 받게 됩니다.

좌 : Lightmap 모드 우 : 일반 모드

여기까지 진행이 완료되면, 처음에 구웠던 라이트맵 텍스처는 더이상 사용할 일이 없으니 삭제해도 상관없습니다.

후처리

마지막으로 SSAO와 Postprocess 효과를 적당히 입혀 씬 완성도를 높입니다.

유니티 안드로이드 빌드 ADB Logcat 명령어

CatDarkGame — Wed, 3 Jul 2024 20:50:47 +0900

개요

adb logcat 명령어를 통해 유니티 엔진 Console에서 확인 할 수 없는 로그 확인 가능합니다.

유니티 엔진에서 logcat 확인 가능한 에셋이 있지만, 이번 포스팅에서는 윈도우 cmd에서 확인하는 방법을 소개합니다.

ADB Logcat 명령어 가이드

1. ADB 연결

adb devices

*안드로이드 디바이스의 개발자 모드 및 USB 디버깅 활성화 필요.

안드로이드 디바이스를 윈도우 PC에 연결 후, CMD에서 위 명령어를 입력합니다.

아래 사진과 같이 연결된 디바이스 목록이 표시됩니다.

https://www.xda-developers.com/install-adb-windows-macos-linux/

adb connect 디바이스이름

다음 connect 명령을 통해 디바이스 연결 진행합니다.

이미 연결되어 있는 경우 에러 메세지가 출력되며 무시합니다. (ADB에 자동으로 연결되는 경우 이런 상황 발생)

2. Logcat 연결

adb -s 디바이스이름 logcat -s Unity

3. Logcat 로그 Clear

adb logcat -c

디바이스 활성화되어 있는 동안 log가 계속 쌓이기 때문에 불편하면 Clear합니다.

안드로이드 빌드 ADB 메모리 측정 (Release Build 메모리 측정)

CatDarkGame — Wed, 3 Jul 2024 20:42:53 +0900

개요

유니티 엔진 게임 개발 과정에서 시스템 메모리 측정을 위해 메모리 프로파일러를 사용합니다.

하지만 Development Build가 아닌 앱 메모리 측정이 필요한 경우, ADB 명령어를 활용할 수 있습니다.

이번 포스팅은 윈도우 cmd에서 ADB 명령어를 활용해 메모리 측정 방법을 소개합니다.

주의

이 메모리 측정 방식은 유니티 메모리 프로파일러의 결과와 차이가 발생 할 수 있습니다.

또한 같은 앱이라도 디바이스 및 OS에 따라 ADB 측정 결과가 차이가 발생 할 수 있습니다.

ADB 메모리 측정 가이

1. ADB 연결

adb devices

*안드로이드 디바이스의 개발자 모드 및 USB 디버깅 활성화 필요.

안드로이드 디바이스를 윈도우 PC에 연결 후, CMD에서 위 명령어를 입력합니다.

아래 사진과 같이 연결된 디바이스 목록이 표시됩니다.

https://www.xda-developers.com/install-adb-windows-macos-linux/

adb connect 디바이스이름

다음 connect 명령을 통해 디바이스 연결 진행합니다.

이미 연결되어 있는 경우 에러 메세지가 출력되며 무시합니다. (ADB에 자동으로 연결되는 경우 이런 상황 발생)

2. 앱 패키지 이름 확인

adb shell pm list packages | grep 앱이름

위 명령어를 통해 디바이스에 설치된 앱 패키지 이름을 확인합니다.

위 ADB 명령어 없이, 유니티 엔진 Project Settings/Other Settings의 Package Name을 그대로 사용해도 됩니다.

3. 메모리 사용량 측정

adb shell dumpsys meminfo 패키지이름 -d

위 명령어를 통해 특정 앱의 메모리 사용 정보 확인합니다.

'-d'는 상세한 정보를 표시하는 필터링 명령어입니다.

메모리 용량 KB 단위 표시

많은 정보가 표시되지만, 전체 메모리는 Pss Total 메모리 용량을 확인하면 됩니다.

각 항목별 자세한 해석은 아래 Android Studio 도큐먼트 자료를 참고해주세요.

https://developer.android.com/studio/profile/memory-profiler?hl=ko

Unreal VertexAnimationTool.ms Unity 호환 버전

CatDarkGame — Wed, 5 Jun 2024 00:32:13 +0900

개요

언리얼 엔진 디렉토리 내부에 있는 VertexAnimationTool.ms는 3dsMax에서 VAT 리소스를 생성하는 스크립트입니다.

해당 리소스는 언리얼 엔진에서 바로 사용 가능하지만, 유니티 엔진에는 축(Axis)가 일치하지 않는 이유로 사용 할 수 없습니다.

VertexAnimationTool.ms 경로 : UE_5.3\Engine\Extras\3dsMaxScripts\VertexAnimationTool.ms
언리얼 VAT 튜토리얼 : https://youtu.be/6Cain-u9_g4?feature=shared

이 포스팅은 VertexAnimationTool.ms 스크립트를 유니티에서 사용할 수 있도록 수정하는 방법과 유니티 엔진 쉐이더 활용 예시를 작성합니다.

(맥스 스크립트 파일은 언리얼 설치 후 직접 획득합니다.)

VertexAnimationTool.ms 수정 내용

축 변경 외에 수정 사항 없습니다.

스크립트 외에 중요한 부분은 3dsMax에서 Import & Export 과정에서 Unit 기준을 Meter로 세팅해야합니다.

-- 기존 코드
oldnormal=((((normalize (getTheVertexNormal currentMorphTarget j))*[1.0,-1.0,1.0])+1.0)*0.5)*255.0
append CurrentMorphTargetNormalArray oldnormal
originalVertPos=originalMeshVertPositions[j]
currentModelVertPos=getVertPos currentMorphTarget j
if (captureAbsolutePositions.checked) 
then (
	currentOffset=currentModelVertPos
)
else (
	currentOffset=(currentModelVertPos-originalVertPos)
)
currentOffset=[currentOffset[1],-1.0*currentOffset[2],currentOffset[3]]
currentOffset*=255.0
append currentMorphVertexOffsetArray currentOffset


-- 변경 코드
oldnormal=((((normalize (getTheVertexNormal currentMorphTarget j))*[1.0,1.0,-1.0])+1.0)*0.5)*255.0
append CurrentMorphTargetNormalArray oldnormal
originalVertPos=originalMeshVertPositions[j]
currentModelVertPos=getVertPos currentMorphTarget j
if (captureAbsolutePositions.checked) 
then (
	currentOffset=currentModelVertPos
)
else (
	currentOffset=(currentModelVertPos-originalVertPos)
)
currentOffset=[currentOffset[1], currentOffset[3], -1.0*currentOffset[2]]
currentOffset*=255.0
append currentMorphVertexOffsetArray currentOffset

유니티 쉐이더 사용 예시

샘플링 코드는 언리얼 엔진 MS_VertexAnimationTools_NorphTargets 노드의 핵심 로직을 코드로 변환했습니다.

            float3 ConvertAxis(float3 v)
            {
               return v.xzy * float3(-1, -1, 1);
            }

			// Ref : UE MS_VertexAnimationTools_NorphTargets
            void GetVATData(float2 uv, out float3 positionOSOffset, out normalOS normalOSOffset)
            {
                float animFrameTotal = _AnimFrameTotal;
                float animFrameCurrent = lerp(0.0f, animTotalFrame, _AnimFrameAmount);

                float ceil_1 = 1.0f / ceil(animFrameTotal);
                float ceil_2 = ceil(animFrameCurrent);
                float mult_1 = ceil_1 * 0.5f;
                float mult_2 = ceil_2 * ceil_1;
                float add_1 = mult_1 + mult_2;
                float2 uv_VAT = float2(uv.x, 1.0f - add_1);
 
                float4 pos_Offset = SAMPLE_TEXTURE2D_LOD(_PositionVAT, sampler_PositionVAT, uv_VAT, 0);
                float4 nor_Offset = SAMPLE_TEXTURE2D_LOD(_NormalVAT, sampler_PositionVAT, uv_VAT, 0); 

                positionOSOffset = ConvertAxis(pos_Offset.xyz);
                normalOSOffset = ConvertAxis(nor_Offset.xyz);
            }
 
            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;
 
                float3 positionOSOffset = 0.0f;
                float3 normalOSOffset = 0.0f;
                GetVATData(input.uv_1, positionOSOffset, normalOSOffset);

                float3 positionOS = input.positionOS.xyz + positionOSOffset;
                float3 normalOS = normalOSOffset;
                output.positionCS = TransformObjectToHClip(positionOS);
                output.normalWS = TransformObjectToWorldNormal(normalOS);
                output.uv = input.uv_0;
                return output;
            }

언리얼5 플레이어 카메라 변경 방법

CatDarkGame — Tue, 7 May 2024 22:38:09 +0900

언리얼5.3.2 기준입니다.

유니티 엔진은 씬에 활성화된 카메라가 게임 뷰에 바로 반영되지만, 언리얼 엔진은 플레이어 액터를 직접 설정해야 합니다.

그래서 레벨(씬) 작업 과정에서 원하는 카메라로 플레이가 바로 되지 않습니다.

이 포스팅은 가장 쉽게 원하는 카메라로 플레이가 되도록 하는 방법을 작성합니다.

레벨에 카메라 액터를 원하는 곳에 배치합니다.

뷰 포트 상단의 아래 메뉴에서 레벨 블루 프린트를 Open합니다.

레벨 블루 프린트는 해당 레벨의 스크립트 로직을 작성할 수 있습니다.

레벨 블루 프린트 열기 단축키 : Ctrl + K

아래 사진과 같이 블루 프린트를 구성합니다.

BeginPlay(게임 시작 이벤트)에서 바로 View Target을 설정하는 로직입니다.

CameraActor는 레벨에 배치된 카메라를 드래그해서 가져오면 됩니다.

직접 블루 프린트 구성하기 어렵다면, 아래 텍스트를 복사해서 블루프린트에 붙여넣기하면 자동으로 세팅됩니다.

Begin Object Class=/Script/BlueprintGraph.K2Node_Event Name="K2Node_Event_0" ExportPath="/Script/BlueprintGraph.K2Node_Event'/Game/ThirdPerson/Maps/ThirdPersonMap.ThirdPersonMap:PersistentLevel.ThirdPersonMap.EventGraph.K2Node_Event_0'"
   EventReference=(MemberParent="/Script/CoreUObject.Class'/Script/Engine.Actor'",MemberName="ReceiveBeginPlay")
   bOverrideFunction=True
   NodePosX=192
   NodePosY=176
   NodeGuid=4E38FF194AB92D986D3EFF9DB43CE8FA
   CustomProperties Pin (PinId=894BA1854DFD7E17363BE688EA949010,PinName="OutputDelegate",Direction="EGPD_Output",PinType.PinCategory="delegate",PinType.PinSubCategory="",PinType.PinSubCategoryObject=None,PinType.PinSubCategoryMemberReference=(MemberParent="/Script/CoreUObject.Class'/Script/Engine.Actor'",MemberName="ReceiveBeginPlay"),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=False,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,PersistentGuid=00000000000000000000000000000000,bHidden=False,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
   CustomProperties Pin (PinId=4F78317140C02B965FF125BD536BE799,PinName="then",Direction="EGPD_Output",PinType.PinCategory="exec",PinType.PinSubCategory="",PinType.PinSubCategoryObject=None,PinType.PinSubCategoryMemberReference=(),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=False,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,LinkedTo=(K2Node_CallFunction_0 594F507347786C2E6C8EE88BB71F2EF3,),PersistentGuid=00000000000000000000000000000000,bHidden=False,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
End Object
Begin Object Class=/Script/BlueprintGraph.K2Node_CallFunction Name="K2Node_CallFunction_0" ExportPath="/Script/BlueprintGraph.K2Node_CallFunction'/Game/ThirdPerson/Maps/ThirdPersonMap.ThirdPersonMap:PersistentLevel.ThirdPersonMap.EventGraph.K2Node_CallFunction_0'"
   FunctionReference=(MemberParent="/Script/CoreUObject.Class'/Script/Engine.PlayerController'",MemberName="SetViewTargetWithBlend")
   NodePosX=464
   NodePosY=160
   ErrorType=1
   ErrorMsg="이 블루프린트(셀프)는 PlayerController 이지 않으므로, \' Target \'에 연결이 있어야 합니다."
   NodeGuid=CA2D1DE440D3EF537866D09EA9948D8F
   CustomProperties Pin (PinId=594F507347786C2E6C8EE88BB71F2EF3,PinName="execute",PinToolTip="\n실행",PinType.PinCategory="exec",PinType.PinSubCategory="",PinType.PinSubCategoryObject=None,PinType.PinSubCategoryMemberReference=(),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=False,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,LinkedTo=(K2Node_Event_0 4F78317140C02B965FF125BD536BE799,),PersistentGuid=00000000000000000000000000000000,bHidden=False,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
   CustomProperties Pin (PinId=81A0E018461139864B0FC8ABE7748D78,PinName="then",PinToolTip="\n실행",Direction="EGPD_Output",PinType.PinCategory="exec",PinType.PinSubCategory="",PinType.PinSubCategoryObject=None,PinType.PinSubCategoryMemberReference=(),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=False,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,PersistentGuid=00000000000000000000000000000000,bHidden=False,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
   CustomProperties Pin (PinId=115E558D463323D44692C796315D3999,PinName="self",PinFriendlyName=NSLOCTEXT("K2Node", "Target", "Target"),PinToolTip="Target\n플레이어 컨트롤러 오브젝트 레퍼런스",PinType.PinCategory="object",PinType.PinSubCategory="",PinType.PinSubCategoryObject="/Script/CoreUObject.Class'/Script/Engine.PlayerController'",PinType.PinSubCategoryMemberReference=(),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=False,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,LinkedTo=(K2Node_CallFunction_3 E61E06F945C391EF864F59A206B93B8B,),PersistentGuid=00000000000000000000000000000000,bHidden=False,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
   CustomProperties Pin (PinId=48FA77F242045A302EAE9CB25B74167B,PinName="NewViewTarget",PinToolTip="New View Target\n액터 오브젝트 레퍼런스\n\n새 뷰 타깃입니다.",PinType.PinCategory="object",PinType.PinSubCategory="",PinType.PinSubCategoryObject="/Script/CoreUObject.Class'/Script/Engine.Actor'",PinType.PinSubCategoryMemberReference=(),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=False,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,LinkedTo=(K2Node_Literal_0 DFE458504126C450B71E1C952632FC77,),PersistentGuid=00000000000000000000000000000000,bHidden=False,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
   CustomProperties Pin (PinId=CF5058AB4CABC3E46FAB5090ECD63EAB,PinName="BlendTime",PinToolTip="Blend Time\n플로트(단정밀도)\n\n블렌드에 걸릴 시간입니다.",PinType.PinCategory="real",PinType.PinSubCategory="float",PinType.PinSubCategoryObject=None,PinType.PinSubCategoryMemberReference=(),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=False,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,DefaultValue="0.000000",AutogeneratedDefaultValue="0.000000",PersistentGuid=00000000000000000000000000000000,bHidden=False,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
   CustomProperties Pin (PinId=10682637496ACDA9100F9DB3E5DF6A11,PinName="BlendFunc",PinToolTip="Blend Func\nEViewTargetBlendFunction 열거형\n\n큐빅, 선형 혹은 기타 블렌딩 함수 설정입니다.",PinType.PinCategory="byte",PinType.PinSubCategory="",PinType.PinSubCategoryObject="/Script/CoreUObject.Enum'/Script/Engine.EViewTargetBlendFunction'",PinType.PinSubCategoryMemberReference=(),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=False,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,DefaultValue="VTBlend_Linear",AutogeneratedDefaultValue="VTBlend_Linear",PersistentGuid=00000000000000000000000000000000,bHidden=False,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
   CustomProperties Pin (PinId=38B9C70349D9A931262506A05355022D,PinName="BlendExp",PinToolTip="Blend Exp\n플로트(단정밀도)\n\nExponent, 블렌드 커브의 모양을 바꿀 수 있는 제곱근 값입니다.",PinType.PinCategory="real",PinType.PinSubCategory="float",PinType.PinSubCategoryObject=None,PinType.PinSubCategoryMemberReference=(),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=False,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,DefaultValue="0.000000",AutogeneratedDefaultValue="0.000000",PersistentGuid=00000000000000000000000000000000,bHidden=False,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
   CustomProperties Pin (PinId=2774DE8D4B48AF8DC2B99183CAD5C472,PinName="bLockOutgoing",PinToolTip="Lock Outgoing\n부울\n\nTrue인 경우, 블렌드가 끝난 뒤에도 뷰 타깃을 마지막 프레임의  카메라 포지션으로 락 합니다.",PinType.PinCategory="bool",PinType.PinSubCategory="",PinType.PinSubCategoryObject=None,PinType.PinSubCategoryMemberReference=(),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=False,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,DefaultValue="false",AutogeneratedDefaultValue="false",PersistentGuid=00000000000000000000000000000000,bHidden=False,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
End Object
Begin Object Class=/Script/BlueprintGraph.K2Node_CallFunction Name="K2Node_CallFunction_3" ExportPath="/Script/BlueprintGraph.K2Node_CallFunction'/Game/ThirdPerson/Maps/ThirdPersonMap.ThirdPersonMap:PersistentLevel.ThirdPersonMap.EventGraph.K2Node_CallFunction_3'"
   bIsPureFunc=True
   FunctionReference=(MemberParent="/Script/CoreUObject.Class'/Script/Engine.GameplayStatics'",MemberName="GetPlayerController")
   NodePosX=96
   NodePosY=272
   NodeGuid=36EBC93A440DB759F37D30A1F1EAD4EF
   CustomProperties Pin (PinId=CB6D690843C19BBF83C3A3BE542F393B,PinName="self",PinFriendlyName=NSLOCTEXT("K2Node", "Target", "Target"),PinToolTip="Target\n게임플레이 스태틱 오브젝트 레퍼런스",PinType.PinCategory="object",PinType.PinSubCategory="",PinType.PinSubCategoryObject="/Script/CoreUObject.Class'/Script/Engine.GameplayStatics'",PinType.PinSubCategoryMemberReference=(),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=False,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,DefaultObject="/Script/Engine.Default__GameplayStatics",PersistentGuid=00000000000000000000000000000000,bHidden=True,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
   CustomProperties Pin (PinId=7BDA28BE475A7ACE9BEA78B7D4768CF8,PinName="WorldContextObject",PinToolTip="World Context Object\n오브젝트 레퍼런스",PinType.PinCategory="object",PinType.PinSubCategory="",PinType.PinSubCategoryObject="/Script/CoreUObject.Class'/Script/CoreUObject.Object'",PinType.PinSubCategoryMemberReference=(),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=True,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,PersistentGuid=00000000000000000000000000000000,bHidden=True,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
   CustomProperties Pin (PinId=AF460BFA4460B1B9C8B713B290433756,PinName="PlayerIndex",PinToolTip="Player Index\n인티저\n\n플레이어 컨트롤러 목록의 인덱스로, 로컬 플레이어로부터 시작하여 사용할 수 있는 리모트 플레이어로 가는 식입니다.",PinType.PinCategory="int",PinType.PinSubCategory="",PinType.PinSubCategoryObject=None,PinType.PinSubCategoryMemberReference=(),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=False,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,DefaultValue="0",AutogeneratedDefaultValue="0",PersistentGuid=00000000000000000000000000000000,bHidden=False,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
   CustomProperties Pin (PinId=E61E06F945C391EF864F59A206B93B8B,PinName="ReturnValue",PinToolTip="Return Value\n플레이어 컨트롤러 오브젝트 레퍼런스",Direction="EGPD_Output",PinType.PinCategory="object",PinType.PinSubCategory="",PinType.PinSubCategoryObject="/Script/CoreUObject.Class'/Script/Engine.PlayerController'",PinType.PinSubCategoryMemberReference=(),PinType.PinValueType=(),PinType.ContainerType=None,PinType.bIsReference=False,PinType.bIsConst=False,PinType.bIsWeakPointer=False,PinType.bIsUObjectWrapper=False,PinType.bSerializeAsSinglePrecisionFloat=False,LinkedTo=(K2Node_CallFunction_0 115E558D463323D44692C796315D3999,),PersistentGuid=00000000000000000000000000000000,bHidden=False,bNotConnectable=False,bDefaultValueIsReadOnly=False,bDefaultValueIsIgnored=False,bAdvancedView=False,bOrphanedPin=False,)
End Object

언리얼5 기본 단축키 정리 (유니티 사용자 추천)

CatDarkGame — Tue, 7 May 2024 22:31:24 +0900

언리얼5.3.2 기준입니다.

기본 단축키 정리

굵은 글자 = 자주 사용하는 기능

오브젝트 & 카메라

Gizmo - Translate(이동)	W
Gizmo - Rotate(회전)	E
Gizmo - Scale(크기)	R
Grid Translate(이동) Snap Size 조절	‘[’ (작게) / ‘]’ (크게)
Grid Rotate(회전) Snap Size 조절	Shift + ‘[’ (작게) / ‘]’ (크게)
Grid Snap Toggle	없음 (직접 커스텀)
선택 오브젝트 Hide	H
UnHide All	Ctrl + H
선택 오브젝트 카메라 포커스	F
선택 오브젝트 복사	Ctrl + D / Alt + Gizmo 이동
선택 오브젝트 에셋 하이라이트	Ctrl + B
Snap to Floor	End
Snap Pivot to Floor	Alt + End
카메라 Zoom In / Out	RMB + C(확대) / Z(축소)
카메라 이동 속도 조절	RMB + Scroll
Directional Light 방향 조절	Ctrl + L → Ctrl 유지 + 마우스 이동
오브젝트를 뷰에 스냅	없음 (직접 커스텀)

뷰포트

와이어 프레임	Alt + 2
언릿 (UnLit)	Alt + 3
라이팅 포함 (Lit) (기본)	Alt + 4
디테일 라이팅	Alt + 5
라이팅만	Alt + 6
그리드 & 뷰포트 아이콘 보기	G
Perspective View (3D) (기본)	Alt + G
Orthographic View (2D) - Front	Alt + H
Orthographic View (2D) - Top	Alt + J
Orthographic View (2D) - Left	Alt + K
Orthographic View (2D) - Right	Alt + Shift + K
에디터 모드 - 액터 배치 (기본)	Shift + 1
에디터 모드 - 랜드 스케이프	Shift + 2
에디터 모드 - 폴리지	Shift + 3
에디터 모드 - 메시 페인트	Shift + 4
에디터 모드 - 모델링	Shift + 5
에디터 모드 - 프랙처	Shift + 6
에디터 모드 - 브러시 편집	Shift + 7

에디터

Play	Alt + P
Pause	?
Eject (Play 유지 & 자유 카메라)	F8
에디터 Full Screen	Shift + F11
뷰포트 크게 보기	F10
뷰포트 Full Screen	F11
Save (레벨 저장)	Ctrl + S
Save All (레벨 & 에셋 저장 / 컴파일)	Ctrl + Shift + S
레벨 블루프린스/스크립트 열기	Ctrl + K
에셋 탐색기 열기	Ctrl + P
선택 오브젝트 에셋 에디터 열기	Ctrl + E
선택 오브젝트 레퍼런스 뷰어 열기	Alt + Shift + R
Undo	Ctrl + Z
Redo (다시 실행) (Undo 반대)	Ctrl + Y

단축키 커스텀

일부 익숙하지 않거나, 단축키 할당 되지 않는 키를 커스텀하는 방법입니다.

상단 바 '편집' -> '에디터 개인설정' 창을 실행합니다.

1. 그리드 스냅 Toggle

그리드 스냅 기능 On/Off 기능은 단축키가 없어 뷰포트에서 아래 표시한 버튼을 클릭해야합니다.

한국어 버전 기준, '그리드 스냅'을 검색하여 키를 할당 할 수 있습니다.

Alt + 마우스 드래그로 지정하고 싶은데 키 바인딩 커스텀에서 마우스 이벤트 넣는 방법을 모르겠습니다.

2. 오브젝트를 뷰에 스냅

선택한 오브젝트를 현재 뷰포트 카메라 Transform으로 맞추는 기능입니다.

오브젝트 선택 후, 우측 마우스 메뉴를 통해 실행 가능하지만, 기본적으로 키 바인딩이 없습니다.

개인적으로 유니티 엔진에서 카메라 위치 제어 할 때 자주 사용하는 기능이기 때문에 키 바인딩하면 유용합니다.

'오브젝트를 뷰에 스냅'을 검색 후, 유니티와 동일하게 'Ctrl+Shift+F'로 세팅합니다.

하지만 이미 다른 기능에 키가 바인딩되어 있습니다, '블루프린트에서 찾기' 기능은 별로 사용하지 않을 것 같으니, 삭제하였습니다.

3. Redo (다시 실행) 키 변경

Undo의 반대 기능입니다. Undo 이벤트를 다시 되돌릴 수 있습니다.

기본적으로 'Ctrl + Y'로 바인딩되어 있지만 익숙하지 않으니 유니티 엔진과 동일하게 'Ctrl + Shift + Z' 로 바인딩했습니다.

레퍼런스

3 Point Lighting

CatDarkGame — Thu, 2 May 2024 22:36:14 +0900

레퍼런스 : Last of us part 2 - joel

레벨 & 라이팅 구성

3 point light 배치

Key Light	Fill Light	Rim Light

라이팅 구성

Diffuse	Specular

URP GPU Instancing와 SRP Batcher 성능 비교

CatDarkGame — Wed, 24 Apr 2024 22:28:39 +0900

개요

SRP Batcher는 RenderState 호출을 배칭하여 렌더콜 API 호출 수를 줄여줍니다.

그러나 DrawCalls 호출 수를 줄이지 않기 때문에 뷰에 Renderer 숫자가 많으면 여전히 CPU 부하 발생 위험이 있습니다.

GPU Instancing은 렌더링에 필요한 API 정보를 GPU 버퍼에 저장하여 반복 렌더링 명령을 하는 방식으로 CPU에서 발생하는 렌더콜 숫자를 줄일 수 있습니다.

이번 포스팅은 GPU Instancing과 SRP Batcher 성능 비교 정리 자료입니다.

테스트 환경

메쉬 3종, Material 2 종으로 구성된 씬입니다. (URP Lit 쉐이더 기반)

Mesh & Material 세팅 조합은 별도로 섞지 않아 총 3개의 Instancing이 나오는 환경입니다.

Batches는 에디터 Stat에 약 2300개가 나오게 세팅했습니다. (막 복사해서 정확한 숫자 모름)

URP 환경에서 SRP Batcher를 지원하는 쉐이더는 GPU Instancing이 비활성화됩니다.

그래서 스크립트에서 Graphics.DrawMeshInstanced 함수를 활용해 GPU Instancing이 작동되도록 했습니다.

스크립트는 포스팅 맨 아래 첨부합니다.

결과 정리

좌 : GPU Instancing / 우 : SRP Batcher

	SRP Batcher	GPU Instancing
프로파일러 - CPU 메인쓰레드	11.84 ms	4.28 ms
프로파일러 - CPU 렌더쓰레드	10.69 ms	2.39 ms
프로팡리러 - CPU 렌더콜 총합	17.10 ms	5.26 ms
RenderDoc - Draw calls	2292	20
RenderDoc - API calls	3558	157
RenderDoc - GPU Buffer + texture load	22.19 MB	24.19 MB

정리

GPU Instancing이 압도적으로 좋은 성능이 나왔습니다.

하지만 이런 GPU 드로우 방식은 다양한 종류의 메쉬 & Material 지원이 제한적입니다.

추후 GPU Instancing 외에 InDirectDraw등 다른 GPU 드로우 방식을 테스트 해볼 예정입니다.

GPU Instancing 드로우 스크립트

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GPUInstancingManager : MonoBehaviour
{
    private class InstanceData
    {
        public MeshRenderer meshRenderer;
        public Mesh mesh;
        public Material material;
        public Matrix4x4[] matrices;
        public int meshCount = 0;

        public InstanceData(MeshRenderer meshRenderer, Mesh mesh, Material material)
        {
            this.meshRenderer = meshRenderer;
            this.mesh = mesh;   
            this.material = material;
        }
    };

    private struct MatrixData
    {
        public List<Matrix4x4> matrices;
        public MatrixData(List<Matrix4x4> matrices)
        {
            this.matrices = matrices;
        }
    };

    private List<InstanceData> _instanceDatas;

    void Start()
    {
        _instanceDatas = InitMeshInstanced();
        Debug.Log("Instance Count : " + _instanceDatas.Count);
    }

    // Update is called once per frame
    void Update()
    {
        for(int i=0;i< _instanceDatas.Count;i++) 
        {
            InstanceData instanceData = _instanceDatas[i];
            Graphics.DrawMeshInstanced(instanceData.mesh, 0, instanceData.material, instanceData.matrices, instanceData.meshCount);
        }
    }

    private List<InstanceData> InitMeshInstanced()
    {
        List<InstanceData> instanceDatas = new List<InstanceData>();
        List<MatrixData> matrixDatas = new List<MatrixData>();
        MeshRenderer[] meshRenderers = transform.GetComponentsInChildren<MeshRenderer>();

        for(int i=0; i< meshRenderers.Length; i++)
        {
            MeshRenderer renderer = meshRenderers[i];
            if (!renderer) continue;
            Material material = renderer.sharedMaterial;
            if (!material) continue;
            MeshFilter meshFilter = renderer.GetComponent<MeshFilter>();
            if(!meshFilter) continue;
            Mesh mesh = meshFilter.sharedMesh;
            if (!mesh) continue;
            Matrix4x4 matrix = renderer.transform.localToWorldMatrix;

            bool isExistsData = false;
            for(int j=0;j< instanceDatas.Count;j++)
            {
                InstanceData instanceData = instanceDatas[j];
                if(instanceData.mesh == mesh && instanceData.material == material) 
                {
                    isExistsData = true;
                    matrixDatas[j].matrices.Add(matrix);
                    break;
                }
            }

            if(!isExistsData)
            {
                material.enableInstancing = true;
                instanceDatas.Add(new InstanceData(renderer, mesh, material));
                List<Matrix4x4> matrices = new List<Matrix4x4>();
                matrices.Add(matrix);
                matrixDatas.Add(new MatrixData(matrices));
            }
            Destroy(renderer.gameObject);
        }

        for(int i=0;i< instanceDatas.Count;i++)
        {
            instanceDatas[i].matrices = matrixDatas[i].matrices.ToArray();
            instanceDatas[i].meshCount = matrixDatas[i].matrices.Count;
        }

        return instanceDatas;
    }
}

Chiaro Scuro - 키아로 스쿠로

CatDarkGame — Tue, 16 Apr 2024 23:44:42 +0900

핵심

밝음과 어두움 라이팅 대비를 활용해 물체 형태(Shape) 표현

https://nofilmschool.com/chiaroscuro-lighting

언리얼 엔진 구현

라이트 1개만 사용한 결과.

구체의 형태가 표현되지 않음.

Chiaro Scuro 반영

구체 피사체 뒤 벽에 추가 라이트를 반영하여 기존 어두운 부분에 대한 명암 대비 구성하여 Chiaro Scuro 이론 구현.

결과적으로 라이팅을 활용해 구체의 형태를 제대로 표현할 수 있게 됨.

Value Contrast Focal Point Case Study

CatDarkGame — Tue, 16 Apr 2024 23:36:55 +0900

핵심

라이팅 명도 대비를 활용한 Focal Point 구성

Case Study - Dark knight 영화 장면

Good Case

전체적으로 밝은 배경에 어두운 복장의 인물에게 Focal Point 구성

Bad Case

동일한 영화 프레임에 인물 복장만 밝은 색으로 변경.

흰색 옷이 상대적으로 높은 Value라서 Focal Point가 작동되긴 하지만, Good Case와 비교해서 아쉬워짐.

단일 Material 공유가 SRPBatcher 성능에 영향을 주는가?

CatDarkGame — Mon, 15 Apr 2024 21:54:44 +0900

개요

SRPBatcher는 SetPass Calls API를 배칭(묶어)하여 CPU 렌더 호출 비용을 최적화하는 시스템입니다.

하지만 SRPBatcher를 사용해도 렌더링하는 오브젝트가 많을 경우에는 여전히 CPU 렌더 호출 비용이 높은 상황이 있습니다.

이번 포스팅은 CPU 렌더 호출 비용을 조금이라도 최적화하기 위해서 SRPBatcher가 효율적으로 동작할 수 있는 환경을 테스트해본 내용을 정리합니다.

테스트 주제는 아래와 같습니다.

SRP Batcher가 동작하는 환경에서 단일 Material을 공유하는게 SRP Batcher에 효과가 있는가?

테스트 결과 미리 요약

단일 Material 공유 여부는 SRP Batcher 및 CPU 렌더 호출 비용에 약간의 성능 향상이 있음.
- Material 1개 vs Mateirla 300개 기준 CPU 렌더콜 성능 1 ~ 2ms 차이 확인.
쉐이더의 CBuffer 변수 갯수는 SRP Batcher 및 CPU 렌더 호출 비용에 유의미한 영향 없음.
CPU 렌더 호출 비용을 줄이는 직접적인 방법은 Renderer를 줄여 드로우콜을 낮추는 것.

테스트 환경

Unity 2022.1.22f1 / URP 13.1.8
갤럭시s10e / ARM Mali-G76 / Vulkan
320p / 30fps
Unity Profiler / RenderDoc

1. Material 1종 vs Material 개별 Instancing

Renderer 300개 / Mesh 1종 / 좌 - Material 1종, 우 - Material 개별 Instancing

좌 - Material 1종, 우 - Material 개별 Instancing

최소 / 최대 ms	Material 1종	Material 개별 Instancing
메인 쓰레드	5.7 / 8.53	5.79 / 9.82
렌더 쓰레드	3.24 / 3.77	4.22 / 5.95
CPU 렌더 콜 총합	7.74 / 10.42	8.69 / 12.80

Material 1종 공유하는 것과, 모든 Renderer가 다른 Material을 Instancing하는 것은 CPU 렌더콜 성능에 약간의 차이가 확인되었습니다.

테스트에 사용한 쉐이더는 URP Lit이며, 쉐이더 복잡도나 메쉬 버텍스 카운트에 따라 결과 차이가 변화될 여지가 있습니다.

2. Material 개별 Instancing vs Material 개별 Instancing + 추가 프로퍼티 변화

다음 테스트는 Material 개별 Instancing은 동일하지만 1개의 Case에는 Material 프로퍼티 변화를 추가로 반영했습니다.

Renderer 300개 / Mesh 1종 / 좌 - Material 개별 Instancing, 우 - Material 개별 Instancing + 추가 프로퍼티 변화

좌 - Material 개별 Instancing, 우 - Material 개별 Instancing + 추가 프로퍼티 변화

최소 / 최대 ms	Material 개별 Instancing	Instancing + 추가 프로퍼티 변화
메인 쓰레드	5.79 / 9.82	5.43 / 8.23
렌더 쓰레드	4.22 / 5.95	4.17 / 5.01
CPU 렌더 콜 총합	8.69 / 12.80	8.04 / 11.45

동일하게 Material 개별 Instancing 환경에서 CBuffer에 선언된 Material 프로퍼티 변화 차이만 측정했습니다.

유의미한 차이는 없으며 심지어, 추가 프로퍼티 변화한 케이스가 더 성능이 가볍게 측정되었습니다.

3. Material 개별 Instancing vs 개별 Instancing + Reflection Probe Blending

이번 테스트는 개별 Instancing 환경에서 5개의 Reflection Probe를 걸쳐서 배치했습니다.

추가로 Reflection Probe Blending 기능까지 활성화했습니다.

렌더피쳐 단계에서 글로벌 프로퍼티로 텍스처 정보를 전달하는 것에 대한 차이를 측정하기 위함입니다.

좌 - Material 개별 Instancing, 우 - Material 개별 Instancing + Reflection Probe Blending

최소 / 최대 ms	Material 개별 Instancing	Instancing + Refl ProbeBlending
메인 쓰레드	5.79 / 9.82	6.93 / 11.32
렌더 쓰레드	4.22 / 5.95	4.76 / 5.16
CPU 렌더 콜 총합	8.69 / 12.80	8.126 / 13.04

동일한 Material 개별 Instancing 환경에서 Reflection Probe Blending 테스트는 유의미한 차이가 없습니다.

4. Material 개별 Instancing, Renderer 100개 vs 300개

Material 개별 Instancing / 좌 - Rendere 100개, 우 - Renderer 300

최소 / 최대 ms	Renderer 100개	Renderer 300개
메인 쓰레드	3.73	5.79 / 9.82
렌더 쓰레드	2.01	4.22 / 5.95
CPU 렌더 콜 총합	5.16	8.69 / 12.80

이번에는 단순히 Renderer 갯수 별로 측정하고 드로우콜 API 차이를 테스트해봤습니다.

결과는 정직하게 드로우콜 API 차이가 CPU 렌더콜 성능에 직접적으로 영향을 주는 것이 확인되었습니다.

Material 개별 Instancing / 좌 - Rendere 100개, 우 - Renderer 300

렌더독 확인 결과 특이사항 없습니다.

유니티 URP RendererFeature 활성화 제어 스크립트

CatDarkGame — Tue, 16 Jan 2024 20:10:13 +0900

개요

유니티 URP 환경에서 Universal Renderer Data에 다양한 렌더피처를 추가 할 수 있습니다.

보통 커스텀 렌더 패스로 활용하기 때문에 그래픽 퀄리티 옵션 제어가 필요한 경우가 많습니다.

이번 포스팅에서 C# 스크립트에서 Universal Renderer Data에 접근해서 원한느 RendererFeature를 활성화 & 비활성화하는 스크립트를 소개합니다.

샘플 코드 & 설명

프로젝트 환경

Unity 2021.3.30f1 (유니티 버전에 따라 API 변경될 수 있음)

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering.Universal;
using UnityEngine.Rendering;
using System.Reflection;

public class RendererFeatureControllSample : MonoBehaviour 
{
    /* 사용 샘플 코드
     * SetActiveRendererFeature<FXAARenderFeature>(toggle); 
     */
    public void SetActiveRendererFeature<T>(bool active) where T : ScriptableRendererFeature
    {
        // URP Asset의 Renderer List에서 0번 인덱스 RendererData 참조
        ScriptableRendererData rendererData = GetRendererData(0);
        if (rendererData == null) return;
   
        List<ScriptableRendererFeature> rendererFeatures = rendererData.rendererFeatures;
        if (rendererFeatures == null || rendererFeatures.Count <= 0) return;
 
        for (int i = 0; i < rendererFeatures.Count; i++)
        {
            ScriptableRendererFeature rendererFeature = rendererFeatures[i];
            if (!rendererFeature) continue;
            if (rendererFeature is T) rendererFeature.SetActive(active);
        }
        #if UNITY_EDITOR
        rendererData.SetDirty();
        #endif
    }


    public ScriptableRendererData GetRendererData(int rendererIndex = 0)
    {
        // 현재 Quality 옵션에 세팅된 URP Asset 참조
        UniversalRenderPipelineAsset pipelineAsset = GraphicsSettings.currentRenderPipeline as UniversalRenderPipelineAsset;
        if (!pipelineAsset) return null;
  
        // URP Renderer List 리플렉션 참조 (Internal 변수라서 그냥 참조 불가능)
        FieldInfo propertyInfo = pipelineAsset.GetType().GetField("m_RendererDataList", BindingFlags.Instance | BindingFlags.NonPublic);
        ScriptableRendererData[] rendererDatas = (ScriptableRendererData[])propertyInfo.GetValue(pipelineAsset);
        if (rendererDatas == null || rendererDatas.Length <= 0) return null;
        if (rendererIndex < 0 || rendererDatas.Length <= rendererIndex) return null;

        return rendererDatas[rendererIndex];
    }
}

현재 Quality 옵션에 세팅된 URP Asset 참조

UniversalRenderPipelineAsset pipelineAsset = GraphicsSettings.currentRenderPipeline as UniversalRenderPipelineAsset;
if (!pipelineAsset) return null;

위 코드는 현재 퀄리티 상태의 Universal Render Pipeline Asset을 참조합니다.

퀄리티 옵션이 변경되면 해당 에셋을 참조하게 됩니다.

URP RendererData List 참조

FieldInfo propertyInfo = pipelineAsset.GetType().GetField("m_RendererDataList", BindingFlags.Instance | BindingFlags.NonPublic);
ScriptableRendererData[] rendererDatas = (ScriptableRendererData[])propertyInfo.GetValue(pipelineAsset);

참조한 Universal Render Pipeline Asset 내부의 Renderer List를 참조하는 코드입니다.

URP 내장 코드에서 Internal로 선언되어 직접 참조는 불가능하여 리플렉션 참조를 해야합니다.

다음, RendererList에서 원하는 인덱스를 참조합니다.

rendererDatas[rendererIndex];

Universal RendererData 내부 RendererFeatures 참조

List<ScriptableRendererFeature> rendererFeatures = rendererData.rendererFeatures;
if (rendererFeatures == null || rendererFeatures.Count <= 0) return;

위 코드를 통해 URP RendererData 내부의 RendererFeature 리스트를 참조할 수 있습니다.

샘플 코드에서는 제네릭 문법을 활용해 찾는 RendererFeature 클래스를 선택 할 수 있게 만들 었습니다.

원하는 RendererFeature를 참조하면 SetActive 함수로 활성화 & 비활성화 가능합니다.

참고자료

https://qiita.com/makisin/items/5d66f1ea97f525f0c6d8

Unity Linear ColorSpace에서 UI 알파가 다르게 보이는 이슈

CatDarkGame — Tue, 2 Jan 2024 21:01:31 +0900

개요

게임 엔진에서 ColorSpace(색공간)을 Gamma, Linear 2가지 중 하나를 선택할 수 있으며 UI를 포함한 2D 텍스처 알파가 ColorSpace에 따라 다르게 보이는 이슈가 있습니다.

이번 포스팅은 이러한 이슈를 해결하기 위한 리서칭, 그리고 작업자를 위한 최적의 세팅 가이드를 소개합니다.

이슈 원인 - Linear ColorSpace에서 알파가 다르게 보이는 이유

https://www.slideshare.net/jpcorp/ss-96115075

게임 엔진에서 Linear ColorSpace를 사용하면 알파 블랜딩, 쉐이더 연산 값이 다르게 변합니다. 이는 PBR(물리기반렌더링) 3D 게임에서 더 현실적이고 정확한 조명 연산을 위해 필요한 기능입니다.

하지만 포토샵 등 텍스처 에셋 제작은 Gamma ColorSpace 기준으로 제작하기 때문에 포토샵에서 알파가 다르게 보이는 이슈가 발생합니다.

위 내용은 간단 요약한 것이며 ColorSpace에 대한 자세한 이론이 궁금하시다면 아래 자료를 참고해주시길 바랍니다.

감마가 어디감마(대마왕님) : https://www.youtube.com/watch?v=Xwlm5V-bnBc&ab_channel=UnityKorea

이슈 해결을 위한 리서칭

Linear ColorSpace에서 포토샵과 알파가 동일하게 보이기 위해 3가지 시도를 해봤습니다.

먼저 3가지 방법을 소개하고, 결과 리뷰를 작성합니다.

1. UI 쉐이더에서 알파 값 감마 보정

Unity Sprite 혹은 UGUI Image 컴포넌트에 커스텀 쉐이더 기반 Material을 세팅할 수 있습니다.

여기에 세팅되는 커스텀 쉐이더에서 알파 값 감마 보정을 시도했습니다.

쉐이더 코드는 아래와 같습니다. fragment 쉐이더에서 알파 값에 대한 감마 보정 코드를 추가합니다.

감마 보정은 pow(alpha, 2.2)해도 되고, 유니티 내장 함수에 있는 코드를 사용해도 됩니다.

(2개 방법 전부 밴딩 현상 문제 있음)

 // Unity 내장 함수
 inline half GammaToLinearSpace (half sRGB)
 {
     // Approximate version from http://chilliant.blogspot.com.au/2012/08/srgb-approximations-for-hlsl.html?m=1
     return sRGB * (sRGB * (sRGB * 0.305306011h + 0.682171111h) + 0.012522878h);
     // Precise version, useful for debugging.
     //return half3(GammaToLinearSpaceExact(sRGB.r), GammaToLinearSpaceExact(sRGB.g), GammaToLinearSpaceExact(sRGB.b));
 }

 float4 frag(v2f IN) : SV_Target
 {
     float4 color = (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd);// * IN.color;
     #if !UNITY_COLORSPACE_GAMMA
         // Gamma to Linear
        //color.a = GammaToLinearSpace(color.a);     // Unity 내장 함수
        color.a *= pow(color.a, 2.2f);
     #endif
     color *= IN.color;

     #ifdef UNITY_UI_CLIP_RECT
     color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
     #endif

     #ifdef UNITY_UI_ALPHACLIP
         clip (color.a - 0.001);
     #endif

     return color;
 }

2. AssetPostprocessor를 활용해 알파 보정하여 텍스처 임포팅

public class SpriteAssetPostprocessor : AssetPostprocessor
{
    private void OnPostprocessTexture(Texture2D texture)
    {
        TextureImporter textureImporter = (TextureImporter)assetImporter;

        ModifySpriteAlphaGammaToLinear(textureImporter, texture);
    }

    private static void ModifySpriteAlphaGammaToLinear(TextureImporter textureImporter, Texture2D texture)
    {
        if (textureImporter.textureType != TextureImporterType.Sprite ||
            PlayerSettings.colorSpace != ColorSpace.Linear) return;
        if (texture.name.Contains("Linear") == false) return;

        Color[] pixels = texture.GetPixels();
        for (int i = 0; i < pixels.Length; i++)
        {
            Color pixel = pixels[i];
            // pixel.a = Mathf.Pow(pixel.a, 2.2f);
            pixel.a = GammaToLinearSpace(pixel.a);
            pixels[i] = pixel;
        }
        texture.SetPixels(pixels);
        texture.Apply();
        Debug.Log(texture.name);
    }

    static float GammaToLinearSpace(float sRGB)
    {
        // Approximate version from http://chilliant.blogspot.com.au/2012/08/srgb-approximations-for-hlsl.html?m=1
        return sRGB * (sRGB * (sRGB * 0.305306011f + 0.682171111f) +0.012522878f);

        // Precise version, useful for debugging.
        //return half3(GammaToLinearSpaceExact(sRGB.r), GammaToLinearSpaceExact(sRGB.g), GammaToLinearSpaceExact(sRGB.b));
    }
}

C# 스크립트에서 Assetpostprocessor 클래스를 활용해 텍스처를 엔진에서 임포트 할때 자동으로 알파 값을 보정하는 기능을 개발했습니다.

쉐이더에서 처리하는 것보다 성능적으로 더 좋다고 판단해서 시도했습니다.

3. 포토샵에서 색상 공간 변경

이번에는 엔진에서 아무것도 하지 않고 포토샵에서 색상 공간을 변경하는 방법입니다.

포토샵의 "색상 설정" 옵션에서 "감마를 사용하여 RGB 색상 혼합" 옵션을 활성화하고 리소스 제작 작업을 합니다.

해당 옵션은 기본적으로 비활성화되어 있지만 활성화한다면 엔진에서 Linear ColorSpace 세팅한것과 동일한 룩으로 변경됩니다.

이 방법의 단점은 포토샵 블랜딩 효과가 불량하게 동작할 수 있고 Gamma ColorSpace에서 다르게 보이는 이슈가 발생할 수 있으니 참고 바랍니다.

(24.04.25 비활성화 <-> 활성화 내용을 반대로 작성한 것 수정, 댓글 피드백 감사합니다)

결과 리뷰

위 사진은 엔진에서 감마, 리니어 결과 그리고 위 리서칭 3가지 방법에 대한 결과물을 모았습니다.

엔진에서 처리하는 2가지 방법은 알파 강도가 비슷해지기는 했지만 색상 블랜딩이 여전히 다르게 보이는 이슈가 있습니다.

반면 포토샵에서 색상 설정 적용한 결과물은 엔진에서 Linear Colorspace와 동일한 결과를 보여주고 있습니다.

다음은 그라데이션 텍스처를 출력한 결과물입니다.

엔진에서 세팅한 2가지 방법은 색상 블랜딩 이슈도 있었지만, 위 사진을 자세히 보시면 밴딩 현상까지 보이는 품질 이슈가 있습니다.

또한 Texture Importer(Asset Postprocessor)에서 처리한 결과물은 알파 값을 다르게 저장했기 때문에 알파 값 이슈도 발생합니다.

결론 및 다른 시도 방향

Linear ColorSpace에서 알파가 다르게 보이는 이슈는 엔진에서 처리하면 문제가 해결되지 않습니다.

최적은 작업자가 포토샵에서 "색상 설정" 기능을 활용해 Linear ColorSpace에 맞는 리소스를 제작하는 것 입니다.

그 외 유니티 엔진에서 UGUI 렌더파이프라인에 대한 커스텀을 시도해볼 수 있을 것 같습니다.

URP 렌더피처를 활용한 Sprite 개별 블러 효과 구현

CatDarkGame — Tue, 5 Dec 2023 23:41:58 +0900

개요

SpriteRenderer 오브젝트 개별로 블러 효과를 다르게 적용하는 것을 목표로 URP 렌더피처 및 쉐이더 개발 과정을 소개합니다.

개발 환경

Unity 2021.3.30f1
URP 12.1.12

핵심 요소

다운 샘플링 블러 - 저비용 고품질 블러 효과
레이어 필터 프리패스 블러 - 원하는 오브젝트만 필터링하여 블러 처리

GitHub 샘플 프로젝트

https://github.com/CatDarkGame/LayerFilterSpriteBlur

GitHub - CatDarkGame/LayerFilterSpriteBlur: Unity URP, Blur effect for each spriterenderer

Unity URP, Blur effect for each spriterenderer. Contribute to CatDarkGame/LayerFilterSpriteBlur development by creating an account on GitHub.

github.com

1. 다운 샘플링 블러 - 저비용 고품질 블러 효과

개발 목표는 모바일 환경까지 고려해 퍼포먼스 비용이 높지 않아야 하며, 블러 품질이 좋아야합니다.

이를 위해 우선 블러를 표현하기 위한 여러가지 방법을 시도했습니다.

가우시안 블러 + Mipmap 샘플링

가우시안 블러는 주변 픽셀로 UV Offset 샘플링을 반복하여 블러를 표현하는 방식으로 가장 보편적으로 사용하는 블러 알고리즘입니다. 가우시안 블러는 만족스러운 블러 퀄리티를 표현하기 위해서는 샘플링 반복 횟수와 패스 스탭이 높여야합니다, 하지만 포스트프로세스가 아닌 SpriteRenderer에 블러 효과를 적용해야하기 때문에 이와 같은 방식을 그대로 적용하기는 어렵습니다.

그래서 1 Pass 가우시안 블러 9x9 방식에 Mipmap 샘플링하는 방식으로 블러를 표현해봤습니다.

 float GaussianWeight(int x, int y)
 {
     float sigma = 1.0;
     float norm = 1.0 / (2.0 * 3.141592 * sigma * sigma);
     float expPart = exp(-((x * x + y * y) / (2.0 * sigma * sigma)));
     return norm * expPart;
 }
 
 half4 frag (Varyings i) : SV_TARGET 
 {
     float2 uv = i.uv * _MainTex_ST.xy + _MainTex_ST.zw;
     half4 baseMap = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv); 
     half4 blurMap = baseMap;
     for (int x = -4; x <= 4; x++)
     {
         for (int y = -4; y <= 4; y++)
         {
             float weight = GaussianWeight(x, y);
             blurMap += SAMPLE_TEXTURE2D_LOD(_MainTex, sampler_MainTex, uv + (float2(x, y) * _Offset) * _MainTex_TexelSize, _Amount * 3) * weight;
         }
     }

     return lerp(baseMap, blurMap, _Amount);
}

의도한대로 블러가 유의미하게 표현되지만 목표한 블러 퀄리티에 비하면 부족하고 각 Sprite별로 82번 샘플링하는 것 자체가 GPU 성능 저하가 발생합니다.

목표 블러 퀄리티(포토샵 제작)

다른 블러 에셋 분석 - Translucent Image

유니티 에셋 스토어에서 판매하는 블러 에셋을 분석했습니다. 이 에셋은 모바일 WebGL에서도 구동 될 만큼 성능이 안정적이면서 블러 퀄리티도 매우 뛰어납니다. (아래 링크에서 WebGL 확인 가능)

https://leloctai.com/asset/translucentimage/index.html

이 에셋의 렌더링 구조는 위와 같습니다. 핵심 블러 알고리즘은 다운샘플링 + 스탭당 Box블러처리 방식으로 의외로 복잡한 알고리즘으로 구현되지 않았습니다.

블러 처리 외에 커스텀 렌더피처 코드 구조가 잘 설계되어 있고 버퍼 업데이트 간격 조절 등 배울 만한 요소가 많은 에셋입니다.

쉐이더 연산은 복잡하지 않고 대부분 다운 샘플링 처리에 의존하는 방식이기 때문에 안드로이드 기기(갤럭시s10e) 프로파일링 결과 GPU보다 CPU 비용이 더 높게 측정되었습니다.

	CPU 렌더쓰레드	Gfx.PresentFrame (GPU Time)
Blur 활성화	1.8ms ~ 2.5ms	3.8ms ~ 4.3ms
Blur 비활성화	0.9ms ~ 1.3ms	3.2ms ~ 3.9ms

2. 레이어 필터 프리패스 블러 - 원하는 오브젝트만 필터링하여 블러 처리

전략

프리패스 버퍼에 특정 레이어 오브젝트 렌더링 (SpriteRenderer 1번 패스)
프리패스 버퍼를 다운 샘플링 블러 처리 (위에서 소개한 블러 에셋 방식 적용)
화면 버퍼에 SpriteRenderer 2번 패스 렌더링 & 블러 버퍼와 블랜딩 적용

1. 프리패스 버퍼에 특정 레이어 오브젝트 렌더링 (SpriteRenderer 1번 패스)

원하는 SpriteRenderer에만 블러 효과를 적용하기 위해 먼저 프리패스 렌더패스를 제작합니다.

화면 버퍼에 렌더링하는 것이 아닌 Depthpass & ShadowPass와 같이 별도의 렌더 텍스처 버퍼에 렌더링하는 방식입니다.

public class LayerFilterRendererPass_Prepass : ScriptableRenderPass
{
    private const string k_ProfilingSamplerName = "LayerFilterPrepass";
    private const string k_RenderTextureName = "_LayerFilterPrepassBufferRT";
    private const string k_TexturePropertyName = "_LayerFilterPrepassBufferTex";

    public RenderTargetHandle prepassBufferRTH;
    private ProfilingSampler m_ProfilingSampler;

    private LayerMask _layerMask;
    private ShaderTagId _shaderTagId;

    private bool _isClearBlack = false;

    public LayerFilterRendererPass_Prepass(RenderPassEvent passEvent, LayerMask layerMask, ShaderTagId shaderTagId, bool isClearBlack)
    {
        renderPassEvent = passEvent;
        _layerMask = layerMask;
        _shaderTagId = shaderTagId;

        m_ProfilingSampler = new ProfilingSampler(k_ProfilingSamplerName);
        _isClearBlack = isClearBlack;
    }

    public void Setup(ref RenderTargetHandle source, RenderTargetIdentifier renderTargetDestination)
    {
        source.Init(k_RenderTextureName);
        prepassBufferRTH = source;
    }

    public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
    {
        // Prepass 렌더링할 새로운 렌더버퍼 생성 (기존 colorpass에 렌더링하는게 아닌 별도 버퍼에 렌더링하기 위함)
        RenderTextureDescriptor renderTextureDescriptor = renderingData.cameraData.cameraTargetDescriptor;
        renderTextureDescriptor.graphicsFormat = GetGraphicsFormat();
        renderTextureDescriptor.msaaSamples = 1;
        cmd.GetTemporaryRT(prepassBufferRTH.id, renderTextureDescriptor);
        cmd.SetGlobalTexture(k_TexturePropertyName, prepassBufferRTH.Identifier());

        if(_isClearBlack) ConfigureClear(ClearFlag.All, Color.black);     // Pass 렌더링 이전에 프레임 Clear 세팅 (검은색 프레임에 Sprite 렌더링)
        ConfigureInput(ScriptableRenderPassInput.Color);
        ConfigureTarget(new RenderTargetIdentifier(prepassBufferRTH.Identifier(), 0, CubemapFace.Unknown, -1));     // Pass 렌더링 대상 세팅
    }

    public override void OnCameraCleanup(CommandBuffer cmd)
    {
        cmd.ReleaseTemporaryRT(prepassBufferRTH.id);
    }


    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        CommandBuffer cmd = CommandBufferPool.Get();
        using (new UnityEngine.Rendering.ProfilingScope(cmd, m_ProfilingSampler))
        {
            context.ExecuteCommandBuffer(cmd);
            cmd.Clear();

            DrawingSettings drawSetting = CreateDrawingSettings(_shaderTagId, ref renderingData, SortingCriteria.CommonTransparent);
            FilteringSettings filterSetting = new FilteringSettings(RenderQueueRange.transparent, _layerMask);
            context.DrawRenderers(renderingData.cullResults, ref drawSetting, ref filterSetting);
        }

        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }

    public static GraphicsFormat GetGraphicsFormat()
    {
        if (SystemInfo.IsFormatSupported(GraphicsFormat.B10G11R11_UFloatPack32, FormatUsage.Linear | FormatUsage.Render))
        {
            return GraphicsFormat.B10G11R11_UFloatPack32;
        }
        else
        {
            return QualitySettings.activeColorSpace == ColorSpace.Linear
                ? GraphicsFormat.R8G8B8A8_SRGB
                : GraphicsFormat.R8G8B8A8_UNorm;
        }
    }
}

여기에 사용되는 쉐이더는 2 Pass로 제작합니다.

1번 패스는 Prepass 렌더링, 2번 패스는 최종 화면 버퍼에 렌더링 & 블러 버퍼와 블랜딩하는 기능을 구현합니다.

// 1번 패스 
half4 PrePassFragment (Varyings i) : SV_TARGET 
{
    float2 uv = i.uv * _MainTex_ST.xy + _MainTex_ST.zw;
    half4 baseMap = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv); 
    return baseMap;
}

// 2번 패스
half4 DrawPassFragment (Varyings i) : SV_TARGET 
{
    float2 uv = i.uv * _MainTex_ST.xy + _MainTex_ST.zw;
    half blendAmount = i.color.a * _BlendAmount;
    blendAmount = saturate(pow(blendAmount, 2.2));

    //half4 baseMap = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv); 
    half4 baseMap = SAMPLE_TEXTURE2D_LOD(_MainTex, sampler_MainTex, uv, blendAmount * 3.2); // 자연스러운 블랜딩을 위해 mipmap 샘플링 이용
    
    float2 uv_prepass = i.screenPosition.xy / i.screenPosition.w;
    half4 prepassMap = SAMPLE_TEXTURE2D(_LayerFilterCopypassBufferTex, sampler_LayerFilterCopypassBufferTex, uv_prepass); 
    
    half4 finalColor = lerp(baseMap, prepassMap, blendAmount);
    finalColor.a = baseMap.a;
    return finalColor;
}

2. 프리패스 버퍼를 다운 샘플링 블러 처리 (위에서 소개한 블러 에셋 방식 적용)

다음 다운 샘플링 렌더패스입니다. 다운 샘플링 + 4방향 박스 블러 처리를 수행하는데 블러 퀄리티가 훌륭하게 나옵니다.

렌더 패스 코드에서는 이전 프리패스에서 생성한 렌더 텍스처를 참조해 다운 샘플링 처리합니다.
(GetTemporaryRT 함수로 추가 렌더텍스처 생성하지 않음)

public class LayerFilterRendererPass_Copy : ScriptableRenderPass
{
    private const string k_ProfilingSamplerName = "LayerFilter_Copypass";
    private const string k_TexturePropertyName = "_LayerFilterCopypassBufferTex";
    private static int k_DownSampleTexPropertyName = Shader.PropertyToID("_DownsampleTex");
    private static int k_BlurOffsetPropertyName = Shader.PropertyToID("_blurOffset");
    private static int k_TexturePropertyID => Shader.PropertyToID(k_TexturePropertyName);

    private RenderTargetHandle copypassBufferRTH;
    private ProfilingSampler m_ProfilingSampler;
    private Material _material;
    private Shader _shader;

    private int _blurIteration = 3;
    private float _blurOffset = 1.0f;

    public LayerFilterRendererPass_Copy(RenderPassEvent passEvent, Shader shader)
    {
        renderPassEvent = passEvent;
        _shader = shader;

        m_ProfilingSampler = new ProfilingSampler(k_ProfilingSamplerName);
    }


    public void Setup(ref RenderTargetHandle source, int blurIteration = 3, float blurOffset = 1.0f)
    {
        copypassBufferRTH = source;
        _blurIteration = blurIteration;
        _blurOffset = blurOffset;

        if(!_material && _shader)
        {
            _material = CoreUtils.CreateEngineMaterial(_shader);
        }

        ConfigureClear(ClearFlag.None, Color.white);
        ConfigureTarget(copypassBufferRTH.id);
    }

    public void Destroy()
    {
        if (_material)
        {
            CoreUtils.Destroy(_material);
            _material = null;
        }
    }

    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        if (!_material || copypassBufferRTH == null) return;

        CommandBuffer cmd = CommandBufferPool.Get();
        using (new UnityEngine.Rendering.ProfilingScope(cmd, m_ProfilingSampler))
        {
            context.ExecuteCommandBuffer(cmd);
            cmd.Clear();

            int iteration = _blurIteration;
            int stepCount = Mathf.Max(iteration * 2 - 1, 1);
            string[] shaderIDStr = new string[stepCount];
            int[] shaderID = new int[stepCount];

            RenderTargetIdentifier identifier = new RenderTargetIdentifier(copypassBufferRTH.id);
            RenderTextureDescriptor rtdTempRT = renderingData.cameraData.cameraTargetDescriptor;
            rtdTempRT.msaaSamples = 1;

            int sourceSize_Width = rtdTempRT.width;
            int sourceSize_Height = rtdTempRT.height;

            // 다운 샘플링 Blit 반복
            for (int i = 0; i < stepCount; i++)
            {
                int downsampleIndex = SimplePingPong(i, iteration - 1);
                rtdTempRT.width = sourceSize_Width >> downsampleIndex + 1;
                rtdTempRT.height = sourceSize_Height >> downsampleIndex + 1;
                shaderIDStr[i] = k_TexturePropertyName + i.ToString();
                shaderID[i] = Shader.PropertyToID(shaderIDStr[i]);

                cmd.SetGlobalTexture(k_DownSampleTexPropertyName, identifier);
                _material.SetFloat(k_BlurOffsetPropertyName, _blurOffset);

                cmd.GetTemporaryRT(shaderID[i], rtdTempRT, FilterMode.Bilinear);
                cmd.Blit(identifier, new RenderTargetIdentifier(shaderIDStr[i]), _material, 0);
                if (i < stepCount - 1) identifier = new RenderTargetIdentifier(shaderIDStr[i]);
            }

            // 최종 Blit
            rtdTempRT.width = sourceSize_Width;
            rtdTempRT.height = sourceSize_Height;
            identifier = new RenderTargetIdentifier(k_TexturePropertyName);
            cmd.GetTemporaryRT(k_TexturePropertyID, rtdTempRT, FilterMode.Bilinear);
            cmd.Blit(identifier, new RenderTargetIdentifier(k_TexturePropertyName), _material, 0);

            // RT 메모리 해제
            for (int i = 0; i < stepCount; i++)
            {
                cmd.ReleaseTemporaryRT(shaderID[i]);
            }
            cmd.ReleaseTemporaryRT(k_TexturePropertyID);
        }

        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }

    private static int SimplePingPong(int t, int max)
    {
        if (t > max) return 2 * max - t;
        return t;
    }
}

Blit에서 활용하는 쉐이더는 단순하게 4방향 박스 블러 샘플링처리만 합니다.

float4 frag(Varyings input) : SV_Target
{
    float2 baseMapUV = input.uv.xy;

    float offset = _blurOffset;
    float4 tex_1 = SAMPLE_TEXTURE2D(_DownsampleTex, sampler_linear_clamp, baseMapUV + float2(_DownsampleTex_TexelSize.x * -offset, 0.0));
    float4 tex_2 = SAMPLE_TEXTURE2D(_DownsampleTex, sampler_linear_clamp, baseMapUV + float2(_DownsampleTex_TexelSize.x * offset, 0.0));
    float4 tex_3 = SAMPLE_TEXTURE2D(_DownsampleTex, sampler_linear_clamp, baseMapUV + float2(0.0, _DownsampleTex_TexelSize.y * -offset));
    float4 tex_4 = SAMPLE_TEXTURE2D(_DownsampleTex, sampler_linear_clamp, baseMapUV + float2(0.0, _DownsampleTex_TexelSize.y * offset));
    
    float4 finalColor = (tex_1 + tex_2 + tex_3 + tex_4) * 0.25f;
    return finalColor;
}

3. 화면 버퍼에 SpriteRenderer 2번 패스 렌더링 & 블러 버퍼와 블랜딩 적용

마지막으로 화면 버퍼에 렌더링하는 렌더 패스입니다.

이 렌더 패스에서는 단순히 SpriteRenderer 쉐이더의 2번 패스를 렌더링하는 역할만 수행하며

쉐이더에서 이전 블러 패스에서 제작된 블러 텍스처와 Sprite 텍스처를 단순히 Lerp 연산으로 블랜딩하여 블러 강도를 조절합니다.

추가로 블러 텍스처와 자연스러운 블랜딩을 위해 mipmap 샘플링까지 추가했습니다.

public class LayerFilterRendererPass_Drawpass : ScriptableRenderPass
{
    private const string k_ProfilingSamplerName = "LayerFilterDrawpass";

    private ProfilingSampler m_ProfilingSampler;

    private LayerMask _layerMask;
    private ShaderTagId _shaderTagId;

    public LayerFilterRendererPass_Drawpass(RenderPassEvent passEvent, LayerMask layerMask, ShaderTagId shaderTagId)
    {
        renderPassEvent = passEvent;
        _layerMask = layerMask;
        _shaderTagId = shaderTagId;

        m_ProfilingSampler = new ProfilingSampler(k_ProfilingSamplerName);
    }

    public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
    {
        ConfigureInput(ScriptableRenderPassInput.None);     // 필요한 렌더버퍼 명시 함수, Copypass에서 원본 패스로 전환하기 위해 사용
    }

    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        CommandBuffer cmd = CommandBufferPool.Get();
        using (new UnityEngine.Rendering.ProfilingScope(cmd, m_ProfilingSampler))
        {
            context.ExecuteCommandBuffer(cmd);
            cmd.Clear();

            DrawingSettings drawSettings = CreateDrawingSettings(_shaderTagId, ref renderingData, SortingCriteria.CommonTransparent);
            FilteringSettings filterSetting = new FilteringSettings(RenderQueueRange.transparent, _layerMask);
            context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filterSetting);
        }

        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }
}

// 2번 패스
half4 DrawPassFragment (Varyings i) : SV_TARGET 
{
    float2 uv = i.uv * _MainTex_ST.xy + _MainTex_ST.zw;
    half blendAmount = i.color.a * _BlendAmount;
    blendAmount = saturate(pow(blendAmount, 2.2));

    //half4 baseMap = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv); 
    half4 baseMap = SAMPLE_TEXTURE2D_LOD(_MainTex, sampler_MainTex, uv, blendAmount * 3.2); // 자연스러운 블랜딩을 위해 mipmap 샘플링 이용
    
    float2 uv_prepass = i.screenPosition.xy / i.screenPosition.w;
    half4 prepassMap = SAMPLE_TEXTURE2D(_LayerFilterCopypassBufferTex, sampler_LayerFilterCopypassBufferTex, uv_prepass); 
    
    half4 finalColor = lerp(baseMap, prepassMap, blendAmount);
    finalColor.a = baseMap.a;
    return finalColor;
}

한계점

Dynamic Batching을 위해 버텍스 컬러 알파 값으로 블러 강도 조절

SpriteRenderer의 색상 값 외에 다른 Material Property를 추가하면 Dynamic Batching이 깨지는 이슈가 발생합니다.

그래서 이 포스팅에서 소개하는 예제에서는 알파 색상 값으로 블러 강도를 조절하게 제작했습니다.

관련 포스팅 : https://darkcatgame.tistory.com/159

블러 강도 중간 단계가 어색함

이미 완성된 블러 텍스처와 Lerp 블랜딩하는 방식이기 때문에 블러 강도가 중간 값이면 블러가 퍼지는 느낌이 부족합니다.

mipmap 샘플링을 최대한 보완했지만 여전히 어색합니다.

스프라이트 외부 영역 블러 침범 & 알파 마스킹 영역에 블러까지 끊김

Sprite 텍스처의 알파 마스킹 영역(투명 픽셀)이 존재하는 경우 블러가 끊겨 보이는 문제와 스프라이트 외부 픽셀이 침범하는 문제가 있습니다.

알파 정보가 없는 블러 패스를 샘플링하는 방식이기 때문에 이런 이슈가 발생합니다.

Prepass에 렌더링 할 때 뒷 배경을 포함하는 방식으로 어느 정도 완화 할 수 있지만 SpriteRenderer는 알파 모양에 맞게 메쉬를 재구성하는 특성 때문에 완벽하게 해결하기는 어렵습니다.

좌 : 개선 전 우 : 개선 후

Prepass에 뒷 배경 포함하는 기능은 렌더피처의 Use Copy Color Pass 옵션을 활성화하면 되고 코드는 LayerFilterRendererPass_CopyColor 클래스를 참고해주세요.

SpriteRenderer CustomVertex Attributes R&D

CatDarkGame — Mon, 4 Dec 2023 21:37:49 +0900

개요

Unity SpriteRenderer에 커스텀 쉐이더를 사용할 수 있지만 MaterialPropertyBlock을 사용하는 경우 Dynamic Batcing이 묶이지 않기 때문에 사용이 제한됩니다.

Particle System의 CustomVertexSteam, UGUI의 BaseMeshEffect 클래스와 같이 Vertex Attributes를 추가하는 방식으로 커스텀 쉐이더를 사용해도 배칭 이슈가 발생하지 않는데 SpriteRenderer는 기본 Vertex Color 외에 다른 방법이 없습니다.

이번 포스팅은 SpriteRenderer에 Vertex Attributes를 추가하는 방법에 대한 R&D 내용을 작성합니다.

Sprite.SetVertexAttribute 활용

void ModifyVertexAttribute(SpriteRenderer spriteRenderer)
{
    Sprite sprite = spriteRenderer.sprite;
    if(sprite == null) return;
    
    int vertexCount = sprite.GetVertexCount();
    NativeArray<Vector2> texcoords2 = new NativeArray<Vector2>(vertexCount, Allocator.Temp);

    for (int i = 0; i < vertexCount; i++)
    {
        texcoords2[i] = new Vector2(_blurPower, _BlendAmount);
    }

    sprite.SetVertexAttribute(VertexAttribute.TexCoord1, texcoords2);
    texcoords2.Dispose();

    spriteRenderer.sprite = sprite;
}

위와 같이 Sprite.SetVertexAttribute 함수를 통해 Sprite의 버텍스 정보를 수정할 수 있습니다.

예제에서는 Texcoord1 항목을 추가했으며 쉐이더에서는 TEXCOORD1 값을 받아 Fragment로 전달하여 값을 활용합니다.

결과, 의도한대로 Vertex Attribute로 값을 전달하여 작동까지 되며, 배칭이 유지되는 것을 확인할 수 있습니다.

한계점 - Sprite 에셋을 새로 생성 필요

Unity Sprite의 내부 구조를 확인할 수 없지만, Sprite 에셋 자체가 Mesh처럼 버텍스 정보를 포함하고 있는 것 같습니다.

그래서 이 방식이 동작하기 위해서는 VertexAttribute를 수정하는 Sprite마다 에셋을 새로 생성해야 하며 메모리 부담이 높아지는 위험성이 있습니다.

결론

이 포스팅에서 소개한 VertexAttribute 방식은 메모리 이슈로 사용하면 안됩니다.

직접 SpriteRenderer 시스템을 구현하는 방법이 가장 적절할 것으로 판단합니다. (맨 아래 레퍼런스 참고)

*Unity 2023.1부터 SpriteRenderer에 SRPBatcher가 지원됩니다. (23.12.04기준 아직 Beta버전)

예제 전체 코드

SpriteRenderer에 붙이는 스크립트

using UnityEngine;
using UnityEngine.U2D;
using UnityEngine.Rendering;
using Unity.Collections;
#if UNITY_EDITOR
using UnityEditor;
#endif


namespace CatDarkGame
{
    //[ExecuteInEditMode]
    [RequireComponent(typeof(SpriteRenderer))]
    [DisallowMultipleComponent]
    public class SpriteBlurRenderer : MonoBehaviour
    {
        [SerializeField][HideInInspector] private Material _materialAsset = null;
        [SerializeField][HideInInspector] private SpriteRenderer _spriteRenderer;
        private Sprite _sprite;
        
        [Range(0.01f, 16)][SerializeField] private float _blurPower = 2.0f;
        [Range(0, 1)][SerializeField] private float _BlendAmount = 0.5f;
        [SerializeField] private bool _customVertexStream = false;

        private void OnEnable()
        {
#if UNITY_EDITOR
            if (!_materialAsset)
            {
                string assetPath = GetScriptAssetPath + "/Material/CatDarkGame_Sprites_Sprite_Blur.mat";
                Debug.Log(assetPath);
                _materialAsset = AssetDatabase.LoadAssetAtPath<Material>(assetPath);
            }
#endif
            if (!_spriteRenderer) _spriteRenderer = GetComponent<SpriteRenderer>();
            _spriteRenderer.material = _materialAsset;


            // Sprite 에셋을 새로 생성하는 방식, (메모리 증가 위험)
            // Unity Sprite 시스템은 Sprite 에셋 = Mesh 역할.
            // 결론 : 이 방식도 올바른 솔루션이 아님
            if (_spriteRenderer && !_sprite)
            {
                _sprite = Instantiate(_spriteRenderer.sprite);
                _sprite.hideFlags = HideFlags.HideAndDontSave;
                _sprite.name = _sprite.name.Replace("(Clone)", "");
                _spriteRenderer.sprite = _sprite;
            }

        }

        private bool CheckCanUpdate()
        {
            if (!_spriteRenderer) return false;
            return true;
        }

        private void Update()
        {
            if (!CheckCanUpdate()) return;
            
            if (!_customVertexStream)
            {
                _materialAsset.DisableKeyword("_CUSTOMVERTEXSTREAM");
                MaterialPropertyBlock mpb = new MaterialPropertyBlock();
                _spriteRenderer.GetPropertyBlock(mpb);
                mpb.SetFloat("_BlurPower", _blurPower);
                mpb.SetFloat("_BlendAmount", _BlendAmount);
                _spriteRenderer.SetPropertyBlock(mpb);
            }
            else
            {
                _materialAsset.EnableKeyword("_CUSTOMVERTEXSTREAM");
                ModifyVertexAttribute(_spriteRenderer);
            }
        }

        void ModifyVertexAttribute(SpriteRenderer spriteRenderer)
        {
            Sprite sprite = spriteRenderer.sprite;
            if(sprite == null) return;
            
            int vertexCount = sprite.GetVertexCount();
            NativeArray<Vector2> texcoords2 = new NativeArray<Vector2>(vertexCount, Allocator.Temp);

            for (int i = 0; i < vertexCount; i++)
            {
                texcoords2[i] = new Vector2(_blurPower, _BlendAmount);
            }

            sprite.SetVertexAttribute(VertexAttribute.TexCoord1, texcoords2);
            texcoords2.Dispose();

            spriteRenderer.sprite = sprite;
        }


#if UNITY_EDITOR
        private string GetScriptAssetPath
        {
            get
            {
                string path = AssetDatabase.FindAssets($"t:Script {nameof(SpriteBlurRenderer)}")[0];
                path = AssetDatabase.GUIDToAssetPath(path);
                return path.Substring(0, path.LastIndexOf("/"));
            }
        }
#endif
    }
}

쉐이더

Shader "CatDarkGame/Sprites/Sprite_Blur"
{
    /* 
       
    */
    Properties
    {
        //[PerRendererData] 
        _MainTex ("Sprite Texture", 2D) = "white" {}

        _BlurPower("Blur Power", Range(0.01, 16)) = 2
        _BlendAmount("Blend Amount", Range(0,1)) = 0.5

         [Toggle(_CUSTOMVERTEXSTREAM)]_EnableCustomVertexStream("Enable CustomVertexStream", float) = 0

        // Legacy properties. They're here so that materials using this shader can gracefully fallback to the legacy sprite shader.
        [HideInInspector] _Color ("Tint", Color) = (1,1,1,1)
        [HideInInspector] PixelSnap ("Pixel snap", Float) = 0
        [HideInInspector] _RendererColor ("RendererColor", Color) = (1,1,1,1)
        [HideInInspector] _Flip ("Flip", Vector) = (1,1,1,1)
        [HideInInspector] _AlphaTex ("External Alpha", 2D) = "white" {}
        [HideInInspector] _EnableExternalAlpha ("Enable External Alpha", Float) = 0
    }

    SubShader
    {
        Tags {"Queue" = "Transparent" "RenderType" = "Transparent" "RenderPipeline" = "UniversalPipeline" }

        Blend SrcAlpha OneMinusSrcAlpha
        Cull Off
        ZWrite Off


        Pass
        {
            //Tags { "LightMode" = "Universal2D" }
            Tags { "LightMode" = "UniversalForward" "Queue"="Transparent" "RenderType"="Transparent"}

            HLSLPROGRAM
            #pragma target 4.5
            #pragma multi_compile_instancing
            #pragma multi_compile_fragment _ DEBUG_DISPLAY

            #pragma shader_feature _CUSTOMVERTEXSTREAM

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/UnityInstancing.hlsl"
            #include "HLSL/CommonUtil.hlsl"
            #if defined(DEBUG_DISPLAY)
                #include "Packages/com.unity.render-pipelines.universal/Shaders/2D/Include/InputData2D.hlsl"
                #include "Packages/com.unity.render-pipelines.universal/Shaders/2D/Include/SurfaceData2D.hlsl"
                #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Debug/Debugging2D.hlsl"
            #endif

            #pragma vertex UnlitVertex
            #pragma fragment UnlitFragment

            struct Attributes
            {
                float3 positionOS   : POSITION;
                float4 color        : COLOR;
                float2 uv           : TEXCOORD0;
                float2 custom           : TEXCOORD1;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float4  positionCS      : SV_POSITION;
                float4  color           : COLOR;
                float2  uv              : TEXCOORD0;
                float2 custom           : TEXCOORD1;
                #if defined(DEBUG_DISPLAY)
                    float3  positionWS      : TEXCOORD2;
                #endif
                UNITY_VERTEX_OUTPUT_STEREO
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex);
            float4 _MainTex_ST;
           
            float4 _Color;
            half4 _RendererColor;
           
           
            #ifdef UNITY_INSTANCING_ENABLED
                UNITY_INSTANCING_BUFFER_START(Props)
                    UNITY_DEFINE_INSTANCED_PROP(half, _BlurPower)
                    UNITY_DEFINE_INSTANCED_PROP(half, _BlendAmount)

                UNITY_INSTANCING_BUFFER_END(Props)

                #define _BlurPower      UNITY_ACCESS_INSTANCED_PROP(Props, _BlurPower)
                #define _BlendAmount    UNITY_ACCESS_INSTANCED_PROP(Props, _BlendAmount)
            #endif 

           CBUFFER_START(UnityPerDrawSprite)
            #ifndef UNITY_INSTANCING_ENABLED
                half _BlurPower;
                half _BlendAmount;
            #endif
            CBUFFER_END

            Varyings UnlitVertex(Attributes attributes)
            {
                Varyings o = (Varyings)0;
                UNITY_SETUP_INSTANCE_ID(attributes);
                UNITY_TRANSFER_INSTANCE_ID(attributes, o);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

                o.positionCS = TransformObjectToHClip(attributes.positionOS);
                #if defined(DEBUG_DISPLAY)
                    o.positionWS = TransformObjectToWorld(attributes.positionOS);
                #endif
                o.uv = TRANSFORM_TEX(attributes.uv, _MainTex);
                o.color = attributes.color * _Color * _RendererColor;

                o.custom = attributes.custom;
                return o;
            }


            float4 UnlitFragment(Varyings i) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(i);
               
                float2 uv = i.uv;
                float4 mainTex = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
                
                float3 blurCol = 0;
                float blurAlpha = 0;
                half blurPower = _BlurPower;
                #ifdef _CUSTOMVERTEXSTREAM
                    blurPower = i.custom.x;
                #endif
                SumBlur_float(TEXTURE2D_ARGS(_MainTex, sampler_MainTex), uv, blurPower, blurCol, blurAlpha);

                float4 result = 1;
                half blendAmount = _BlendAmount;
                #ifdef _CUSTOMVERTEXSTREAM
                    blendAmount = i.custom.y;
                #endif
                half smoothAmount = smoothstep(0.0, 1, blendAmount); // _BlendAmount;
                result = lerp(mainTex, float4(blurCol, blurAlpha), smoothAmount) * i.color;

                
                #if defined(DEBUG_DISPLAY)
                    SurfaceData2D surfaceData;
                    InputData2D inputData;
                    half4 debugColor = 0;

                    InitializeSurfaceData(result.rgb, result.a, surfaceData);
                    InitializeInputData(i.uv, inputData);
                    SETUP_DEBUG_DATA_2D(inputData, i.positionWS);

                    if(CanDebugOverrideOutputColor(surfaceData, inputData, debugColor))
                    {
                        return debugColor;
                    }
                #endif

                return result;
            }
            ENDHLSL
        }
    }


    Fallback "Sprites/Default"
}

레퍼런스

유니티 포럼 : Additional Per-Vertex Data for SpriteRenderer?

https://forum.unity.com/threads/additional-per-vertex-data-for-spriterenderer.1270244/

ECS Instanced SpriteRenderer github

https://github.com/paullj/unity-ecs-instanced-sprite-renderer/blob/master/Assets/Scripts/Rendering/SpriteInstanceRenderSystem.cs

Entitiy 시스템으로 SpriteRenderer 구현

https://tsyang.tistory.com/161

Unity Sprite GPU Instance github

https://github.com/ownself/UnitySpriteGPUInstancing

Shader Keyword & Variants 체크 툴

CatDarkGame — Tue, 21 Nov 2023 21:48:12 +0900

프로젝트에서 사용하는 특정 쉐이더의 키워드 및 Variants 숫자를 리스트로 정렬해주는 툴
사용되는 키워드 분량, 필요 없는 키워드를 판별하는 용도로 사용
글로벌로 제어되는 multi_compile 키워드는 카운팅되지 않음. (예 : _MAIN_LIGHT_SHWDOWS)
- 정확히 Material에 저장된 Keyword만 카운트됨.

using System.Collections.Generic;
using System.Reflection;
using UnityEditor;
using UnityEngine;

// Ref - https://github.com/needle-tools/shader-variant-explorer

public class ShaderVariantChecker : EditorWindow
{
    private static MethodInfo GetVariantCount, GetShaderGlobalKeywords, GetShaderLocalKeywords;

    private Shader _shader;
 
    private ulong _variantCount = 0;
    private ulong _usedVariantCount = 0;
    private int _keywordCount = 0;
    private int _materialCount = 0;
    private Dictionary<string, int> _materialKeywords = new Dictionary<string, int>();
    private bool _isChecked = false;

    private Vector2 scrollPosition;

    [MenuItem("CustomTool/ShaderVariantChecker")]
    private static void ShowWindow()
    {
        GetWindow<ShaderVariantChecker>().Show();
    }



    public void OnGUI()
    {
        _shader = EditorGUILayout.ObjectField("Shader", _shader, typeof(Shader), true) as Shader;
        if(GUILayout.Button("Check"))
        {
            if (!_shader) return;
            Process(_shader);
        }

        if (!_isChecked) return;
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.LabelField("Variant Count : " + _variantCount);
        EditorGUILayout.LabelField("Used Variant Count : " + _usedVariantCount);
        EditorGUILayout.LabelField("Keyword Count : " + _keywordCount);

        EditorGUILayout.EndHorizontal();

        EditorGUILayout.LabelField("Used Material Count : " + _materialCount);
        scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);

        Color defaultColor = GUI.color;
        foreach (KeyValuePair<string, int> keyword in _materialKeywords)
        {
            EditorGUILayout.BeginHorizontal();
            bool isValid = keyword.Value > 0;
            if (isValid) GUI.color = Color.red;
            EditorGUILayout.TextField(keyword.Key);
            EditorGUILayout.TextField(keyword.Value.ToString(), GUILayout.Width(30));

            GUI.color = defaultColor;
            EditorGUILayout.EndHorizontal();
        }
        EditorGUILayout.EndScrollView();
    }

    private void Process(Shader shader)
    {
        if (!shader) return;

   
        GetShaderDetails(shader, out var variantCount, out var usedVariantCount, out string[] localKeywords, out string[] globalKeywords);
        
        _materialKeywords.Clear();
        for (int i = 0; i < localKeywords.Length; i++)
        {
            _materialKeywords.Add(localKeywords[i], 0);
        }
        for (int i = 0; i < globalKeywords.Length; i++)
        {
            if (_materialKeywords.ContainsKey(globalKeywords[i])) continue;
            _materialKeywords.Add(globalKeywords[i], 0);
        }
   
        _variantCount = variantCount;
        _usedVariantCount = usedVariantCount;
        _keywordCount = _materialKeywords.Count;

        // Debug.Log("variantCount : " + variantCount + ", usedVariantCount : " + usedVariantCount + ", keywordCount : " + keywordTotalCount);

        List<Material> materials = FindMaterialsUsingShader(shader);
        _materialCount = materials.Count;
        for (int i=0; i< materials.Count; i++)
        {
            Material mat = materials[i];
            if (!mat) continue;
            string[] keywords = mat.shaderKeywords;
            if(keywords == null || keywords.Length ==0) continue;

            for(int j=0; j< keywords.Length; j++)
            {
                if (!_materialKeywords.ContainsKey(keywords[j])) continue;
                _materialKeywords[keywords[j]]++;
            }
        }

        _isChecked = true;
    }

    void GetShaderDetails(Shader requestedShader, out ulong shaderVariantCount, out ulong usedShaderVariantCount, out string[] localKeywords, out string[] globalKeywords)
    {
        if (GetVariantCount == null) GetVariantCount = typeof(ShaderUtil).GetMethod("GetVariantCount", (BindingFlags)(-1));
        if (GetShaderGlobalKeywords == null) GetShaderGlobalKeywords = typeof(ShaderUtil).GetMethod("GetShaderGlobalKeywords", (BindingFlags)(-1));
        if (GetShaderLocalKeywords == null) GetShaderLocalKeywords = typeof(ShaderUtil).GetMethod("GetShaderLocalKeywords", (BindingFlags)(-1));

        if (GetVariantCount == null || GetShaderGlobalKeywords == null || GetShaderLocalKeywords == null)
        {
            shaderVariantCount = 0;
            usedShaderVariantCount = 0;
            localKeywords = null;
            globalKeywords = null;
            return;
        }

        shaderVariantCount = (ulong)GetVariantCount.Invoke(null, new object[] { requestedShader, false });
        usedShaderVariantCount = (ulong)GetVariantCount.Invoke(null, new object[] { requestedShader, true });
        localKeywords = (string[])GetShaderLocalKeywords.Invoke(null, new object[] { requestedShader });
        globalKeywords = (string[])GetShaderGlobalKeywords.Invoke(null, new object[] { requestedShader });

        // var name = $"{requestedShader.name}: ({shaderVariantCount} variants, {localKeywords.Length} local, {globalKeywords.Length} global)";
    }

    public static List<Material> FindMaterialsUsingShader(Shader shader)
    {
        List<Material> materialsUsingShader = new List<Material>();
        string[] materialAssetGUIDs = AssetDatabase.FindAssets("t:Material");
        foreach (var guid in materialAssetGUIDs)
        {
            string assetPath = AssetDatabase.GUIDToAssetPath(guid);
            Material material = AssetDatabase.LoadAssetAtPath<Material>(assetPath);

            if (material != null && material.shader != null)
            { 
                if (material.shader.name == shader.name)
                {
                    materialsUsingShader.Add(material);
                }
            }
        }

        return materialsUsingShader;
    }

}

SRP Batcher GLES & Vulkan 비교

CatDarkGame — Tue, 14 Nov 2023 23:34:11 +0900

개요

유니티의 SRP Batcher가 OpenGLES와 Vulkan API에서 차이점과 기타 특이사항을 정리했습니다.

테스트 환경

Unity 2022.1.22f1 / URP 13.1.8
갤럭시s10e / ARM Mali-G76
Unity Profiler / RenderDoc

SRP Batcher 기능과 성능 측정

SRP Batcher는 Render States 변동이 필요 없는 경우 추가 명령을 생성하지 않는 방식으로 최적화합니다.

Render States 변동 여부는 유니티 엔진에서는 SetPass Calls 수치로 확인 할 수 있습니다.

SRP Batcher 유무에 따라 RenderDoc에서 API 호출 상태를 비교해보겠습니다. (OpenGLES 빌드)

Renderer 9개 / Mesh 1종 / Material 9종

유니티 엔진에서 Draw calls와 SetPass Calls는 RenderDoc에서 렌더 이벤트와 그 내부의 렌더 API 호출 내용으로 확인 할 수 있습니다.

아래와 같은 경우는 첫번째 렌더 이벤트에서 Draw calls와 SetPass Calls API 명령이 전부 들어 있습니다.

두 번째 이벤트부터 SRP Batcher 유무 차이를 확인 할 수 있습니다.

SRP Batcher를 활성화 상태인 경우 Render States 변경 명령이 없어 API 갯수가 줄어들 었습니다.

RenderDoc의 Statistics창에서 최종 렌더 정보 요약을 확인 할 수 있는데 여기서도 API calls 갯수 차이를 확인 할 수 있습니다.

좌 : SRP Batcher Off 우 : SRP Batcher On

다음 유니티 프로파일러에서 성능 비교입니다. 확실한 비교를 위해 200개의 오브젝트 세팅했습니다.

Renderer 200개 / Mesh 1종 / Material 200종

Draw calls 및 SetPass Calls에 의한 성능 측정은 CPU Usage의 Render Loop 항목을 확인합니다.

SRP Batcher를 활성화하는 경우 그래프 스파이크 폭이 줄어들고 메인 쓰레드와 렌더 쓰레드의 Render Loop 소요 시간이 줄어 들었습니다.

SRP Batcher Off

SRP Batcher On

Material을 1종 사용하는 상황에 SRP Batcher 성능 비교

모든 Renderer가 동일한 Material 1종을 사용하는 상황. 즉, 애초부터 SetPass Calls가 1인 상황에 SRP Batcher 성능 비교에 대해서 정리했습니다. (OpenGLES 빌드)

Renderer 200개 / Mesh 1종 / Material 1종

RenderDoc API 호출 비교입니다. 유니티 Stats에서 SetPass Calls 수치는 동일하지만 실제로 API 호출 수치는 SRP Batcher가 활성화했을 때 더 줄어듭니다.

좌 : SRP Batcher Off 우 : SRP Batcher On

유니티 프로파일러에서 또한 SRP Bathcer를 활성화했을 때 Render Loop 소요 시간이 더 줄어든 것을 확인 할 수 있습니다.

SRP Batcher Off

SRP Batcher On

Vulkan API 환경에서 SRP Batcher 결과 비교

지금까지 내용은 전부 OpenGLES 환경에서 측정한 데이터입니다. Vulkan API 환경에서는 여러가지 다른 결과가 측정되었습니다.

테스트 환경은 이전과 동일하게 SetPass Calls가 1인 상황입니다..

Renderer 200개 / Mesh 1종 / Material 1종

RenderDoc에서 API 호출 내용을 비교해보면 SRP Batcher On/Off 결과가 동일하게 표시됩니다.

SRP Batcher Off

SRP Batcher On

Statisics정보입니다, 이전 OpenGLES에서는 SRP Batcher가 Off 상황에 API calls가 600개 측정되었지만 Vulkan에서는 SRP Batcher On/Off 둘다 API calls가 약 260개가 측정되었습니다.

마치 Vulkan API 환경에서는 자동으로 불필요한 RenderStates 변경 명령이 호출되지 않는 것으로 보입니다.

좌 : SRP Batcher Off 우 : SRP Batcher On

유니티 프로파일러에서도 SRP Batcher On/Off 결과가 거의 동일하게 측정되었습니다.

SRP Batcher Off

SRP Batcher On

이번엔 개별 Material을 사용하는 SetPass Calls가 200인 테스트 환경입니다.

Renderer 200개 / Mesh 1종 / Material 200종

RenderDoc API 호출 내용은 SRP Batcher On/Off 둘다 동일합니다.(세부 내용 차이가 조금 있음)

SRP Batcher Off

SRP Batcher On

좌 : SRP Batcher Off 우 : SRP Batcher On

유니티 프로파일러에서는 그래프 스파이크 폭과 성능이 SRP Batcher가 더 개선된 것으로 확인됩니다.

정리하자면 Vulkan API 환경에서는 SRP Batcher 성능 비교 결과, RenderDoc에서 측정한 API 호출 리스트는 거의 동일하지만 유니티 프로파일러에서는 성능 차이가 확인됩니다.

RenderDoc이 Vulkan API 환경에서 RenderStates 변화가 정확한 측정이 되는지 확인하기 위해 2개의 다른 쉐이더를 세팅한 환경을 테스트했습니다. 이 테스트 환경은 SRP Batcher를 사용해도 SetPass Calls가 증가되기 때문에 RenderDoc에서는 어떤 결과가 나오는지 확인하기 위함입니다.

RenderDoc에서는 정확히 다른 쉐이더가 렌더링되는 이벤트에 API가 변화가 확인되었습니다. RenderStates 변화 측정은 되긴 하는 것 같습니다.

결론

SRP Batcher는 불필요한 Render States 명령 호출을 줄여 렌더링 최적화하는 시스템으로 유니티 엔진에서는 SetPass Calls 수치로 확인가능하고 RenderDoc에서 API 호출 상태를 통해 확인 가능.
OpenGLES 기준, SetPass Calls가 1인 상태에서도 SRP Batcher가 활성화되는 경우 렌더 명령 API 호출이 줄어들고 실제 성능이 개선됨.
Vulkan 기준, SRP Batcher를 활성화하지 않아도 불필요한 Render State 명령 호출이 줄어들고 실제 성능이 개선되는 결과가 확인됨.

프로파일링 성능 측정 결과는 상황과 환경에 따라 다르게 측정되기 때문에 테스트 내용과 결과 참고용으로만 봐주세요,

CustomInspector CategoryHeaderGUI - 어두운 폴드바GUI

CatDarkGame — Thu, 12 Oct 2023 22:28:33 +0900

Unity 엔진 내장 에디터툴에서 자주 사용되는 폴드바 GUI 에디터 스크립트입니다.

EditorGUILayout과 같은 기본 에디터 클래스에는 구현되어 있지 않아 직접 제작해야합니다.

GUI 클래스

public static class CategoryHeader
{
    protected static class Styles
    {
        public static readonly GUIStyle foldoutStyle;
        public static readonly GUIStyle categoryHeader;

        static Styles()
        {
            var builtInSkin = GetCurrentSkin();
            foldoutStyle = new GUIStyle(EditorStyles.foldout);
            foldoutStyle.fontStyle = FontStyle.Bold;

            categoryHeader = new GUIStyle(builtInSkin.label);
            categoryHeader.fontStyle = FontStyle.Bold;
            categoryHeader.border.left = 2;
            categoryHeader.padding.left = 32;
            categoryHeader.padding.top = 2;
            categoryHeader.border.right = 2;
  
            categoryHeader.normal.background = GetBackgroundProcedural_Twotone(new Color(0.196f, 0.196f, 0.196f),
                                                                                new Color(0.121f, 0.121f, 0.121f));
        }

        private static Texture2D GetBackgroundProcedural(Color color)
        {
            Texture2D texture = new Texture2D(1, 1);
            texture.SetPixel(0, 0, color);
            texture.Apply();
            return texture;
        }

        private static Texture2D GetBackgroundProcedural_Twotone(Color color, Color headerColor)
        {
            const int height = 16;
            Texture2D texture = new Texture2D(1, height);
            for(int i=0; i< height - 1; i++)
            {
                texture.SetPixel(0, i, color);
            }
            texture.SetPixel(0, height - 1, headerColor);
            texture.Apply();
            return texture;
        }

        private static Texture2D GetBackgroundAsset(string assetPath)
        {
            Texture2D texture = (Texture2D)AssetDatabase.LoadAssetAtPath<Texture2D>(assetPath);
            if (!texture)
            {
                Debug.LogWarning("GUITexture Asset does not exist : " + assetPath);
                texture = null;
            }
            return texture;
        }

        public static GUISkin GetCurrentSkin()
        {
            return EditorGUIUtility.isProSkin ? EditorGUIUtility.GetBuiltinSkin(EditorSkin.Scene) : EditorGUIUtility.GetBuiltinSkin(EditorSkin.Inspector);
        }
    }

    public static bool ShowHeader(GUIContent nameContent, bool foldoutState, string preferenceName = null)
    {
        float height = Styles.categoryHeader.CalcHeight(nameContent, 4000) + 3;

        Rect rect = GUILayoutUtility.GetRect(1, height - 1);
        rect.width += rect.x;
        rect.x = 0;

        if (Event.current.type == EventType.Repaint)
            Styles.categoryHeader.Draw(rect, nameContent, false, true, true, false);

        bool result = false;
        rect.x += 14;
        rect.width -= 2;
        result = EditorGUI.Toggle(rect, foldoutState, Styles.foldoutStyle);

        EditorGUI.indentLevel = result ? 1 : 0;

        if (preferenceName != null && result != foldoutState)
        {
            EditorPrefs.SetBool(preferenceName, result);
        }

        return result;
    }

    public static bool ShowHeader(string label, bool foldoutState, string preferenceName = null)
    {
        return ShowHeader(EditorGUIUtility.TrTempContent(label), foldoutState, preferenceName);
    }
}

사용 샘플 & 전체 스크립트

using System.Collections;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;


[CustomEditor(typeof(CustomInspectorSample))]
public class CustomInspectorSample_Editor : Editor
{
    protected struct PropertyDefine
    {
        public SerializedProperty prop;
        public string path;

        public PropertyDefine(string path)
        {
            this.prop = null;
            this.path = path;
        }

        public void Init(SerializedObject serializedObject)
        {
            prop = serializedObject.FindProperty(path);
        }
    }

    protected static class Contents
    {
        public static readonly GUIContent headerGeneral = EditorGUIUtility.TrTextContent("General");
        public static readonly GUIContent amount = EditorGUIUtility.TrTextContent("Amount", "Amount Property Description");
    }

    const string kGeneralFoldoutStatePreferenceName = "CustomInspectorSample_Editor.Foldout.General";
    private bool showGeneralCategory;
    private bool showRendererCategory;

    private PropertyDefine _amountProp = new PropertyDefine("_amount");
    private PropertyDefine _colorProp = new PropertyDefine("_color");

    private CustomInspectorSample _component;
    

    private void OnEnable()
    {
        _component = (CustomInspectorSample)target;
        showGeneralCategory = EditorPrefs.GetBool(kGeneralFoldoutStatePreferenceName, true);
        
        _amountProp.Init(serializedObject);
        _colorProp.Init(serializedObject);
    }

   
    public override void OnInspectorGUI()
    { 
        if (!_component) return;
        serializedObject.Update();

        EditorGUI.BeginChangeCheck();
        GUILayout.Space(6);

        showGeneralCategory = CategoryHeader.ShowHeader(Contents.headerGeneral, showGeneralCategory, kGeneralFoldoutStatePreferenceName);
        if(showGeneralCategory)
        {
            EditorGUILayout.PropertyField(_amountProp.prop, Contents.amount);
            GUILayout.Space(6);
        }
        
        showRendererCategory = CategoryHeader.ShowHeader("Renderer", showRendererCategory);
        if (showRendererCategory)
        {
            EditorGUILayout.PropertyField(_colorProp.prop);
            GUILayout.Space(6);
        }

        if (EditorGUI.EndChangeCheck())
        {
            serializedObject.ApplyModifiedProperties();
        }   
    }
}

public static class CategoryHeader
{
    protected static class Styles
    {
        public static readonly GUIStyle foldoutStyle;
        public static readonly GUIStyle categoryHeader;

        static Styles()
        {
            var builtInSkin = GetCurrentSkin();
            foldoutStyle = new GUIStyle(EditorStyles.foldout);
            foldoutStyle.fontStyle = FontStyle.Bold;

            categoryHeader = new GUIStyle(builtInSkin.label);
            categoryHeader.fontStyle = FontStyle.Bold;
            categoryHeader.border.left = 2;
            categoryHeader.padding.left = 32;
            categoryHeader.padding.top = 2;
            categoryHeader.border.right = 2;
  
            categoryHeader.normal.background = GetBackgroundProcedural_Twotone(new Color(0.196f, 0.196f, 0.196f),
                                                                                new Color(0.121f, 0.121f, 0.121f));
        }

        private static Texture2D GetBackgroundProcedural(Color color)
        {
            Texture2D texture = new Texture2D(1, 1);
            texture.SetPixel(0, 0, color);
            texture.Apply();
            return texture;
        }

        private static Texture2D GetBackgroundProcedural_Twotone(Color color, Color headerColor)
        {
            const int height = 16;
            Texture2D texture = new Texture2D(1, height);
            for(int i=0; i< height - 1; i++)
            {
                texture.SetPixel(0, i, color);
            }
            texture.SetPixel(0, height - 1, headerColor);
            texture.Apply();
            return texture;
        }

        private static Texture2D GetBackgroundAsset(string assetPath)
        {
            Texture2D texture = (Texture2D)AssetDatabase.LoadAssetAtPath<Texture2D>(assetPath);
            if (!texture)
            {
                Debug.LogWarning("GUITexture Asset does not exist : " + assetPath);
                texture = null;
            }
            return texture;
        }

        public static GUISkin GetCurrentSkin()
        {
            return EditorGUIUtility.isProSkin ? EditorGUIUtility.GetBuiltinSkin(EditorSkin.Scene) : EditorGUIUtility.GetBuiltinSkin(EditorSkin.Inspector);
        }
    }

    public static bool ShowHeader(GUIContent nameContent, bool foldoutState, string preferenceName = null)
    {
        float height = Styles.categoryHeader.CalcHeight(nameContent, 4000) + 3;

        Rect rect = GUILayoutUtility.GetRect(1, height - 1);
        rect.width += rect.x;
        rect.x = 0;

        if (Event.current.type == EventType.Repaint)
            Styles.categoryHeader.Draw(rect, nameContent, false, true, true, false);

        bool result = false;
        rect.x += 14;
        rect.width -= 2;
        result = EditorGUI.Toggle(rect, foldoutState, Styles.foldoutStyle);

        EditorGUI.indentLevel = result ? 1 : 0;

        if (preferenceName != null && result != foldoutState)
        {
            EditorPrefs.SetBool(preferenceName, result);
        }

        return result;
    }

    public static bool ShowHeader(string label, bool foldoutState, string preferenceName = null)
    {
        return ShowHeader(EditorGUIUtility.TrTempContent(label), foldoutState, preferenceName);
    }
}

Unity 2023-URP 16 렌더피처 API 변경 정리

CatDarkGame — Fri, 22 Sep 2023 20:16:05 +0900

URP 16.0.3 기준, ScriptableRenderFeature & Pass API가 변경되면서 이전 버전 코드를 수정하지 않으면 에러가 발생합니다.

참고자료

https://forum.unity.com/threads/rendertargethandle-is-obsolete-deprecated-in-favor-of-rthandle.1211052/

https://docs.unity3d.com/Packages/com.unity.render-pipelines.universal@16.0/manual/upgrade-guide-2023-2.html

RTHandle System도입으로 인한 ScriptableRenderPass 클래스 API 주요 변경 코드

(빨강 = Before, 초록 = After)

1. Change render target type

RenderTargetHandle renderTarget;
RTHandle renderTarget;

2. Associate the shader property with the render target using RTHandles.Alloc instead of renderTarget.Init

renderTarget.Init("_ShaderProperty");
renderTarget = RTHandles.Alloc("_ShaderProperty", name: "_ShaderProperty");

3. Assign temporary render texture using the shader property identifier

cmd.GetTemporaryRT(renderTarget.id, targetDescriptor, filterMode);
cmd.GetTemporaryRT(Shader.PropertyToID(renderTarget.name), targetDescriptor, filterMode);

4. Modify ConfigureTarget to use the new RTHandle instead of the old RenderTargetIdentifier

ConfigureTarget(renderTarget.id);
ConfigureTarget(renderTarget);

5. Get the render texture identifier from the shader property

cmd.ReleaseTemporaryRT(renderTarget.id);
cmd.ReleaseTemporaryRT(Shader.PropertyToID(renderTarget.name));

클래스 코드 예제

RTHandle 도입 이전

public class CustomPass : ScriptableRenderPass
{
    RenderTargetHandle m_Handle;
    // With the old API, RenderTargetIdentifier might combine color and depth
    RenderTargetIdentifier m_Destination;

    public CustomPass()
    {
        m_Handle.Init("_CustomPassHandle");
    }

    public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
    {
        var desc = renderingData.cameraData.cameraTargetDescriptor;
        cmd.GetTemporaryRT(m_Handle.id, desc, FilterMode.Point);
    }

    public override void OnCameraCleanup(CommandBuffer cmd)
    {
        cmd.ReleaseTemporaryRT(m_Handle.id);
    }

    public void Setup(RenderTargetIdentifier destination)
    {
        m_Destination = destination;
    }

    public override void Execute(ScriptableRenderContext context,
                                    ref RenderingData renderingData)
    {
        CommandBuffer cmd = CommandBufferPool.Get();
        // Set the same target for color and depth
        ScriptableRenderer.SetRenderTarget(cmd, m_Destination, m_Destination, clearFlag,
                                              clearColor);
        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }
}

RTHandle 도입 후

public class CustomPass : ScriptableRenderPass
{
    RTHandle m_Handle;
    // Then using RTHandles, the color and the depth properties must be separate
    RTHandle m_DestinationColor;
    RTHandle m_DestinationDepth;

    void Dispose()
    {
        m_Handle?.Release();
    }

    public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
    {
        var desc = renderingData.cameraData.cameraTargetDescriptor;
        // Then using RTHandles, the color and the depth properties must be separate
        desc.depthBufferBits = 0;
        RenderingUtils.ReAllocateIfNeeded(ref m_Handle, desc, FilterMode.Point,
                                         TextureWrapMode.Clamp, name: "_CustomPassHandle");
    }

    public override void OnCameraCleanup(CommandBuffer cmd)
    {
        m_DestinationColor = null;
        m_DestinationDepth = null;
    }

    public void Setup(RTHandle destinationColor, RTHandle destinationDepth)
    {
        m_DestinationColor = destinationColor;
        m_DestinationDepth = destinationDepth;
    }

    public override void Execute(ScriptableRenderContext context,
                                    ref RenderingData renderingData)
    {
        CommandBuffer cmd = CommandBufferPool.Get();
        ScriptableRenderer.SetRenderTarget(cmd, m_DestinationColor, m_DestinationDepth,
                                              clearFlag, clearColor);
        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
     }
  }

URP 15 데칼 레이어 분석 & 구현 방법

CatDarkGame — Thu, 31 Aug 2023 21:39:30 +0900

https://youtu.be/QLrBoXCu6_Q?t=1233

데칼 레이어란

데칼 레이어는 데칼을 사용할 때 지형에는 적용하면서 캐릭터를 예외 처리 하고 싶을 때 사용합니다.

Unity 2023 URP 15에서 도입되었으며 Decal 렌더피쳐에서 옵션을 활성화 할 수 있습니다.

이번 포스팅은 데칼 레이어 원리와 데칼 레이어를 지원하는 쉐이더 구현 방법을 소개합니다.

URP 15 이전 데칼 레이어 구현 방법

간단히 스텐실 테스트를 통해 데칼이 원하지 않은 오브젝트에 덮히지 않게 할 수 있습니다.

특정 스텐실 넘버에 Replace 옵션으로 정보를 기록하고 데칼 마테리얼에서 NotEqual 옵션으로 스텐실 넘버가 겹치지 않은 부분만 렌더링하는 원리입니다.

좌 : Before 우 : After

쉐이더에 스텐실 제어하는 코드는 아래와 같습니다.

 Properties
    { 
        _BaseColor("Color", Color) = (1, 1, 1, 1)
        _BaseMap("Texture", 2D) = "white" {}

        [Header(Stencil Test)]
        [Space(10)]
        [IntRange] _Reference("Ref", Range(0,255)) = 0
        [Enum(UnityEngine.Rendering.CompareFunction)] _Comp("Comp", float) = 8
        [Enum(UnityEngine.Rendering.StencilOp)] _Pass("Pass", float) = 0
        [Enum(UnityEngine.Rendering.StencilOp)] _fail("fail", float) = 0
        [Enum(UnityEngine.Rendering.StencilOp)] _Zfail("Zfail", float) = 0
    }
    
     Pass
        {
            Name  "ScreenSpaceDecal"
            Tags {"LightMode" = "SRPDefaultUnlit"}

            Cull back
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha 

             Stencil
            {
                Ref [_Reference] 
                Comp [_Comp] 
                Pass [_Pass] 
                fail [_fail] 
                Zfail [_Zfail]
            }

URP 15 데칼 레이어 원리 분석

URP 15의 데칼 레이어는 스텐실 방식이 아닌 별도의 레이어 버퍼를 추가로 사용하여 데칼 쉐이더 내부에서 필터링하는 방식입니다. Decal 렌더피쳐에서 데칼 레이어 옵션을 활성화하면 아래와 같이 _CameraRenderingLayerTexture 버퍼가 추가로 생성되는 것을 확인 할 수 있습니다.

렌더링레이어 버퍼는 UniversalRenderer에서 렌더패스 호출하고 있으며 데칼레이어 옵션이 활성화되면 Forward 렌더링 환경에서 OpaqueForwardPass 대신 RenderingLayer 기능이 추가된 OpaqueForwardPass가 렌더패스 호출됩니다.

UniversalRenderer.cs / UniversalRenderer(생성자)

UniversalRenderer.cs / Setup

RenderingLayersPass 렌더패스에서는 렌더링 레이어 쉐이더 키워드를 활성화 시켜줍니다.

LitForward.hlsl를 보면 이전 버전과 다르게 쉐이더 결과를 return하는게 아닌 out 방식으로 변경되었고 렌더링 레이어 분기가 활성화되어 있으면 메쉬 레이어 정보를 추가로 내보냅니다.

GetMeshRenderingLayer() 함수는 Renderer 컴포넌트의 Rendering Layer Mask 정보 값이 들어옵니다.

이 정보 값을 SV_Target1로 내보내면 _CameraRenderingLayerTexture 버퍼에 정보가 그려지게 됩니다.

Opaque렌더링 이후에 렌더링되는 쉐이더에서 _CameraRenderingLayersTexture를 샘플링하여 렌더링레이어 정보를 사용할 수 있습니다. 데칼 쉐이더에서는 해당 버퍼를 샘플링하는 방식으로 필터링하는 방식으로 데칼 레이어가 구현되어 있습니다.

이 기술은 데칼뿐만 아니라 레이어 필터링이 필요한 기능을 구현할 때 응용 가능할 것으로 보입니다.
(예를 들어 포스트프로세스에서 특정 오브젝트를 제외하고 효과를 입히기.)

"Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareRenderingLayerTexture.hlsl"

렌더링 레이어 사용 예제

RenderingLayer Write지원하는 쉐이더 샘플

Shader "CatDarkGame/Unlit_WriteRenderingLayer"
{
    Properties
    { 
        [MainTexture] _BaseMap("Texture", 2D) = "white" {}
        [MainColor] _BaseColor("Color", Color) = (1, 1, 1, 1)
    }

    SubShader
    {
         Tags
        {
            "RenderType" = "Opaque"
            "RenderPipeline" = "UniversalPipeline"
            "UniversalMaterialType" = "Lit"
            "IgnoreProjector" = "True"
        }

        Pass
        {
            Name  "URPUnlit"
            Tags {"LightMode" = "UniversalForward"}

            ZWrite on
            Cull back

            HLSLPROGRAM
            #pragma target 4.5
            #pragma exclude_renderers gles d3d9
            
            #pragma vertex vert
            #pragma fragment frag

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonLighting.hlsl"
            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl"


            CBUFFER_START(UnityPerMaterial)
                float4 _BaseMap_ST;
                float4 _BaseColor;
            CBUFFER_END

            TEXTURE2D(_BaseMap);    SAMPLER(sampler_BaseMap);


            struct Attributes
            {
                float4 positionOS    : POSITION;
                float2 uv            : TEXCOORD0;
            };

            struct Varyings
            {
                float4 positionCS    : SV_POSITION;
                float2 uv            : TEXCOORD0;
            }; 
            

            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;

                float4 positionOS = input.positionOS;
                float3 positionWS = TransformObjectToWorld(positionOS.xyz);
                float4 positionCS = TransformWorldToHClip(positionWS);

                output.positionCS = positionCS;
                output.uv = input.uv;
                return output;
            }

            void frag(Varyings input, out half4 outColor : SV_Target0
                                        #ifdef _WRITE_RENDERING_LAYERS
                                            , out float4 outRenderingLayers : SV_Target1
                                        #endif
                                        )
            {
                float2 baseMapUV = input.uv.xy * _BaseMap_ST.xy + _BaseMap_ST.zw;
                float4 texColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, baseMapUV);
                
                #ifdef _WRITE_RENDERING_LAYERS
                    uint renderingLayers = GetMeshRenderingLayer();
                    outRenderingLayers = float4(EncodeMeshRenderingLayer(renderingLayers), 0, 0, 0);
                #endif

           
                float4 finalColor = texColor * _BaseColor;
                outColor = finalColor;
            }
            
            ENDHLSL
        }
    }
}

데칼레이어 기능이 추가된 데칼 쉐이더 (Decal Projection 컴포넌트 전용)

Shader "CatDarkGame/ScreenSpaceDecal"
{
    Properties
    { 
        _BaseColor("Color", Color) = (1, 1, 1, 1)
        _BaseMap("Texture", 2D) = "white" {}
    }

    SubShader
    {
       Tags
        {
            "RenderPipeline"="UniversalPipeline"
            "PreviewType"="Plane"
            "DisableBatching"="False"
            "ShaderGraphShader"="true"
            "ShaderGraphTargetId"="UniversalDecalSubTarget"
        }
        

        Pass
        {
            Name  "DecalScreenSpaceProjector"
            Tags {"LightMode" = "DecalScreenSpaceProjector"}


            Cull back
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha 

            HLSLPROGRAM
            
            #define DECAL_PROJECTOR

            #pragma target 4.5
            
            
            #pragma vertex vert 
            #pragma fragment frag

            #pragma multi_compile _ _DECAL_LAYERS

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
            #ifdef _DECAL_LAYERS
                #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareRenderingLayerTexture.hlsl"
                #include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderVariablesDecal.hlsl"
            #endif

            CBUFFER_START(UnityPerMaterial)
                float4 _BaseMap_ST;
                float4 _BaseColor;
            CBUFFER_END

            TEXTURE2D(_BaseMap);    SAMPLER(sampler_BaseMap);


            struct Attributes
            {
                float4 positionOS    : POSITION;
                float2 uv            : TEXCOORD0;
            };

            struct Varyings
            {
                float4 positionCS    : SV_POSITION;
                float2 uv            : TEXCOORD0;
                float4 positionSS    : TEXCOORD1;
                float4 viewRayOS     : TEXCOORD2; 
                float3 cameraPosOS   : TEXCOORD3;
            }; 
            
            
            void GetObjectSpaceViewTransform(float3 positionVS, out float4 objectToViewDir, out float3 viewPositionOS)
            {
                float viewZ = positionVS.z;
                float4x4 viewToObjectMatrix = mul(UNITY_MATRIX_I_M, UNITY_MATRIX_I_V);
                objectToViewDir.xyz = mul((float3x3)viewToObjectMatrix, positionVS.xyz * -1).xyz;
                objectToViewDir.w = viewZ;
                viewPositionOS.xyz = mul(viewToObjectMatrix, float4(0.0f, 0.0f, 0.0f, 1.0f)).xyz; 
            }


            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;

                float4 positionOS = input.positionOS;
                float3 positionWS = TransformObjectToWorld(positionOS.xyz);
                float4 positionCS = TransformWorldToHClip(positionWS);
                
                float4 positionSS = ComputeScreenPos(positionCS);
               
                float3 positionVS = TransformWorldToView(positionWS);
                float4 objectToViewDir = 0;
                float3 viewPositionOS = 0;
                GetObjectSpaceViewTransform(positionVS, objectToViewDir, viewPositionOS);
                
                output.viewRayOS = objectToViewDir;
                output.cameraPosOS = viewPositionOS ;
                output.positionSS = positionSS;
                output.positionCS = positionCS;
                output.uv = input.uv;
                return output;
            }

            float4 frag(Varyings input) : SV_Target
            {
                float decalLayerClip = 0;
                #ifdef _DECAL_LAYERS
                    uint surfaceRenderingLayer = LoadSceneRenderingLayer(input.positionCS.xy);
                    uint projectorRenderingLayer = uint(UNITY_ACCESS_INSTANCED_PROP(Decal, _DecalLayerMaskFromDecal));
                    decalLayerClip = 1 - (surfaceRenderingLayer & projectorRenderingLayer);
                #endif
          
                float sceneRawDepth = SampleSceneDepth(input.positionSS.xy / input.positionSS.w).r; 
                float sceneDepthVS = LinearEyeDepth(sceneRawDepth, _ZBufferParams);
                float3 viewRayOS = (input.viewRayOS.xyz / input.viewRayOS.w) * sceneDepthVS;
                float3 decalSpaceScenePos = input.cameraPosOS.xyz + viewRayOS.xyz;
             
                float3 absDecalSpaceScenePos = abs(decalSpaceScenePos);
                float decalClipAlpha = max(max(absDecalSpaceScenePos.x, absDecalSpaceScenePos.y), absDecalSpaceScenePos.z);
                clip(0.5f - decalClipAlpha - decalLayerClip);
               
                #ifndef DECAL_PROJECTOR
                    float2 decalSpaceUV = decalSpaceScenePos.xy + 0.5f;
                #else
                    float2 decalSpaceUV = decalSpaceScenePos.xz + 0.5f;
                #endif
               
                float2 uv = decalSpaceUV.xy * _BaseMap_ST.xy + _BaseMap_ST.zw;
                uv = frac(uv);
              
                float4 texColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv);
                float4 finalColor = texColor * _BaseColor;
                return finalColor;
            }
            
            ENDHLSL
        }
    }
}

URP 15.0.5 데칼 레이어 렌더링 이슈

CatDarkGame — Tue, 25 Jul 2023 23:36:41 +0900

이슈 개요

- Unity 2023.1.0 DX11 API

URP 데칼 렌더피처에는 뎁스 정보를 활용하는 ScreenSpace와 디퍼드 렌더링의 데칼 버퍼를 활용하는 DBuffer 2가지 모드가 있다.

Screen Space 데칼 모드에서 Rendering Layer 기능을 활성화 상태로 Depth Priming Mode와 MSAA가 활성화되어 있으면 GameView에서만 Opaque 오브젝트가 렌더링되지 않는 이슈가 있다.
뎁스 테스트를 하지 않는 Transparent 오브젝트는 렌더링이 잘된다.

데칼 레이어 구조

URP 15버전 기준 Lit 쉐이더를 보면 Forward와 DepthNormal 패스에서 Mesh RenderingLayer 정보를 출력하는 코드가 있는데 데칼 레이어는 해당 정보를 활용해 레이어 필터링하는 방식이다.
(GbufferPass에서도 출력하지만 디퍼드 렌더링 관련 내용은 생략)

_WRITE_RENDERING_LAYERS multi complie 분기처리 되어 있으며 쉐이더에서는 아래와 같이 RenderingLayers.hlsl파일을 Include하고 URP Core 렌더피처의 DrawObjectPass와 DepthNormalOnly에서 해당 키워드를 제어한다 .

(URP 15에서는 hlsl파일 내부에서 #pragma 구문까지 읽을 수 있는 include 문법이 가능하다)

DrawObjectsPass.cs

RenderingLayer는 URP12버전에서 LightLayer 기능에서 발전된 시스템으로 원래 라이트 레이어 정보와 자기 자신 메쉬 레이어 정보를 비교하여 라이트 연산을 필터링하는 기능으로 활용되었다.

대표적으로 아래처럼 쉐이더 코드는 Lighting.hlsl에서 라이트 레이어가 일치하는지 검사하는 코드가 있다.

현재 URP15에서는 _WRITE_RENDERING_LAYERS 분기가 활성화되어 있을 경우 자기 자신 메쉬 레이어를 SV_Target1로 출력하게 되어 있고 데칼 레이어와 같이 다른 메쉬의 레이어 정보 읽기가 필요한 시스템이 활성화되면 자동으로 분기가 활성화된다.

LitForwardPass.hlsl / LitPassFragment

_WRITE_RENDERING_LAYERS 분기는 여러 패스 중에 먼저 렌더링되는 패스에만 활성화되고 나머지 패스는 비활성화 상태가 유지된다.

예를 들어 DepthNormal 패스가 프리패스로 먼저 렌더링되면 Forward패스는 해당 분기가 비활성화 된다.

이슈 발생 조건

일반적으로 ScreenSpace 데칼은 뎁스 정보를 사용하지만 특이한 점은 MSAA를 활성화하면 DepthNormalPrepass가 활성화되어 DepthPass대신 DepthNormal 정보를 사용하게 된다.

ScreenSpace 데칼가 데칼 레이어를 사용한다고 해서 DepthNormal 정보를 사용하는 이유를 못 찾았고 명확한 이유가 진짜 없으면 이 현상은 유니티 버그 가능성이 높을 것 같다.

좌 : MSAA Off 우 : MSAA On

문제는 데칼 레이어와 MSAA가 활성화된 상태로 Depth Priming Mode를 활성화하면 DepthNormalPrepass에 MSAA 처리가 들어가면서 렌더링되지 않는 이슈가 발생한다.

아래와 같이 동일하게 DepthNormalPrepass가 프레임 디버거에 찍히지만 이슈가 발생하는 경우 그냥 렌더링되지 않는다.

따라서 DepthNormalPrepass에 정보가 없는 상태에서 뎁스 테스트 컬링이 동작하게 되어 불투명 오브젝트가 렌더링되지 않는 결과가 나온다.

좌 : Depth Priming Mode Off 우 : Depth Priming Mode On

데칼 레이어 대신 DepthNormalPass를 사용하는 SSAO로 동일한 조건을 만들면 이슈가 발생하지 않고 렌더링된다.

이점을 보아선 DepthNormalPrepass에 MSAA가 적용되서 문제가 발생하는게 아니라 데칼 레이어 내부 시스템에 의한 문제로 원인이 좁혀진다.

결론

1. ScreenSpace 데칼 레이어를 활성화 상태로 MSAA를 활성화하면 DepthNormalPrepass를 강제로 사용한다. 이 부분은 유니티 버그로 추측된다.

2. 1번 상태에서 Depth Priming Mode가 활성화되면 DepthNormalPrepass에 아무것도 렌더링되지 않아 불투명 오브젝트가 렌더링되지 않는다. (GameView에서만 문제가 발생하고 SceneView는 정상 렌더링된다.)

3. 데칼이 아닌 SSAO로 동일한 조건을 만들면 이슈가 발생하지 않는다.

[번역] Arm Mali GPU Training Series Ep 2.6 : Shader best practices

CatDarkGame — Mon, 24 Jul 2023 23:09:31 +0900

원문

https://youtu.be/KCL9xiN_UbM

개요

Mali GPU에서 더 나은 성능을 낼 수 있는 쉐이더 프로그래밍 Best Practices 소개

1. Use lower precision - 낮은 정밀도 사용

Mediump 또는 Vulkan Relaxed Precision을 사용하는 것을 권장.

(중간 정밀도를 의미하며 HLSL에서 half가 mediump에 가장 가까운 자료형.)

중간 정밀도는 16비트 자료형 및 정수 유형에 매핑되고 사용은 에너지 효율이 더 좋고 더 작은 레지스터(메모리)를 사용하고 연산이 빠르다, Mail GPU에서 16비트 Vector2 2개를 연산하는 속도와 32비트 연산과 동일한 속도로 처리된다.

(GPU API마다 특정 조건에서 16비트가 더 낮은 퍼포먼스가 나오는 경우도 있음)

중간 정밀도 자료형의 단점은 동적 범위와 정밀도에서 제한이 있다.

(최대 & 최소 값과 소수점 길이 제한이 있다는 뜻)

일반적으로 월드 공간에서 위치나 거리를 계산하는 공간 연산, 그림자 맵핑 & 뎁스 맵핑과 같은 샘플링 & 텍스처 샘플링에 사용되는 UV 좌표에는 32비트 보간자를 권장한다.

(추가로 _Time변수와 연산하는 변수에도 32비트 권장)

형변환 주의, 이것은 공짜가 아니다.(퍼포먼스 공짜가 아니다)

2. 부동소수점 연산 주의 (부동소수점 = float, half와 같은 자료형)

1번 코드에서 2번 코드로 곱연산을 1번으로 줄여 최적화한것 처럼 보이겠지만, 부동소수점을 사용하고 있다면 컴파일러가 에러가 발생할 수 있다.

예시로 위와 같이 a와 b에 부동 소수점의 최대값으로 세팅한다면, 우측 최적화 시도한 코드에서 덧셈이 먼저 진행되어 부동소수점이 초과되는 이슈가 발생한다.

(이러한 경우 GPU마다 다르겠지만 대체로 큰 퍼포먼스 저하와 무한대 값이 들어가 픽셀 이상 이슈 발생)

3. 내장 함수를 사용하자

쉐이더 언어에는 내장 함수 및 대규모 내장 함수 라이브러리가 있다.
(ESSL = OpenGLES Shading Language, ESSL 뿐만 아니라 HLSL와 같이 각 쉐이더 언어마다 비슷하게 내장 함수 있음)

쉐이더 언어에서 제공하는 내장 함수를 사용하는 것이 직접 구현하는 것보다 거의 항상 퍼포먼스적으로 효율적이다.

왜냐하면 하드웨어에 의해 지원되거나 특정 GPU 버전에 대한 핸드 튜닝했기 때문이다.

대부분 고정밀도 인자(inputs)를 사용하는 함수는 비싸다.

(void function(float a) <- float a을 의미)

내장 함수 중에 같은 함수라도 중간 정밀도를 사용하는 함수가 더 빠르기 때문에 권장한다.

아래 내장 함수들은 퍼포먼스가 무거우니 피하도록 노력해라 - 삼각함수 계열(sin, cos, tan), Atomics, textureGrad

4. 유니폼 계산은 CPU에서 처리

유니폼 연산은 드로우 콜이나 컴퓨트 디스패치의 모든 스레드에 대해 동일한 결과를 내는 연산을 의미한다. 이러한 경우 CPU에서 연산을 처리하는 것을 권장한다.

Mali GPU에서 이러한 연산에 대해서 어느정도 최적화 할 수 있지만, 완전 최적화할 수 없다.

(예 : 오브젝트 Pivot과 카메라와 거리 계산은 모든 픽셀의 결과 값이 동일하기 때문에 CPU에서 처리하는 것이 효율적임)

5. 쉐이더 베리에이션 관련

쉐이더 사용 용도에 맞게 Specailization(특화)해라.

(용도 외에 쓸데없는 기능 빼라)

복잡한 우버 쉐이더 1개보다 특정 용도로 특화된 쉐이더를 사용하는 것을 권장한다.

특화 쉐이더는 컴파일 시간 단축에 효과적이다.

- 런타임 쉐이더 변경은 부하가 있다.

특화 방식

- if-else 조건문을 특수화하면 쉐이더에서 중복 연산을 방지할 수 있다.
(if else쓰지 말라는 뜻)

- for문 같은 반복문은 unroll 구문과 같은 고정 반복문으로 변경

- 유니폼 함수에서 절대 변동되지 않는 상수를 반환하게 하면 컴파일 시간 단

- 단인 일스턴스를 드로우 할때 인스턴싱을 사용하지 않는 것이 좋음.
(예 : GPU Instancing)

결론 = 단일 기능이 있는 특화 쉐이더와 여러 기능이 포함된 쉐이더를 만들어 관리가 용의하게 하는 것은 프로젝트 및 개발자에 맞게 균형을 잡고 개발하는 것이 중요.

6. 브렌치 구문 주의점 (if-else)

이전 세대 Mali GPU 아키텍처인 Utgard/Midgard에서는 분기문을 사용하면 SIMD 처리 방식에서 연산 그룹이 더 잘게 분할되어 비효율적으로 동작한다.

최신 세대 Mali GPU 아키텍처인 Bifrost / Valhall에서는 분기문은 상대적으로 가볍다.

- SIMD : Single Instruction, Multiple Data의 약자로 한번에 여러 데이터를 동시에 연산하는 처리 방식의 의미.

- Utgard/Midgard : Utgard는 OpenGLES 2.0까지 지원, Midgard는 OpenGLES 3.1, Vulkan 1.0까지 지원.

- Bifrost / Valhall : 가장 최신 Mali 아키텍처로 OpenGLES 3.2, Vulkan 1.1 이상 지원

요약 : 최신 Mali GPU에서는 분기문이 더 가볍다.

일정 거리 이상의 픽셀에서 라이팅 연산을 하지 않는 조건문을 예시로 모든 라이팅 연산이 진행되지 않을 경우 5 사이클이지만, 라이팅 연산이 모두 진행하면 13사이클이 나왔다.

만약 조건문을 제거하여 항상 라이팅 연산을 진행하게 할 경우, 최소 사이클은 조금 늘어나지만, 최대 사이클은 약 2배 감소되었다.

결과적으로 위 예시와 같은 경우 조건문이 없는게 더 나은 상황이다.

조건문은 상황에 따라 좋을 수도 나쁠 수 도있으며 조건문 내부 코드는 심플할 수록 좋다.

7. Vertex inputs 변수 패킹

버텍스 쉐이더에서 Vector4를 로드하는 것이 Vector2 2개를 로드하는 것보다 효율적이다.

(Vertex 쉐이더에서 Input & Output 구조체를 의미하는 것으로 추측)

프레그먼트 쉐이더에서 단일 Vector4 보간하는 것이 Vector3 + float을 보간하는 것보다 효율적이다.

(? Interpolator-보간이 무엇을 의미하는지 모름)

8. ZS Test 관련 주의점 (Z Buffer & Stencil Test)

Early ZS 테스트 혹은 숨겨진 표면 제거를 이용해 가능한 많은 중복 오버드로를 제거하는 것이 성능 향상에 좋다.

(번역 그대로 작성, 정확한 내용 정리 후 추후 다시 정리)

일부 셰이더 기능은 상태가 셰이더가 실행될 때까지 알려지지 않기 때문에 이러한 최적화를 비활성화할 수 있습니다.
discard 문을 사용하면 조기 ZS 테스팅은 가능하지만, 조기 ZS 업데이트와 숨겨진 표면 제거는 비활성화됩니다.
프로그래마틱 깊이 쓰기를 사용하면 모든 조기 ZS와 숨겨진 표면 제거가 비활성화됩니다.
프레임 버퍼에서 프로그래마틱 깊이 읽기를 사용하면 조기 ZS 테스팅은 가능하지만, 조기 ZS 업데이트와 숨겨진 표면 제거는 비활성화됩니다.
프레임 버퍼 또는 픽셀 로컬 스토리지 구조에서 프로그래마틱 색상 읽기를 사용하면 숨겨진 표면 제거가 비활성화됩니다.
이러한 조기 ZS 작업을 수행하는 콘텐츠의 경우, 업데이트가 필요하지 않은 경우 깊이 테스팅을 비활성화하거나 깊이 쓰기를 마스킹하는 것이 도움이 될 수 있습니다. 이는 성능을 향상시킬 수 있습니다.
또한 셰이더에 layout early_fragment_tests를 추가하는 것이 가능하며, 이는 조기 테스팅을 사용하는 것이 안전하다는 것을 컴파일러에 알려주는 역할을 합니다. 이는 셰이더가 위에서 언급한 작업 중 하나를 사용하더라도 적용됩니다.
이 내용은 그래픽스 렌더링에서 중요한 최적화 기법 중 하나인 조기 ZS 테스팅 또는 숨겨진 표면 제거에 대한 설명입니다. 이를 통해 불필요한 렌더링 작업을 최소화하고 성능을 향상시킬 수 있습니다.

9. Compute Shader 개발 고려 사항(가이드)

쓰레드 그룹 사이즈는 적당하게 세팅해야하며 보편적인 사이즈는 64다.

최적 쓰레드 그룹 사이즈는 GPU마다 다르기 때문에 게임 최초 실행시 벤치마크를 통해 적합한 크기를 찾는게 좋다.

쓰레드 공유 메모리는 쓰레드간에 데이터를 공유하는 역할을 하는데 일부 GPU에서는 성능을 높이기 위해서 메인 메모리에서 전용 RAM으로 데이터를 복사한다. 하지만 Mali GPU는 이에 해당되지 않는다.

전역 메모리에서 쓰레드 로컬 메모리로 복사하면 캐시가 오염되기 떄문에 실제 성능이 느려진다.

따라서 알고리즘 데이터 공유에만 작업 그룹 로컬 메모리를 사용해라.

(Mali GPU에서 쓰레드 공유 메모리 사용시 성능 하락한다는 의미)

URP ScreenSpaceDecal Shader

CatDarkGame — Tue, 18 Jul 2023 22:52:17 +0900

Shader "CatDarkGame/ScreenSpaceDecal"
{
    Properties
    { 
        _BaseColor("Color", Color) = (1, 1, 1, 1)
        _BaseMap("Texture", 2D) = "white" {}
    }

    SubShader
    {
        Tags { "RenderType" = "Transparent" "Queue" = "Transparent-499" "DisableBatching" = "True" }
        

        Pass
        {
            Name  "ScreenSpaceDecal"
            Tags {"LightMode" = "SRPDefaultUnlit"}

            Cull back
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha 

            HLSLPROGRAM
            
            #pragma target 4.5
            
            
            #pragma vertex vert 
            #pragma fragment frag

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"


            CBUFFER_START(UnityPerMaterial)
                float4 _BaseMap_ST;
                float4 _BaseColor;
            CBUFFER_END

            TEXTURE2D(_BaseMap);    SAMPLER(sampler_BaseMap);


            struct Attributes
            {
                float4 positionOS : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 positionSS : TEXCOORD1;
                float4 viewRayOS : TEXCOORD2; 
                float3 cameraPosOS : TEXCOORD3;
            }; 
            
            
            void GetObjectSpaceViewTransform(float3 positionVS, out float4 objectToViewDir, out float3 viewPositionOS)
            {
                float viewZ = positionVS.z;
                float4x4 viewToObjectMatrix = mul(UNITY_MATRIX_I_M, UNITY_MATRIX_I_V);
                objectToViewDir.xyz = mul((float3x3)viewToObjectMatrix, positionVS.xyz * -1).xyz;
                objectToViewDir.w = viewZ;
                viewPositionOS.xyz = mul(viewToObjectMatrix, float4(0.0f, 0.0f, 0.0f, 1.0f)).xyz; 
            }


            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;

                float4 positionOS = input.positionOS;
                float3 positionWS = TransformObjectToWorld(positionOS.xyz);
                float4 positionCS = TransformWorldToHClip(positionWS);
                float3 positionVS = TransformWorldToView(positionWS);
                float4 positionSS = ComputeScreenPos(positionCS);
               
                float4 objectToViewDir = 0;
                float3 viewPositionOS = 0;
                GetObjectSpaceViewTransform(positionVS, objectToViewDir, viewPositionOS);
                
                output.viewRayOS = objectToViewDir;
                output.cameraPosOS = viewPositionOS;
                output.positionSS = positionSS;
                output.positionCS = positionCS;
                output.uv = input.uv;
                return output;
            }

            float4 frag(Varyings input) : SV_Target
            {
                float sceneRawDepth = SampleSceneDepth(input.positionSS.xy / input.positionSS.w).r; 
                float sceneDepthVS = LinearEyeDepth(sceneRawDepth, _ZBufferParams);
                float3 viewRayOS = (input.viewRayOS.xyz / input.viewRayOS.w) * sceneDepthVS;
                float3 decalSpaceScenePos = input.cameraPosOS.xyz + viewRayOS.xyz;
                
                float3 absDecalSpaceScenePos = abs(decalSpaceScenePos);
                float decalClipAlpha = max(max(absDecalSpaceScenePos.x, absDecalSpaceScenePos.y), absDecalSpaceScenePos.z);
                clip(0.5f - decalClipAlpha);
               
                float2 decalSpaceUV = decalSpaceScenePos.xy + 0.5f;
                float2 uv = decalSpaceUV.xy * _BaseMap_ST.xy + _BaseMap_ST.zw;
                uv = frac(uv);
              
                float4 texColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv);
                float4 finalColor = texColor * _BaseColor;
                return finalColor;
            }
            
            ENDHLSL
        }
    }
}

구현 원리

1. View Space 기준 Object Transform 계산

View Space, 즉 카메라가 오브젝트를 보는 기준으로 변형된 Transform를 다시 ObjectSpace로 변환합니다.

나중에 Fragment 쉐이더에서 깊이값과 Screen Position 기준으로 데칼 맵핑을 하기 위함입니다.

void GetObjectSpaceViewTransform(float3 positionVS, out float4 objectToViewDir, out float3 viewPositionOS)
{
    float viewZ = positionVS.z;
    
    // 월드 공간 -> 뷰 공간 -> 오브젝트 공간으로 변환하기 위한 역행렬 계산
    float4x4 viewToObjectMatrix = mul(UNITY_MATRIX_I_M, UNITY_MATRIX_I_V);
    
    // View -> 오브젝트가 아닌 오브젝트 -> View 방향의 Transform으로 역행렬 계산
    objectToViewDir.xyz = mul((float3x3)viewToObjectMatrix, positionVS.xyz * -1).xyz;
    
    // w에는 뷰 공간 깊이값 정보 저장
    objectToViewDir.w = viewZ;
    
    // 카메라 Transform를 오브젝트 공간 변환
    viewPositionOS.xyz = mul(viewToObjectMatrix, float4(0.0f, 0.0f, 0.0f, 1.0f)).xyz; 
}

Varyings vert(Attributes input)
{
    Varyings output = (Varyings)0;

    float4 positionOS = input.positionOS;
    float3 positionWS = TransformObjectToWorld(positionOS.xyz);
    float3 positionVS = TransformWorldToView(positionWS);
    float4 objectToViewDir = 0;
    float3 viewPositionOS = 0;
    GetObjectSpaceViewTransform(positionVS, objectToViewDir, viewPositionOS);

2. 데칼 맵핑 포지션 계산

다음 카메라 공간 기준, 거리 값을 이용해서 화면 상의 정확한 위치에 데칼 맵핑 포지션을 계산합니다.

float4 frag(Varyings input) : SV_Target
{
	// SceneDepth 샘플링, ScreenPos XY에 W를 나눠서 원근 기준 값을 평면 기준으로 변환 
    float sceneRawDepth = SampleSceneDepth(input.positionSS.xy / input.positionSS.w).r; 
    
    // 카메라에서 Depth픽셀까지 거리 값 계산
    float sceneDepthVS = LinearEyeDepth(sceneRawDepth, _ZBufferParams);
    
    // xyz/w 계산으로 오브젝트 스페이스의 포지션 값을 원점으로 변환, 다음 depth값을 곱하여 올바른 거리 위치로 좌표 계산
    float3 viewRayOS = (input.viewRayOS.xyz / input.viewRayOS.w) * sceneDepthVS;
    
    // 카메라 원점 기준으로 Offset처리하여 올바른 XY위치로 위치 변환
    float3 decalSpaceScenePos = input.cameraPosOS.xyz + viewRayOS.xyz;

설명이 복잡하지만 예시 자료처럼 화면 기준으로 위치 값을 계산해서 카메라로 부터 뎁스 깊이 위치까지 레이저를 쏘는 흐름으로 이해하시면 됩니다.

3. AlphaClip으로 데칼 외부 픽셀 제거

데칼은 Mesh가 겹쳐진 부분에 맵핑됩니다, 따라서 아래와 같이 실제 데칼 픽셀보다 큰 사이즈의 메쉬를 사용하게 되는데 실제 데칼 맵핑 외부 픽셀은 Clip함수로 제거해야합니다.

float3 absDecalSpaceScenePos = abs(decalSpaceScenePos);
float decalClipAlpha = max(max(absDecalSpaceScenePos.x, absDecalSpaceScenePos.y), absDecalSpaceScenePos.z);
clip(0.5f - decalClipAlpha);

이전에 계산했던 데칼 포지션은 오브젝트 공간 기준으로 계산되었기 때문에 UV값이 중심에서 밖으로 커집니다.

쉽게 말해서 메쉬 사이즈 밖으로 나가는 픽셀을 제거하면 되기 때문에 위와 같이 xyz의 최대 값 기준으로 일정 값이상 커지는 픽셀을 clip처리 합니다.

(추후 쉽게 설명할 수 있게 되면 글 업데이트 예정)

참고자료

https://github.com/ColinLeung-NiloCat/UnityURPUnlitScreenSpaceDecalShader/blob/master/URP_NiloCatExtension_ScreenSpaceDecal_Unlit.shader

LinearEyeDepth와 Linear01Depth

CatDarkGame — Thu, 13 Jul 2023 21:27:21 +0900

LinearEyeDepth

이 함수는 카메라에서 픽셀까지의 거리를 선형 스케일로 반환합니다. 이 값은 월드 공간에서의 실제 거리를 나타내며, 일반적으로 뷰 공간에서의 Z 좌표로 해석됩니다. 이 함수는 깊이 정보를 실제 거리 값으로 사용해야 하는 경우에 유용합니다. 예를 들어, 포그(fog) 효과를 구현하거나, 깊이에 따라 물체의 색상을 변경하는 등의 작업에 사용될 수 있습니다.

Linear01Depth

이 함수는 카메라에서 픽셀까지의 거리를 0과 1 사이의 값으로 정규화하여 반환합니다. 이 값은 카메라의 가까운 클리핑 평면(near clipping plane)에서 멀리 있는 클리핑 평면(far clipping plane)까지의 거리를 0과 1 사이로 나타냅니다. 이 함수는 깊이 정보를 비율이나 백분율로 해석해야 하는 경우에 유용합니다. 예를 들어, 깊이에 따라 투명도를 변경하거나, 포스트 프로세싱 효과를 적용하는 등의 작업에 사용될 수 있습니다.

Unity Triplanar Shader 분석 & StaticWorldPosition 응용

CatDarkGame — Mon, 10 Jul 2023 23:26:26 +0900

Triplanar 기본 구현

월드 포지션 2개 축을 조합해서 UV 좌표로 활용 할 수 있습니다.

아래는 예시입니다.

Varyings vert(Attributes input)
{
    Varyings output = (Varyings)0;

    float4 positionOS = input.positionOS;
    float3 positionWS = TransformObjectToWorld(positionOS.xyz);
    float4 positionCS = TransformWorldToHClip(positionWS);
    ...
    
    
float4 frag(Varyings input) : SV_Target
{
    float3 positionWS = input.positionWS;
    return float4(positionWS.xy + 0.5f, 0,0);
    return float4(positionWS.zx + 0.5f, 0,0);
    return float4(positionWS.zy + 0.5f, 0,0);

positionWS.XY, positionWS.ZX, positionWS.ZY

다음 월드 노말 벡터를 픽셀 쉐이더로 확인하면 아래와 같이 각 방향 별로 마스킹 가능합니다.

Varyings vert(Attributes input)
{
    Varyings output = (Varyings)0;

    float3 normalWS = TransformObjectToWorldNormal(input.normalOS);
    ...
    
    
float4 frag(Varyings input) : SV_Target
{
    float3 normalWS = NormalizeNormalPerPixel(input.normalWS);
    return float4(normalWS, 0);

월드 포지션 기반 UV와 월드 노말 각 축을 곱하면 아래와 같이 깔끔하게 UV 좌표 계산 가능합니다.

 float4 frag(Varyings input) : SV_Target
{
    float3 positionWS = input.positionWS;
    float3 normalWS = NormalizeNormalPerPixel(input.normalWS);

    return float4((positionWS.xy + 0.5f) * normalWS.z, 0,0);
    return float4((positionWS.xz + 0.5f) * normalWS.y, 0,0);
    return float4((positionWS.zy + 0.5f) * normalWS.x, 0,0);

positionWS.XY, positionWS.ZX, positionWS.ZY

위에서 계산한 UV 좌표로 각각 3개 샘플링에 사용하면 Triplanar 기본형 완성입니다.

float4 frag(Varyings input) : SV_Target
{
    float3 positionWS = input.positionWS + 0.5f;
    float3 normalWS = NormalizeNormalPerPixel(input.normalWS);

    float4 texColor_X = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, positionWS.zy * _BaseMap_ST.xy + _BaseMap_ST.zw);
    float4 texColor_Y = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, positionWS.zx * _BaseMap_ST.xy + _BaseMap_ST.zw);
    float4 texColor_Z = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, positionWS.xy * _BaseMap_ST.xy + _BaseMap_ST.zw);
    float4 triplanar = texColor_X * normalWS.x + texColor_Y * normalWS.y + texColor_Z * normalWS.z;

    float4 finalColor = triplanar;
    return finalColor;
}

하지만 아래와 같이 월드 노말 반대 편은 0 이하 값이 되기 때문에 월드 노말에 abs처리하여 음수를 양수로 변환합니다.

다음 아래 Shader Graph의 Triplanar 코드를 참고하여 함수 형태로 만들고 기능을 개선합니다.

https://docs.unity3d.com/Packages/com.unity.shadergraph@16.0/manual/Triplanar-Node.html

float4 TriplanarSample(float3 positionWS, float3 normalWS, float blend, 
                        TEXTURE2D_PARAM(Texture_X, sampler_Texture_X), float4 tilingOffsetX,
                        TEXTURE2D_PARAM(Texture_Y, sampler_Texture_Y), float4 tilingOffsetY,
                        TEXTURE2D_PARAM(Texture_Z, sampler_Texture_Z), float4 tilingOffsetZ)
{
    float3 Node_Blend = pow(abs(normalWS), blend);
    Node_Blend /= dot(Node_Blend, 1.0);
    float scrollSpeed = 0;
    scrollSpeed = _Time.y;
    float4 texColor_X = SAMPLE_TEXTURE2D(Texture_X, sampler_Texture_X, positionWS.zy * tilingOffsetX.xy + (tilingOffsetX.zw * scrollSpeed));
    float4 texColor_Y = SAMPLE_TEXTURE2D(Texture_Y, sampler_Texture_Y, positionWS.zx * tilingOffsetY.xy + (tilingOffsetY.zw * scrollSpeed));
    float4 texColor_Z = SAMPLE_TEXTURE2D(Texture_Z, sampler_Texture_Z, positionWS.xy * tilingOffsetZ.xy + (tilingOffsetZ.zw * scrollSpeed));

    float4 triplanar = texColor_X * Node_Blend.x + texColor_Y * Node_Blend.y + texColor_Z * Node_Blend.z;
    return triplanar;
}


float4 frag(Varyings input) : SV_Target
{
    float3 positionWS = input.positionWS;
    float3 normalWS = NormalizeNormalPerPixel(input.normalWS);

    float4 triplanar = TriplanarSample(positionWS + 0.5f, normalWS, 1, 
                                        TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap), float4(_BaseMap_ST.xy, 0, 0),
                                        TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap), float4(_BaseMap_ST.xy, 0, 0),
                                        TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap), float4(_BaseMap_ST.xy, 0, 0));

    float4 finalColor = triplanar;
    return finalColor;
}

Triplanar 월드 포지션 고정하기

Triplanar 기본은 구현되었지만 오브젝트 좌표가 움직여도 월드 포지션 UV는 변하지 않기 때문에 위 결과물 예시와 같이 텍스처 UV가 움직이지 않는 현상이 있습니다.

보통 좌표가 이동하지 않는 배경 오브젝트에는 문제 없지만, 캐릭터와 같이 움직이는 오브젝트에는 문제가 발생할 수 있습니다.

그래서 이동행렬을 고정한 상태로 월드 포지션을 계산하여 Triplanar에 사용한다면 개선 가능합니다.

아래 예시는 이전 빌보드 구현 과정에서 Rotation Transform을 고정하는 부분이 있었는데, 해당 구현 부분을 응용합니다.

https://darkcatgame.tistory.com/137

void GetCustomModelMatrix(out float4x4 outMoveMatrix, out float4x4 outRotationMatrix, out float4x4 outScaleMatrix)
{
    float4x4 scaleMatrix;
    float4 sx = float4(UNITY_MATRIX_M._m00, UNITY_MATRIX_M._m10, UNITY_MATRIX_M._m20, 0);
    float4 sy = float4(UNITY_MATRIX_M._m01, UNITY_MATRIX_M._m11, UNITY_MATRIX_M._m21, 0);
    float4 sz = float4(UNITY_MATRIX_M._m02, UNITY_MATRIX_M._m12, UNITY_MATRIX_M._m22, 0);
    float scaleX = length(sx);
    float scaleY = length(sy);
    float scaleZ = length(sz);
    scaleMatrix[0] = float4(scaleX, 0, 0, 0);
    scaleMatrix[1] = float4(0, scaleY, 0, 0);
    scaleMatrix[2] = float4(0, 0, scaleZ, 0);
    scaleMatrix[3] = float4(0, 0, 0, 1);
    outScaleMatrix = scaleMatrix;

    float4x4 rotationMatrix;
    rotationMatrix[0] = float4(UNITY_MATRIX_M._m00 / scaleX, UNITY_MATRIX_M._m01 / scaleY, UNITY_MATRIX_M._m02 / scaleZ, 0);
    rotationMatrix[1] = float4(UNITY_MATRIX_M._m10 / scaleX, UNITY_MATRIX_M._m11 / scaleY, UNITY_MATRIX_M._m12 / scaleZ, 0);
    rotationMatrix[2] = float4(UNITY_MATRIX_M._m20 / scaleX, UNITY_MATRIX_M._m21 / scaleY, UNITY_MATRIX_M._m22 / scaleZ, 0);
    rotationMatrix[3] = float4(0, 0, 0, 1);
    outRotationMatrix = rotationMatrix;

    float4x4 moveMatrix;
    moveMatrix[0] = float4(1, 0, 0, UNITY_MATRIX_M._m03);
    moveMatrix[1] = float4(0, 1, 0, UNITY_MATRIX_M._m13);
    moveMatrix[2] = float4(0, 0, 1, UNITY_MATRIX_M._m23);
    moveMatrix[3] = float4(0, 0, 0, UNITY_MATRIX_M._m33);
    outMoveMatrix = moveMatrix;
}

float3 TransformObjectToWorld_StaticPosition(float3 positionOS)
{
    float4x4 scaleMatrix;
    float4x4 rotationMatrix;
    float4x4 moveMatrix;
    GetCustomModelMatrix(moveMatrix, rotationMatrix, scaleMatrix);
    float4x4 modelMatrix_Static = mul(mul(1, rotationMatrix), scaleMatrix);
    return mul(modelMatrix_Static, float4(positionOS.xyz, 1)).xyz;
}

Varyings vert(Attributes input)
{
    Varyings output = (Varyings)0;

    float4 positionOS = input.positionOS;
    float3 positionWS = TransformObjectToWorld(positionOS.xyz);
    float4 positionCS = TransformWorldToHClip(positionWS);

    float3 positionWS_Static = TransformObjectToWorld_StaticPosition(positionOS.xyz);

    float3 normalWS = TransformObjectToWorldNormal(input.normalOS);

    output.normalWS = normalWS;
    output.positionCS = positionCS;
    output.uv = input.uv;
    output.positionWS_Static = positionWS_Static.xyz;
    return output;
}

float4x4 modelMatrix_Static = mul(mul(1, rotationMatrix), scaleMatrix);

빌보드 자료에는 rotationMatrix를 고정했지만 이번엔 이동행렬을 고정하기 때문에 위와 같이 코드를 작성합니다.

Shader "CatDarkGame/Triplanar"
{
    Properties
    { 
        [MainTexture] _BaseMap("Texture", 2D) = "white" {}
        [MainColor] _BaseColor("Color", Color) = (1, 1, 1, 1)
    }

    SubShader
    {
        Tags { "RenderType" = "Opaque" "Queue"="Geometry" "RenderPipeline" = "UniversalPipeline" }
        LOD 100

        Pass
        {
            Name  "URPUnlit"
            Tags {"LightMode" = "SRPDefaultUnlit"}

            HLSLPROGRAM
            #pragma target 4.5
            #pragma exclude_renderers gles d3d9
            
            #pragma vertex vert
            #pragma fragment frag

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"


            CBUFFER_START(UnityPerMaterial)
                float4 _BaseMap_ST;
                float4 _BaseColor;
            CBUFFER_END

            TEXTURE2D(_BaseMap);    SAMPLER(sampler_BaseMap);


            struct Attributes
            {
                float4 positionOS : POSITION;
                float3 normalOS : NORMAL;
                float2 uv : TEXCOORD0;
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv : TEXCOORD0;
                float3 positionWS_Static : TEXCOORD1;
                float3 normalWS : TEXCOORD2;
            }; 
            

            void GetCustomModelMatrix(out float4x4 outMoveMatrix, out float4x4 outRotationMatrix, out float4x4 outScaleMatrix)
            {
                float4x4 scaleMatrix;
                float4 sx = float4(UNITY_MATRIX_M._m00, UNITY_MATRIX_M._m10, UNITY_MATRIX_M._m20, 0);
                float4 sy = float4(UNITY_MATRIX_M._m01, UNITY_MATRIX_M._m11, UNITY_MATRIX_M._m21, 0);
                float4 sz = float4(UNITY_MATRIX_M._m02, UNITY_MATRIX_M._m12, UNITY_MATRIX_M._m22, 0);
                float scaleX = length(sx);
                float scaleY = length(sy);
                float scaleZ = length(sz);
                scaleMatrix[0] = float4(scaleX, 0, 0, 0);
                scaleMatrix[1] = float4(0, scaleY, 0, 0);
                scaleMatrix[2] = float4(0, 0, scaleZ, 0);
                scaleMatrix[3] = float4(0, 0, 0, 1);
                outScaleMatrix = scaleMatrix;

                float4x4 rotationMatrix;
                rotationMatrix[0] = float4(UNITY_MATRIX_M._m00 / scaleX, UNITY_MATRIX_M._m01 / scaleY, UNITY_MATRIX_M._m02 / scaleZ, 0);
                rotationMatrix[1] = float4(UNITY_MATRIX_M._m10 / scaleX, UNITY_MATRIX_M._m11 / scaleY, UNITY_MATRIX_M._m12 / scaleZ, 0);
                rotationMatrix[2] = float4(UNITY_MATRIX_M._m20 / scaleX, UNITY_MATRIX_M._m21 / scaleY, UNITY_MATRIX_M._m22 / scaleZ, 0);
                rotationMatrix[3] = float4(0, 0, 0, 1);
                outRotationMatrix = rotationMatrix;

                float4x4 moveMatrix;
                moveMatrix[0] = float4(1, 0, 0, UNITY_MATRIX_M._m03);
                moveMatrix[1] = float4(0, 1, 0, UNITY_MATRIX_M._m13);
                moveMatrix[2] = float4(0, 0, 1, UNITY_MATRIX_M._m23);
                moveMatrix[3] = float4(0, 0, 0, UNITY_MATRIX_M._m33);
                outMoveMatrix = moveMatrix;
            }

            float3 TransformObjectToWorld_StaticPosition(float3 positionOS)
            {
                float4x4 scaleMatrix;
                float4x4 rotationMatrix;
                float4x4 moveMatrix;
                GetCustomModelMatrix(moveMatrix, rotationMatrix, scaleMatrix);
                float4x4 modelMatrix_Static = mul(mul(1, rotationMatrix), scaleMatrix);
                return mul(modelMatrix_Static, float4(positionOS.xyz, 1)).xyz;
            }

            float4 TriplanarSample(float3 positionWS, float3 normalWS, float blend, 
                                    TEXTURE2D_PARAM(Texture_X, sampler_Texture_X), float4 tilingOffsetX,
                                    TEXTURE2D_PARAM(Texture_Y, sampler_Texture_Y), float4 tilingOffsetY,
                                    TEXTURE2D_PARAM(Texture_Z, sampler_Texture_Z), float4 tilingOffsetZ)
            {
                float3 Node_Blend = pow(abs(normalWS), blend);
                Node_Blend /= dot(Node_Blend, 1.0);
                float scrollSpeed = 0;
                scrollSpeed = _Time.y;
                float4 texColor_X = SAMPLE_TEXTURE2D(Texture_X, sampler_Texture_X, positionWS.zy * tilingOffsetX.xy + (tilingOffsetX.zw * scrollSpeed));
                float4 texColor_Y = SAMPLE_TEXTURE2D(Texture_Y, sampler_Texture_Y, positionWS.zx * tilingOffsetY.xy + (tilingOffsetY.zw * scrollSpeed));
                float4 texColor_Z = SAMPLE_TEXTURE2D(Texture_Z, sampler_Texture_Z, positionWS.xy * tilingOffsetZ.xy + (tilingOffsetZ.zw * scrollSpeed));

                float4 triplanar = texColor_X * Node_Blend.x + texColor_Y * Node_Blend.y + texColor_Z * Node_Blend.z;
                return triplanar;
            }


            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;

                float4 positionOS = input.positionOS;
                float3 positionWS = TransformObjectToWorld(positionOS.xyz);
                float4 positionCS = TransformWorldToHClip(positionWS);

                float3 positionWS_Static = TransformObjectToWorld_StaticPosition(positionOS.xyz);
 
                float3 normalWS = TransformObjectToWorldNormal(input.normalOS);

                output.normalWS = normalWS;
                output.positionCS = positionCS;
                output.uv = input.uv;
                output.positionWS_Static = positionWS_Static.xyz;
                return output;
            }

            float4 frag(Varyings input) : SV_Target
            {
                float3 positionWS = input.positionWS_Static;
                float3 normalWS = NormalizeNormalPerPixel(input.normalWS);
             
                float4 triplanar = TriplanarSample(positionWS + 0.5f, normalWS, 1, 
                                                    TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap), float4(_BaseMap_ST.xy, 0, 0),
                                                    TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap), float4(_BaseMap_ST.xy, 0, 0),
                                                    TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap), float4(_BaseMap_ST.xy, 0, 0));
                
                float4 finalColor = triplanar;
                return finalColor;
            }
            
            ENDHLSL
        }
    }
}

worldPivot계산하는 방식

Shader "CatDarkGame/Triplanar"
{
    Properties
    { 
        [MainTexture] _BaseMap("Texture", 2D) = "white" {}
        [MainColor] _BaseColor("Color", Color) = (1, 1, 1, 1)
    }

    SubShader
    {
        Tags { "RenderType" = "Opaque" "Queue"="Geometry" "RenderPipeline" = "UniversalPipeline" }
        LOD 100

        Pass
        {
            Name  "URPUnlit"
            Tags {"LightMode" = "SRPDefaultUnlit"}

            HLSLPROGRAM
            #pragma target 4.5
            #pragma exclude_renderers gles d3d9
            
            #pragma vertex vert
            #pragma fragment frag

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"


            CBUFFER_START(UnityPerMaterial)
                float4 _BaseMap_ST;
                float4 _BaseColor;
            CBUFFER_END

            TEXTURE2D(_BaseMap);    SAMPLER(sampler_BaseMap);


            struct Attributes
            {
                float4 positionOS : POSITION;
                float3 normalOS : NORMAL;
                float2 uv : TEXCOORD0;
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv : TEXCOORD0;
                float3 positionWS_Static : TEXCOORD1;
                float3 normalWS : TEXCOORD2;
            }; 
            

            float4 TriplanarSample(float3 positionWS, float3 normalWS, float blend, 
                                    TEXTURE2D_PARAM(Texture_X, sampler_Texture_X), float4 tilingOffsetX,
                                    TEXTURE2D_PARAM(Texture_Y, sampler_Texture_Y), float4 tilingOffsetY,
                                    TEXTURE2D_PARAM(Texture_Z, sampler_Texture_Z), float4 tilingOffsetZ)
            {
                float3 Node_Blend = pow(abs(normalWS), blend);
                Node_Blend /= dot(Node_Blend, 1.0);
                float scrollSpeed = 0;
                scrollSpeed = _Time.y;
                float4 texColor_X = SAMPLE_TEXTURE2D(Texture_X, sampler_Texture_X, positionWS.zy * tilingOffsetX.xy + (tilingOffsetX.zw * scrollSpeed));
                float4 texColor_Y = SAMPLE_TEXTURE2D(Texture_Y, sampler_Texture_Y, positionWS.zx * tilingOffsetY.xy + (tilingOffsetY.zw * scrollSpeed));
                float4 texColor_Z = SAMPLE_TEXTURE2D(Texture_Z, sampler_Texture_Z, positionWS.xy * tilingOffsetZ.xy + (tilingOffsetZ.zw * scrollSpeed));

                float4 triplanar = texColor_X * Node_Blend.x + texColor_Y * Node_Blend.y + texColor_Z * Node_Blend.z;
                return triplanar;
            }


            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;

                float4 positionOS = input.positionOS;
                float3 positionWS = TransformObjectToWorld(positionOS.xyz);
                float4 positionCS = TransformWorldToHClip(positionWS);
                float3 pivotWS = float3(unity_ObjectToWorld._m03,  unity_ObjectToWorld._m13,  unity_ObjectToWorld._m23);

                float3 normalWS = TransformObjectToWorldNormal(input.normalOS);

       
                output.normalWS = normalWS;
                output.positionCS = positionCS;
                output.uv = input.uv;
                output.positionWS_Static = positionWS.xyz - pivotWS;
                return output;
            }

            float4 frag(Varyings input) : SV_Target
            {
                float3 positionWS = input.positionWS_Static;
                float3 normalWS = NormalizeNormalPerPixel(input.normalWS);
             
                float4 triplanar = TriplanarSample(positionWS + 0.5f, normalWS, 1, 
                                                    TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap), float4(_BaseMap_ST.xy, 0, 0),
                                                    TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap), float4(_BaseMap_ST.xy, 0, 0),
                                                    TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap), float4(_BaseMap_ST.xy, 0, 0));
                
                float4 finalColor = triplanar;
                return finalColor;
            }
            
            ENDHLSL
        }
    }
}