1.4MB로 3D 게임 하나를 담을 수 있다고? AI가 코드로 모델과 텍스처를 생성하는 방법

1.4MB로 3D 게임 하나를 담을 수 있다고? AI가 코드로 모델과 텍스처를 생성하는 방법

작가 노트: Saltline은 지오메트리, 텍스처, 사운드의 생성 규칙을 코드로 기술하기 때문에 배포 용량이 아주 작아요. 다만 그 일부 작업은 플레이어 기기의 런타임 계산으로 넘어갔어요.

Saltline은 약 1.4MB밖에 되지 않아요. 이유는 단일 HTML 파일 안에 모델, 텍스처, 사운드를 생성하는 규칙을 담아 두었기 때문이에요. 미리 만들어 둔 모델 파일이나 텍스처, 음향 효과를 저장한 게 아니죠. 브라우저에서 파일을 열면 JavaScript와 셰이더가 로컬에서 비 내리는 밤의 항구, 컨테이너, 드론을 실시간으로 만들어 냅니다. 절차적 생성은 게임 리소스의 표현 방식과 전달 방식을 바꿨어요. 다운로드량은 크게 줄어드는 대신, CPU가 지오메트리를 만들고 GPU가 픽셀을 계산하는 작업량은 그만큼 늘어납니다. 파일 크기, 런타임 메모리, GPU 부하는 각각 따로 계산해야 하는 비용이에요.

아래에서는 먼저 이 1.4MB 파일의 구성을 하나씩 뜯어볼게요. 이어서 전통적인 게임 에셋 제작 방식과 비교하고, 컨테이너, 금속 재질, 빗물이라는 세 가지 예시로 절차적 지오메트리, 절차적 텍스처, 셰이더, 절차적 음향 효과가 각각 어떻게 작동하는지 설명할게요. 그다음 작은 용량 뒤에 숨은 런타임 비용을 분석하고, 마지막으로 실행 가능한 코드를 하나 보여 드릴게요. API를 통해 대규모 언어 모델이 같은 유형의 절차적 장면을 생성하도록 하는 방법을 시연할 거예요.

ai-procedural-3d-game-1-4mb-code-generated-models-textures-ko-image-0

Table of Contents

To Know: 절차적 3D 게임 용어 준비

용어 설명
절차적 지오메트리 매개변수와 규칙에 따라 정점과 모델 형상을 만들어요. 예를 들어 가로·세로·높이 값으로 상자 하나를 생성하는 식이에요
절차적 텍스처 수학 함수(노이즈 등)를 통해 표면의 색상과 패턴을 계산해요
셰이더(Shader) GPU에서 실행되는 작은 프로그램으로, 각 정점의 위치와 각 픽셀의 색상을 결정해요
노이즈 함수 Perlin, Simplex 같은 알고리즘으로 자연스럽고 불규칙한 무작위 패턴을 만들어낼 수 있어요
인스턴싱 렌더링 한 번의 드로우 콜로 수많은 유사 오브젝트를 그리는 기법이에요. Three.js에서는 InstancedMesh에 해당해요
WebGL 브라우저가 제공하는 GPU 그래픽 인터페이스로, 웹 페이지에서 3D 화면을 렌더링할 수 있게 해줘요
Three.js JavaScript 기반의 웹 3D 그래픽 라이브러리로, 장면(scene), 카메라, 재질 같은 개념을 감싸 구현했어요
HTML 웹 페이지의 콘텐츠와 코드를 구성하는 파일 형식이에요. Saltline의 모든 핵심 코드는 하나의 HTML 파일 안에 들어 있어요
배포 용량 플레이어가 다운로드해야 하는 파일 데이터의 양이에요
실행 메모리 프로그램이 실행될 때 점유하는 메모리로, 런타임에 생성되는 지오메트리와 텍스처까지 포함해요
GPU 부하 그래픽 프로세서가 매 프레임마다 완료해야 하는 계산량이에요
토큰(Token) 대규모 언어 모델이 텍스트를 처리하는 기본 단위이자 API 과금 단위이기도 해요

1 1.4MB HTML 파일에는 무엇이 들어있나: Saltline 단일 파일 아키텍처

1.1 Saltline은 어떤 AI 생성 3D 게임인가

2026년 11월 9일, Anthropic 엔지니어 Felix Rieseberg는 Claude Fable 5.2 프로그래밍 실험을 공개했어요. 하나의 프롬프트로 모델에게 시각 효과가 최대한 AAA 게임에 가까운 소규모 1인칭 슈팅 게임을 만들도록 요청했고, 그 과정에서 사람의 피드백은 전혀 제공하지 않았죠. 그 결과물이 바로 Saltline이에요.

게임은 비 오는 밤의 컨테이너 항구를 배경으로 하며, 플레이어는 세 개의 신호 중계소를 폐쇄한 뒤 철수해야 해요. 적은 공중 순찰 드론과 지상 기계 사냥견이에요. 1인칭 이동, 사격, 상호작용, 임무 목표를 지원하고, 빗물과 조명, 환경 음향, 무기 효과를 갖추고 있으며 그래픽 설정도 제공해요. 싱글 플레이, 단일 레벨의 플레이 가능한 프로토타입이고, 여기서 “3A”는 실험 목표이자 시각적 비유일 뿐이에요. 중국 내 소셜 플랫폼에서 퍼진 “几猫·국산 3A 대작”은 Saltline의 중국어 버전 혹은 재포장 버전이며, 그 이름은 확산 과정에서 붙은 것이에요.

