Catatan penulis: Saltline mendeskripsikan aturan pembangkitan geometri, tekstur, dan suara lewat kode, sehingga ukuran distribusinya sangat kecil, tetapi sebagian beban kerja dialihkan ke komputasi runtime di perangkat pemain.
Saltline hanya berukuran sekitar 1.4MB karena file HTML tunggalnya menyimpan aturan untuk menghasilkan model, tekstur, dan suara, bukan file model, tekstur, dan efek suara yang sudah jadi. Setelah file dibuka di browser, JavaScript dan shader membangun pelabuhan malam hujan, kontainer, dan drone secara real-time di perangkat lokal. Pembuatan prosedural mengubah cara aset game direpresentasikan dan dikirim: ukuran unduhan turun drastis, sementara beban kerja CPU untuk membangun geometri dan GPU untuk menghitung piksel justru meningkat. Ukuran file, memori runtime, dan beban GPU adalah tiga hal yang dihitung secara terpisah.
Berikut ini kita bongkar dulu komposisi file 1.4MB tersebut, lalu membandingkannya dengan cara produksi aset game tradisional, kemudian memakai tiga contoh—kontainer, material logam, dan air hujan—untuk menjelaskan bagaimana geometri prosedural, tekstur prosedural, shader, dan efek suara prosedural masing-masing bekerja, setelah itu menganalisis biaya runtime di balik ukuran kecil tersebut, dan terakhir menyajikan sepotong kode yang bisa dijalankan untuk mendemonstrasikan cara meminta Model Bahasa Besar menghasilkan pemandangan prosedural sejenis lewat API.

