Merge branch 'main' into feat/ref-value

Author: iwoplaza

apps/typegpu-docs/src/examples/rendering/jelly-slider/index.ts

@@ -618,7 +618,7 @@ const renderBackground = (
 
   let highlights = d.f32();
 
-  const highlightWidth = 1;
+  const highlightWidth = d.f32(1);
   const highlightHeight = 0.2;
   let offsetX = d.f32();
   let offsetZ = d.f32(0.05);

packages/tgpu-gen/package.json

@@ -18,7 +18,7 @@
     "wgsl_reflect": "git://github.com/mhawryluk/wgsl_reflect.git#85994fdc8d8a3abbb4f79baf3891e54eed0c1c63"
   },
   "peerDependencies": {
-    "typegpu": "workspace:^0.8.0"
+    "typegpu": "workspace:^0.8.1"
   },
   "files": ["README.md", "LICENSE", "package.json", "**/*.mjs"],
   "devDependencies": {

packages/typegpu/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typegpu",
   "private": true,
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.",
   "license": "MIT",
   "type": "module",

packages/typegpu/src/core/pipeline/renderPipeline.ts

@@ -8,6 +8,7 @@ import { isBuiltin } from '../../data/attributes.ts';
 import { type Disarray, getCustomLocation } from '../../data/dataTypes.ts';
 import { sizeOf } from '../../data/sizeOf.ts';
 import { type ResolvedSnippet, snip } from '../../data/snippet.ts';
+import type { WgslTexture } from '../../data/texture.ts';
 import {
   type AnyWgslData,
   isWgslData,
@@ -46,7 +47,12 @@ import type { TgpuVertexFn } from '../function/tgpuVertexFn.ts';
 import { namespace } from '../resolve/namespace.ts';
 import type { ExperimentalTgpuRoot } from '../root/rootTypes.ts';
 import type { TgpuSlot } from '../slot/slotTypes.ts';
-import { isTexture, type TgpuTexture } from '../texture/texture.ts';
+import {
+  isTexture,
+  isTextureView,
+  type TgpuTexture,
+  type TgpuTextureView,
+} from '../texture/texture.ts';
 import type { RenderFlag } from '../texture/usageExtension.ts';
 import { connectAttributesToShader } from '../vertexLayout/connectAttributesToShader.ts';
 import {
@@ -155,7 +161,10 @@ export interface ColorAttachment {
    * A {@link GPUTextureView} describing the texture subresource that will be output to for this
    * color attachment.
    */
-  view: (TgpuTexture & RenderFlag) | GPUTextureView;
+  view:
+    | (TgpuTexture & RenderFlag)
+    | GPUTextureView
+    | TgpuTextureView<WgslTexture>;
   /**
    * Indicates the depth slice index of {@link GPUTextureViewDimension#"3d"} {@link GPURenderPassColorAttachment#view}
    * that will be output to for this color attachment.
@@ -506,6 +515,13 @@ class TgpuRenderPipelineImpl implements TgpuRenderPipeline {
           };
         }
 
+        if (isTextureView(attachment.view)) {
+          return {
+            ...attachment,
+            view: branch.unwrap(attachment.view),
+          };
+        }
+
         return attachment;
       }) as GPURenderPassColorAttachment[]
       : [null];

packages/typegpu/src/core/resolve/stitch.ts

@@ -11,32 +11,12 @@ type ValueOrArray<T> = T | T[];
 export function stitch(
   strings: TemplateStringsArray,
   ...snippets: ValueOrArray<Snippet | string | number | undefined>[]
-) {
-  return internalStitch(strings, snippets, false);
-}
-
-/**
- * "The reverse of snipping"
- * Injects resolved snippets into a template string, ensuring
- * the generated code represents it's type exactly.
- */
-export function stitchWithExactTypes(
-  strings: TemplateStringsArray,
-  ...snippets: ValueOrArray<Snippet | string | number | undefined>[]
-) {
-  return internalStitch(strings, snippets, true);
-}
-
-function internalStitch(
-  strings: TemplateStringsArray,
-  snippets: ValueOrArray<Snippet | string | number | undefined>[],
-  exact: boolean,
 ) {
   const ctx = getResolutionCtx() as ResolutionCtx;
 
   function resolveSnippet(maybeSnippet: Snippet | string | number) {
     return isSnippet(maybeSnippet)
-      ? ctx.resolve(maybeSnippet.value, maybeSnippet.dataType, exact).value
+      ? ctx.resolve(maybeSnippet.value, maybeSnippet.dataType).value
       : maybeSnippet;
   }
 

packages/typegpu/src/data/vector.ts

@@ -317,6 +317,7 @@ function makeVecSchema<TValue, S extends number | boolean>(
       returnType: schema as AnyData,
     }),
     normalImpl: cpuConstruct,
+    ignoreImplicitCastWarning: true,
     codegenImpl: (...args) => {
       if (args.length === 1 && args[0]?.dataType === schema) {
         // Already typed as the schema

packages/typegpu/src/resolutionCtx.ts

@@ -703,7 +703,6 @@ export class ResolutionCtxImpl implements ResolutionCtx {
   resolve(
     item: unknown,
     schema?: AnyData | UnknownData | undefined,
-    exact = false,
   ): ResolvedSnippet {
     if (isTgpuFn(item) || hasTinyestMetadata(item)) {
       if (
@@ -720,7 +719,7 @@ export class ResolutionCtxImpl implements ResolutionCtx {
     if (isProviding(item)) {
       return this.withSlots(
         item[$providing].pairs,
-        () => this.resolve(item[$providing].inner, schema, exact),
+        () => this.resolve(item[$providing].inner, schema),
       );
     }
 
@@ -745,41 +744,34 @@ export class ResolutionCtxImpl implements ResolutionCtx {
 
     // This is a value that comes from the outside, maybe we can coerce it
     if (typeof item === 'number') {
-      const reinterpretedType = exact
-        ? schema
-        : numericLiteralToSnippet(item).dataType;
       const realSchema = schema ?? numericLiteralToSnippet(item).dataType;
-      invariant(
-        reinterpretedType,
-        'Schema has to be defined for resolving numbers',
-      );
       invariant(
         realSchema.type !== 'unknown',
         'Schema has to be known for resolving numbers',
       );
 
-      if (reinterpretedType.type === 'abstractInt') {
+      if (realSchema.type === 'abstractInt') {
         return snip(`${item}`, realSchema, /* ref */ 'constant');
       }
-      if (reinterpretedType.type === 'u32') {
+      if (realSchema.type === 'u32') {
         return snip(`${item}u`, realSchema, /* ref */ 'constant');
       }
-      if (reinterpretedType.type === 'i32') {
+      if (realSchema.type === 'i32') {
         return snip(`${item}i`, realSchema, /* ref */ 'constant');
       }
 
       const exp = item.toExponential();
       const decimal =
-        reinterpretedType.type === 'abstractFloat' && Number.isInteger(item)
+        realSchema.type === 'abstractFloat' && Number.isInteger(item)
           ? `${item}.`
           : `${item}`;
 
       // Just picking the shorter one
       const base = exp.length < decimal.length ? exp : decimal;
-      if (reinterpretedType.type === 'f32') {
+      if (realSchema.type === 'f32') {
         return snip(`${base}f`, realSchema, /* ref */ 'constant');
       }
-      if (reinterpretedType.type === 'f16') {
+      if (realSchema.type === 'f16') {
         return snip(`${base}h`, realSchema, /* ref */ 'constant');
       }
       return snip(base, realSchema, /* ref */ 'constant');

packages/typegpu/src/std/boolean.ts

@@ -340,7 +340,7 @@ export const select = dualImpl({
   name: 'select',
   signature: (...args) => {
     const [f, t, cond] = toStorables(args);
-    const [uf, ut] = unify<[AnyData, AnyData]>([f, t]) ?? [f, t];
+    const [uf, ut] = unify([f, t]) ?? [f, t] as const;
     return ({ argTypes: [uf, ut, cond], returnType: uf });
   },
   normalImpl: cpuSelect,

packages/typegpu/src/std/operators.ts

@@ -1,5 +1,5 @@
 import { dualImpl } from '../core/function/dualImpl.ts';
-import { stitch, stitchWithExactTypes } from '../core/resolve/stitch.ts';
+import { stitch } from '../core/resolve/stitch.ts';
 import { toStorable, toStorables } from '../data/dataTypes.ts';
 import { abstractFloat, f16, f32 } from '../data/numeric.ts';
 import { vecTypeToConstructor } from '../data/vector.ts';
@@ -196,7 +196,7 @@ export const div = dualImpl({
     });
   },
   normalImpl: cpuDiv,
-  codegenImpl: (lhs, rhs) => stitchWithExactTypes`(${lhs} / ${rhs})`,
+  codegenImpl: (lhs, rhs) => stitch`(${lhs} / ${rhs})`,
   ignoreImplicitCastWarning: true,
 });
 

packages/typegpu/src/tgsl/wgslGenerator.ts

@@ -1,5 +1,5 @@
 import * as tinyest from 'tinyest';
-import { stitch, stitchWithExactTypes } from '../core/resolve/stitch.ts';
+import { stitch } from '../core/resolve/stitch.ts';
 import { arrayOf } from '../data/array.ts';
 import {
   type AnyData,
@@ -43,6 +43,7 @@ import type { ShaderGenerator } from './shaderGenerator.ts';
 import type { DualFn } from '../data/dualFn.ts';
 import { INTERNAL_createPtr, ptrFn } from '../data/ptr.ts';
 import { RefOnGPU, RefOperator } from '../data/ref.ts';
+import { constant } from '../core/constant/tgpuConstant.ts';
 
 const { NodeTypeCatalog: NODE } = tinyest;
 
@@ -312,7 +313,7 @@ ${this.ctx.pre}}`;
       // Post-Update Expression
       const [_, op, arg] = expression;
       const argExpr = this.expression(arg);
-      const argStr = this.ctx.resolve(argExpr.value).value;
+      const argStr = this.ctx.resolve(argExpr.value, argExpr.dataType).value;
 
       // Result of an operation, so not a reference to anything
       return snip(`${argStr}${op}`, argExpr.dataType, /* ref */ 'runtime');
@@ -329,7 +330,7 @@ ${this.ctx.pre}}`;
         return codegen(argExpr);
       }
 
-      const argStr = this.ctx.resolve(argExpr.value).value;
+      const argStr = this.ctx.resolve(argExpr.value, argExpr.dataType).value;
 
       const type = operatorToType(argExpr.dataType, op);
       // Result of an operation, so not a reference to anything
@@ -374,7 +375,7 @@ ${this.ctx.pre}}`;
           this.ctx.resolve(property.value, property.dataType).value;
 
         throw new Error(
-          `Cannot index value ${targetStr} with index ${propertyStr}`,
+          `Unable to index value ${targetStr} of unknown type with index ${propertyStr}. If the value is an array, to address this, consider one of the following approaches: (1) declare the array using 'tgpu.const', (2) store the array in a buffer, or (3) define the array within the GPU function scope.`,
         );
       }
 
@@ -431,6 +432,12 @@ ${this.ctx.pre}}`;
         );
       }
 
+      if (callee.value === constant) {
+        throw new Error(
+          'Constants cannot be defined within TypeGPU function scope. To address this, move the constant definition outside the function scope.',
+        );
+      }
+
       if (callee.value instanceof InfixDispatch) {
         // Infix operator dispatch.
         if (!argNodes[0]) {
@@ -780,7 +787,7 @@ ${this.ctx.pre}else ${alternate}`;
           rawId,
           concretize(refSnippet.dataType as AnyData) as wgsl.StorableData,
         );
-        return stitchWithExactTypes`${this.ctx.pre}var ${varName} = ${
+        return stitch`${this.ctx.pre}var ${varName} = ${
           tryConvertSnippet(
             refSnippet,
             refSnippet.dataType as wgsl.AnyWgslData,
@@ -845,7 +852,7 @@ ${this.ctx.pre}else ${alternate}`;
         concretize(dataType),
         eq.origin,
       );
-      return stitchWithExactTypes`${this.ctx.pre}${varType} ${snippet
+      return stitch`${this.ctx.pre}${varType} ${snippet
         .value as string} = ${tryConvertSnippet(eq, dataType, false)};`;
     }