개발자가 직접 밝힌 데이터는 다음과 같으며, 모두 본인이 X에 공개한 추정치로 제3자 감사를 거치지 않았어요:

  • 개발 시간 약 8시간
  • API 가격 기준 추정 비용 약 550달러
  • 입력 토큰 약 4억 4,500만 개, 그중 상당량이 캐시를 사용
  • 출력 토큰 약 270만 개

입력 토큰이 대량으로 캐시에 적중했기 때문에 이 비용은 일반 입력 단가에 총량을 곱하는 식으로 간단히 재계산할 수 없고, 구체적인 청구서 구조도 공개되지 않았어요. 이 550달러는 일회성 생성 비용이며, 플레이어가 브라우저에서 게임을 즐길 때는 모델을 다시 호출하지 않아요.

1.2 index.html의 구성: Three.js, 생성 코드, 외부 폰트

GitHub 미러 저장소는 정확한 데이터를 제공해요. 핵심 파일인 index.html은 1,425,707바이트, 약 1.43MB(1.36MiB)예요. 이 파일의 구성은 크게 네 부분으로 나눌 수 있어요.

  1. Three.js 실행 코드: 3D 라이브러리 전체가 HTML 안에 패키징되어 있으며, 씬, 카메라, 머티리얼, WebGL 렌더링을 담당해요.
  2. 씬 및 에셋 생성 코드: 지오메트리, 텍스처, 머티리얼은 JavaScript 함수와 셰이더로 만들어져요.
  3. 프로그래매틱 오디오 코드: 사운드 역시 코드로 합성되며, 저장소에는 별도의 오디오 파일이 없어요.
  4. 게임 로직: 입력 제어, 적의 행동, 퀘스트 흐름이에요.

저장소에는 독립된 이미지, 동영상, 오디오 파일이 없어요. 유일하게 명확한 외부 의존성은 Google Fonts 폰트예요. 개발자는 11월 10일에 보충 설명을 남겼는데, 게임의 모든 콘텐츠는 코드이며 텍스처와 모델도 함수라는 점을 밝혔어요.

1.3 브라우저에서 Saltline을 열면 벌어지는 일

실행 흐름은 명확한 로컬 파이프라인이에요. 브라우저가 HTML을 읽음 → JavaScript 실행 시작 → Three.js와 WebGL 렌더링 환경 초기화 → 코드가 씬 지오메트리, 머티리얼, 텍스처, 사운드를 생성 → GPU가 프레임마다 화면을 렌더링 → 플레이어가 키보드와 마우스로 조작하면 게임 로직이 계속 업데이트되는 구조예요.

이 파이프라인에서 “에셋 생성” 단계는 플레이어의 기기에서 일어나요. Saltline 공식 체험 페이지에서도 안내하고 있어요. 페이지 초기화에 시간이 꽤 걸릴 수 있고, 기기 성능이 시작 속도에 영향을 준다는 점이에요. 대기 화면에서 멈춰 있다면 WebGL 2와 브라우저 하드웨어 가속을 확인하고, 버벅인다면 Low 화질로 바꾸면 돼요. 이런 안내 자체가 런타임 연산의 비중이 얼마나 큰지를 보여줘요.

ai-procedural-3d-game-1-4mb-code-generated-models-textures-ko-image-1

2 전통 게임은 모델, 텍스처, 사운드를 어떻게 만들까

2.1 전통 3D 게임의 세 가지 핵심 에셋

전통적인 3D 게임의 화면과 사운드는 대부분 미리 제작된 에셋 파일에서 나옵니다.

  • 모델 파일: 아티스트가 모델링 소프트웨어에서 제작하고, 정점, 면, UV 좌표 등의 데이터로 저장합니다.
  • 텍스처 맵: 디퓨즈, 노멀, 러프니스, 메탈니스 등 여러 장의 이미지를 모델 표면에 입혀 디테일을 더합니다.
  • 사운드 파일: 녹음하거나 합성해 내보낸 오디오로, 특정 이벤트가 발생할 때 재생됩니다.

이 에셋들은 제작, 최적화, 압축, 패키징 과정을 거쳐 게임과 함께 배포됩니다. 엔진은 실행 중에 이들을 불러오며, 주요 작업은 “읽고 표시하는” 것입니다.

2.2 전통 에셋이 큰 공간을 차지하는 이유

미리 만든 에셋은 결과를 저장합니다. 고해상도 텍스처는 모든 픽셀의 색상 값을 기록하고, 정교한 모델은 모든 정점의 위치를 기록하며, 음향 효과는 모든 샘플 지점을 기록합니다. 장면이 풍부해지고 해상도가 높아질수록 기록해야 할 결과 데이터가 늘어나고, 용량도 그에 비례해 커집니다.

