Basics
Source
ts
import { ContentLoader } from '@gglib/content'
import { TonemapOperator } from '@gglib/effects'
import { CommonInputs, createDevice, FrameContext, PlatformId, sphereGeometry } from '@gglib/graphics'
import {
DEGREE_TO_RAD,
mat4$initLookAt,
mat4$initPerspectiveFieldOfView,
mat4$setTranslationY,
mat4GetTranslationX,
mat4GetTranslationZ,
mat4Invert,
vec3,
} from '@gglib/math'
import { BloomPass, opaquePassMSAA, PixelatePass, Renderer, TonemapPass, transparentPassMSAA } from '@gglib/render'
import { mount } from 'tweak-ui'
import { createCamera, createObject, createScene } from './basics-scene'
const SIZE = 20
export default async (canvas: HTMLCanvasElement, tools: HTMLElement, platform: PlatformId) => {
const device = await createDevice({ canvas, platform }).ready
const content = new ContentLoader(device)
const pixelate = new PixelatePass(device, { enabled: false })
const bloom = new BloomPass(device, { enabled: false })
const tonemap = new TonemapPass(device, { enabled: false })
const renderer = new Renderer(device, {
pipeline: {
passes: [opaquePassMSAA(), transparentPassMSAA(), pixelate, bloom, tonemap],
},
})
renderer.inputs.set(CommonInputs.Global.AmbientColor, vec3(0))
renderer.inputs.set(CommonInputs.Global.AmbientColorTop, vec3(1))
const scene = createScene()
const camera = createCamera()
mat4$initLookAt(camera.world, vec3(SIZE), vec3(SIZE / 2, 0, SIZE / 2), vec3.UnitY)
const textures = await Promise.all(
[
'/textures/prototype/light/texture_02.png',
'/textures/prototype/red/texture_02.png',
'/textures/prototype/green/texture_02.png',
'/textures/prototype/orange/texture_02.png',
'/textures/prototype/purple/texture_02.png',
].map((it) => content.loadTexture(it)),
)
const geometry = sphereGeometry(device)
const view = renderer.createView({
name: 'main',
camera,
})
scene.views.push(view)
for (let z = 0; z < SIZE; z++) {
for (let x = 0; x < SIZE; x++) {
const texture = textures[Math.max(x, z) % textures.length]
const object = createObject(device, texture, geometry, vec3(x, 0, z))
scene.items.push(object)
}
}
function frame(ctx: FrameContext) {
device.resize()
mat4Invert(view.camera.world, view.camera.view)
mat4$initPerspectiveFieldOfView(
view.camera.projection,
45 * DEGREE_TO_RAD,
device.output.aspectRatio,
camera.near,
camera.far,
device.ndcMinZ,
camera.reversedZ,
)
for (const item of scene.items) {
const w = item.transform
const x = mat4GetTranslationX(w) - SIZE / 2
const z = mat4GetTranslationZ(w) - SIZE / 2
const r = Math.sqrt(x * x + z * z)
const y = Math.sin(r - ctx.time) * 0.5
mat4$setTranslationY(w, y)
}
renderer.update(ctx.time)
renderer.render(scene)
}
const panel = mount(tools, (ui) => {
ui.group('Settings', { collapsible: true, defaultCollapsed: true }, () => {
ui.tabs(() => {
ui.group('Pixelate', {}, (ui) => {
ui.bool(pixelate, 'enabled')
ui.scalar(pixelate, 'size', { range: true, min: 1, max: 50, step: 1 })
ui.scalar(pixelate, 'aspect', { range: true, min: 0.001, max: 2, step: 0.001 })
ui.scalar(pixelate, 'corner', { range: true, min: 0, max: 1 })
ui.scalar(pixelate, 'dither', { range: true, min: 0, max: 1 })
ui.scalar(pixelate, 'gap', { range: true, min: 0, max: 1 })
})
ui.group('Bloom', {}, (ui) => {
ui.bool(bloom, 'enabled')
ui.scalar(bloom, 'threshold', { range: true, min: 0, max: 1 })
ui.scalar(bloom, 'knee', { range: true, min: 0, max: 1 })
ui.scalar(bloom, 'steps', { range: true, min: 1, max: 10, step: 1 })
ui.scalar(bloom, 'intensity', { range: true, min: 0, max: 1 })
})
ui.group('Tonemap', {}, (ui) => {
ui.bool(tonemap, 'enabled')
ui.scalar(tonemap, 'exposure', { range: true, min: 0, max: 10 })
ui.select(tonemap, 'operator', {
options: TonemapOperator,
})
})
})
})
})
device.schedule(frame)
return () => {
device.dispose()
panel.dispose()
}
}
ts
import { BasicMaterial, CommonInputs, Device, Geometry, Mesh, Texture, TRUE } from '@gglib/graphics'
import { IVec3, mat4CreateTranslation, mat4Identity } from '@gglib/math'
import {
CameraData,
isRenderItem,
LayerMask,
MeshRenderItem,
RenderItem,
RenderItemFlags,
RenderItemType,
RenderScene,
} from '@gglib/render'
export interface Scene extends RenderScene {
items: RenderItem[]
}
export function createScene(): Scene {
const scene: Scene = {
items: [],
views: [],
output: null,
collect: (frame, camera, out) => {
for (const item of scene.items) {
if (isRenderItem(item, RenderItemType.Mesh)) {
item.data.materials[0].setInput(CommonInputs.Object.ModelMatrix, item.transform)
}
out.push(item)
}
},
}
return scene
}
export function createCamera(data?: Partial<CameraData>): CameraData {
return {
visibilityMask: LayerMask.All,
world: mat4Identity(),
view: mat4Identity(),
projection: mat4Identity(),
reversedZ: false,
near: 0.1,
far: 100,
...(data || {}),
}
}
export function createObject(device: Device, texture: Texture, geometry: Geometry, position: IVec3): RenderItem {
const material = new BasicMaterial(device, { properties: {} })
material.BaseMap = texture
material.UseBaseMap = TRUE
return {
type: RenderItemType.Mesh,
layer: LayerMask.All,
flags: RenderItemFlags.Opaque,
transform: mat4CreateTranslation(position),
data: new Mesh(device, {
materials: [material],
geometries: [geometry],
parts: [
{
geometryIndex: 0,
materialIndex: 0,
},
],
}),
} satisfies MeshRenderItem
}