Perlu Diketahui: Persiapan Terminologi Gaya Bahasa untuk Game 3D Prosedural
| Istilah | Penjelasan |
|---|---|
| Geometri Prosedural | Membuat vertex dan bentuk model berdasarkan parameter dan aturan, misalnya membuat bentuk kotak dari panjang, lebar, dan tinggi |
| Tekstur Prosedural | Menghitung warna dan pola permukaan melalui fungsi matematika (seperti noise) |
| Shader | Program kecil yang dijalankan di GPU, menentukan posisi setiap vertex dan warna setiap piksel |
| Fungsi Noise | Algoritma seperti Perlin, Simplex, dan sebagainya yang dapat menghasilkan pola acak yang alami dan tidak beraturan |
| Rendering Terinstansiasi | Menggambar banyak objek serupa dalam satu panggilan gambar; di Three.js disebut InstancedMesh |
| WebGL | Antarmuka grafis GPU yang disediakan browser, memungkinkan halaman web merender gambar 3D |
| Three.js | Pustaka grafis 3D web berbasis JavaScript yang membungkus konsep seperti scene, kamera, dan material |
| HTML | Format berkas untuk mengorganisasi konten halaman web dan kode; seluruh kode inti Saltline berada dalam satu berkas HTML |
| Ukuran Distribusi | Jumlah data berkas yang perlu diunduh pemain |
| Memori Runtime | Memori yang digunakan saat program berjalan, termasuk geometri dan tekstur yang dihasilkan saat runtime |
| Beban GPU | Jumlah komputasi yang harus diselesaikan pemroses grafis setiap frame |
| Token | Unit dasar pemrosesan teks oleh Model Bahasa Besar, sekaligus unit penagihan API |
1 Apa yang terkandung dalam file HTML 1.4MB: arsitektur satu file Saltline
1.1 Seperti apa game 3D hasil AI bernama Saltline
Pada 9 November 2026, engineer Anthropic bernama Felix Rieseberg mempublikasikan sebuah eksperimen pemrograman Claude Fable 5.2: dengan satu petunjuk, ia meminta model membuat game first-person shooter skala kecil dengan tampilan visual yang sedapat mungkin mendekati game AAA, tanpa memberikan umpan balik manusia selama prosesnya. Hasilnya adalah Saltline.
Game ini berlatar di pelabuhan kontainer pada malam hujan; pemain harus mematikan tiga stasiun relay sinyal lalu mengevakuasi diri, dengan musuh berupa drone patroli udara dan anjing mekanis darat. Game ini mendukung gerakan orang pertama, menembak, interaksi, dan tujuan misi, dilengkapi hujan, pencahayaan, efek suara lingkungan, dan efek senjata, serta menyediakan pengaturan kualitas grafis. Ini adalah prototipe yang dapat dimainkan, single player, dan satu level; “3A” adalah target eksperimen dan analogi visual. Versi yang beredar di platform sosial di Tiongkok dengan nama “几猫·karya besar 3A domestik” adalah versi Mandarin atau versi yang dikemas ulang dari Saltline, dan nama itu muncul dari proses penyebarannya.
Data yang disampaikan sendiri oleh pengembang adalah sebagai berikut, semuanya merupakan estimasi yang ia umumkan sendiri di X dan belum diaudit pihak ketiga:
- Waktu pengembangan sekitar 8 jam;
- Biaya yang diestimasi berdasarkan harga API sekitar 550 dolar;
- Token input sekitar 445 juta, sebagian besar menggunakan cache;
- Token output sekitar 2,7 juta.
Karena Token input sebagian besar mengenai cache, perhitungan biaya ini tidak bisa dengan mudah dihitung ulang hanya dengan mengalikan harga satuan input biasa dengan total volume, dan struktur tagihan spesifiknya juga tidak dipublikasikan. Biaya 550 dolar ini merupakan biaya pembuatan sekali jalan; saat pemain bermain di browser, model tidak dipanggil lagi.
1.2 Struktur index.html: Three.js, kode generatif, dan font eksternal
Repositori mirror GitHub memberikan data yang presisi: berkas inti index.html berukuran 1,425,707 byte, sekitar 1.43MB (1.36MiB). Komposisi berkas ini dapat diringkas menjadi empat bagian:
- Kode runtime Three.js: seluruh pustaka 3D dikemas ke dalam HTML, bertanggung jawab atas scene, kamera, material, dan rendering WebGL;
- Kode generasi scene dan aset: geometri, tekstur, dan material dibangun oleh fungsi JavaScript dan Shader;
- Kode audio prosedural: suara juga disintesis oleh kode, tidak ada berkas audio terpisah di repositori;
- Logika game: kontrol input, perilaku musuh, alur misi.
Di repositori tidak ada berkas gambar, video, atau audio terpisah. Satu-satunya dependensi eksternal yang jelas adalah font Google Fonts. Pada 10 November, pengembang menambahkan penjelasan bahwa semua konten dalam game adalah kode; tekstur dan model adalah fungsi.
1.3 Apa yang terjadi saat Saltline dibuka di browser
Alur eksekusinya adalah pipeline lokal yang jelas: browser membaca HTML → JavaScript mulai dieksekusi → inisialisasi Three.js dan lingkungan rendering WebGL → kode menghasilkan geometri scene, material, tekstur, dan suara → GPU merender gambar setiap frame → pemain mengoperasikan keyboard dan mouse, logika game terus diperbarui.
Dalam pipeline ini, langkah “menghasilkan aset” terjadi di perangkat pemain. Halaman pengalaman resmi Saltline juga memberi petunjuk: inisialisasi halaman mungkin memerlukan waktu lebih lama, performa perangkat memengaruhi kecepatan mulai; jika macet di layar tunggu, periksa WebGL 2 dan akselerasi perangkat keras browser; jika tersendat, beralihlah ke kualitas Low. Petunjuk ini sendiri menunjukkan besarnya beban komputasi saat runtime.