프로그래밍 방식은 과정을 저장합니다. 노이즈 함수는 수십 줄의 코드에 불과하지만 어떤 해상도에서도 녹 패턴을 만들어낼 수 있고, 매개변수화된 박스 함수는 원하는 크기의 컨테이너를 생성할 수 있습니다. 바로 이것이 1.4MB로 완전한 항구 장면을 담아낼 수 있는 근본 이유입니다.

비교 항목 전통적인 미리 만든 에셋 절차적 생성 에셋
파일에 저장되는 내용 최종 결과 데이터(정점, 픽셀, 샘플) 생성 규칙(함수, 매개변수, 셰이더)
제작 방식 아티스트가 전문 도구에서 하나씩 제작 코드와 매개변수를 작성하고 실행 시 계산
배포 용량 에셋 수와 정밀도에 따라 증가 주로 코드 양에 의해 결정되며 보통 작음
실행 시 주요 작업 로드, 디코드, 표시 지오메트리 구성, 텍스처 계산, 사운드 합성
디테일 제어력 아티스트가 세부 요소를 정밀하게 제어 가능 알고리즘의 표현력에 의존하며 튜닝 비용이 높음
대표적인 적용 대상 캐릭터, 핵심 아이템, 사실적인 장면 반복 구조, 자연 표면, 날씨 효과

3 AI가 코드로 게임 애셋을 생성하는 방법: 네 가지 절차적 기술

절차적 생성은 게임 업계에서 오랫동안 사용해 온 기술이에요. 《마인크래프트》의 지형, 수많은 로그라이크 게임의 레벨 모두 이 기술에 의존하고 있죠. Saltline의 새로움은 AI 모델이 하나의 연속된 생성 과정에서 기하, 텍스처, 셰이더, 오디오, 게임 로직의 모든 코드를 동시에 작성해, 모델링, 재질, 음향 효과, 프로그래밍 사이의 인력 인수인계를 줄였다는 점이에요.

계층 생성 대상 기술적 접근 Saltline의 대응 예시
기하 생성 모델 형상 정점, 면, 매개변수적 기하 컨테이너, 창고, 부두 구조
재질 생성 표면 속성 색상, 거칠기, 금속도 매개변수 컨테이너의 금속 외피
텍스처 생성 표면 디테일 노이즈, 프랙털, 보로노이 녹, 얼룩, 마모
환경 생성 장면 배치 규칙, 난수, 공간 관계 컨테이너 적재 배치
애니메이션 생성 물체 운동 수학 함수, 상태 변화 드론 순찰, 빗방울 낙하
사운드 생성 음향 효과 오실레이터, 필터, 노이즈 빗소리, 총소리, 환경음

3.1 절차적 지오메트리: 파라미터로 컨테이너 만들기

컨테이너는 본질적으로 골판 측판을 가진 직육면체예요. 절차적 지오메트리의 방식은 이렇습니다: 길이, 너비, 높이 파라미터로 육면체를 생성한 다음, 측면을 따라 사인 함수로 정점을 오프셋해서 골판 강판의 굴곡을 흉내 내는 거예요. Three.js의 BufferGeometry는 정점 배열을 직접 쓸 수 있게 해주고, BoxGeometry는 미리 만들어진 매개변수화된 상자를 제공해요.

항구에는 수백, 수천 개의 컨테이너가 있는데, 이들은 동일한 지오메트리 데이터를 공유해요. 이럴 때 InstancedMesh로 인스턴스 렌더링을 하면, 각 인스턴스마다 변환 행렬(위치, 회전, 스케일)과 색상 하나만 저장하고 한 번의 드로우 콜로 컨테이너 야적장 전체를 그릴 수 있어요.

3.2 절차적 텍스처: 노이즈 함수로 녹 얼룩 그리기

절차적 텍스처는 알고리즘으로 텍스처 데이터를 생성해요. 자주 쓰이는 알고리즘으로는 Perlin Noise, Simplex Noise, Voronoi, 프랙탈 노이즈가 있어요: 서로 다른 주파수의 노이즈를 여러 겹 겹치면 자연스러운 녹 얼룩 분포를 얻을 수 있고, Voronoi로는 페인트가 벗겨진 덩어리 경계를 만들 수 있어요.

Three.js에서 이런 텍스처는 보통 초기화 단계에서 한 번 계산해서 DataTexture(픽셀 배열을 직접 채움)나 CanvasTexture(Canvas 2D로 그림)에 기록한 다음, 일반 텍스처처럼 머티리얼에 넘겨서 사용해요. 텍스처는 한 번 생성되면 VRAM에 상주하므로, 런타임의 추가 오버헤드는 주로 이 VRAM 점유예요.

3.3 Shader: GPU에서 픽셀 단위로 금속과 빗물 계산하기

Shader는 GPU에서 실행되며, 좌표·시간·조명 같은 입력을 바탕으로 각 픽셀의 색상을 실시간으로 계산합니다. 프로시저럴 텍스처와의 차이는 계산이 일어나는 시점에 있어요: 프로시저럴 텍스처는 미리 이미지 한 장을 만들어 둘 수 있고, Shader는 매 프레임 그 자리에서 계산하므로 완전한 이미지를 생성할 필요가 없습니다.

