Try & Error

[링크] [VSCode] 파일명으로 파일 찾기 (단축키, 멀티파일 열기)

blueasa — Mon, 23 Mar 2026 10:11:17 +0900

[VSCode] 파일명으로 파일 찾기 (단축키, 멀티파일 열기)

VSCode에서 파일명으로 파일을 검색하여 파일을 찾는 방법입니다. 'GO > Go to File' 또는 단축키 'Ctrl + P' Go > Go to File 메뉴를 이용하거나, 단축키 Ctrl + P를 이용해 파일 검색창을 엽니다. 검색창에 검

hianna.tistory.com

[펌] 카카오톡 숏폼 막기(in AdGuard/유니콘 Pro)

blueasa — Mon, 23 Mar 2026 09:41:32 +0900

이번에 AdGuard Pro Lifetime을 싸게 팔길래 사게되면서 숏폼을 차단할 수 있다고 해서 해보고 글 남김

아래 내용을 AdGuard DNS 필터에 추가하면 된다.(유니콘 Pro도 별반 다르진 않은것 같다)

나는 숏폼만 차단할 생각이라 (2)번만 등록했다.

----

(1) 메인피드 차단
talk-pilsner.kakao.com
ik.kakaocdn.net

(2) 숏폼 차단
play.kakao.com
shorformstats.kakao.com

(3) 쇼핑 차단
shopper.kakao.com

----

[추가]

AdGuard와 유니콘 Pro는 유료인데, 무료 DNS Filter로도 된다고 해서 링크 남겨 둠

[링크] https://www.clien.net/service/board/use/19073067

카톡 숏폼 차단용 무료 DNS 필터 앱 - personalDNSfilter : 클리앙

아이들 폰의 카톡 숏폼 막을 방법을 찾아보니, 대부분 AdGuard나 유니콘Pro 같은 유료 앱으로 DNS 필터링을 하더라구요. DNS 필터링 가능한 무료 안드로이드 앱을 찾다가 괜찮은 앱을 하나 발견해서

www.clien.net

----

[참조] https://bbs.ruliweb.com/mobile/board/300010/read/2278728

카톡 숏폼막아버리기

애드가드나 유니콘을 이용해서 숏폼 접속 자체를 막아버려서 뜨지 않게 만드는 방법입니다 유니콘 프로1 광고차단앱 유니콘 프로 Unicorn Pro 을 설치한다2 앱실행 후 차단 및 허용 관리 메뉴에

bbs.ruliweb.com

[참조] https://blog.naver.com/deathbed2/224023733267

카카오톡 숏폼, 피드, 쇼핑 끄기 삭제방법(ft.애드가드, 유니콘프로 활용)

들어가기전에... - 요즘 핫한 카톡 업데이트. 참고 쓸려고 해도 광고를 떠나 사람찾아 메시지 하나 보내는...

blog.naver.com

[링크][크롬확장] Simple Allow Copy 2(웹페이지 복사방지 해제)

blueasa — Tue, 24 Feb 2026 15:24:43 +0900

[링크] https://chromewebstore.google.com/detail/amnlhffheggkehikhanljohklfjiailo?utm_source=item-share-cb

Simple Allow Copy 2 - Chrome 웹 스토어

Simply allow copy on every website

chromewebstore.google.com

복사 방지 해제 크롬 확장으로 Simple Allow Copy가 있었는데, 작동을 안해서 보니 무슨 이유에선지 삭제 됐다.

그래서 다시 찾아보니 Simple Allow Copy 2가 나와서 새로 설치하고 링크 올려둔다.

[링크] [무엇이든 알려드려요] Rule 타일에 버금가는 Unity 6.1만의 오토 타일 소개

blueasa — Tue, 24 Feb 2026 10:00:49 +0900

[링크] 게임 스크롤의 역사

blueasa — Tue, 24 Feb 2026 09:47:35 +0900

게임 스크롤의 역사(1): 횡스크롤 게임 카메라의 이론과 사례 (번역)

게임 스크롤의 역사(2): 횡스크롤 게임 카메라의 이론과 사례 (번역)

[링크] 무료 파일 복구 프로그램(TestDisk) 사용 방법 - 용량 상관없이 삭제 파일 복구하기

blueasa — Mon, 23 Feb 2026 16:01:49 +0900

[링크] https://postiveemblem.tistory.com/188

무료 파일 복구 프로그램(TestDisk) 사용 방법 - 용량 상관없이 삭제 파일 복구하기

컴퓨터를 사용하다 보면 실수로 파일을 삭제할 때가 있습니다. 크게 중요하지 않은 파일이라면 그냥 넘어갈 수 있겠죠. 하지만 추억이 담긴 사진, 사라지면 안 되는 보고서, 작업내역 등이 사라

postiveemblem.tistory.com

[링크] GPT5 Codex CLI 사용방법(설치방법) - OpenAI Codex CLI 시작하기

blueasa — Fri, 13 Feb 2026 14:27:06 +0900

[링크] https://goddaehee.tistory.com/402

GPT5 Codex CLI 사용방법(설치방법) - OpenAI Codex CLI 시작하기

안녕하세요! 갓대희입니다. 오늘은 Claude Code, Gemini CLI 등의 출시 이후 갑자기 뜨거운 감자처럼 떠오르는 Codex CLI에 대해 알아보려고 한다. 최근 OpenAI가 2025년 9월에 발표한 GPT-5-Codex에 대해 계속

goddaehee.tistory.com

[링크] 시놀로지 NAS의 VPN Server 설정하고 아이폰에서 VPN 접속하기

blueasa — Tue, 10 Feb 2026 13:21:30 +0900

[링크] https://me.tistory.com/659

시놀로지 NAS의 VPN Server 설정하고 아이폰에서 VPN 접속하기

안녕하세요. 예전에 VPN을 라즈베리파이를 써서 썼던 적이 있습니다. OpenVPN을 써서 구성했었는데, 아이폰의 경우 PPTP? 어떤 방식이 보안에 취약하다는 이유로 지원을 중단했고, 그 이후로 VPN을 따

me.tistory.com

[링크] 유니티 Platform Effector2D 관통되는 바닥만들기

blueasa — Thu, 5 Feb 2026 17:49:50 +0900

[링크] https://unitybeginner.tistory.com/105

유니티 Platform Effector2D 관통되는 바닥만들기