2 Bagaimana game tradisional membuat model, tekstur, dan suara
2.1 Tiga jenis aset inti dalam game 3D tradisional
Visual dan suara dalam game 3D tradisional sebagian besar berasal dari file aset yang sudah dibuat sebelumnya:
- File model: dibuat oleh seniman di perangkat lunak pemodelan, lalu disimpan sebagai data vertex, face, koordinat UV, dan sebagainya;
- Tekstur: beberapa gambar seperti diffuse, normal, roughness, dan metallic yang ditempelkan pada permukaan model untuk memberikan detail;
- File efek suara: audio yang direkam atau disintesis lalu diekspor, dan diputar saat peristiwa tertentu terpicu.
Setelah dibuat, dioptimalkan, dikompresi, dan dikemas, aset-aset ini didistribusikan bersama game. Engine memuatnya saat runtime; tugas utamanya adalah “membaca dan menampilkan”.
2.2 Mengapa aset tradisional bisa memakan banyak ruang
Aset siap pakai menyimpan hasil. Satu tekstur beresolusi tinggi harus merekam nilai warna setiap piksel; model yang detail harus merekam posisi setiap vertex; satu efek suara harus merekam setiap titik sampel. Semakin kaya sebuah scene dan semakin tinggi resolusinya, semakin banyak data hasil yang perlu direkam, dan ukurannya pun tumbuh secara linear.
Pendekatan prosedural menyimpan proses. Sebuah fungsi noise hanya perlu beberapa puluh baris kode, tetapi dapat menghasilkan pola karat pada resolusi apa pun; sebuah fungsi kotak parametrik dapat menghasilkan kontainer berukuran apa pun. Inilah alasan mendasar mengapa 1.4MB dapat menampung keseluruhan scene pelabuhan.
| Aspek perbandingan | Aset siap pakai tradisional | Aset yang dihasilkan secara prosedural |
|---|---|---|
| Isi yang disimpan dalam file | Data hasil akhir (vertex, piksel, sampel) | Aturan pembangkitan (fungsi, parameter, Shader) |
| Cara produksi | Seniman membuatnya satu per satu di alat profesional | Menulis kode dan parameter, dihitung saat runtime |
| Ukuran distribusi | Bertambah seiring jumlah dan presisi aset | Terutama ditentukan oleh jumlah kode, biasanya kecil |
| Pekerjaan utama saat runtime | Memuat, mendekode, menampilkan | Membangun geometri, menghitung tekstur, menyintesis suara |
| Kontrol atas detail | Seniman dapat mengontrol setiap detail secara presisi | Bergantung pada kemampuan algoritma, biaya penyetelan parameter tinggi |
| Objek yang cocok secara umum | Karakter, item penting, adegan realistis | Struktur berulang, permukaan alami, efek cuaca |
3 Bagaimana AI Menghasilkan Aset Game dengan Kode: Empat Teknik Prosedural
Pembuatan prosedural adalah teknik yang telah lama digunakan industri game; medan di Minecraft dan level di berbagai game Roguelike bergantung padanya. Kebaruan Saltline terletak pada kenyataan bahwa model AI menulis seluruh kode untuk geometri, tekstur, shader, audio, dan logika game sekaligus dalam satu proses pembuatan yang berkelanjutan, sehingga mengurangi serah-terima antar personel di antara pemodelan, material, efek suara, dan pemrograman.
| Lapisan | Objek yang Dihasilkan | Pendekatan Teknis | Contoh Terkait di Saltline |
|---|---|---|---|
| Pembuatan geometri | Bentuk model | Vertex, face, geometri parametrik | Struktur kontainer, gudang, dermaga |
| Pembuatan material | Properti permukaan | Parameter warna, kekasaran, tingkat logam | Cangkang logam kontainer |
| Pembuatan tekstur | Detail permukaan | Noise, fraktal, Voronoi | Karat, noda, keausan |
| Pembuatan lingkungan | Tata letak scene | Aturan, angka acak, hubungan spasial | Susunan tumpukan kontainer |
| Pembuatan animasi | Gerakan objek | Fungsi matematika, perubahan status | Patroli drone, tetes hujan yang jatuh |
| Pembuatan suara | Efek suara | Osilator, filter, noise | Suara hujan, suara tembakan, suara lingkungan |
3.1 Geometri terprogram: merakit kontainer dengan parameter
Kontainer pada dasarnya adalah balok persegi panjang dengan panel samping berombak. Pendekatan geometri terprogram adalah: gunakan parameter panjang, lebar, dan tinggi untuk menghasilkan sebuah heksahedron, lalu geser titik-titik sudut di sepanjang sisi samping mengikuti fungsi sinus untuk mensimulasikan naik-turunnya pelat baja bergelombang. BufferGeometry dari Three.js memungkinkan penulisan langsung ke array vertex, sedangkan BoxGeometry menyediakan kotak terparameterisasi yang siap pakai.
Di pelabuhan ada ratusan hingga ribuan kontainer, dan semuanya berbagi data geometri yang sama. Di sinilah InstancedMesh dipakai untuk rendering terinstansiasi: cukup simpan satu matriks transformasi (posisi, rotasi, skala) dan satu warna untuk setiap instans, dan seluruh hamparan kontainer bisa digambar dalam satu panggilan draw.
3.2 Tekstur terprogram: melukis karat dengan fungsi noise
Tekstur terprogram dihasilkan lewat algoritma. Algoritma yang umum dipakai antara lain Perlin Noise, Simplex Noise, Voronoi, dan fractal noise: menumpuk beberapa lapis noise dengan frekuensi berbeda akan menghasilkan sebaran bercak karat yang natural; dengan Voronoi kita bisa membuat batas blok pada cat yang mengelupas.
Di Three.js, tekstur semacam ini biasanya dihitung sekali pada tahap inisialisasi, ditulis ke DataTexture (langsung mengisi array piksel) atau CanvasTexture (digambar dengan Canvas 2D), lalu diserahkan ke material seperti tekstur biasa. Setelah dibuat sekali, tekstur akan menetap di memori GPU; beban tambahan saat runtime terutama berasal dari penggunaan memori tersebut.
3.3 Shader: Menghitung Logam dan Air Hujan per Piksel di GPU
Shader berjalan di GPU, menghitung warna setiap piksel secara real-time berdasarkan input seperti koordinat, waktu, dan pencahayaan. Bedanya dengan tekstur prosedural terletak pada kapan perhitungan dilakukan: tekstur prosedural bisa dihitung sekali di muka menjadi sebuah gambar; Shader bisa menghitung langsung setiap frame, tanpa perlu menghasilkan gambar utuh.
Pelabuhan di malam hujan adalah lahan yang pas untuk Shader. Pantulan pada permukaan logam yang basah, riak genangan air yang berubah seiring waktu, dan butiran hujan yang jatuh—semuanya bisa ditulis sebagai fungsi dengan waktu sebagai input, lalu dihitung ulang tiap frame. ShaderMaterial dari Three.js memungkinkan kita menulis vertex shader dan fragment shader langsung untuk mewujudkan efek-efek ini. Trade-off antara kedua pendekatan ini lugas saja: tekstur yang dibuat di muka memakan memori tapi menghemat daya komputasi; perhitungan real-time lewat Shader menghemat memori tapi boros daya komputasi.
3.4 Efek Suara Prosedural: Menyintesis Suara Hujan dengan Oscillator dan Filter
Web Audio API di browser menyediakan node oscillator, buffer noise, dan filter. White noise yang dilewatkan filter low-pass sudah mendekati suara hujan; ledakan noise singkat ditambah envelope volume yang turun cepat menjadi suara tembakan; oscillator frekuensi rendah yang memodulasi pitch bisa menirukan dengung drone. Di repositori Saltline tidak ada satu pun berkas audio—semua suara disintesis secara real-time oleh kode semacam ini.