비 내리는 밤의 항구는 Shader가 빛을 발하는 대표적인 무대예요. 젖은 금속 표면의 반사, 지면에 고인 물이 시간에 따라 일렁이는 파동, 빗줄기가 떨어지는 모습 모두 시간을 입력으로 하는 함수로 작성해 매 프레임 다시 계산할 수 있습니다. Three.js의 ShaderMaterial을 사용하면 버텍스 셰이더와 프래그먼트 셰이더를 직접 작성해 이런 효과를 구현할 수 있어요. 두 방식의 트레이드오프는 아주 명확합니다. 미리 생성한 텍스처는 메모리를 차지하는 대신 연산을 아껴주고, Shader 실시간 계산은 메모리를 아끼는 대신 연산을 많이 씁니다.

3.4 프로시저럴 오디오 효과: 오실레이터와 필터로 빗소리 합성하기

브라우저의 Web Audio API는 오실레이터, 노이즈 버퍼, 필터 노드를 제공합니다. 백색 소음에 로우패스 필터를 적용하면 빗소리에 가까워지고, 짧은 노이즈 폭발에 빠르게 감쇠하는 볼륨 엔벨로프를 더하면 총소리가 되며, 저주파 오실레이터로 음높이를 변조하면 드론의 웅웅거림을 흉내 낼 수 있어요. Saltline 저장소에는 오디오 파일이 전혀 없고, 소리는 전부 이런 코드로 실시간 합성됩니다.

ai-procedural-3d-game-1-4mb-code-generated-models-textures-ko-image-2

4 파일 크기가 작아졌다고 실행도 가벼워질까요: 절차적 생성의 비용 분석

4.1 배포 용량, 실행 메모리, GPU 부하를 구분하기

3D 게임의 “무게”를 가늠하려면 최소한 세 가지 차원을 살펴봐야 해요:

  1. 배포 용량: 플레이어가 다운로드하는 데이터의 양이에요. Saltline은 이 항목에서 확실한 강점을 가져요;
  2. 실행 메모리: 런타임에 생성되는 버텍스 버퍼, 텍스처, 오디오 버퍼는 모두 메모리와 VRAM을 차지해요. 1.4MB짜리 프로그램 하나가 런타임에 수백 MB의 데이터를 만들어낼 수도 있죠;
  3. 계산 부하: CPU와 GPU가 매 프레임 처리해야 하는 작업량이에요. 복잡한 셰이더는 이 항목을 곧바로 끌어올려요.

반대로, 용량이 큰 게임도 압축, 청크 단위 로딩, 리소스 스트리밍을 활용하면 실행 효율을 충분히 좋게 만들 수 있어요. 파일 크기만으로 기술 방식의 우열을 판단하면 편협한 결론에 빠지게 돼요.

4.2 절차적 생성은 비용을 어디로 옮겼을까요

기술 방식 줄어들 수 있는 비용 늘어날 수 있는 비용
절차적 모델 모델 다운로드와 저장 CPU 지오메트리 생성 시간
Shader 텍스처 이미지 파일과 텍스처 전송 GPU의 프레임별 실시간 계산
절차적 텍스처(사전 생성) 이미지 파일 다운로드 초기화 계산과 VRAM 점유
인스턴싱 렌더링 중복된 드로우 콜 씬 관리와 인스턴스 데이터 유지
동적 씬 생성 사전 제작된 에셋 수 초기화와 런타임 계산
절차적 사운드 오디오 파일 저장 실시간 오디오 합성 오버헤드

Saltline의 초기화가 느리고 Low 화질 옵션을 제공해야 하는 이유가 바로 이 표에 담겨 있어요. 다운로드 단계에서 아낀 작업을 시작 단계와 매 프레임 렌더링에서 다시 지불하는 셈이죠.

4.3 Shader, 인스턴싱 렌더링, 동적 지오메트리의 트레이드오프

세 기술은 각기 다른 문제를 해결하기 때문에 함께 조합할수록 효과가 좋아요:

  • 인스턴싱 렌더링은 CPU가 GPU로 드로우 콜을 보내는 횟수를 줄여줘요. 컨테이너 야적장, 가로등, 빗방울 파티클처럼 대량의 반복 물체에 가장 잘 맞아요.
  • Shader는 세부 계산을 GPU로 넘겨요. 시간에 따라 변하는 효과(빗물, 고인 물, 깜빡이는 조명)에 적합하지만, 프래그먼트 셰이더가 복잡할수록 고해상도에서 GPU 부하가 커지는 대가를 치러요.
  • 동적 지오메트리는 파라미터에 따라 변해야 하거나 수가 제한된 구조물에 어울려요. 생성 비용은 초기화 단계에 집중되고, 생성이 끝나면 그냥 평범한 메시가 돼요.

실무에서 흔히 쓰는 최적화 방향은 이래요. 미리 계산할 수 있는 건 초기화 단계에서 한 번 계산해 캐시해 두고, 시간에 따라 반드시 변해야 하는 것만 매 프레임 Shader에 넣는 거죠.

4.4 Saltline 방식과 클라우드 게임, AI 월드 모델의 차이

“AI로 게임 만들기”는 현재 최소 세 가지 기술 경로로 나뉘며, Saltline은 그중 첫 번째 방식에 속해요.