안녕하세요 유니티 비기너입니다. 이번 시간에는 Platform Effector2D 컴포넌트를 활용하여 슈퍼마리오와 같은 관통이 되는 바닥을 만들어 보겠습니다. (유니티 버전 2019.3.7f1으로 실습을 진행했습니

unitybeginner.tistory.com

[이슈] 2D 게임에서 캐릭터 점프 후, 벽쪽으로 이동키를 누르고 있으면 캐릭터가 떨어지지 않는 문제

blueasa — Wed, 28 Jan 2026 09:53:35 +0900

Unity 6000.3.5f2

----

[추가] 2026-01-30

Friction(마찰)을 0으로 주면 벽에 붙는 문제는 해결되지만,

비스듬한 대각선 지형에서는 Friction이 0이어서 조금씩 밀려서 내려가는 문제가 있는걸 확인했다.

그래서 좌/우 벽을 90도 돌려서 만들지 않고 BoxCollider2D 모양대로 윗면이 위로 향하게 한 상태로 크기를 조절해서 BoxCollider2D의 옆면을 벽으로 사용하도록 했다.

옆면이어서 Friction 상관없이 캐릭터가 벽에 붙지 않는 것 같다.

----

~~2D 게임에서 캐릭터 점프 후, 벽쪽으로 이동키(혹은 조이스틱)를 누르고 있으면 캐릭터가 떨어지지 않는 문제가 있어서 해결하면서 정리해 둔다.~~

~~2D 캐릭터에 Capsule Collider 2D를 사용중인데~~

~~점프 후 BoxCollider2D가 있는 벽쪽으로 이동키를 계속 누르고 있으면 캐릭터가 중력에 의해 떨어지지않고 그대로 벽에 붙어있는 문제가 확인됐다.~~

~~결론적으로 Collider끼리의 마찰력(Friction)에 의한 정상적인 상황으로 보인다.~~

~~그래서 마찰력(Friction) 값을 0을 셋팅해서 테스트 해보니 정상적으로 벽에 걸리지 않고 잘 떨어진다.~~

~~아래는 셋팅 방법이다.~~

~~----~~

~~[Unity Inspector에서 설정]~~
1. Project 창에서 우클릭 → Create → 2D → Physics Material 2D
~~2. 이름: PlayerNoFriction~~
~~3. Inspector에서 설정:~~
- Friction: 0
- Bounciness: 0
~~4. Player2D 오브젝트의 Collider2D 컴포넌트에서 Material 필드에 이 PhysicsMaterial2D 할당~~

----

[링크] “재미”라는 단어의 함정

blueasa — Tue, 27 Jan 2026 16:27:39 +0900

[링크] https://brunch.co.kr/@seunghoju/144

“재미”라는 단어의 함정

재미, 마케팅, 매출 | 예전에 퍼블리셔에서 PD로 일할 때였다. 기획 회의를 하다 보면, 어느 시점엔가 꼭 이런 말을 던지는 기획자가 있었다. “게임이 재미만 있으면 됐지. 뭐가 더 필요해요?”“

brunch.co.kr

[에셋/Custom] PinePie Simple Joystick v1.0.0(Custom)(with NGUI)

blueasa — Thu, 8 Jan 2026 14:50:49 +0900

Unity 6000.3.2f1 (URP)

NGUI v2025.07.01

PinePie Simple Joystick v1.0.0

----

조이스틱 관련 쓸만한 무료 에셋이 있어서 적용해보려 했더니 UGUI 전용이다.

Claude Code AI를 사용해서 NGUI 버전도 추가 및 정리해서 올려 둠.

[파일]

PinePie_SimpleJoystick_v1.0.0_withNGUI.unitypackage

0.39MB

[참조] https://assetstore.unity.com/packages/tools/gui/pinepie-joystick-325958

PinePie Joystick | GUI 도구 | Unity Asset Store

Use the PinePie Joystick from Pine Pie on your next project. Find this GUI tool & more on the Unity Asset Store.

assetstore.unity.com

[링크] 이게 된다고?! 닌텐도 스위치2 구형 조이콘 10초만에 연결하는 방법

blueasa — Thu, 8 Jan 2026 13:43:24 +0900

스위치2를 사고, 스위치1 조이콘을 연결하려면 본체에 결착을 해야되는 줄 알고 젠더를 사고 이래저래 하다가 안돼서 혹시나하고 검색해봤더니

스위치2에서도 스위치1용 조이콘의 페어링 버튼만 누르면 그냥 연결이 된다.

굳이 본체에 결착할 필요가 없다는걸 이제서야 알게 됨..

----

[링크] https://m.blog.naver.com/vtq99/223860939909

이게 된다고?! 닌텐도 스위치2 구형 조이콘 10초만에 연결하는 방법

어릴 적 동생과 함께 마주 앉아 즐기던 닌텐도 스위치. 시간이 흘러 ‘닌텐도 스위치2’를 처음 켰을 때, ...

blog.naver.com

[링크] 휴대폰 인증 없이 구글 계정 만드는 법 (완벽 정리)

blueasa — Tue, 16 Dec 2025 13:55:39 +0900

여분의 구글 계정을 추가로 만들다보니 요즘은 휴대폰 인증을 하게해서 했는데 3-4개정도 만들고나니

이 휴대폰으로 더이상 계정생성을 할 수 없다고 하면서 생성이 안된다.

찾아보니 스팸방지등의 이슈로 기간내에 일정 이상 계정생성을 못하도록 막아 놓은것 같은데 나는 정말 필요해서 더 만들어야되는데 갑갑하던차에 좀 더 검색해보니 휴대폰 인증 없이 계정을 생성할 수 있는 방법이 있어서 이 방법으로 생성했다.

휴대폰번호는 필요하면 추가 하면 되는 것 같다.

----

[링크] https://happy-virus81.tistory.com/1092

휴대폰 인증 없이 구글 계정 만드는 법 (완벽 정리)

목차휴대폰 인증 없이 가능할까?방법 1. 구글 플레이스토어에서 계정 만들기방법 2. 스마트폰 설정에서 계정 만들기활용 팁: 가상 계정 안전하게 사용하는 법마무리 요약 및 주의사항휴대폰 인

happy-virus81.tistory.com

[에셋] CustomToolbar v2.8.1(Custom)

blueasa — Fri, 12 Dec 2025 20:39:34 +0900

[개요]

CustomToolbar는 마음에 드는데 추가하고 싶은 부분이 있어서 조금 수정함.

- FPS / Time 슬라이더 크기 줄이기

- FPS / Time 'Reset' 버튼 추가

[파일]

CustomToolbar_v2.8.1(custom).zip

0.07MB

[스토어 링크] https://assetstore.unity.com/packages/tools/utilities/customtoolbar-327041

CustomToolbar | 유틸리티 도구 | Unity Asset Store

Use the CustomToolbar from Opal on your next project. Find this utility tool & more on the Unity Asset Store.

assetstore.unity.com

[링크] 연금저축/IRP/ISA 관련

blueasa — Fri, 12 Dec 2025 15:27:39 +0900

[링크] 연금계좌 IRP ISA 간단 설명

연금계좌 IRP ISA 간단 설명

친구한테 설명하고자 작성한 글인데 틀린 점이나 추가할 내용 있으면 알려주세요 활용

m.ppomppu.co.kr

2025년 연금저축펀드 추천: 수익률 높이는 최고의 상품 & 세액공제 완전 가이드

안녕하세요! 노후 준비와 절세라는 두 마리 토끼를 잡으려는 현명한 투자자 여러분. 2025년 새해를 맞아 연금저축펀드를 어떻게 운용해야 최고의 수익률과 최대의 세액공제 혜택을 누릴 수 있을

meorosi.com

[링크] https://blog.naver.com/bowon1462/223705352043

IRP 계좌에서 안전자산 30%로 투자할 수 있는 상품 (초급자, 중급자, 상급자 별 매수상품)

헤이 유, 당신! 온라인 도비 동지. 올해 IRP 300만원 납입 채우셨나요? 먼저 연말정산용 세액공제를 위...

blog.naver.com

[링크] 해외 주식 ETF 투자 가이드

해외 주식 ETF 투자 가이드

와우

www.inven.co.kr

[링크] 운영형 모바일 게임이 살아남기 어려운 구조적 이유와 그 돌파구

blueasa — Wed, 10 Dec 2025 17:50:40 +0900

[링크 (일본어)] https://note.com/ukyousan/n/n68014445fb7f?sub_rt=share_pb

運営型モバイルゲームが生き残りづらい構造的理由と、その突破口｜うきょう|フリーゲームプ

とりあえず思うことをつらつら書いていたら長くなったので、こちらの記事はAI等で要約して読むことをオススメします。長文になります。一応私の経歴を書いておくと、コンシューマから

note.com

[설명 영상(한글)] https://www.youtube.com/watch?v=BgzpeDG0d5g

[링크] KB증권 자녀 클라우드 인증서 발급 방법

blueasa — Wed, 3 Dec 2025 17:48:35 +0900

[링크] https://blog.naver.com/songsigu5/223748854283

KB증권 자녀 클라우드 인증서 발급 방법

오늘 개고생 끝에 알게된 KB증권 미성년 자녀 클라우드 인증서 발급 방법 스스로 해도 잘 안 되고 블로그...

blog.naver.com

[링크] Github에 100MB 이상의 파일을 올리는 방법

blueasa — Thu, 13 Nov 2025 00:37:55 +0900

[링크]

https://medium.com/@stargt/github%EC%97%90-100mb-%EC%9D%B4%EC%83%81%EC%9D%98-%ED%8C%8C%EC%9D%BC%EC%9D%84-%EC%98%AC%EB%A6%AC%EB%8A%94-%EB%B0%A9%EB%B2%95-9d9e6e3b94ef

Github에 100MB 이상의 파일을 올리는 방법

문제점

medium.com

[링크] Convert 'Built-in -> URP' Shader Mapping

blueasa — Wed, 12 Nov 2025 15:24:56 +0900

[링크] https://docs.unity3d.com/Packages/com.unity.render-pipelines.universal@12.1/manual/upgrading-your-shaders.html#shader-mappings

Shader mappings

The following table shows which URP shaders the Built-in Render Pipeline shaders convert to when you use the Render Pipeline Converter.

Unity built-in shaderUniversal Render Pipeline shader

Standard	Universal Render Pipeline/Lit
Standard (Specular Setup)	Universal Render Pipeline/Lit
Standard Terrain	Universal Render Pipeline/Terrain/Lit
Particles/Standard Surface	Universal Render Pipeline/Particles/Lit
Particles/Standard Unlit	Universal Render Pipeline/Particles/Unlit
Mobile/Diffuse	Universal Render Pipeline/Simple Lit
Mobile/Bumped Specular	Universal Render Pipeline/Simple Lit
Mobile/Bumped Specular(1 Directional Light)	Universal Render Pipeline/Simple Lit
Mobile/Unlit (Supports Lightmap)	Universal Render Pipeline/Simple Lit
Mobile/VertexLit	Universal Render Pipeline/Simple Lit
Legacy Shaders/Diffuse	Universal Render Pipeline/Simple Lit
Legacy Shaders/Specular	Universal Render Pipeline/Simple Lit
Legacy Shaders/Bumped Diffuse	Universal Render Pipeline/Simple Lit
Legacy Shaders/Bumped Specular	Universal Render Pipeline/Simple Lit
Legacy Shaders/Self-Illumin/Diffuse	Universal Render Pipeline/Simple Lit
Legacy Shaders/Self-Illumin/Bumped Diffuse	Universal Render Pipeline/Simple Lit
Legacy Shaders/Self-Illumin/Specular	Universal Render Pipeline/Simple Lit
Legacy Shaders/Self-Illumin/Bumped Specular	Universal Render Pipeline/Simple Lit
Legacy Shaders/Transparent/Diffuse	Universal Render Pipeline/Simple Lit
Legacy Shaders/Transparent/Specular	Universal Render Pipeline/Simple Lit
Legacy Shaders/Transparent/Bumped Diffuse	Universal Render Pipeline/Simple Lit
Legacy Shaders/Transparent/Bumped Specular	Universal Render Pipeline/Simple Lit
Legacy Shaders/Transparent/Cutout/Diffuse	Universal Render Pipeline/Simple Lit
Legacy Shaders/Transparent/Cutout/Specular	Universal Render Pipeline/Simple Lit
Legacy Shaders/Transparent/Cutout/Bumped Diffuse	Universal Render Pipeline/Simple Lit
Legacy Shaders/Transparent/Cutout/Bumped Specular	Universal Render Pipeline/Simple Lit

[링크] Unity) ScriptableObject Sington (instance)

blueasa — Mon, 10 Nov 2025 11:11:44 +0900

[링크] https://drehzr.tistory.com/1501

Unity) ScriptableObject Sington (instance)

ScriptableObject Sington (instance) ScriptableObject를 Sington 형태로 사용하는 간략한 코드 정리이다. Lazy를 사용해도 되지만 없는 경우에 Load Asset 을 통해서 자동 생성하는 코드이다. private class ScriptableSinglet

drehzr.tistory.com

[링크] 윈도우 11 업그레이드 제한 우회하기 (ISO 다운받아 업그레이드 시)

blueasa — Fri, 7 Nov 2025 11:20:48 +0900

[링크] https://it-manager.tistory.com/294

윈도우 11 업그레이드 제한 우회하기 (ISO 다운받아 업그레이드 시)

드디어 2025년 10월이면 윈도우10 지원이 만료된다.그래서 기존에 윈도우10 PC를 11로 업그레이드하고 있는데....TPM 2.0 탑재, 2017년 이후 CPU 만을 지원한다.그래서 간혹 업그레이드 안 되는 PC가 있다.

it-manager.tistory.com

[Windows 11 다운로드] https://www.microsoft.com/ko-kr/software-download/windows11

Windows 11 다운로드

이 옵션은 부팅 가능한 설치 미디어(USB 플래시 드라이브, DVD)를 만들거나 가상 컴퓨터(.ISO 파일)을 만들어 Windows 11을 설치하려는 사용자를 위한 옵션입니다. 이 다운로드는 제품 키를 통해 올바

www.microsoft.com

[링크] [Android] Firebase에서 Google Play Games로 유저 식별하기

blueasa — Wed, 5 Nov 2025 11:01:33 +0900

[링크] https://psych-dobby.tistory.com/entry/Android-Firebase%EC%97%90%EC%84%9C-Google-Play-Games%EB%A1%9C-%EC%9C%A0%EC%A0%80-%EC%8B%9D%EB%B3%84%ED%95%98%EA%B8%B0#:~:text=%EA%B0%81%20%EC%9C%A0%EC%A0%80%EB%B3%84%EB%A1%9C%20%EA%B0%80%EC%A7%80%EA%B3%A0%20%EC%9E%88%EB%8A%94%20%EC%9C%A0%EB%A3%8C%20%EC%9E%AC%ED%99%94%EC%9D%98%20%EB%82%B4%EC%97%AD%EC%9D%84,%EB%A1%9C%EA%B7%B8%EC%9D%B8%20%EC%A0%95%EB%B3%B4%EB%A1%9C%20Firebase%20Authentication%EC%97%90%EC%84%9C%20%EC%9C%A0%EC%A0%80%EB%A5%BC%20%EC%8B%9D%EB%B3%84%ED%95%98%EA%B3%A0%EC%9E%90%20%ED%96%88%EA%B3%A0%2C

[Android] Firebase에서 Google Play Games로 유저 식별하기

각 유저별로 가지고 있는 유료 재화의 내역을 보관하기 위해 Firebase Realtime Database를 사용하고 싶었고, 유저를 식별하기 위해 Firebase Authentication을 사용하게 되었다. 나의 경우 Google Play Games로 로

psych-dobby.tistory.com

[링크] 기존 프로젝트를 URP로 변경하기

blueasa — Tue, 28 Oct 2025 09:58:12 +0900

[링크] https://wincnt-shim.tistory.com/356

