Skip to content

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
}

Released under the MIT License.