비교 항목 로컬 웹 게임 클라우드 게임 AI 월드 모델
대표 사례 Saltline GeForce NOW, Pixel Streaming Genie 3, Muse/WHAMM, Oasis
AI 참여 단계 개발 단계에서 코드 생성 일반적으로 관련 없음 실행 시 프레임 단위로 화면 생성
화면 생성 로컬 GPU 렌더링 클라우드 GPU 렌더링 후 비디오 스트림 전송 모델이 실시간으로 예측 생성
네트워크 요구 사항 최초 로딩 후 오프라인 가능 지속적인 인터넷 연결 일반적으로 지속적인 인터넷 연결 필요
비용 발생 시점 일회성 개발 비용, 이후 플레이어 기기에서 부담 플레이할 때마다 서버 비용 발생 플레이할 때마다 추론 비용 발생
주요 제약 브라우저와 로컬 하드웨어 네트워크 지연, 대역폭 일관성, 지연, 제어 가능성

Saltline은 AI 비용을 개발 단계에 집중시켜요. 생성이 끝나면 게임 규칙은 코드로 확정되고, 실행은 모델과 무관해져요. 이 점 덕분에 오프라인 실행이 가능하고, 동시에 플레이어 기기 성능이 경험의 상한을 결정한다는 것도 이 구조에서 비롯돼요.

5 프로시저럴 3D 게임 빠르게 시작하기: API로 대규모 언어 모델이 장면 코드를 생성하게 만들기

5.1 아주 간단한 예: 한 번의 호출로 프로시저럴 장면 생성

아래 스크립트는 OpenAI 호환 인터페이스를 통해 대규모 언어 모델을 호출하고, 프로시저럴 컨테이너, 노이즈 녹, 셰이더 비가 포함된 단일 HTML 파일을 출력하게 해요. 모델 이름은 플랫폼 모델 목록에 있는 실제 이름을 기준으로 사용하세요:

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # APIYI 통합 인터페이스, 하나의 키로 여러 모델 호출
)

prompt = """生成一个单文件 HTML,用 Three.js(CDN 引入)实现:
1. 用 InstancedMesh 程序化生成 200 个随机颜色的集装箱堆场;
2. 用 DataTexture + 多层噪声生成锈迹纹理,不使用任何图片文件;
3. 用 ShaderMaterial 实现随时间下落的雨丝;
4. 用 Web Audio API 合成低通滤波白噪声作为雨声。
只输出完整 HTML 代码。"""

resp = client.chat.completions.create(
    model="your-model-name",  # 플랫폼의 실제 모델명으로 교체하세요
    messages=[{"role": "user", "content": prompt}],
)
open("procedural_port.html", "w", encoding="utf-8").write(resp.choices[0].message.content)

실행한 뒤 브라우저에서 procedural_port.html을 열면 결과를 확인할 수 있어요. Saltline은 8시간 동안 수억 토큰을 사용하는 장시간 생성 과정이며, 이 예제는 같은 아이디어의 가장 작은 전체 흐름만 보여줘요.

전체 구현 보기: 프로시저럴 컨테이너, 노이즈 녹, 셰이더 비, 합성 빗소리를 직접 작성한 참고 코드

다음은 모델이 생성한 코드 구조를 비교해 이해하기 쉽도록 정리한 수작업 참고 구현이에요. 3장의 네 가지 기술을 하나의 파일에 담았습니다:

<!DOCTYPE html>
<html><head><meta charset="utf-8"><style>body{margin:0;background:#000}</style></head>
<body>
<script type="module">
import * as THREE from 'https://unpkg.com/[email protected]/build/three.module.js';

const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setSize(innerWidth, innerHeight);
document.body.appendChild(renderer.domElement);
const scene = new THREE.Scene();
scene.fog = new THREE.Fog(0x0a0f18, 20, 120);
const camera = new THREE.PerspectiveCamera(60, innerWidth / innerHeight, 0.1, 500);
camera.position.set(0, 12, 40);
camera.lookAt(0, 0, 0);

// 1. 절차적 텍스처: 다중 레이어 밸류 노이즈로 녹(부식)을 만들어 DataTexture에 기록
const size = 256, data = new Uint8Array(size * size * 4);
const rand = (x, y) => (Math.sin(x * 127.1 + y * 311.7) * 43758.5453) % 1;
function noise(x, y) {
  const xi = Math.floor(x), yi = Math.floor(y), xf = x - xi, yf = y - yi;
  const a = rand(xi, yi), b = rand(xi + 1, yi), c = rand(xi, yi + 1), d = rand(xi + 1, yi + 1);
  const u = xf * xf * (3 - 2 * xf), v = yf * yf * (3 - 2 * yf);
  return Math.abs(a + (b - a) * u + (c - a) * v + (a - b - c + d) * u * v);
}
for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
  let n = 0, amp = 0.5, f = 4 / size;
  for (let o = 0; o < 4; o++) { n += noise(x * f, y * f) * amp; amp *= 0.5; f *= 2; }
  const rust = Math.min(1, n * 1.4), i = (y * size + x) * 4;
  data[i] = 120 + rust * 100; data[i + 1] = 110 - rust * 40; data[i + 2] = 100 - rust * 60; data[i + 3] = 255;
}
const rustTex = new THREE.DataTexture(data, size, size, THREE.RGBAFormat);
rustTex.wrapS = rustTex.wrapT = THREE.RepeatWrapping;
rustTex.needsUpdate = true;