4 Berkas jadi lebih kecil, apakah menjalannya ikut lebih ringan? Analisis biaya pembuatan prosedural
4.1 Membedakan ukuran distribusi, memori runtime, dan beban GPU
Untuk mengukur “berat” sebuah game 3D, setidaknya ada tiga dimensi yang perlu dilihat:
- Ukuran distribusi: berapa banyak data yang diunduh pemain. Saltline sangat unggul di aspek ini;
- Memori runtime: vertex buffer, tekstur, dan buffer audio yang dihasilkan saat berjalan akan memakan memori dan VRAM. Sebuah program berukuran 1,4MB bisa saja membuat data ratusan MB saat dijalankan;
- Beban komputasi: jumlah pekerjaan yang harus diselesaikan CPU dan GPU setiap frame. Shader yang kompleks akan langsung mendongkrak angka ini.
Sebaliknya, game berukuran besar pun bisa mencapai efisiensi runtime yang baik lewat kompresi, pemuatan bertahap (chunked loading), dan streaming aset. Menilai baik-buruknya sebuah pendekatan teknis hanya dari ukuran berkas akan menghasilkan kesimpulan yang berat sebelah.
4.2 Ke mana biaya dialihkan oleh pembuatan secara prosedural
| Pendekatan teknis | Biaya yang mungkin berkurang | Biaya yang mungkin bertambah |
|---|---|---|
| Model prosedural | Unduhan dan penyimpanan model | Waktu pembangunan geometri di CPU |
| Tekstur shader | File gambar dan transfer tekstur | Komputasi real-time GPU per frame |
| Tekstur prosedural (dipre-generate) | Unduhan file gambar | Komputasi inisialisasi dan pemakaian memori GPU |
| Rendering instanced | Panggilan draw berulang | Pengelolaan scene dan pemeliharaan data instance |
| Scene yang digenerate dinamis | Jumlah aset pra-buat | Komputasi inisialisasi dan runtime |
| Efek suara prosedural | Penyimpanan file audio | Beban sintesis audio real-time |
Inisialisasi Saltline yang terasa lambat dan kebutuhan menyediakan opsi kualitas Low adalah cerminan nyata dari tabel ini: pekerjaan yang dihemat di fase unduhan harus dibayar ulang di fase startup dan di setiap frame rendering.
4.3 Trade-off antara shader, rendering instanced, dan geometri dinamis
Ketiga teknik ini memecahkan masalah yang berbeda-beda, dan hasil terbaik didapat bila dikombinasikan:
- Rendering instanced mengurangi jumlah panggilan draw yang dikirim CPU ke GPU, paling cocok untuk objek yang berulang dalam jumlah besar, misalnya area penumpukan kontainer, lampu jalan, dan partikel tetesan hujan;
- Shader memindahkan komputasi detail ke GPU, cocok untuk efek yang berubah seiring waktu (air hujan, genangan air, lampu yang berkedip), dengan konsekuensi semakin kompleks fragment shader, semakin berat beban GPU pada resolusi tinggi;
- Geometri dinamis cocok untuk struktur yang perlu berubah sesuai parameter atau jumlahnya terbatas; biaya pembangunannya terkonsentrasi di fase inisialisasi, dan setelah selesai dibangun ia menjadi mesh biasa.
Arah optimasi yang umum dalam praktik engineering adalah: apa pun yang bisa dihitung lebih dulu, hitung sekali di fase inisialisasi lalu simpan di cache; hanya hal-hal yang memang harus berubah seiring waktu yang dimasukkan ke shader per frame.
4.4 Perbedaan Pendekatan Saltline dengan Cloud Gaming dan Model Dunia AI
“AI untuk membuat game” saat ini setidaknya mencakup tiga jalur teknologi, dan Saltline termasuk jalur pertama.
| Dimensi perbandingan | Game Web Lokal | Cloud Gaming | Model Dunia AI |
|---|---|---|---|
| Contoh representatif | Saltline | GeForce NOW, Pixel Streaming | Genie 3, Muse/WHAMM, Oasis |
| Tahap keterlibatan AI | Menghasilkan kode pada tahap pengembangan | Biasanya tidak terlibat | Menghasilkan visual per frame saat runtime |
| Pembuatan visual | Rendering GPU lokal | Rendering GPU di cloud, lalu mengirim stream video | Model memprediksi dan menghasilkan secara real-time |
| Kebutuhan jaringan | Dapat offline setelah pemuatan awal | Harus terus terhubung ke internet | Biasanya perlu terus terhubung ke internet |
| Waktu terjadinya biaya | Biaya pengembangan sekali saja, selanjutnya ditanggung perangkat pemain | Biaya server muncul setiap kali bermain | Biaya inferensi muncul setiap kali bermain |
| Batasan utama | Browser dan perangkat keras lokal | Latensi jaringan, bandwidth | Konsistensi, latensi, kontrolabilitas |
Saltline memusatkan biaya AI pada tahap pengembangan. Setelah proses pembuatan selesai, aturan game ditentukan oleh kode, dan operasionalnya tidak bergantung pada model. Ini yang membuatnya dapat berjalan offline, sekaligus menjadikan performa perangkat pemain sebagai batas atas pengalaman.
5 Memulai Cepat Game 3D Prosedural: Membuat Kode Scene dengan API dan Model Bahasa Besar
5.1 Contoh Minimal: Satu Panggilan Menghasilkan Scene Prosedural
Skrip di bawah ini memanggil Model Bahasa Besar melalui antarmuka yang kompatibel dengan OpenAI, lalu memintanya mengeluarkan satu file HTML tunggal berisi kontainer prosedural, karat berbasis noise, dan hujan berbasis Shader. Nama model mohon mengikuti nama sebenarnya yang ada di daftar model platform:
import openai
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # Antarmuka terpadu APIYI, satu Key untuk memanggil banyak model
)
prompt = """Buat satu file HTML tunggal yang menggunakan Three.js (diimpor via CDN) untuk mewujudkan:
1. Menghasilkan 200 kontainer dengan warna acak secara prosedural memakai InstancedMesh sebagai area penumpukan;
2. Menghasilkan tekstur karat dengan DataTexture + noise berlapis, tanpa memakai file gambar apa pun;
3. Menerapkan ShaderMaterial untuk membuat garis-garis hujan yang jatuh seiring waktu;
4. Menyintesis white noise berfilter low-pass dengan Web Audio API sebagai suara hujan.
Keluarkan hanya kode HTML lengkap."""
resp = client.chat.completions.create(
model="your-model-name", # Ganti dengan nama model sebenarnya di platform
messages=[{"role": "user", "content": prompt}],
)
open("procedural_port.html", "w", encoding="utf-8").write(resp.choices[0].message.content)
Setelah dijalankan, buka procedural_port.html di browser untuk melihat hasilnya. Saltline sendiri merupakan proses generasi panjang selama 8 jam dengan ratusan juta Token; contoh ini hanya mendemonstrasikan siklus tertutup paling minimal dari ide yang sama.
Lihat implementasi lengkap: kode referensi tulisan tangan untuk kontainer prosedural, karat noise, hujan Shader, dan suara hujan sintetis
Berikut ini adalah implementasi referensi yang ditulis tangan, agar lebih mudah membandingkan dan memahami struktur kode yang dihasilkan model. Implementasi ini menempatkan keempat teknik dari Bab 3 dalam satu file yang sama:
<!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. Tekstur prosedural: noise nilai berlapis menghasilkan karat, ditulis ke 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. Geometri prosedural + rendering terinstansiasi: 200 kontainer berbagi satu geometri
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. Shader: posisi tetes hujan dihitung di GPU seiring waktu
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. Efek suara prosedural: white noise yang dilewatkan filter low-pass meniru suara hujan (dimulai setelah halaman diklik)
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>
Seluruh file tidak berisi satu pun gambar, file model, atau audio. Tekstur karat dihitung sekali saat inisialisasi (biaya CPU + memori GPU), posisi butiran hujan dihitung setiap frame di vertex shader (biaya GPU), dan kontainer diselesaikan melalui satu panggilan draw (mengurangi overhead panggilan CPU).
Saran untuk memulai dengan cepat: Saat membuat kode adegan prosedural, berbagai model menunjukkan perbedaan yang jelas dalam akurasi API Three.js dan cara penulisan Shader. Melalui APIYI apiyi.com, gunakan Key yang sama untuk beralih antara beberapa model dan membandingkan kualitas output secara berdampingan; kuota uji gratis untuk pengguna baru cukup untuk menjalankan beberapa putaran perbandingan.
5.2 Tiga Tips Praktis untuk Menyusun Petunjuk
Menulis petunjuk seperti spesifikasi teknis menghasilkan efek yang lebih baik daripada menuliskannya sebagai satu kalimat visi:
- Tentukan poin teknis: Mintalah secara eksplisit API spesifik seperti InstancedMesh, DataTexture, ShaderMaterial, maka model akan mengimplementasikannya melalui jalur prosedural, bukan mengasumsikan adanya sumber daya eksternal;
- Nyatakan batasan: Tuliskan “tidak menggunakan file gambar, model, atau audio apa pun” dan “HTML satu file”, sejalan dengan batasan Saltline;
- Minta tingkat kualitas performa: Mintalah model menyediakan pengalihan kualitas rendah, sedang, dan tinggi (misalnya mengurangi jumlah tetesan hujan, mematikan bayangan), sesuai dengan pendekatan Saltline yang menyediakan kualitas Low.
5.3 Cara Mengestimasi Biaya Generasi
Dengan mengacu pada harga Claude Fable 5.2 yang diumumkan resmi oleh Anthropic: input 8 dolar/juta token, output 40 dolar/juta token, pembacaan cache 0,20 dolar/juta token, penulisan cache 5 menit 10 dolar/juta token; jendela konteks 1M token, output maksimum 128K token. Untuk satu kali generasi seperti pada bagian 5.1, pemakaian token biasanya hanya berada di kisaran beberapa ribu hingga puluhan ribu. Iterasi otonom berdurasi panjang seperti yang dilakukan Saltline selama 8 jam akan berulang kali membaca kode yang sudah ada, sehingga selisih harga akibat cache hit sangat memengaruhi total biaya. Karena itu, untuk tugas berdurasi panjang, manfaatkan cache petunjuk (prompt caching) terlebih dahulu.
Saran biaya: Saat menjalankan eksperimen pembuatan kode berdurasi panjang, Anda bisa lebih dulu mengukur konsumsi token per putaran menggunakan petunjuk berskala kecil di APIYI apiyi.com, lalu memperkirakan anggaran total berdasarkan jumlah putaran iterasi. Platform menagih sesuai pemakaian, jadi cocok untuk memvalidasi rencana dari skala kecil ke besar.
6 FAQ (Pertanyaan yang Sering Diajukan)
Q1: Apa yang dimaksud dengan aset game 3D yang dihasilkan secara prosedural?
Aset yang dihasilkan secara prosedural adalah model, tekstur, dan suara yang aturan pembuatannya dijelaskan lewat kode dan parameter, lalu hasilnya dihitung saat runtime. File menyimpan “cara menggambarnya”, sedangkan file aset tradisional menyimpan “hasil yang sudah digambar”. Kontainer, bekas karat, dan suara hujan di Saltline semuanya termasuk kategori ini.
Q2: Apa perbedaan antara tekstur prosedural dan Shader?
Tekstur prosedural menghasilkan data tekstur melalui algoritma, dan bisa dihitung lebih dulu menjadi sebuah gambar lalu dimasukkan ke VRAM; Shader adalah program di GPU yang bisa langsung menghitung warna piksel pada setiap frame render. Yang pertama lebih banyak memakai memori dan lebih sedikit memakai daya komputasi, yang kedua sebaliknya, dan keduanya sering dipakai bersama.
Q3: Kapan Saltline dirilis, dan model apa yang dipakai?
Dirilis pada 9 November 2026 oleh Felix Rieseberg, engineer dari Anthropic, menggunakan Claude Fable 5.2, dengan sekali petunjuk dan tanpa umpan balik manusia. Sekitar 8 jam, sekitar 550 dolar, sekitar 445 juta Token input dan 2,7 juta Token output — semuanya merupakan estimasi yang disampaikan sendiri oleh developer. Pada 10 November ia menambahkan penjelasan bahwa model dan tekstur seluruhnya dihasilkan oleh kode.
Q4: Skenario game seperti apa yang paling cocok untuk pembuatan prosedural?
– **Struktur yang sangat berulang**: area tumpukan kontainer, kumpulan gedung, vegetasi — hasil terbaik didapat dengan dikombinasikan dengan instanced rendering;
– **Permukaan alami**: material seperti karat, batu, dan motif kayu yang cocok diekspresikan dengan noise;
– **Cuaca dinamis dan efek khusus**: efek yang berubah seiring waktu seperti air hujan, riak genangan air, dan lampu yang berkedip;
– **Skenario distribusi yang sensitif terhadap ukuran file**: game web kecil, iklan interaktif, prototipe yang bisa langsung dimainkan.
Untuk karakter utama dan properti cerita penting yang butuh kontrol artistik presisi, aset pra-buat masih lebih cocok; proyek komersial biasanya memakai pendekatan campuran.
Q5: Bagaimana cara membuat Model Bahasa Besar menghasilkan kode adegan 3D prosedural lewat API?
1. Daftar di APIYI apiyi.com dan dapatkan API Key serta kuota uji gratis;
2. Gunakan skrip pada bagian 5.1 artikel ini, atur base_url ke `https://api.apiyi.com/v1`;
3. Tuliskan batasan seperti API Three.js, satu file, tanpa sumber daya eksternal di dalam petunjuk, lalu buka hasilnya di browser untuk verifikasi.
Karena antarmuka kompatibel dengan format OpenAI, untuk beralih ke model seperti Claude, GPT, atau Gemini cukup mengubah parameter model.
Q6: Apa saja keterbatasan pembuatan prosedural yang sudah diketahui?
– **Biaya runtime**: komputasi inisialisasi, pemakaian VRAM, dan beban GPU dari Shader yang rumit akan dibebankan ke perangkat pemain; Saltline pun butuh opsi kualitas Low dan waktu inisialisasi yang cukup lama;
– **Batasan browser**: dokumentasi resmi Unity menyebutkan bahwa platform Web terbatas pada sistem file, thread, dan memori, serta dukungan di perangkat mobile terbatas;
– **Kontrol artistik**: daya ekspresi algoritma punya batas; karakter realistis dan properti detail sulit dihasilkan murni lewat kode;
– **Kematangan rekayasa**: AI bisa cepat menghasilkan prototipe yang bisa dimainkan, tetapi optimasi jangka panjang, pengujian, dan perluasan konten yang dibutuhkan game komersial masih memerlukan investasi rekayasa yang besar.
7 Poin Utama: Game 3D 1.4MB dan Pembuatan Prosedural
- Sumber ukuran: Saltline berukuran sekitar 1.4MB karena yang disimpan adalah aturan generasi, bukan file gambar, model, atau audio.
- Empat teknik: Geometri prosedural, tekstur prosedural, shader, dan efek suara prosedural masing-masing menangani satu lapisan dengan pembagian tugas yang jelas.
- Transfer biaya: Ukuran unduhan berkurang, tetapi pembangunan oleh CPU, pemakaian VRAM, dan komputasi GPU per frame justru meningkat.
- Dimensi evaluasi: Perlu melihat ukuran distribusi, waktu inisialisasi, memori runtime, dan biaya GPU per frame secara bersamaan.
- Peran AI: AI bertugas menulis kode generasi, sementara teknik prosedural sendiri sudah lama digunakan secara luas dalam pengembangan game.
- Cara mencoba: Lewat APIYI apiyi.com, gunakan satu kunci API untuk membandingkan kode scene Three.js yang dihasilkan beberapa model.
8 Kesimpulan: Pengembangan game bergeser dari membuat aset ke menulis aturan pembuatan aset
Saltline menunjukkan perubahan cara aset direpresentasikan: game tradisional mengirimkan “aset yang sudah dibuat”, sedangkan game prosedural mengirimkan “aturan untuk menghasilkan aset”. Pembuatan kode oleh AI membuat ambang rute ini turun secara signifikan. Satu model dapat, dalam satu proses generasi berkelanjutan, sekaligus menulis geometri, tekstur, shader, audio, dan logika game, sehingga menghilangkan serah-terima antar disiplin kerja.
Rute ini punya batas penerapan yang jelas. Keunggulannya menonjol pada ukuran distribusi dan kemudahan deployment, tetapi beban komputasi dipindahkan ke perangkat pemain. Pendekatan ini cocok untuk struktur berulang, permukaan alami, dan efek dinamis; aset seni yang detail masih bergantung pada produksi tradisional. Produksi aset tradisional dan produksi prosedural akan saling melengkapi dalam jangka panjang. Nilai Saltline terletak pada pembuktian bahwa program berukuran kecil pun dapat membangun scene interaktif yang kaya.
Jika ingin memverifikasi rute ini sendiri, mulailah dari skrip di bagian 5.1. Disarankan memanggil berbagai model melalui APIYI apiyi.com untuk menghasilkan scene prosedural, lalu membandingkan seberapa baik mereka menguasai Three.js dan shader.
📚 Referensi
- Mirror kode dan README Saltline: Struktur file tunggal, jumlah byte, dan kepemilikan data pengembang
- Tautan:
github.com/realcodebear/saltline-fable-5.2 -
Keterangan: Dapat langsung melihat kode yang dihasilkan secara terprogram di index.html
-
Halaman pengalaman mandiri Saltline: Uji coba online serta penjelasan inisialisasi dan pengaturan kualitas grafis
- Tautan:
saltline.games -
Keterangan: Versi bahasa Mandarin tersedia di
saltline.games/zh -
Repositori GitHub versi bahasa Mandarin Jimao: Arsip versi distribusi domestik
- Tautan:
github.com/Megasu/jimao-3a-game -
Keterangan: Menyediakan petunjuk menjalankan secara offline dan data ukuran file
-
Spesifikasi dan harga model Claude Fable 5.2: Dokumentasi resmi Anthropic
- Tautan:
platform.claude.com/docs/en/models/fable-5-2/overview -
Keterangan: Harga input, output, cache, dan spesifikasi jendela konteks
-
Dokumentasi dan contoh resmi Three.js: InstancedMesh, ShaderMaterial, BufferGeometry, DataTexture
- Tautan:
threejs.org/docsdanthreejs.org/examples -
Keterangan: Penjelasan otoritatif untuk API yang digunakan dalam kode artikel ini
-
MDN WebGL API: Antarmuka rendering GPU browser
- Tautan:
developer.mozilla.org/en-US/docs/Web/API/WebGL_API -
Keterangan: Memahami mekanisme rendering dasar Three.js
-
Ikhtisar teknis Unity WebGL: Batasan thread, memori, dan perangkat seluler di platform Web
- Tautan:
docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html - Keterangan: Referensi untuk menilai batas rekayasa game browser
Penulis: Tim Teknis APIYI
Diskusi teknis: Silakan hubungi kami di halaman utama APIYI apiyi.com; materi integrasi selengkapnya dapat diakses di pusat dokumentasi docs.apiyi.com