기존 프로젝트를 URP로 변경하기

서론 이전에 빌트인으로 만들었던 프로젝트를 URP로 변경해보려고 한다 매우 간단한 프로젝트이라서 다른 변수가 영향을 주지 않으리라 생각한다 (참고로 설치하는 URP의 버전은 12.1) 방법은 Unity

wincnt-shim.tistory.com

[참고] Converting your shaders | Universal RP | 12.1.11

[링크] 크롬의 윈도우 효율성 모드 비활성화로 느려짐 및 충돌 현상 해결

blueasa — Tue, 21 Oct 2025 13:58:29 +0900

[링크] https://m.blog.naver.com/toruin84/223269593801

크롬의 윈도우 효율성 모드 비활성화로 느려짐 및 충돌 현상 해결

Microsoft가 도입한 윈도우의 효율성 모드는 운영 체제에서 배터리 소모와 CPU 리소스 사용을 줄이는 ...

blog.naver.com

[링크] 윈도우11 마우스 오른쪽 클릭 (우클릭) 윈도우10 구버전 스타일로 변경하는 방법 (더 많은 옵션 표시 해제)

blueasa — Tue, 21 Oct 2025 13:57:24 +0900

[링크] https://rgy0409.tistory.com/4973

윈도우11 마우스 오른쪽 클릭 (우클릭) 윈도우10 구버전 스타일로 변경하는 방법 (더 많은 옵션 표

윈도우11로 넘어오면서 마우스 우클릭 메뉴가 심플하게 변경되었습니다. 사실 완전 바뀐게 아니라 숨겨진 기능으로 일부가 들어가 버렸습니다. 「더 많은 옵션 표시」라는 새로운 메뉴가 추가

rgy0409.tistory.com

[Tip] Xcode 에러(Error) 내용 상세 보기(+단축키)

blueasa — Wed, 24 Sep 2025 16:28:41 +0900

Xcode 26.0.1

----

[에러 내용 상세보기]

1. 우측 상단 에러 아이콘(빨간 X) 클릭

2. Report Navigator (⌘ + 9) 클릭(좌측 상단 아이콘들 중에 있음)

3. 에러 아이콘(빨간 X)이 있는 곳을 눌러서 상세 정보 및 에러 표시가 있는 줄 확인

[참조] https://community.nianticspatial.com/t/command-ld-failed-with-a-nonzero-exit-code/5506/5

Command Ld failed with a nonzero exit code

Thank you for providing that. Let’s narrow this down further. Please complete the following steps: Click the red X Open the Report Navigator (⌘ + 9) Look at and provide the first real linker error (above the “command ld failed” line) Alternatively,

community.nianticspatial.com

[BuildError][Xcode26] Assertion failed: (it != _dylibToOrDinal.end()), function getDylibOrdinal, file OutputFile.cpp, line 5196.

blueasa — Wed, 24 Sep 2025 16:12:04 +0900

Xcode 26.0.1

Unity 6000.2.5f1

----

[Build Error]

Assertion failed: (it != _dylibToOrDinal.end()), function getDylibOrdinal, file OutputFile.cpp, line 5196.

----

Xcode 16.4에서 Xcode 26으로 올리고나니 잘되던 빌드가 위와 같은 에러가 나면서 빌드 실패를 한다.

찾아보니 Xcode 16.4까지 계속 쓰고있던 플래그인 -ld_classic이 Xcode PostProcessor에 있는데,

Xcode 26에서 OTHER_LDFLAGS의 -ld_classic이 제거 됐다고 한다.

그래서 PostProcessor에서 -ld_classic 관련을 주석처리 하니 빌드가 잘된다.

(참고로 -ld64도 함께 제거 된 것 같으니 -ld64도 있으면 제거하자)

[요약]

Xcode 26에서 -ld_classic, -ld64 제거 됨.

[liltoon] 릴툰 그림자 카툰느낌내는 에셋(무료)

blueasa — Mon, 22 Sep 2025 14:47:01 +0900

[링크] https://misos03hop.booth.pm/items/5135844

【vrchat】[free]MisoShadow - MISO# - BOOTH

写真を撮ったり、きれいな影が欲しい人におすすめです。 ◎ 説明 ● liltoonの影をアニメの感じに変えてくれるアセットです。 ● リアルタイムでライトを使用しないため、フレームドロップ

misos03hop.booth.pm

[참조] https://gall.dcinside.com/mgallery/board/view/?id=vr&no=3367059

릴툰 그림자 카툰느낌내는 에셋 무료배포함 - 브이알챗 (VRChat) 마이너 갤러리

이런느낌으로 카툰느낌 나고그림자 각도조절 가능함광원 생각하면서 찍으면 사진도 잘나오고그냥 평범하게 있어도 이쁨그리고 젤 중요한게 pcss마냥 실시간 라이트가 아니라서프레임 드랍 없

gall.dcinside.com

[확장프로그램] LiveWiki: 유튜브 핵심 요약

blueasa — Fri, 12 Sep 2025 17:19:36 +0900

유튜브 옆에 떠있어서 요약만 보고 싶을 때 좋음.

[링크] https://chromewebstore.google.com/detail/gaaicdedebppdnadcdddckdmccfejjli?utm_source=item-share-cb

LiveWiki: 유튜브 핵심 요약 - Chrome 웹 스토어

복잡한 유튜브 영상도 핵심만 빠르게 정리해, 더 똑똑하게 선택할 수 있도록 돕습니다.

chromewebstore.google.com

[링크] 주차(Week) 계산기

blueasa — Fri, 5 Sep 2025 10:19:26 +0900

[링크] https://littlecandle.co.kr/weekcal.php

리틀캔들 - 연간 주차(Week) 계산기 - 리틀캔들

< {{item}} >

littlecandle.co.kr

[링크] Game UI Database

blueasa — Fri, 5 Sep 2025 10:11:36 +0900

[링크] https://www.gameuidatabase.com/

[파일] CustomURPToon(NiloToon 예제소스 참조)

blueasa — Mon, 1 Sep 2025 18:21:12 +0900

NiloToon 같이 만들어 보고 싶어서 NiloToon 공개 소스를 참조한 URPSimpleGenshin Shader를 좀 개조해서 기능 추가 해봄.

// Based on SimpleGenshinFacial shader
// Simplified NiloToon Shader for Unity URP

/*
CustomURPToon Shader - A simplified toon shader based on SimpleGenshinFacial
Features:
- Basic toon lighting with cel shading
- Rim lighting
- Outline rendering
- Face shadow mapping support
- Mobile optimized
*/

[파일]

CustomURPToon.zip

0.51MB

[참조] https://github.com/NoiRC256/URPSimpleGenshinShaders

GitHub - NoiRC256/URPSimpleGenshinShaders: A simple Genshin Impact facial shader for Unity URP, based on NiloCat shader example

A simple Genshin Impact facial shader for Unity URP, based on NiloCat shader example - NoiRC256/URPSimpleGenshinShaders

github.com

[링크] URPSimpleGenshinShaders

blueasa — Mon, 1 Sep 2025 18:17:29 +0900

[링크] https://github.com/NoiRC256/URPSimpleGenshinShaders

GitHub - NoiRC256/URPSimpleGenshinShaders: A simple Genshin Impact facial shader for Unity URP, based on NiloCat shader example

A simple Genshin Impact facial shader for Unity URP, based on NiloCat shader example - NoiRC256/URPSimpleGenshinShaders

github.com

[링크] 플레이스토어 구글 개발자 계정 만들기 (개인 계정)

blueasa — Thu, 28 Aug 2025 13:45:23 +0900

[링크] https://daco2020.tistory.com/894

플레이스토어 구글 개발자 계정 만들기 (개인 계정)

이번 글에서는플레이스토어에 앱을 출시하기 위한 구글 개발자 개인 계정을 만들어보겠습니다. 1. 구글 계정 만들기구글 개발자 계정을 만들기 위해서는 먼저 구글 계정이 필요합니다.*만약 이

daco2020.tistory.com

[확장프로그램] Immersive Translate (몰입형 번역 - 웹 사이트 번역 확장 프로그램 | PDF 번역 | 무료)

blueasa — Wed, 27 Aug 2025 20:22:32 +0900

[링크] https://chromewebstore.google.com/detail/bpoadfkcbjbfhfodiogcnhhhpibjhbnh?utm_source=item-share-cb

몰입형 번역 - 웹 사이트 번역 확장 프로그램 | PDF 번역 | 무료 - Chrome 웹 스토어

[몰입형 번역] 무료 (원문/번역문) 이중 언어 대조 웹사이트 번역 확장 프로그램으로 PDF 번역(조판 유지), 비디오 이중 언어 자막 번역(YouTube, Netflix 등), EPUB 전자책 번역을 지원합니다.

chromewebstore.google.com

- 웹번역 / 유튜브 자막 실시간 번역도 됨.

- 유료 서비스가 있지만, 무료로도 충분한 듯.

[링크] Google Play Game Service V2(GPGS2) 사용

blueasa — Wed, 27 Aug 2025 11:18:02 +0900

[링크] https://docs.backnd.com/sdk-docs/backend/base/user/federation/example-using-gpgs2/

Google Play Game Service V2(GPGS2) 사용 | 뒤끝 개발자

Google Play Games Service (GPGS)로 간편하게 로그인하는 기능을 넣어서, 사용자 경험을 향상하세요.

docs.backnd.com

[링크] Unity용 Google Play 게임즈 설정 및 로그인

blueasa — Wed, 27 Aug 2025 10:56:31 +0900

[링크] https://developer.android.com/games/pgs/unity/overview?hl=ko

Unity용 Google Play 게임즈 플러그인 | Android game development | Android Developers

이 페이지는 Cloud Translation API를 통해 번역되었습니다. 의견 보내기 Unity용 Google Play 게임즈 플러그인 컬렉션을 사용해 정리하기 내 환경설정을 기준으로 콘텐츠를 저장하고 분류하세요. Unity용 Go

developer.android.com

[링크] ttps://developer.android.com/games/pgs/unity/unity-start?hl=ko

Unity용 Google Play 게임즈 설정 및 로그인 | Android game development | Android Developers

이 페이지는 Cloud Translation API를 통해 번역되었습니다. 의견 보내기 Unity용 Google Play 게임즈 설정 및 로그인 컬렉션을 사용해 정리하기 내 환경설정을 기준으로 콘텐츠를 저장하고 분류하세요. 이

developer.android.com

[github] Google Play Games plugin for Unity

blueasa — Wed, 27 Aug 2025 10:55:01 +0900

[링크] https://github.com/playgameservices/play-games-plugin-for-unity

GitHub - playgameservices/play-games-plugin-for-unity: Google Play Games plugin for Unity

Google Play Games plugin for Unity. Contribute to playgameservices/play-games-plugin-for-unity development by creating an account on GitHub.

github.com

[링크] [2024 최신] 유니티 게임과 구글 플레이 게임즈 연동하기 GPGS - Google Play Games Plugin for unity - v.11.01

blueasa — Wed, 27 Aug 2025 10:52:25 +0900

[링크] https://nybot-house.tistory.com/99

[2024 최신] 유니티 게임과 구글 플레이 게임즈 연동하기 GPGS - Google Play Games Plugin for unity - v.11.01

현제 개발 중인 모바일 게임, '전설의 대장장이 이야기-The Legend Of BlackSmith'가 출시되었다.구글 플레이 스토어 링크 전설의 대장장이 이야기 - Google Play 앱무기를 제작하고 판매해서 전설적인 대

nybot-house.tistory.com

[Lunar Console] Unity6 - New Input에서 Swipe Down 안되는 버그 수정(우회)

blueasa — Mon, 25 Aug 2025 16:11:43 +0900

[파일]

LunarConsoleAssist.cs

0.00MB

using UnityEngine;

#if UNITY_ANDROID || UNITY_IOS
using LunarConsolePlugin;
#endif

/// <summary>
/// 모바일 기기에서 멀티터치를 통해 LunarConsole을 활성화하는 도우미 클래스
/// </summary>
public class LunarConsoleAssist : MonoBehaviour
{
    [Header("Touch Settings")]
    [SerializeField, Range(2, 5)]
    private int requiredFingers = 3;

    [SerializeField, Range(0.1f, 2.0f)]
    private float requiredHoldTime = 0.3f;

    [Header("Debug")]
    [SerializeField]
    private bool enableDebugLog = false;

    private float currentHoldTimer;
    private bool isConsoleShown;

    // 성능 최적화를 위한 캐싱
    private Touch[] cachedTouches;

    private void Awake()
    {
        // 필요한 경우에만 초기화
#if !(UNITY_ANDROID || UNITY_IOS) || UNITY_EDITOR
        if (enableDebugLog)
            Debug.LogWarning("[LunarConsoleAssist] This component only works on Android/iOS devices.");
#endif
    }

    private void Update()
    {
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
        HandleTouchInput();
#endif
    }

#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
    private void HandleTouchInput()
    {
        int touchCount = Input.touchCount;
        
        // 필요한 손가락 수가 맞는지 확인
        if (requiredFingers <= touchCount)
        {
            if (AreRequiredTouchesValid(touchCount))
            {
                currentHoldTimer += Time.unscaledDeltaTime;
                
                if (requiredHoldTime <= currentHoldTimer && !isConsoleShown)
                {
                    ShowLunarConsole();
                }
            }
            else
            {
                ResetTimer();
            }
        }
        else
        {
            ResetTimer();
        }
    }
    
    private bool AreRequiredTouchesValid(int touchCount)
    {
        // 성능 최적화: 필요한 터치만 확인
        int validTouchCount = 0;
        
        for (int i = 0; i < touchCount && validTouchCount < requiredFingers; i++)
        {
            TouchPhase phase = Input.touches[i].phase;
            
            if (IsTouchPhaseValid(phase))
            {
                validTouchCount++;
            }
        }
        
        return requiredFingers <= validTouchCount;
    }
    
    private bool IsTouchPhaseValid(TouchPhase phase)
    {
        return phase == TouchPhase.Began || 
               phase == TouchPhase.Stationary || 
               phase == TouchPhase.Moved;
    }
    
    private void ShowLunarConsole()
    {
        try
        {
            LunarConsole.Show();
            isConsoleShown = true;
            
            if (enableDebugLog)
                Debug.Log("[LunarConsoleAssist] Console activated!");
                
            ResetTimer();
        }
        catch (System.Exception e)
        {
            if (enableDebugLog)
                Debug.LogError($"[LunarConsoleAssist] Failed to show console: {e.Message}");
        }
    }
    
    private void ResetTimer()
    {
        currentHoldTimer = 0f;
        isConsoleShown = false;
    }
#endif

#if UNITY_EDITOR
    private void OnValidate()
    {
        // 에디터에서 값 검증
        requiredFingers = Mathf.Clamp(requiredFingers, 2, 5);
        requiredHoldTime = Mathf.Clamp(requiredHoldTime, 0.1f, 2.0f);
    }
#endif
}

[출처] 지인

Unity scripting symbol reference(Platform symbols)

blueasa — Thu, 21 Aug 2025 17:18:44 +0900

[링크] https://docs.unity3d.com/6000.2/Documentation/Manual/scripting-symbol-reference.html

----

Platform symbols

Unity automatically defines certain symbols based on the authoring and build target platform. These are as follows:

DefineFunction

UNITY_EDITOR	Scripting symbol to call Unity Editor scripts from your game code.
UNITY_EDITOR_WIN	Scripting symbol for Editor code on Windows.
UNITY_EDITOR_OSX	Scripting symbol for Editor code in macOS.
UNITY_EDITOR_LINUX	Scripting symbol for Editor code on Linux.
UNITY_EMBEDDED_LINUX	Scripting symbol for embedded Linux.
UNITY_QNX	Scripting symbol for QNX.
UNITY_STANDALONE_OSX	Scripting symbol to compile or execute code specifically for macOS (including Universal, PPC and Intel architectures).
UNITY_STANDALONE_WIN	Scripting symbol for compiling/executing code specifically for Windows standalone applications.
UNITY_STANDALONE_LINUX	Scripting symbol for compiling/executing code specifically for Linux standalone applications.
UNITY_STANDALONE	Scripting symbol for compiling/executing code for any standalone platform (Mac OS X, Windows or Linux).
UNITY_SERVER	Scripting symbol for compiling/executing code for a dedicated server (macOS, Windows or Linux).
UNITY_IOS	Scripting symbol for compiling/executing code for the iOS platform.
UNITY_ANDROID	Scripting symbol for the Android platform.
UNITY_TVOS	Scripting symbol for the Apple TV platform.
UNITY_VISIONOS	Scripting symbol for the VisionOS platform.
UNITY_WSA	Scripting symbol for Universal Windows Platform.
UNITY_WSA_10_0	Scripting symbol for Universal Windows Platform.
UNITY_WEBGL	Scripting symbol for Web.
UNITY_FACEBOOK_INSTANT_GAMES	Scripting symbol for the Facebook Instant Games platform.
UNITY_ANALYTICS	Scripting symbol for calling Unity Analytics methods from your game code.
UNITY_ASSERTIONS	Scripting symbol for assertions control process.
UNITY_64	Scripting symbol for 64-bit platforms. In practice this should not be used because it does not work on all 64-bit architectures and different CPU architectures on a given platform can share the same compiled assemblies. To execute code conditionally based on architecture, use a standard if statement that checks IntPtr.Size, which is 4 in a 32-bit process and 8 in a 64-bit process. For an example, refer to Alternatives to directives.

Unity Editor version symbols

Unity automatically defines certain scripting symbols based on the version of the Unity Editor that you’re currently using.

Given a version number X.Y.Z (for example, 6000.0.33), Unity exposes three global scripting symbols in the following formats: UNITY_X, UNITY_X_Y and UNITY_X_Y_Z.

Here is an example of scripting symbols exposed in Unity 6000.0.33:

DefineFunction

UNITY_6000	Scripting symbol for the release version of Unity 6, exposed in every 6000.Y.Z release.
UNITY_6000_0	Scripting symbol for the major version of Unity 6.0, exposed in every 6000.0.Z release.
UNITY_6000_0_33	Scripting symbol for the minor version of Unity 6000.0.33.

You can also compile code selectively based on the earliest version of Unity required to compile or execute a section of code snippet. Following the same version format describd previously (X.Y), Unity exposes one global #define in the format UNITY_X_Y_OR_NEWER (for example, UNITY_6000_0_OR_NEWER), that you can use for this purpose.

Other symbols

The other symbols Unity defines are:

DefineFunction

CSHARP_7_3_OR_NEWER	Defined when building scripts with support for C# 7.3 or newer.
ENABLE_MONO	Scripting back end #define for Mono.
ENABLE_IL2CPP	Scripting back end #define for IL2CPP .
ENABLE_VR	Defined when the target build platform supports VR . Doesn’t imply that VR is currently enabled or that the necessary plug-ins and packages needed to support VR are installed.
NET_2_0	Defined when building scripts against .NET 2.0 API compatibility level on Mono and IL2CPP.
NET_2_0_SUBSET	Defined when building scripts against .NET 2.0 Subset API compatibility level on Mono and IL2CPP.
NET_LEGACY	Defined when building scripts against .NET 2.0 or .NET 2.0 Subset API compatibility level on Mono and IL2CPP.
NET_4_6	Defined when building scripts against .NET 4.x API compatibility level on Mono and IL2CPP.
NET_STANDARD_2_0	Defined when building scripts against .NET Standard 2.0 API compatibility level on Mono and IL2CPP.
NET_STANDARD_2_1	Defined when building scripts against .NET Standard 2.1 API compatibility level on Mono and IL2CPP.
NET_STANDARD	Defined when building scripts against .NET Standard 2.1 API compatibility level on Mono and IL2CPP.
NETSTANDARD2_1	Defined when building scripts against .NET Standard 2.1 API compatibility level on Mono and IL2CPP.
NETSTANDARD	Defined when building scripts against .NET Standard 2.1 API compatibility level on Mono and IL2CPP.
ENABLE_WINMD_SUPPORT	Defined when Windows Runtime support is enabled on IL2CPP. For more information, refer to WinRT API in C# scripts for UWP.
ENABLE_INPUT_SYSTEM	Defined when the Input System package is enabled in Player Settings .
ENABLE_LEGACY_INPUT_MANAGER	Defined when the legacy Input Manager is enabled in Player Settings.
DEVELOPMENT_BUILD	Defined when your script is running in a Player which was built with the Development Build option enabled. This define only reflects whether the development build option was enabled at the time of the build. To know whether your script is running in the development build mode, use Debug.isDebugBuild. DEVELOPMENT_BUILD isn’t sufficient to determine whether you’re currently running in a development build because most platforms allow changing between development and non-development build without rebuilding the project. However, on some platforms, Unity doesn’t support switching between development and non-development builds in the Editor and requires you to switch after the build is complete. For example, on Windows, you can choose the Create Visual Studio solution option to choose whether you want a development or non-development build in Visual Studio. Switching in Visual Studio doesn’t recompile your scripts and therefore, it will not reevaluate scripting defines. You can also switch from the final game build to a development build by swapping UnityPlayer.dll in the game build with the one from a development build for debugging live game builds.
UNITY_CLOUD_BUILD	Defined when the project is built with Unity Build Automation .

Note: The DEBUG symbol is predefined in C# and in Unity using the directive #if DEBUG is equivalent to #if UNITY_EDITOR || DEVELOPMENT_BUILD

Additional resources

Define Invoker

blueasa — Thu, 21 Aug 2025 17:14:57 +0900

Unity 6000.1.15f1

----

유니티 Platform Define Symbols를 직접 사용하지 않고 Invoke Class로 묶어서

내가 작성한 코드가 Define 때문에 비활성화 되어서 빌드 할 때 에러를 보게 되는 경우를 방지하기 위해 제작(Cursor AI 시킴)

[파일]

DefineInvoker.cs

0.02MB

DefineInvokerExample.cs

0.00MB

[DefineInvoker.cs]

using System;

/// <summary>
/// Unity platform define을 사용하여 플랫폼별 조건부 실행을 지원하는 클래스
/// </summary>
public static class DefineInvoker
{
    /// <summary>
    /// 메서드 체이닝을 지원하는 InvokerChain 클래스
    /// </summary>
    public class InvokerChain
    {
        /// <summary>
        /// Android 플랫폼에서만 실행되는 코드 (에디터 제외)
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain Android(Action action)
        {
#if UNITY_ANDROID && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// Android 플랫폼에서만 실행되는 코드 (에디터 제외, 반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T Android<T>(Func<T> func)
        {
#if UNITY_ANDROID && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// iOS 플랫폼에서만 실행되는 코드 (에디터 제외)
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain iOS(Action action)
        {
#if UNITY_IOS && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// iOS 플랫폼에서만 실행되는 코드 (에디터 제외, 반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T iOS<T>(Func<T> func)
        {
#if UNITY_IOS && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// Windows 플랫폼에서만 실행되는 코드
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain Windows(Action action)
        {
#if UNITY_STANDALONE_WIN && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// Windows 플랫폼에서만 실행되는 코드 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T Windows<T>(Func<T> func)
        {
#if UNITY_STANDALONE_WIN && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// macOS 플랫폼에서만 실행되는 코드
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain macOS(Action action)
        {
#if UNITY_STANDALONE_OSX && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// macOS 플랫폼에서만 실행되는 코드 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T macOS<T>(Func<T> func)
        {
#if UNITY_STANDALONE_OSX && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// Linux 플랫폼에서만 실행되는 코드
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain Linux(Action action)
        {
#if UNITY_STANDALONE_LINUX && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// Linux 플랫폼에서만 실행되는 코드 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T Linux<T>(Func<T> func)
        {
#if UNITY_STANDALONE_LINUX && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// WebGL 플랫폼에서만 실행되는 코드
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain WebGL(Action action)
        {
#if UNITY_WEBGL && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// WebGL 플랫폼에서만 실행되는 코드 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T WebGL<T>(Func<T> func)
        {
#if UNITY_WEBGL && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// Unity 에디터에서만 실행되는 코드
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain Editor(Action action)
        {
#if UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// Unity 에디터에서만 실행되는 코드 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T Editor<T>(Func<T> func)
        {
#if UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// Standalone 플랫폼(Windows, macOS, Linux)에서만 실행되는 코드
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain Standalone(Action action)
        {
#if UNITY_STANDALONE && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// Standalone 플랫폼(Windows, macOS, Linux)에서만 실행되는 코드 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T Standalone<T>(Func<T> func)
        {
#if UNITY_STANDALONE && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// 모바일 플랫폼(Android, iOS)에서만 실행되는 코드 (에디터 제외)
        /// </summary>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain Mobile(Action action)
        {
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
            action?.Invoke();
#endif
            return this;
        }

        /// <summary>
        /// 모바일 플랫폼(Android, iOS)에서만 실행되는 코드 (에디터 제외, 반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T Mobile<T>(Func<T> func)
        {
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
            return func != null ? func.Invoke() : default(T);
#else
            return default(T);
#endif
        }

        /// <summary>
        /// 커스텀 조건문을 사용하여 실행
        /// </summary>
        /// <param name="condition">실행 조건</param>
        /// <param name="action">실행할 액션</param>
        /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
        public InvokerChain When(bool condition, Action action)
        {
            if (condition)
            {
                action?.Invoke();
            }
            return this;
        }

        /// <summary>
        /// 커스텀 조건문을 사용하여 실행 (반환값 있음)
        /// </summary>
        /// <typeparam name="T">반환 타입</typeparam>
        /// <param name="condition">실행 조건</param>
        /// <param name="func">실행할 함수</param>
        /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
        public T When<T>(bool condition, Func<T> func)
        {
            if (condition)
            {
                return func != null ? func.Invoke() : default(T);
            }
            return default(T);
        }
    }

    // 정적 메서드들 - 단일 플랫폼 실행용
    
    /// <summary>
    /// Android 플랫폼에서만 실행되는 코드 (에디터 제외)
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Android(Action action)
    {
#if UNITY_ANDROID && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// Android 플랫폼에서만 실행되는 코드 (에디터 제외, 반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T Android<T>(Func<T> func)
    {
#if UNITY_ANDROID && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// iOS 플랫폼에서만 실행되는 코드 (에디터 제외)
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain iOS(Action action)
    {
#if UNITY_IOS && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// iOS 플랫폼에서만 실행되는 코드 (에디터 제외, 반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T iOS<T>(Func<T> func)
    {
#if UNITY_IOS && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// Windows 플랫폼에서만 실행되는 코드
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Windows(Action action)
    {
#if UNITY_STANDALONE_WIN && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// Windows 플랫폼에서만 실행되는 코드 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T Windows<T>(Func<T> func)
    {
#if UNITY_STANDALONE_WIN && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// macOS 플랫폼에서만 실행되는 코드
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain macOS(Action action)
    {
#if UNITY_STANDALONE_OSX && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// macOS 플랫폼에서만 실행되는 코드 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T macOS<T>(Func<T> func)
    {
#if UNITY_STANDALONE_OSX && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// Linux 플랫폼에서만 실행되는 코드
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Linux(Action action)
    {
#if UNITY_STANDALONE_LINUX && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// Linux 플랫폼에서만 실행되는 코드 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T Linux<T>(Func<T> func)
    {
#if UNITY_STANDALONE_LINUX && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// WebGL 플랫폼에서만 실행되는 코드
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain WebGL(Action action)
    {
#if UNITY_WEBGL && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// WebGL 플랫폼에서만 실행되는 코드 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T WebGL<T>(Func<T> func)
    {
#if UNITY_WEBGL && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// Unity 에디터에서만 실행되는 코드
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Editor(Action action)
    {
#if UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// Unity 에디터에서만 실행되는 코드 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T Editor<T>(Func<T> func)
    {
#if UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// Standalone 플랫폼(Windows, macOS, Linux)에서만 실행되는 코드
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Standalone(Action action)
    {
#if UNITY_STANDALONE && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// Standalone 플랫폼(Windows, macOS, Linux)에서만 실행되는 코드 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T Standalone<T>(Func<T> func)
    {
#if UNITY_STANDALONE && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// 모바일 플랫폼(Android, iOS)에서만 실행되는 코드 (에디터 제외)
    /// </summary>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Mobile(Action action)
    {
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
        action?.Invoke();
#endif
        return new InvokerChain();
    }

    /// <summary>
    /// 모바일 플랫폼(Android, iOS)에서만 실행되는 코드 (에디터 제외, 반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T Mobile<T>(Func<T> func)
    {
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
        return func != null ? func.Invoke() : default(T);
#else
        return default(T);
#endif
    }

    /// <summary>
    /// 커스텀 조건문을 사용하여 실행
    /// </summary>
    /// <param name="condition">실행 조건</param>
    /// <param name="action">실행할 액션</param>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain When(bool condition, Action action)
    {
        if (condition)
        {
            action?.Invoke();
        }
        return new InvokerChain();
    }

    /// <summary>
    /// 커스텀 조건문을 사용하여 실행 (반환값 있음)
    /// </summary>
    /// <typeparam name="T">반환 타입</typeparam>
    /// <param name="condition">실행 조건</param>
    /// <param name="func">실행할 함수</param>
    /// <returns>함수의 실행 결과 (조건이 맞지 않으면 default(T))</returns>
    public static T When<T>(bool condition, Func<T> func)
    {
        if (condition)
        {
            return func != null ? func.Invoke() : default(T);
        }
        return default(T);
    }

    /// <summary>
    /// 체이닝을 시작하기 위한 메서드
    /// </summary>
    /// <returns>체이닝을 위한 InvokerChain 인스턴스</returns>
    public static InvokerChain Chain()
    {
        return new InvokerChain();
    }
}

[DefineInvokerExample.cs]

using UnityEngine;

/// <summary>
/// DefineInvoker 사용 예시 클래스
/// </summary>
public class DefineInvokerExample : MonoBehaviour
{
    void Start()
    {
        // 예시 1: 단일 플랫폼 실행
        DefineInvoker.Android(() => 
        {
            Debug.Log("Android 플랫폼에서 실행됨");
            // Android 전용 코드
        });

        DefineInvoker.iOS(() => 
        {
            Debug.Log("iOS 플랫폼에서 실행됨");
            // iOS 전용 코드
        });

        DefineInvoker.Editor(() => 
        {
            Debug.Log("Unity 에디터에서 실행됨");
            // 에디터 전용 코드
        });

        // 예시 2: 메서드 체이닝 사용
        DefineInvoker.Android(() => 
            {
                Debug.Log("Android 초기화");
                InitializeAndroid();
            })
            .iOS(() => 
            {
                Debug.Log("iOS 초기화");
                InitializeiOS();
            })
            .Windows(() => 
            {
                Debug.Log("Windows 초기화");
                InitializeWindows();
            })
            .Editor(() => 
            {
                Debug.Log("에디터 초기화");
                InitializeEditor();
            });

        // 예시 3: Chain() 메서드로 시작하는 체이닝
        DefineInvoker.Chain()
            .Mobile(() => 
            {
                Debug.Log("모바일 플랫폼 공통 설정");
                SetupMobileSettings();
            })
            .Standalone(() => 
            {
                Debug.Log("PC 플랫폼 공통 설정");
                SetupDesktopSettings();
            })
            .WebGL(() => 
            {
                Debug.Log("WebGL 플랫폼 설정");
                SetupWebGLSettings();
            });

        // 예시 4: 커스텀 조건과 함께 사용
        bool isDebugBuild = Debug.isDebugBuild;
        DefineInvoker.When(isDebugBuild, () => 
        {
            Debug.Log("디버그 빌드에서만 실행되는 코드");
            EnableDebugFeatures();
        })
        .Android(() => 
        {
            Debug.Log("Android + 추가 설정");
        });

        // 예시 5: 복잡한 조건부 실행
        DefineInvoker.Chain()
            .When(Application.platform == RuntimePlatform.Android, () => 
            {
                Debug.Log("런타임에서 Android 플랫폼 확인");
            })
            .When(SystemInfo.deviceType == DeviceType.Handheld, () => 
            {
                Debug.Log("핸드헬드 기기에서 실행");
            })
            .Editor(() => 
            {
                Debug.Log("에디터에서 테스트 실행");
            });

        // 예시 6: Func 사용 (반환값 있는 함수)
        string platformName = DefineInvoker.Android(() => 
        {
            return "Android 플랫폼";
        });
        Debug.Log($"플랫폼 이름: {platformName}");

        int playerLevel = DefineInvoker.Mobile(() => 
        {
            return GetMobilePlayerLevel();
        });
        Debug.Log($"모바일 플레이어 레벨: {playerLevel}");

        // 예시 7: 여러 플랫폼에서 다른 값 반환
        string apiUrl = DefineInvoker.Android(() => "https://android-api.game.com")
                     ?? DefineInvoker.iOS(() => "https://ios-api.game.com")
                     ?? DefineInvoker.Editor(() => "https://dev-api.game.com")
                     ?? "https://default-api.game.com";
        Debug.Log($"API URL: {apiUrl}");

        // 예시 8: 조건부 값 반환
        bool isDevelopment = DefineInvoker.Editor(() => true);
        Debug.Log($"개발 모드: {isDevelopment}");
    }

    private void InitializeAndroid()
    {
        // Android 초기화 로직
        Debug.Log("Android 특화 초기화 완료");
    }

    private void InitializeiOS()
    {
        // iOS 초기화 로직
        Debug.Log("iOS 특화 초기화 완료");
    }

    private void InitializeWindows()
    {
        // Windows 초기화 로직
        Debug.Log("Windows 특화 초기화 완료");
    }

    private void InitializeEditor()
    {
        // 에디터 초기화 로직
        Debug.Log("에디터 특화 초기화 완료");
    }

    private void SetupMobileSettings()
    {
        // 모바일 공통 설정
        Debug.Log("모바일 공통 설정 적용");
        Screen.sleepTimeout = SleepTimeout.NeverSleep;
    }

    private void SetupDesktopSettings()
    {
        // 데스크탑 공통 설정
        Debug.Log("데스크탑 공통 설정 적용");
        Screen.fullScreen = true;
    }

    private void SetupWebGLSettings()
    {
        // WebGL 설정
        Debug.Log("WebGL 특화 설정 적용");
    }

    private void EnableDebugFeatures()
    {
        // 디버그 기능 활성화
        Debug.Log("디버그 기능 활성화됨");
    }

    private int GetMobilePlayerLevel()
    {
        // 모바일 플레이어 레벨 반환 예시
        return 42;
    }
}

[참조] https://docs.unity3d.com/6000.2/Documentation/Manual/scripting-symbol-reference.html

[링크] UnityURPToonLitShaderExample(NiloToonURP)

blueasa — Tue, 19 Aug 2025 11:12:25 +0900

[링크] https://github.com/ColinLeung-NiloCat/UnityURPToonLitShaderExample

GitHub - ColinLeung-NiloCat/UnityURPToonLitShaderExample: A very simple toon lit shader example, for you to learn writing custom

A very simple toon lit shader example, for you to learn writing custom lit shader in Unity URP - ColinLeung-NiloCat/UnityURPToonLitShaderExample

github.com

[링크] 복잡한 앱 설치 없이 광고 제거, 애드가드 DNS 설정 가이드(안드로이드, 아이폰)

blueasa — Thu, 14 Aug 2025 15:12:01 +0900

[링크] https://yoonsidae.tistory.com/112

복잡한 앱 설치 없이 광고 제거, 애드가드 DNS 설정 가이드(안드로이드, 아이폰)

안녕하세요. 윤시대입니다.지난번엔 크롬 확장 프로그램으로 광고 제거 방법을 알려드렸는데, 이번엔 아이폰에서 잘 사용하고 있는 DNS 설정으로 모든 앱에서 광고를 제거하는 방법을 알려드리

yoonsidae.tistory.com

Legacy Input System(Old)을 New Input System으로 Wrapping하는 클래스

blueasa — Fri, 18 Jul 2025 18:19:42 +0900

[추가] 2026-01-21

다른 에셋들에서 asmdef 파일을 사용하면서 Global 참조하게 했던 Input 클래스가 먹히지 않아서

NewInputSystemWrapper.asmdef를 만들고, asmdef를 사용하는 에셋의 asmdef 설정에 있는 Use GUIDs에 NewInputSystemWrapper.asmdef를 직접 링크 시켜서 문제를 해결했다.

(Input.cs와 NewInputSystemWrapper.asmdef 파일은 아래 NewInputSystemWrapper.zip 파일안에 압축해서 포함시켰다.)

[참고]

Input 클래스를 사용하는 다른 스크립트 상에서 namespace 안쪽에 using UnityEngine; 이 정의되면,

Unity 자체 Input인 UnityEngine.Input이 우선시 되어서 아래 Custom Input 클래스를 넣어도 제대로 작동하지 않는다.

이럴 땐 using UnityEngine; 정의를 namespace 밖으로 옮겨주자.

※ 아래 예제와 같이 using UnityEngine; 문만 밖으로 빼주면 된다.

/// 1. 에러 상황

namespace Ex
{
    using UnityEngine;	// namespace 안에 있음(X)
    
    public class Test
	{
        void Update()
        {
        	// UnityEngine.Input을 참조하면서 에러 발생
            if (Input.GetKeyDown(KeyCode.Escape))
            {
                Application.Quit();
            }
        }
    }
}

////////////////////////////////////////////////////

/// 2. 정상 동작

using UnityEngine;	// namespace 밖에 있음(O)

namespace Ex
{
    public class Test
	{
        void Update()
        {
        	// 정상적으로 Custom Input 클래스를 참조 함.
            if (Input.GetKeyDown(KeyCode.Escape))
            {
                Application.Quit();
            }
        }
    }
}

----

Unity 6000.1.11f1

URP

InputSystem 1.14.1

NGUI 2025.07.01

----

Legacy Input System을 new Input System으로 변환하면서 기존 Third Party 에셋들이 기존 Legacy Input을 계속 사용하고 있어서(특히 NGUI)

에러나는 부분을 가능하면 손을 덜 대고 해결하기 위해서,

Legacy Input System을 New Input System으로 Wrapping하는 클래스를 만들었다.

(왠만한 건 다 Wrapping 한 것 같은데 혹시나 빠진게 있을수도 있다.)

Activate Input Handling을 New Input System으로 변경하고 아래 스크립트를 Plugins 폴더에 넣어주면 된다.

[파일]

NewInputSystemWrapper.zip

0.01MB

[코드]

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using Debug = UnityEngine.Debug;

// 별칭 지정
using InputSystemTouchPhase = UnityEngine.InputSystem.TouchPhase;
using LegacyTouchPhase = UnityEngine.TouchPhase;
using InputSystemGyroscope = UnityEngine.InputSystem.Gyroscope;



/// <summary>
/// Legacy Input System을 New Input System으로 Wrapping하는 클래스.
/// </summary>
public static class Input
{
    #region 필드

    /// <summary>
    /// 가속도계 이벤트를 나타냅니다.
    /// </summary>
    public struct AccelerationEvent
    {
        public Vector3 acceleration;
        public float deltaTime;
    }

    /// <summary>
    /// Legacy Gyroscope API를 모방하는 래퍼 클래스입니다.
    /// </summary>
    public class Gyroscope
    {
        private readonly InputSystemGyroscope device;
        private readonly GravitySensor gravityDevice;
        private readonly AttitudeSensor attitudeDevice;

        internal Gyroscope(InputSystemGyroscope device)
        {
            this.device = device;
            this.gravityDevice = GravitySensor.current;
            this.attitudeDevice = AttitudeSensor.current;
        }

        /// <summary>
        /// 자이로스코프 활성화 여부입니다.
        /// </summary>
        public bool enabled
        {
            get => device != null && device.enabled;
            set
            {
                if (device != null && device.enabled != value)
                {
                    if (value)
                    {
                        InputSystem.EnableDevice(device);
                        if (attitudeDevice != null) InputSystem.EnableDevice(attitudeDevice);
                    }
                    else
                    {
                        InputSystem.DisableDevice(device);
                        if (attitudeDevice != null) InputSystem.DisableDevice(attitudeDevice);
                    }
                }
            }
        }

        /// <summary>
        /// 장치의 자세(Attitude)를 반환합니다.
        /// </summary>
        public Quaternion attitude => attitudeDevice?.attitude.ReadValue() ?? Quaternion.identity;

        /// <summary>
        /// 장치의 중력 가속도 벡터를 반환합니다.
        /// </summary>
        public Vector3 gravity => gravityDevice?.gravity.ReadValue() ?? Vector3.zero;

        /// <summary>
        /// 장치의 회전 속도를 반환합니다. (deg/s)
        /// </summary>
        public Vector3 rotationRate => (device?.angularVelocity.ReadValue() ?? Vector3.zero) * Mathf.Rad2Deg;

        /// <summary>
        /// 바이어스가 보정된 장치의 회전 속도를 반환합니다. (New Input System에서는 rotationRate와 동일)
        /// </summary>
        public Vector3 rotationRateUnbiased => rotationRate;

        /// <summary>
        /// 자이로스코프의 업데이트 간격(초)입니다.
        /// </summary>
        public float updateInterval
        {
            get => (device != null && device.samplingFrequency > 0) ? 1.0f / device.samplingFrequency : 0;
            set
            {
                // New Input System에서는 프로그래밍 방식으로 업데이트 간격을 설정할 수 없습니다.
                LogInfo("Gyroscope.updateInterval은 New Input System에서 설정할 수 없습니다.");
            }
        }
    }


    private static readonly Dictionary<KeyCode, Key> keyMapping = new Dictionary<KeyCode, Key>();
    private static readonly Dictionary<string, InputAction> axisActions = new Dictionary<string, InputAction>();
    private static readonly List<Touch> cachedTouches = new List<Touch>();
    private static readonly List<AccelerationEvent> accelerationEventBuffer = new List<AccelerationEvent>();

    private static InputAction anyKeyAction;
    private static float lastTouchUpdateTime;
    private static bool isInitialized;
    private static bool enableDebugLogs = true;
    private static Gyroscope _gyroscope;


    // UIInput 호환성을 위한 필드
    private static readonly StringBuilder inputBuffer = new StringBuilder();
    public static string compositionString { get; private set; } = "";
    public static Vector2 compositionCursorPos { get; set; }

    // 현재 입력 장치들
    private static Mouse currentMouse => Mouse.current;
    private static Keyboard currentKeyboard => Keyboard.current;
    private static Gamepad currentGamepad => Gamepad.current;
    private static Touchscreen currentTouchscreen => Touchscreen.current;
    private static Accelerometer currentAccelerometer => Accelerometer.current;
    private static InputSystemGyroscope currentGyro => InputSystemGyroscope.current;


    private enum KeyState { Down, Up, Held }

    #endregion

    #region 초기화

    static Input()
    {
        Initialize();
    }

    /// <summary>
    /// NewInput 시스템을 명시적으로 초기화합니다.
    /// </summary>
    public static void Initialize()
    {
        if (isInitialized) return;

        try
        {
            LogInfo("NewInput 시스템 초기화 시작...");

            InitializeKeyMapping();
            InitializeDefaultActions();
            SetupAnyKeyAction();
            SetupTextHandling();

#if UNITY_ANDROID || UNITY_IOS
            if (!UnityEngine.InputSystem.EnhancedTouch.EnhancedTouchSupport.enabled)
            {
                UnityEngine.InputSystem.EnhancedTouch.EnhancedTouchSupport.Enable();
                LogInfo("EnhancedTouchSupport 활성화됨.");
            }
            if (currentAccelerometer != null && !currentAccelerometer.enabled)
            {
                InputSystem.EnableDevice(currentAccelerometer);
                LogInfo("가속도계 활성화됨.");
            }
            if (currentGyro != null && !currentGyro.enabled)
            {
                InputSystem.EnableDevice(currentGyro);
                LogInfo("자이로스코프 활성화됨.");
            }
            if (GravitySensor.current != null && !GravitySensor.current.enabled)
            {
                InputSystem.EnableDevice(GravitySensor.current);
                LogInfo("중력 센서 활성화됨.");
            }
            if (AttitudeSensor.current != null && !AttitudeSensor.current.enabled)
            {
                InputSystem.EnableDevice(AttitudeSensor.current);
                LogInfo("자세 센서 활성화됨.");
            }
#endif

            isInitialized = true;
            LogInfo("NewInput 시스템 초기화 완료.");
        }
        catch (Exception ex)
        {
            LogError($"NewInput 초기화 중 오류 발생: {ex.Message}");
        }
    }

    private static void InitializeKeyMapping()
    {
        keyMapping.Clear();
        // 알파벳, 숫자, 특수 키 매핑 (기존과 동일)
        for (int i = 0; i < 26; i++) keyMapping[(KeyCode)((int)KeyCode.A + i)] = Key.A + i;
        for (int i = 0; i < 10; i++) keyMapping[(KeyCode)((int)KeyCode.Alpha0 + i)] = Key.Digit0 + i;
        for (int i = 0; i < 10; i++) keyMapping[(KeyCode)((int)KeyCode.Keypad0 + i)] = Key.Numpad0 + i;
        for (int i = 0; i < 15; i++) keyMapping[(KeyCode)((int)KeyCode.F1 + i)] = Key.F1 + i;
        keyMapping[KeyCode.Backspace] = Key.Backspace;
        keyMapping[KeyCode.Tab] = Key.Tab;
        keyMapping[KeyCode.Return] = Key.Enter;
        keyMapping[KeyCode.Pause] = Key.Pause;
        keyMapping[KeyCode.Escape] = Key.Escape;
        keyMapping[KeyCode.Space] = Key.Space;
        keyMapping[KeyCode.Delete] = Key.Delete;
        keyMapping[KeyCode.LeftShift] = Key.LeftShift;
        keyMapping[KeyCode.RightShift] = Key.RightShift;
        keyMapping[KeyCode.LeftControl] = Key.LeftCtrl;
        keyMapping[KeyCode.RightControl] = Key.RightCtrl;
        keyMapping[KeyCode.LeftAlt] = Key.LeftAlt;
        keyMapping[KeyCode.RightAlt] = Key.RightAlt;
        keyMapping[KeyCode.LeftArrow] = Key.LeftArrow;
        keyMapping[KeyCode.RightArrow] = Key.RightArrow;
        keyMapping[KeyCode.UpArrow] = Key.UpArrow;
        keyMapping[KeyCode.DownArrow] = Key.DownArrow;
        keyMapping[KeyCode.KeypadEnter] = Key.NumpadEnter;
        keyMapping[KeyCode.Insert] = Key.Insert;
        keyMapping[KeyCode.Home] = Key.Home;
        keyMapping[KeyCode.End] = Key.End;
        keyMapping[KeyCode.PageUp] = Key.PageUp;
        keyMapping[KeyCode.PageDown] = Key.PageDown;
    }

    private static void InitializeDefaultActions()
    {
        // 기존 축 액션 정리
        if (axisActions.TryGetValue("Horizontal", out var horizontalAction)) horizontalAction.Disable();
        if (axisActions.TryGetValue("Vertical", out var verticalAction)) verticalAction.Disable();

        // Horizontal 축 설정 (키보드 좌/우 화살표, A/D 키)
        var horizontal = new InputAction("Horizontal", type: InputActionType.Value);
        horizontal.AddCompositeBinding("1DAxis")
            .With("negative", "<Keyboard>/leftArrow")
            .With("positive", "<Keyboard>/rightArrow");
        horizontal.AddCompositeBinding("1DAxis")
            .With("negative", "<Keyboard>/a")
            .With("positive", "<Keyboard>/d");
        horizontal.AddBinding("<Gamepad>/leftStick/x");
        horizontal.Enable();
        axisActions["Horizontal"] = horizontal;

        // Vertical 축 설정 (키보드 상/하 화살표, W/S 키)
        var vertical = new InputAction("Vertical", type: InputActionType.Value);
        vertical.AddCompositeBinding("1DAxis")
            .With("negative", "<Keyboard>/downArrow")
            .With("positive", "<Keyboard>/upArrow");
        vertical.AddCompositeBinding("1DAxis")
            .With("negative", "<Keyboard>/s")
            .With("positive", "<Keyboard>/w");
        vertical.AddBinding("<Gamepad>/leftStick/y");
        vertical.Enable();
        axisActions["Vertical"] = vertical;

        // 마우스 축 설정
        CreateAxisAction("Mouse X", "<Mouse>/delta/x");
        CreateAxisAction("Mouse Y", "<Mouse>/delta/y");
        CreateAxisAction("Mouse ScrollWheel", "<Mouse>/scroll/y");
    }

    private static void SetupAnyKeyAction()
    {
        anyKeyAction?.Disable();
        anyKeyAction = new InputAction("AnyKey", type: InputActionType.PassThrough);
        anyKeyAction.AddBinding("<Keyboard>/anyKey");
        anyKeyAction.AddBinding("<Mouse>/leftButton");
        anyKeyAction.AddBinding("<Mouse>/rightButton");
        anyKeyAction.AddBinding("<Mouse>/middleButton");
        anyKeyAction.AddBinding("<Touchscreen>/primaryTouch/press");
        anyKeyAction.AddBinding("<Gamepad>/buttonSouth");
        anyKeyAction.AddBinding("<Gamepad>/buttonNorth");
        anyKeyAction.AddBinding("<Gamepad>/buttonEast");
        anyKeyAction.AddBinding("<Gamepad>/buttonWest");
        anyKeyAction.Enable();
    }

    private static void CreateAxisAction(string name, params string[] bindings)
    {
        var action = new InputAction(name, InputActionType.Value);
        foreach (var binding in bindings) action.AddBinding(binding);
        action.Enable();
        axisActions[name] = action;
    }

    private static void SetupTextHandling()
    {
        if (currentKeyboard != null)
        {
            currentKeyboard.onTextInput -= OnTextInput;
            currentKeyboard.onTextInput += OnTextInput;
        }
        // InputSystem.onIMECompositionChange는 존재하지 않으므로 제거합니다.
        // IME 처리는 onTextInput을 통해 간접적으로 지원됩니다.
        Application.onBeforeRender -= FrameReset;
        Application.onBeforeRender += FrameReset;
    }

    #endregion

    #region 공개 API

    // UIInput 호환성 API
    public static string inputString => inputBuffer.ToString();
    public static IMECompositionMode imeCompositionMode { get; set; }
    public static bool imeIsSelected => !string.IsNullOrEmpty(compositionString);

    public static bool GetKeyDown(KeyCode key) => GetKeyState(key, KeyState.Down);
    public static bool GetKeyUp(KeyCode key) => GetKeyState(key, KeyState.Up);
    public static bool GetKey(KeyCode key) => GetKeyState(key, KeyState.Held);

    public static bool GetKeyDown(string name)
    {
        if (TryParseKeyCode(name, out var key))
        {
            return GetKeyDown(key);
        }
        return false;
    }

    public static bool GetKeyUp(string name)
    {
        if (TryParseKeyCode(name, out var key))
        {
            return GetKeyUp(key);
        }
        return false;
    }

    public static bool GetKey(string name)
    {
        if (TryParseKeyCode(name, out var key))
        {
            return GetKey(key);
        }
        return false;
    }

    public static float GetAxis(string axisName)
    {
        if (string.IsNullOrEmpty(axisName) || !axisActions.TryGetValue(axisName, out var action) || action == null || !action.enabled)
            return 0f;

        if (action.expectedControlType == "Vector2")
        {
            var value = action.ReadValue<Vector2>();
            if (axisName.EndsWith("X") || axisName == "Horizontal") return value.x;
            if (axisName.EndsWith("Y") || axisName == "Vertical") return value.y;
            return value.magnitude;
        }
        return action.ReadValue<float>();
    }

    public static float GetAxisRaw(string axisName)
    {
        if (string.IsNullOrEmpty(axisName) || !axisActions.TryGetValue(axisName, out var action) || action == null || !action.enabled)
            return 0f;

        if (action.expectedControlType == "Vector2")
        {
            var value = action.ReadValue<Vector2>();
            if (axisName.EndsWith("X") || axisName == "Horizontal") return value.x;
            if (axisName.EndsWith("Y") || axisName == "Vertical") return value.y;
            return value.magnitude;
        }
        var rawValue = action.ReadValue<float>();
        return Mathf.Abs(rawValue) > 0 ? Mathf.Sign(rawValue) : 0;
    }

    public static bool GetButton(string buttonName) => GetButtonState(buttonName, KeyState.Held);
    public static bool GetButtonDown(string buttonName) => GetButtonState(buttonName, KeyState.Down);
    public static bool GetButtonUp(string buttonName) => GetButtonState(buttonName, KeyState.Up);

    public static bool GetMouseButton(int button) => GetKey(KeyCode.Mouse0 + button);
    public static bool GetMouseButtonDown(int button) => GetKeyDown(KeyCode.Mouse0 + button);
    public static bool GetMouseButtonUp(int button) => GetKeyUp(KeyCode.Mouse0 + button);

    public static Vector3 mousePosition => currentMouse?.position.ReadValue() ?? Vector3.zero;
    public static Vector2 mouseScrollDelta => currentMouse?.scroll.ReadValue() ?? Vector2.zero;
    public static bool mousePresent => currentMouse != null;

    public static bool anyKey => anyKeyAction?.IsPressed() ?? false;
    public static bool anyKeyDown => anyKeyAction?.triggered ?? false;

    public static bool touchSupported => currentTouchscreen != null;
    public static bool stylusTouchSupported => Pen.current != null;
    public static bool touchPressureSupported => currentTouchscreen?.pressure.IsActuated() ?? false;
    public static bool multiTouchEnabled { get; set; } = true;
    public static bool simulateMouseWithTouches { get; set; } = true;
    public static int touchCount
    {
        get
        {
            UpdateCachedTouches();
            return cachedTouches.Count;
        }
    }

    public static Touch GetTouch(int index)
    {
        UpdateCachedTouches();
        if (index < 0 || index >= cachedTouches.Count)
            throw new ArgumentOutOfRangeException(nameof(index), $"Touch index {index} is out of range. Count: {cachedTouches.Count}");
        return cachedTouches[index];
    }

    public static Touch[] touches
    {
        get
        {
            UpdateCachedTouches();
            return cachedTouches.ToArray();
        }
    }

    public static Vector3 acceleration
    {
        get
        {
            if (currentAccelerometer != null && currentAccelerometer.enabled)
            {
                return currentAccelerometer.acceleration.ReadValue();
            }
            return Vector3.zero;
        }
    }

    public static int accelerationEventCount
    {
        get
        {
            UpdateAccelerationEvents();
            return accelerationEventBuffer.Count;
        }
    }

    public static AccelerationEvent[] accelerationEvents
    {
        get
        {
            UpdateAccelerationEvents();
            return accelerationEventBuffer.ToArray();
        }
    }

    public static AccelerationEvent GetAccelerationEvent(int index)
    {
        UpdateAccelerationEvents();
        if (index < 0 || index >= accelerationEventBuffer.Count)
            throw new ArgumentOutOfRangeException(nameof(index));
        return accelerationEventBuffer[index];
    }

    public static Gyroscope gyro
    {
        get
        {
            if (_gyroscope == null && currentGyro != null)
            {
                _gyroscope = new Gyroscope(currentGyro);
            }
            return _gyroscope;
        }
    }
    public static bool isGyroAvailable => currentGyro != null && currentGyro.enabled;
    public static DeviceOrientation deviceOrientation
    {
        get
        {
            switch (Screen.orientation)
            {
                case ScreenOrientation.Portrait:
                    return DeviceOrientation.Portrait;
                case ScreenOrientation.PortraitUpsideDown:
                    return DeviceOrientation.PortraitUpsideDown;
                case ScreenOrientation.LandscapeLeft:
                    return DeviceOrientation.LandscapeLeft;
                case ScreenOrientation.LandscapeRight:
                    return DeviceOrientation.LandscapeRight;
                default:
                    return DeviceOrientation.Unknown;
            }
        }
    }

    /// <summary>
    /// 안드로이드에서 뒤로가기 버튼이 앱을 종료할지 여부를 결정합니다.
    /// New Input System에서는 이 기능을 직접 제어할 수 없으므로, 이 속성은 동작하지 않습니다.
    /// </summary>
    public static bool backButtonLeavesApp { get; set; } = true;

    public static string[] GetJoystickNames()
    {
        return Gamepad.all.Select(g => g.displayName).ToArray();
    }

    public static void ResetInputAxes()
    {
        foreach (var action in axisActions.Values)
        {
            // New Input System에서는 직접 리셋하는 기능 대신,
            // 다음 프레임에 값이 0으로 돌아가는 것을 기대합니다.
            // 필요 시, action.Disable() / action.Enable()을 고려할 수 있습니다.
        }
        LogInfo("Input axes reset requested.");
    }

    #endregion

    #region 내부 로직

    private static void OnTextInput(char character) => inputBuffer.Append(character);
    private static void FrameReset()
    {
        inputBuffer.Clear();
        accelerationEventBuffer.Clear();
    }

    private static bool TryParseKeyCode(string name, out KeyCode key)
    {
        try
        {
            key = (KeyCode)Enum.Parse(typeof(KeyCode), name, true);
            return true;
        }
        catch (ArgumentException)
        {
            LogError($"'{name}'은(는) 유효한 KeyCode가 아닙니다.");
            key = KeyCode.None;
            return false;
        }
    }

    private static bool GetButtonState(string buttonName, KeyState state)
    {
        if (TryParseKeyCode(buttonName, out var key))
        {
            return GetKeyState(key, state);
        }

        LogError($"'{buttonName}'은(는) 유효한 KeyCode 이름이 아닙니다.");
        return false;
    }

    private static bool GetKeyState(KeyCode key, KeyState state)
    {
        try
        {
            // 마우스 버튼 처리
            if (key >= KeyCode.Mouse0 && key <= KeyCode.Mouse6)
            {
                if (currentMouse == null) return false;
                var button = (key - KeyCode.Mouse0) switch
                {
                    0 => currentMouse.leftButton,
                    1 => currentMouse.rightButton,
                    2 => currentMouse.middleButton,
                    _ => null
                };
                return button != null && CheckButtonState(button, state);
            }

            // 조이스틱 버튼 처리
            if (key >= KeyCode.JoystickButton0 && key <= KeyCode.JoystickButton19)
            {
                if (currentGamepad == null) return false;
                int buttonIndex = (int)key - (int)KeyCode.JoystickButton0;
                if (currentGamepad.allControls.Count <= buttonIndex) return false;
                var button = currentGamepad.allControls[buttonIndex] as ButtonControl;
                return button != null && CheckButtonState(button, state);
            }

            // 키보드 키 처리
            if (currentKeyboard != null && keyMapping.TryGetValue(key, out var mappedKey) && mappedKey != Key.None)
            {
                return CheckButtonState(currentKeyboard[mappedKey], state);
            }
        }
        catch (Exception ex)
        {
            LogError($"GetKeyState 오류 (Key: {key}, State: {state}): {ex.Message}");
        }
        return false;
    }

    private static bool CheckButtonState(ButtonControl button, KeyState state)
    {
        return state switch
        {
            KeyState.Down => button.wasPressedThisFrame,
            KeyState.Up => button.wasReleasedThisFrame,
            KeyState.Held => button.isPressed,
            _ => false
        };
    }

    private static void UpdateCachedTouches()
    {
        if (Time.unscaledTime == lastTouchUpdateTime) return;
        lastTouchUpdateTime = Time.unscaledTime;
        cachedTouches.Clear();

#if UNITY_EDITOR || UNITY_STANDALONE
        if (simulateMouseWithTouches) SimulateMouseAsTouch();
#else
        if (currentTouchscreen == null) return;

        foreach (var activeTouch in UnityEngine.InputSystem.EnhancedTouch.Touch.activeTouches)
        {
            cachedTouches.Add(ConvertEnhancedTouch(activeTouch));
            if (!multiTouchEnabled) break;
        }
#endif
    }

    private static void UpdateAccelerationEvents()
    {
        if (currentAccelerometer != null && currentAccelerometer.enabled)
        {
            var accel = currentAccelerometer.acceleration.ReadValue();
            accelerationEventBuffer.Add(new AccelerationEvent { acceleration = accel, deltaTime = Time.deltaTime });
        }
    }

    private static Touch ConvertEnhancedTouch(UnityEngine.InputSystem.EnhancedTouch.Touch enhancedTouch)
    {
        var legacyPhase = enhancedTouch.phase switch
        {
            InputSystemTouchPhase.Began => LegacyTouchPhase.Began,
            InputSystemTouchPhase.Moved => LegacyTouchPhase.Moved,
            InputSystemTouchPhase.Stationary => LegacyTouchPhase.Stationary,
            InputSystemTouchPhase.Ended => LegacyTouchPhase.Ended,
            InputSystemTouchPhase.Canceled => LegacyTouchPhase.Canceled,
            _ => LegacyTouchPhase.Canceled
        };

        return new Touch
        {
            fingerId = enhancedTouch.finger.index,
            position = enhancedTouch.screenPosition,
            deltaPosition = legacyPhase == LegacyTouchPhase.Began ? Vector2.zero : enhancedTouch.delta,
            deltaTime = Time.unscaledDeltaTime,
            tapCount = enhancedTouch.tapCount,
            phase = legacyPhase
        };
    }

    private static void SimulateMouseAsTouch()
    {
        if (currentMouse == null) return;

        const int mouseFingerId = 0;
        var phase = LegacyTouchPhase.Canceled;
        bool addToList = false;

        if (currentMouse.leftButton.wasPressedThisFrame)
        {
            phase = LegacyTouchPhase.Began;
            addToList = true;
        }
        else if (currentMouse.leftButton.wasReleasedThisFrame)
        {
            phase = LegacyTouchPhase.Ended;
            addToList = true;
        }
        else if (currentMouse.leftButton.isPressed)
        {
            phase = currentMouse.delta.ReadValue().sqrMagnitude < 0.1f ? LegacyTouchPhase.Stationary : LegacyTouchPhase.Moved;
            addToList = true;
        }

        if (addToList)
        {
            cachedTouches.Add(new Touch
            {
                fingerId = mouseFingerId,
                position = currentMouse.position.ReadValue(),
                deltaPosition = phase == LegacyTouchPhase.Began ? Vector2.zero : currentMouse.delta.ReadValue(),
                deltaTime = Time.unscaledDeltaTime,
                tapCount = 1,
                phase = phase
            });
        }
    }

    #endregion

    #region 유틸리티 및 헬퍼 클래스

    [Conditional("UNITY_EDITOR"), Conditional("DEVELOPMENT_BUILD")]
    private static void LogInfo(string message)
    {
        if (enableDebugLogs) Debug.Log($"[Input(Legacy Input Wrapper)] {message}");
    }

    [Conditional("UNITY_EDITOR"), Conditional("DEVELOPMENT_BUILD")]
    private static void LogError(string message)
    {
        if (enableDebugLogs) Debug.LogError($"[Input(Legacy Input Wrapper)] {message}");
    }

    public static void SetDebugLogging(bool enabled) => enableDebugLogs = enabled;

    #endregion
}

[참고]

강제로 Wrapping 하지 않고, 필요한 부분만 하고싶다면,

위 Input.cs를 NewInput.cs로 클래스/파일 명을 변경하고
적용하고 싶은 스크립트 상단에 using Input = NewInput; 을 써서 해당 스크립트만 부분적으로 적용해도 될 것 같다.

[링크] 5. 릴툰 쉐이더의 수치와 기능에 대해 알아보자!

blueasa — Fri, 18 Jul 2025 10:59:28 +0900

[링크] https://www.postype.com/@fail-blanc/post/17808791

5. 릴툰 쉐이더의 수치와 기능에 대해 알아보자!: 잡동사니

VRChat에서 사용되는 쉐이더에는 여러 종류가 있습니다… UTS라고 불리는 유니티 쨩 툰 쉐이더도 있고, poiyomi toon shader도 있습니다. 하지만 가장 대중적으로 많이 사용되는 건 누가 뭐래도 lilToon이

www.postype.com

[github] liltoon shader

blueasa — Fri, 18 Jul 2025 10:58:24 +0900

[링크] https://github.com/lilxyzw/lilToon

GitHub - lilxyzw/lilToon: Feature-rich shaders for avatars

Feature-rich shaders for avatars. Contribute to lilxyzw/lilToon development by creating an account on GitHub.

github.com

[링크] [Unity] New Input System

blueasa — Tue, 15 Jul 2025 11:07:41 +0900

[링크]

[Unity] New Input System #1 | 세팅하기

[Unity] New Input System #1 | 세팅하기

/* 수업 들으며 했던 내용들을 실습해보며 정리한 글입니다. 잘못된 부분이 있다면 말씀해주세요. */ 게임은 특정 플랫폼 하나만을 겨냥하고 개발하는 경우는 거의 없다. 스케일이 커지게 되면 PC

daekyoulibrary.tistory.com

[Unity] New Input System #2 | 키 입력을 스크립트에 전달하여 처리하기

[Unity] New Input System #2 | 키 입력을 스크립트에 전달하여 처리하기

저번 글에서 기본적인 셋팅을 끝냈었다. 이번 글에서는 입력값을 스크립트(script)에 전달하는 방식 중 2가지 정도를 사용하여 로직을 제어하는 걸 해보고자 한다. Player 게임 오브젝트에 Player Input

daekyoulibrary.tistory.com

[링크] Unity New Input System(PlayerInput 사용방식)

blueasa — Mon, 14 Jul 2025 18:44:44 +0900

[링크] https://gamecoke.tistory.com/entry/Unity-New-Input-System

Unity New Input System

New Input System은 기존의 Input Manager의 문제점인플랫폼 간의 키 연동 문제를 개선하기 위해 나온 툴입니다. 또한, 위 사진처럼 키 매핑을 보기 쉽게 만들어서 개발자가 한눈에 어떤 키가 있는지 파

gamecoke.tistory.com