// 2. 절차적 지오메트리 + 인스턴스 렌더링: 200개의 컨테이너가 하나의 지오메트리를 공유
const box = new THREE.BoxGeometry(6, 2.6, 2.4);
const mat = new THREE.MeshStandardMaterial({ map: rustTex, metalness: 0.6, roughness: 0.5 });
const containers = new THREE.InstancedMesh(box, mat, 200);
const m = new THREE.Matrix4(), color = new THREE.Color();
for (let i = 0; i < 200; i++) {
  const col = i % 10, row = Math.floor(i / 10) % 5, layer = Math.floor(i / 50);
  m.makeTranslation(col * 6.5 - 30, layer * 2.7 + 1.3, row * 3 - 7);
  containers.setMatrixAt(i, m);
  containers.setColorAt(i, color.setHSL(Math.random(), 0.5, 0.45));
}
containers.instanceMatrix.needsUpdate = true;
scene.add(containers);
scene.add(new THREE.HemisphereLight(0x6688aa, 0x111111, 0.6));
const lamp = new THREE.PointLight(0xffaa55, 80, 60);
lamp.position.set(0, 15, 10);
scene.add(lamp);

// 3. 셰이더: 빗줄기 위치를 GPU에서 시간에 따라 계산
const rainCount = 6000, pos = new Float32Array(rainCount * 3);
for (let i = 0; i < rainCount * 3; i++) pos[i] = (Math.random() - 0.5) * 80;
const rainGeo = new THREE.BufferGeometry();
rainGeo.setAttribute('position', new THREE.BufferAttribute(pos, 3));
const rainMat = new THREE.ShaderMaterial({
  uniforms: { uTime: { value: 0 } },
  transparent: true,
  vertexShader: `uniform float uTime;
    void main(){
      vec3 p = position;
      p.y = mod(p.y - uTime * 25.0, 40.0);
      gl_Position = projectionMatrix * modelViewMatrix * vec4(p, 1.0);
      gl_PointSize = 2.0;
    }`,
  fragmentShader: `void main(){ gl_FragColor = vec4(0.6, 0.7, 0.9, 0.5); }`
});
scene.add(new THREE.Points(rainGeo, rainMat));

// 4. 절차적 사운드: 백색 잡음을 로우패스 필터로 걸러 빗소리를 흉내 냄 (페이지 클릭 후 시작)
addEventListener('click', () => {
  const ctx = new AudioContext();
  const buf = ctx.createBuffer(1, ctx.sampleRate * 2, ctx.sampleRate);
  const ch = buf.getChannelData(0);
  for (let i = 0; i < ch.length; i++) ch[i] = Math.random() * 2 - 1;
  const src = ctx.createBufferSource(); src.buffer = buf; src.loop = true;
  const lp = ctx.createBiquadFilter(); lp.type = 'lowpass'; lp.frequency.value = 1200;
  const gain = ctx.createGain(); gain.gain.value = 0.15;
  src.connect(lp).connect(gain).connect(ctx.destination); src.start();
}, { once: true });

const clock = new THREE.Clock();
renderer.setAnimationLoop(() => {
  rainMat.uniforms.uTime.value = clock.getElapsedTime();
  renderer.render(scene, camera);
});
</script>
</body></html>

파일 전체에 이미지 한 장, 모델 파일 하나, 오디오 한 조각도 없습니다. 녹슨 텍스처는 초기화 시 한 번 계산되고(CPU 비용 + VRAM), 빗줄기 위치는 매 프레임 버텍스 셰이더에서 계산되며(GPU 비용), 컨테이너는 한 번의 드로우 콜로 처리됩니다(CPU 호출 오버헤드 감소).

빠른 시작 제안: 절차적 장면 코드를 생성할 때 모델마다 Three.js API 정확도와 셰이더 작성 방식의 차이가 뚜렷합니다. APIYI apiyi.com을 통해 동일한 키로 여러 모델을 전환하며 출력 품질을 나란히 비교해 보세요. 신규 사용자의 무료 테스트 크레딧은 여러 라운드 비교를 마치기에 충분합니다.

5.2 프롬프트를 작성하는 세 가지 실용 팁

프롬프트를 한 줄짜리 비전 선언처럼 쓰기보다 기술 사양서처럼 작성하는 편이 훨씬 효과적입니다:

  • 기술 포인트 지정: InstancedMesh, DataTexture, ShaderMaterial 등 구체적인 API를 명시적으로 요구하세요. 그러면 모델은 외부 리소스가 존재한다고 가정하는 대신 절차적 방식으로 구현합니다.
  • 제약 조건 선언: “이미지, 모델, 오디오 파일을 전혀 사용하지 않음”과 “단일 파일 HTML”을 명시해 Saltline의 제약과 일치시키세요.
  • 성능 등급 요구: 모델이 저/중/고 화질 전환을 제공하도록 요청하세요(예: 빗방울 수 줄이기, 그림자 끄기). 이는 Saltline이 Low 화질을 제공하는 방식에 대응합니다.

5.3 생성 비용 산정 방식

Anthropic이 공식 발표한 Claude Fable 5.2 가격을 기준으로 보면, 입력은 100만 Token당 8달러, 출력은 100만 Token당 40달러, 캐시 읽기는 100만 Token당 0.20달러, 5분 캐시 쓰기는 100만 Token당 10달러예요. 컨텍스트 윈도우는 1M Token, 최대 출력은 128K Token이에요. 5.1절에서처럼 단일 생성이라면 Token 사용량은 보통 수천에서 수만 수준에 불과해요. Saltline처럼 8시간 동안 진행되는 장시간 자율 반복 작업은 기존 코드를 계속 다시 읽게 되므로, 캐시 적중이 만들어내는 가격 차이가 총비용에 크게 영향을 미쳐요. 그래서 긴 작업에서는 프롬프트 캐시를 우선적으로 활용해야 해요.

비용 팁: 장시간 코드 생성 실험을 할 때는 먼저 APIYI apiyi.com에서 소규모 프롬프트로 1회 Token 소비량을 측정한 뒤, 반복 횟수에 맞춰 총예산을 추산해 보세요. 플랫폼은 사용량 기준 과금이라 작게 시작해 크게 검증하는 방식에 잘 맞아요.

6 자주 묻는 질문 FAQ

Q1: 프로그래밍 방식으로 생성된 3D 게임 에셋이란 무엇인가요?

프로그래밍 방식 생성 에셋은 코드와 파라미터로 모델, 텍스처, 사운드의 생성 규칙을 기술하고, 실행 시점에 결과를 계산하는 방식이에요. 파일에는 “어떻게 그릴지”가 저장되고, 전통적인 에셋 파일에는 “그려진 결과”가 저장돼요. Saltline의 컨테이너, 녹슨 자국, 빗소리가 모두 여기에 해당해요.

Q2: 절차적 텍스처와 Shader의 차이는 무엇인가요?

절차적 텍스처는 알고리즘으로 텍스처 데이터를 생성하며, 미리 계산해서 한 장의 이미지로 VRAM에 넣을 수 있어요. Shader는 GPU 위에서 동작하는 프로그램으로, 매 프레임 렌더링 시 픽셀 색상을 직접 계산할 수 있어요. 전자는 메모리를 많이 차지하고 연산은 적게 쓰며, 후자는 그 반대예요. 두 방식은 자주 함께 사용돼요.

Q3: Saltline은 언제 공개됐고, 어떤 모델을 사용했나요?

2026년 11월 9일 Anthropic 엔지니어 Felix Rieseberg가 공개했으며, Claude Fable 5.2를 사용했고 단일 프롬프트에 인간 피드백은 없었어요. 약 8시간, 약 550달러, 약 4억 4500만 입력 Token과 270만 출력 Token은 모두 개발자가 직접 밝힌 추정치예요. 11월 10일 그는 모델과 텍스처가 전부 코드로 생성됐다고 덧붙여 설명했어요.

Q4: 절차적 생성이 가장 적합한 게임 장면은 어떤 것들인가요?

– **대량 반복 구조**: 컨테이너 야드, 건물군, 식생 등은 인스턴싱 렌더링과 함께 쓸 때 효과가 가장 좋아요;
– **자연 표면**: 녹슨 자국, 암석, 나무결처럼 노이즈로 표현하기 좋은 재질;
– **동적 날씨와 특수 효과**: 빗물, 물웅덩이 물결, 조명 깜빡임처럼 시간에 따라 변하는 효과;
– **용량에 민감한 배포 환경**: 웹 미니게임, 인터랙티브 광고, 바로 클릭해서 플레이할 수 있는 프로토타입.

정밀한 예술적 제어가 필요한 주인공이나 핵심 스토리 소품에는 여전히 프리메이드 에셋이 더 적합하며, 상용 프로젝트는 보통 하이브리드 방식을 채택해요.

Q5: API를 통해 대규모 언어 모델이 절차적 3D 장면 코드를 생성하게 하려면 어떻게 하나요?

1. APIYI apiyi.com에서 가입하고 API Key와 무료 테스트 한도를 발급받으세요;
2. 본문 5.1절의 스크립트를 사용하고 base_url을 `https://api.apiyi.com/v1`로 설정하세요;
3. 프롬프트에 Three.js API, 단일 파일, 외부 리소스 없음 등의 제약을 명시하고, 생성 후 브라우저에서 열어 검증하세요.

인터페이스가 OpenAI 형식과 호환되기 때문에 Claude, GPT, Gemini 등 모델을 전환할 때는 model 파라미터만 수정하면 돼요.

Q6: 절차적 생성에는 어떤 알려진 한계가 있나요?

– **런타임 비용**: 초기화 연산, VRAM 점유, 복잡한 Shader의 GPU 부하가 모두 플레이어 기기로 전가돼요. Saltline도 Low 화질 옵션과 긴 초기화 시간이 필요해요;
– **브라우저 제약**: Unity 공식 문서에 따르면 Web 플랫폼은 파일 시스템, 스레드, 메모리에서 제약이 있고 모바일 지원도 제한적이에요;
– **예술적 제어 가능성**: 알고리즘의 표현력에는 한계가 있어 사실적인 캐릭터와 정교한 소품은 순수 코드로 생성하기 어려워요;
– **엔지니어링 성숙도**: AI는 플레이 가능한 프로토타입을 빠르게 만들어내지만, 상용 게임에 필요한 장기 최적화, 테스트, 콘텐츠 확장에는 여전히 많은 엔지니어링 투입이 필요해요.

7 1.4MB 3D 게임과 절차적 생성 핵심 요점

  • 크기의 출처: Saltline은 약 1.4MB이며, 저장하는 것은 생성 규칙이고 이미지, 모델, 오디오 파일은 없습니다.
  • 네 가지 기술: 절차적 기하학, 절차적 텍스처, 셰이더, 절차적 음향이 각각 한 계층을 담당하며 분업이 명확합니다.
  • 비용 이전: 다운로드 크기는 줄어들지만, CPU 빌드, VRAM 점유, GPU 프레임당 연산은 그만큼 늘어납니다.
  • 평가 기준: 배포 크기, 초기화 시간, 런타임 메모리, 프레임당 GPU 비용을 함께 살펴봐야 합니다.
  • AI의 역할: AI는 생성 코드를 작성하고, 절차적 기술 자체는 이미 게임 개발에 폭넓게 활용되고 있습니다.
  • 시작하는 방법: APIYI apiyi.com을 통해 하나의 Key로 여러 모델이 생성한 Three.js 장면 코드를 비교할 수 있습니다.

8 정리: 게임 개발은 자산 제작에서 자산 생성 규칙 작성으로 이동하고 있어요

Saltline은 자원을 표현하는 방식의 변화를 보여줍니다. 전통적인 게임은 “만들어진 자산”을 전달하고, 절차적 게임은 “자산을 생성하는 규칙”을 전달합니다. AI 코드 생성은 이 경로의 진입 장벽을 크게 낮춰주며, 하나의 모델이 한 번의 지속적인 생성 과정에서 기하학, 텍스처, 셰이더, 오디오, 게임 로직을 동시에 작성할 수 있어 여러 직군 간의 인수인계를 생략할 수 있습니다.

이 경로에는 분명한 적용 경계가 있습니다. 배포 크기와 배포 편의성에서는 뚜렷한 우위를 지니지만, 동시에 연산 압력을 플레이어의 기기로 옮깁니다. 반복 구조, 자연스러운 표면, 동적 효과에는 강점을 발휘하지만, 정밀한 예술 자산은 여전히 전통적인 생산 방식에 의존합니다. 전통적인 자산 생산과 절차적 생산은 오랫동안 상호 보완 관계를 유지할 것이며, Saltline의 가치는 작은 크기의 프로그램으로도 풍부한 상호작용 장면을 구축할 수 있음을 증명했다는 점에 있습니다.

이 경로를 직접 검증하고 싶다면 5.1절의 스크립트부터 시작해 보세요. APIYI apiyi.com을 통해 서로 다른 모델을 호출해 절차적 장면을 생성하고, 각 모델이 Three.js와 셰이더를 얼마나 잘 이해하는지 비교해 보시길 권합니다.

📚 참고 자료

  1. Saltline 코드 미러와 README: 단일 파일 구조, 바이트 수 및 개발자 데이터 소유권
  2. 링크: github.com/realcodebear/saltline-fable-5.2
  3. 설명: index.html의 절차적 생성 코드를 직접 확인할 수 있어요

  4. Saltline 독립 체험 페이지: 온라인 시연 및 초기화, 화질 설정 안내

  5. 링크: saltline.games
  6. 설명: 중국어 버전은 saltline.games/zh에 있어요

  7. 几猫 중국어 버전 GitHub 저장소: 국내 유포 버전의 아카이브

  8. 링크: github.com/Megasu/jimao-3a-game
  9. 설명: 오프라인 실행 안내와 파일 크기 데이터를 제공해요

  10. Claude Fable 5.2 모델 사양과 가격: Anthropic 공식 문서

  11. 링크: platform.claude.com/docs/en/models/fable-5-2/overview
  12. 설명: 입력, 출력, 캐시 가격 및 컨텍스트 사양

  13. Three.js 공식 문서와 예제: InstancedMesh, ShaderMaterial, BufferGeometry, DataTexture

  14. 링크: threejs.org/docs 와 threejs.org/examples
  15. 설명: 본문 코드에서 사용하는 API의 권위 있는 설명

  16. MDN WebGL API: 브라우저 GPU 렌더링 인터페이스

  17. 링크: developer.mozilla.org/en-US/docs/Web/API/WebGL_API
  18. 설명: Three.js 저수준 렌더링 메커니즘 이해

  19. Unity WebGL 기술 개요: 웹 플랫폼의 스레드, 메모리 및 모바일 제한

  20. 링크: docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html
  21. 설명: 브라우저 게임 엔지니어링 경계를 평가하기 위한 참고 자료

작성자: APIYI 기술 팀
기술 교류: APIYI apiyi.com 홈페이지에서 저희에게 연락해 주세요. 더 많은 연동 자료는 docs.apiyi.com 문서 센터에서 확인할 수 있어요

관련 글

Similar Posts