gputex 0.3.1 → 0.3.2

package/README.md

@@ -1,6 +1,6 @@
 # GPUtex | On-the-fly GPU texture encoding
 
-Runtime GPU texture compression via WebGPU compute shaders, with a WebGL2 fragment-shader fallback. Feed it a PNG/JPG/WebP/AVIF and get back a GPU-compressed texture (BC7, BC5, ASTC 4x4, or BC1) ready for Three.js or React Three Fiber.
+Runtime GPU texture compression via WebGPU compute shaders, with a WebGL2 fragment-shader fallback. Feed it a PNG/JPG/WebP/AVIF — or an SVG, rasterised on the fly — and get back a GPU-compressed texture (BC7, BC5, ASTC 4x4, or BC1) ready for Three.js or React Three Fiber.
 
 ⚠️ 100% vibe-coded. The code is completely unreviewed and under-tested. Do not use for anything important.
 
@@ -93,6 +93,32 @@ material.map = texture
   (byte-identical on >96% of blocks; the rest are equal-error FP tie-breaks,
   enforced by the GPU test suite).
 
+#### SVG sources
+
+SVGs work anywhere a raster image does — as a URL, a Blob/File, an inline
+markup string (detected by a leading `<`), or an `<img>` element. The vector
+is rasterised before encoding, at the SVG's intrinsic size by default
+(absolute `width`/`height` attributes, else the `viewBox` dimensions). Use
+`svgSize` to pick the raster size — the browser renders the vector directly
+at that size, so upscaling stays crisp:
+
+```ts
+// Longest side 1024, aspect ratio preserved:
+const { texture } = await compressTexture('/logo.svg', { svgSize: 1024 })
+
+// Exact size (aspect mismatches follow the SVG's preserveAspectRatio rules):
+await compressTexture('/icon.svg', { svgSize: { width: 512, height: 512 } })
+
+// Inline markup:
+await compressTexture('<svg viewBox="0 0 32 32">…</svg>', { svgSize: 256 })
+```
+
+An SVG with no `width`/`height` **and** no `viewBox` has no intrinsic size;
+`svgSize` is required for those. Rasterisation needs a DOM `Image`, so SVG
+sources are main-thread only. Non-Three.js users get the same rasteriser as
+a standalone helper: `rasterizeSvg(source, { size })` from the core `gputex`
+entry returns an `ImageBitmap` ready for `encodeToBytes()`.
+
 ### `GputexLoader` — Three.js Loader
 
 ```ts
@@ -211,14 +237,15 @@ const tex = buildCompressedTexture([bytes], TextureFormat.BC7_SRGB)
 
 ### `compressTexture` options
 
-| Option            | Type                 | Default   | Description                                                                                      |
-| ----------------- | -------------------- | --------- | ------------------------------------------------------------------------------------------------ |
-| `hint`            | `TextureHint`        | `'color'` | `'color'`, `'colorWithAlpha'`, or `'normal'`                                                     |
-| `preferredFormat` | `'bc1'`              | —         | Prefer BC1 (half of BC7's size) when supported; normal selection otherwise. `hint: 'color'` only |
-| `colorSpace`      | `'srgb' \| 'linear'` | `'srgb'`  | Use the sRGB or linear variant of the chosen format                                              |
-| `flipY`           | `boolean`            | `true`    | Flip vertically (matches Three.js convention)                                                    |
-| `mipmaps`         | `boolean`            | `false`   | Generate full mip chain down to 1x1                                                              |
-| `device`          | `GPUDevice`          | —         | Reuse an existing WebGPU device instead of creating one                                          |
+| Option            | Type                          | Default   | Description                                                                                      |
+| ----------------- | ----------------------------- | --------- | ------------------------------------------------------------------------------------------------ |
+| `hint`            | `TextureHint`                 | `'color'` | `'color'`, `'colorWithAlpha'`, or `'normal'`                                                     |
+| `preferredFormat` | `'bc1'`                       | —         | Prefer BC1 (half of BC7's size) when supported; normal selection otherwise. `hint: 'color'` only |
+| `colorSpace`      | `'srgb' \| 'linear'`          | `'srgb'`  | Use the sRGB or linear variant of the chosen format                                              |
+| `svgSize`         | `number \| { width, height }` | intrinsic | Raster size for SVG sources: longest side (aspect preserved) or exact size                       |
+| `flipY`           | `boolean`                     | `true`    | Flip vertically (matches Three.js convention)                                                    |
+| `mipmaps`         | `boolean`                     | `false`   | Generate full mip chain down to 1x1                                                              |
+| `device`          | `GPUDevice`                   | —         | Reuse an existing WebGPU device instead of creating one                                          |
 
 ## Benchmarks
 

package/dist/index.d.ts

@@ -440,4 +440,27 @@ declare function generateMipChain(level0: MipLevel): MipLevel[];
  */
 declare function padToBlockMultiple(level: MipLevel): MipLevel;
 
-export { ASTC4x4Encoder, ASTC4x4WebGLEncoder, BC1Encoder, BC1WebGLEncoder, BC5Encoder, BC5WebGLEncoder, BC7Encoder, BC7WebGLEncoder, type Capabilities, type EncodeBytesResult, type EncodeCallOptions, type EncodeQuality, Encoder, type EncoderConstructor, type EncoderImageSource, type EncoderOptions, type ExtensionProvider, type FeatureProvider, type FormatSelection, type FormatVariant, type MipLevel, type PreferredFormat, type RawPixelSource, type SelectFormatOptions, TextureFormat, type TextureHint, WebGLBlockEncoder, type WebGLCapabilities, type WebGLEncodeBytesResult, type WebGLEncoderConstructor, type WebGLEncoderImageSource, type WebGLEncoderOptions, type WebGLFormatSelection, WebGPUFeature, createWebGLContext, detectCapabilities, detectWebGLCapabilities, generateMipChain, getSharedWebGLContext, isWebGLAvailable, padToBlockMultiple, selectFormat, selectWebGLFormat };
+/**
+ * Target raster size for an SVG source. A number scales the SVG so its
+ * longest side matches (aspect ratio preserved); an object rasterises at
+ * exactly that size. When omitted, the SVG's intrinsic size is used
+ * (absolute width/height attributes, else the viewBox dimensions).
+ */
+type SvgRasterSize = number | {
+    width: number;
+    height: number;
+};
+interface RasterizeSvgOptions {
+    /** Target raster size. Default: the SVG's intrinsic size. */
+    size?: SvgRasterSize;
+}
+/**
+ * Rasterise an SVG (markup string or Blob/File) to an `ImageBitmap`.
+ *
+ * Used automatically by `compressTexture()` for SVG sources; exported for
+ * callers driving the core encoders directly — the returned bitmap is a
+ * valid `EncoderImageSource`. Main-thread only (needs `Image`).
+ */
+declare function rasterizeSvg(source: string | Blob, options?: RasterizeSvgOptions): Promise<ImageBitmap>;
+
+export { ASTC4x4Encoder, ASTC4x4WebGLEncoder, BC1Encoder, BC1WebGLEncoder, BC5Encoder, BC5WebGLEncoder, BC7Encoder, BC7WebGLEncoder, type Capabilities, type EncodeBytesResult, type EncodeCallOptions, type EncodeQuality, Encoder, type EncoderConstructor, type EncoderImageSource, type EncoderOptions, type ExtensionProvider, type FeatureProvider, type FormatSelection, type FormatVariant, type MipLevel, type PreferredFormat, type RasterizeSvgOptions, type RawPixelSource, type SelectFormatOptions, type SvgRasterSize, TextureFormat, type TextureHint, WebGLBlockEncoder, type WebGLCapabilities, type WebGLEncodeBytesResult, type WebGLEncoderConstructor, type WebGLEncoderImageSource, type WebGLEncoderOptions, type WebGLFormatSelection, WebGPUFeature, createWebGLContext, detectCapabilities, detectWebGLCapabilities, generateMipChain, getSharedWebGLContext, isWebGLAvailable, padToBlockMultiple, rasterizeSvg, selectFormat, selectWebGLFormat };

package/dist/index.js

@@ -1441,6 +1441,128 @@ function padToBlockMultiple(level) {
   }
   return { data: out, width: pw, height: ph };
 }
+
+// src/svg.ts
+var ROOT_TAG_RE = /<svg(?=[\s/>])[^>]*>/;
+function getAttr(tag, name) {
+  const m = new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`).exec(tag);
+  return m ? m[1] ?? m[2] ?? "" : null;
+}
+function removeAttr(tag, name) {
+  return tag.replace(new RegExp(`\\s${name}\\s*=\\s*(?:"[^"]*"|'[^']*')`, "g"), "");
+}
+function parseAbsoluteLength(value) {
+  if (value == null) return null;
+  const m = /^\s*\+?(\d+(?:\.\d+)?|\.\d+)(?:px)?\s*$/i.exec(value);
+  if (!m) return null;
+  const n = Number(m[1]);
+  return n > 0 ? n : null;
+}
+function parseSvgDimensions(svgText) {
+  const m = ROOT_TAG_RE.exec(svgText);
+  if (!m) return null;
+  const tag = m[0];
+  const dims = {
+    width: parseAbsoluteLength(getAttr(tag, "width")),
+    height: parseAbsoluteLength(getAttr(tag, "height")),
+    viewBoxWidth: null,
+    viewBoxHeight: null
+  };
+  const viewBox = getAttr(tag, "viewBox");
+  if (viewBox) {
+    const parts = viewBox.trim().split(/[\s,]+/).map(Number);
+    if (parts.length === 4 && parts.every(Number.isFinite) && parts[2] > 0 && parts[3] > 0) {
+      dims.viewBoxWidth = parts[2];
+      dims.viewBoxHeight = parts[3];
+    }
+  }
+  return dims;
+}
+function resolveSvgRasterSize(dims, size) {
+  if (size !== void 0 && typeof size === "object") {
+    const width = Math.round(size.width);
+    const height = Math.round(size.height);
+    if (!(width >= 1) || !(height >= 1)) {
+      throw new Error(`rasterizeSvg: svgSize must be \u22651\xD71 (got ${size.width}\xD7${size.height})`);
+    }
+    return { width, height };
+  }
+  let w = dims.width;
+  let h = dims.height;
+  if (dims.viewBoxWidth != null && dims.viewBoxHeight != null) {
+    if (w == null && h != null) w = h * dims.viewBoxWidth / dims.viewBoxHeight;
+    else if (h == null && w != null) h = w * dims.viewBoxHeight / dims.viewBoxWidth;
+    else if (w == null && h == null) {
+      w = dims.viewBoxWidth;
+      h = dims.viewBoxHeight;
+    }
+  }
+  if (typeof size === "number") {
+    if (!(size >= 1)) {
+      throw new Error(`rasterizeSvg: svgSize must be \u22651 (got ${size})`);
+    }
+    const aspect = w != null && h != null ? w / h : 1;
+    return aspect >= 1 ? { width: Math.round(size), height: Math.max(1, Math.round(size / aspect)) } : { width: Math.max(1, Math.round(size * aspect)), height: Math.round(size) };
+  }
+  if (w == null || h == null) {
+    throw new Error(
+      "rasterizeSvg: the SVG has no intrinsic size (no absolute width/height attributes and no viewBox) \u2014 pass svgSize to choose a rasterisation size"
+    );
+  }
+  return { width: Math.max(1, Math.round(w)), height: Math.max(1, Math.round(h)) };
+}
+function setSvgRootSize(svgText, width, height) {
+  const m = ROOT_TAG_RE.exec(svgText);
+  if (!m) {
+    throw new Error("rasterizeSvg: no <svg> root element found in source");
+  }
+  let tag = m[0];
+  const origWidth = parseAbsoluteLength(getAttr(tag, "width"));
+  const origHeight = parseAbsoluteLength(getAttr(tag, "height"));
+  const hasViewBox = getAttr(tag, "viewBox") != null;
+  tag = removeAttr(removeAttr(tag, "width"), "height");
+  let inject = ` width="${width}" height="${height}"`;
+  if (!hasViewBox && origWidth != null && origHeight != null) {
+    inject += ` viewBox="0 0 ${origWidth} ${origHeight}"`;
+  }
+  tag = `<svg${inject}${tag.slice("<svg".length)}`;
+  return svgText.slice(0, m.index) + tag + svgText.slice(m.index + m[0].length);
+}
+async function rasterizeSvg(source, options = {}) {
+  if (typeof Image === "undefined") {
+    throw new Error(
+      "rasterizeSvg: SVG rasterisation needs a DOM Image element and cannot run in this environment (e.g. a worker)"
+    );
+  }
+  const svgText = typeof source === "string" ? source : await source.text();
+  const dims = parseSvgDimensions(svgText);
+  if (!dims) {
+    throw new Error("rasterizeSvg: no <svg> root element found in source");
+  }
+  const { width, height } = resolveSvgRasterSize(dims, options.size);
+  const sized = setSvgRootSize(svgText, width, height);
+  const url = URL.createObjectURL(new Blob([sized], { type: "image/svg+xml;charset=utf-8" }));
+  try {
+    const img = new Image();
+    img.decoding = "async";
+    await new Promise((resolve, reject) => {
+      img.onload = () => resolve();
+      img.onerror = () => reject(new Error("rasterizeSvg: the browser failed to decode the SVG"));
+      img.src = url;
+    });
+    await img.decode().catch(() => {
+    });
+    const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(width, height) : Object.assign(document.createElement("canvas"), { width, height });
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      throw new Error("rasterizeSvg: no 2D context available");
+    }
+    ctx.drawImage(img, 0, 0, width, height);
+    return await createImageBitmap(canvas, { colorSpaceConversion: "none", premultiplyAlpha: "none" });
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
 export {
   ASTC4x4Encoder,
   ASTC4x4WebGLEncoder,
@@ -1461,6 +1583,7 @@ export {
   getSharedWebGLContext,
   isWebGLAvailable,
   padToBlockMultiple,
+  rasterizeSvg,
   selectFormat,
   selectWebGLFormat
 };

package/dist/three.d.ts

@@ -1,11 +1,16 @@
-import { TextureHint, PreferredFormat, EncodeQuality, TextureFormat, Encoder, EncoderImageSource } from './index.js';
-export { ASTC4x4Encoder, ASTC4x4WebGLEncoder, BC1Encoder, BC1WebGLEncoder, BC5Encoder, BC5WebGLEncoder, BC7Encoder, BC7WebGLEncoder, Capabilities, EncodeBytesResult, EncodeCallOptions, EncoderConstructor, EncoderOptions, ExtensionProvider, FeatureProvider, FormatSelection, FormatVariant, MipLevel, RawPixelSource, SelectFormatOptions, WebGLBlockEncoder, WebGLCapabilities, WebGLEncodeBytesResult, WebGLEncoderConstructor, WebGLEncoderImageSource, WebGLEncoderOptions, WebGLFormatSelection, WebGPUFeature, createWebGLContext, detectCapabilities, detectWebGLCapabilities, generateMipChain, getSharedWebGLContext, isWebGLAvailable, padToBlockMultiple, selectFormat, selectWebGLFormat } from './index.js';
+import { TextureHint, PreferredFormat, SvgRasterSize, EncodeQuality, TextureFormat, Encoder, EncoderImageSource } from './index.js';
+export { ASTC4x4Encoder, ASTC4x4WebGLEncoder, BC1Encoder, BC1WebGLEncoder, BC5Encoder, BC5WebGLEncoder, BC7Encoder, BC7WebGLEncoder, Capabilities, EncodeBytesResult, EncodeCallOptions, EncoderConstructor, EncoderOptions, ExtensionProvider, FeatureProvider, FormatSelection, FormatVariant, MipLevel, RasterizeSvgOptions, RawPixelSource, SelectFormatOptions, WebGLBlockEncoder, WebGLCapabilities, WebGLEncodeBytesResult, WebGLEncoderConstructor, WebGLEncoderImageSource, WebGLEncoderOptions, WebGLFormatSelection, WebGPUFeature, createWebGLContext, detectCapabilities, detectWebGLCapabilities, generateMipChain, getSharedWebGLContext, isWebGLAvailable, padToBlockMultiple, rasterizeSvg, selectFormat, selectWebGLFormat } from './index.js';
 import { Texture, CompressedTexture, Loader, CompressedPixelFormat } from 'three';
 
 /**
  * Everything `compressTexture()` can take as an image source. A superset
  * of `EncoderImageSource` (see Encoder.ts) that also accepts URL strings
  * and Blob / File objects — the common cases in a web app.
+ *
+ * SVG works through all of these: a URL to an `.svg` file, a string of
+ * inline SVG markup (detected by a leading `<`), an SVG Blob/File, or an
+ * HTMLImageElement whose src is SVG. Vector sources are rasterised to RGBA
+ * before encoding — see the `svgSize` option.
  */
 type CompressTextureSource = string | Blob | File | ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageData;
 interface CompressOptions {
@@ -21,6 +26,14 @@ interface CompressOptions {
     preferredFormat?: PreferredFormat;
     /** Pick the sRGB or linear variant of the chosen format. Default 'srgb'. */
     colorSpace?: 'srgb' | 'linear';
+    /**
+     * Rasterisation size for SVG sources. A number scales the SVG so its
+     * longest side matches (aspect ratio preserved); `{ width, height }`
+     * rasterises at exactly that size. Default: the SVG's intrinsic size
+     * (absolute width/height attributes, else the viewBox dimensions).
+     * Ignored for non-SVG sources.
+     */
+    svgSize?: SvgRasterSize;
     /** Flip the image vertically before encoding. Default true (matches Three.js convention). */
     flipY?: boolean;
     /** Generate a full mip chain down to 1×1 on the CPU, encode every level. */
@@ -79,6 +92,12 @@ declare class GputexLoader extends Loader<Texture> {
     preferredFormat?: PreferredFormat;
     /** Pick the sRGB or linear variant of the chosen format. Default 'srgb'. */
     colorSpace: 'srgb' | 'linear';
+    /**
+     * Rasterisation size for SVG URLs — a number (longest side, aspect
+     * preserved) or exact `{ width, height }`. Default: the SVG's intrinsic
+     * size. See `CompressOptions.svgSize`.
+     */
+    svgSize?: SvgRasterSize;
     /** Flip the image vertically before encoding. Default true (matches Three.js convention). */
     flipY: boolean;
     /** Generate + encode a full mip chain. Default false. */
@@ -152,4 +171,4 @@ interface EncodeToTextureOptions {
  */
 declare function encodeToTexture(encoder: Encoder, source: EncoderImageSource, { colorSpace, quality, flipY }?: EncodeToTextureOptions): Promise<EncodeResult>;
 
-export { type CompressOptions, type CompressResult, type CompressTextureSource, EncodeQuality, type EncodeResult, type EncodeToTextureOptions, Encoder, EncoderImageSource, GputexLoader, PreferredFormat, TextureFormat, TextureHint, buildCompressedTexture, compressTexture, encodeToTexture, threeFormatFor };
+export { type CompressOptions, type CompressResult, type CompressTextureSource, EncodeQuality, type EncodeResult, type EncodeToTextureOptions, Encoder, EncoderImageSource, GputexLoader, PreferredFormat, SvgRasterSize, TextureFormat, TextureHint, buildCompressedTexture, compressTexture, encodeToTexture, threeFormatFor };

package/dist/three.js

@@ -1446,6 +1446,140 @@ function padToBlockMultiple(level) {
   return { data: out, width: pw, height: ph };
 }
 
+// src/svg.ts
+function isSvgMarkup(source) {
+  return source.trimStart().startsWith("<");
+}
+function hasSvgExtension(url) {
+  return /\.svg$/i.test(url.split(/[?#]/, 1)[0]);
+}
+function isSvgBlob(blob) {
+  if (blob.type) {
+    return blob.type.split(";", 1)[0].trim().toLowerCase() === "image/svg+xml";
+  }
+  return typeof File !== "undefined" && blob instanceof File && hasSvgExtension(blob.name);
+}
+var ROOT_TAG_RE = /<svg(?=[\s/>])[^>]*>/;
+function getAttr(tag, name) {
+  const m = new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`).exec(tag);
+  return m ? m[1] ?? m[2] ?? "" : null;
+}
+function removeAttr(tag, name) {
+  return tag.replace(new RegExp(`\\s${name}\\s*=\\s*(?:"[^"]*"|'[^']*')`, "g"), "");
+}
+function parseAbsoluteLength(value) {
+  if (value == null) return null;
+  const m = /^\s*\+?(\d+(?:\.\d+)?|\.\d+)(?:px)?\s*$/i.exec(value);
+  if (!m) return null;
+  const n = Number(m[1]);
+  return n > 0 ? n : null;
+}
+function parseSvgDimensions(svgText) {
+  const m = ROOT_TAG_RE.exec(svgText);
+  if (!m) return null;
+  const tag = m[0];
+  const dims = {
+    width: parseAbsoluteLength(getAttr(tag, "width")),
+    height: parseAbsoluteLength(getAttr(tag, "height")),
+    viewBoxWidth: null,
+    viewBoxHeight: null
+  };
+  const viewBox = getAttr(tag, "viewBox");
+  if (viewBox) {
+    const parts = viewBox.trim().split(/[\s,]+/).map(Number);
+    if (parts.length === 4 && parts.every(Number.isFinite) && parts[2] > 0 && parts[3] > 0) {
+      dims.viewBoxWidth = parts[2];
+      dims.viewBoxHeight = parts[3];
+    }
+  }
+  return dims;
+}
+function resolveSvgRasterSize(dims, size) {
+  if (size !== void 0 && typeof size === "object") {
+    const width = Math.round(size.width);
+    const height = Math.round(size.height);
+    if (!(width >= 1) || !(height >= 1)) {
+      throw new Error(`rasterizeSvg: svgSize must be \u22651\xD71 (got ${size.width}\xD7${size.height})`);
+    }
+    return { width, height };
+  }
+  let w = dims.width;
+  let h = dims.height;
+  if (dims.viewBoxWidth != null && dims.viewBoxHeight != null) {
+    if (w == null && h != null) w = h * dims.viewBoxWidth / dims.viewBoxHeight;
+    else if (h == null && w != null) h = w * dims.viewBoxHeight / dims.viewBoxWidth;
+    else if (w == null && h == null) {
+      w = dims.viewBoxWidth;
+      h = dims.viewBoxHeight;
+    }
+  }
+  if (typeof size === "number") {
+    if (!(size >= 1)) {
+      throw new Error(`rasterizeSvg: svgSize must be \u22651 (got ${size})`);
+    }
+    const aspect = w != null && h != null ? w / h : 1;
+    return aspect >= 1 ? { width: Math.round(size), height: Math.max(1, Math.round(size / aspect)) } : { width: Math.max(1, Math.round(size * aspect)), height: Math.round(size) };
+  }
+  if (w == null || h == null) {
+    throw new Error(
+      "rasterizeSvg: the SVG has no intrinsic size (no absolute width/height attributes and no viewBox) \u2014 pass svgSize to choose a rasterisation size"
+    );
+  }
+  return { width: Math.max(1, Math.round(w)), height: Math.max(1, Math.round(h)) };
+}
+function setSvgRootSize(svgText, width, height) {
+  const m = ROOT_TAG_RE.exec(svgText);
+  if (!m) {
+    throw new Error("rasterizeSvg: no <svg> root element found in source");
+  }
+  let tag = m[0];
+  const origWidth = parseAbsoluteLength(getAttr(tag, "width"));
+  const origHeight = parseAbsoluteLength(getAttr(tag, "height"));
+  const hasViewBox = getAttr(tag, "viewBox") != null;
+  tag = removeAttr(removeAttr(tag, "width"), "height");
+  let inject = ` width="${width}" height="${height}"`;
+  if (!hasViewBox && origWidth != null && origHeight != null) {
+    inject += ` viewBox="0 0 ${origWidth} ${origHeight}"`;
+  }
+  tag = `<svg${inject}${tag.slice("<svg".length)}`;
+  return svgText.slice(0, m.index) + tag + svgText.slice(m.index + m[0].length);
+}
+async function rasterizeSvg(source, options = {}) {
+  if (typeof Image === "undefined") {
+    throw new Error(
+      "rasterizeSvg: SVG rasterisation needs a DOM Image element and cannot run in this environment (e.g. a worker)"
+    );
+  }
+  const svgText = typeof source === "string" ? source : await source.text();
+  const dims = parseSvgDimensions(svgText);
+  if (!dims) {
+    throw new Error("rasterizeSvg: no <svg> root element found in source");
+  }
+  const { width, height } = resolveSvgRasterSize(dims, options.size);
+  const sized = setSvgRootSize(svgText, width, height);
+  const url = URL.createObjectURL(new Blob([sized], { type: "image/svg+xml;charset=utf-8" }));
+  try {
+    const img = new Image();
+    img.decoding = "async";
+    await new Promise((resolve, reject) => {
+      img.onload = () => resolve();
+      img.onerror = () => reject(new Error("rasterizeSvg: the browser failed to decode the SVG"));
+      img.src = url;
+    });
+    await img.decode().catch(() => {
+    });
+    const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(width, height) : Object.assign(document.createElement("canvas"), { width, height });
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      throw new Error("rasterizeSvg: no 2D context available");
+    }
+    ctx.drawImage(img, 0, 0, width, height);
+    return await createImageBitmap(canvas, { colorSpaceConversion: "none", premultiplyAlpha: "none" });
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+
 // src/three/compressTexture.ts
 import { LinearFilter as LinearFilter2, LinearSRGBColorSpace as LinearSRGBColorSpace2, RepeatWrapping as RepeatWrapping2, SRGBColorSpace as SRGBColorSpace2, Texture } from "three";
 
@@ -1518,27 +1652,49 @@ async function encodeToTexture(encoder, source, { colorSpace = "srgb", quality =
 }
 
 // src/three/compressTexture.ts
-async function sourceToBitmap(source) {
+async function sourceToBitmap(source, svgSize) {
   const opts = {
     colorSpaceConversion: "none",
     premultiplyAlpha: "none"
   };
   if (typeof source === "string") {
+    if (isSvgMarkup(source)) {
+      return rasterizeSvg(source, { size: svgSize });
+    }
     const resp = await fetch(source);
     if (!resp.ok) {
       throw new Error(`compressTexture: fetch ${source} failed (${resp.status})`);
     }
     const blob = await resp.blob();
+    if (isSvgBlob(blob) || !isImageMimeType(blob.type) && hasSvgExtension(source)) {
+      return rasterizeSvg(blob, { size: svgSize });
+    }
     return createImageBitmap(blob, opts);
   }
   if (source instanceof Blob) {
+    if (isSvgBlob(source)) {
+      return rasterizeSvg(source, { size: svgSize });
+    }
     return createImageBitmap(source, opts);
   }
   if (source instanceof ImageBitmap) {
     return source;
   }
+  if (typeof HTMLImageElement !== "undefined" && source instanceof HTMLImageElement) {
+    const src = source.currentSrc || source.src;
+    if (src && (hasSvgExtension(src) || /^data:image\/svg\+xml/i.test(src))) {
+      const resp = await fetch(src);
+      if (!resp.ok) {
+        throw new Error(`compressTexture: fetch ${src} failed (${resp.status})`);
+      }
+      return rasterizeSvg(await resp.blob(), { size: svgSize });
+    }
+  }
   return createImageBitmap(source, opts);
 }
+function isImageMimeType(type) {
+  return /^image\//i.test(type) && !/svg/i.test(type);
+}
 function bitmapToMipLevel(bitmap, flipY) {
   const w = bitmap.width, h = bitmap.height;
   const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(w, h) : Object.assign(document.createElement("canvas"), { width: w, height: h });
@@ -1573,6 +1729,7 @@ async function compressTexture(source, options = {}) {
     hint = "color",
     preferredFormat,
     colorSpace = "srgb",
+    svgSize,
     flipY = true,
     mipmaps = false,
     quality = "fast",
@@ -1580,7 +1737,7 @@ async function compressTexture(source, options = {}) {
     adapter: providedAdapter
   } = options;
   const srgb = colorSpace === "srgb";
-  const bitmap = await sourceToBitmap(source);
+  const bitmap = await sourceToBitmap(source, svgSize);
   const viaWebGPU = await encodeViaWebGPU();
   if (viaWebGPU) return viaWebGPU;
   const viaWebGL = encodeViaWebGL();
@@ -1750,6 +1907,12 @@ var GputexLoader = class extends Loader {
   preferredFormat;
   /** Pick the sRGB or linear variant of the chosen format. Default 'srgb'. */
   colorSpace = "srgb";
+  /**
+   * Rasterisation size for SVG URLs — a number (longest side, aspect
+   * preserved) or exact `{ width, height }`. Default: the SVG's intrinsic
+   * size. See `CompressOptions.svgSize`.
+   */
+  svgSize;
   /** Flip the image vertically before encoding. Default true (matches Three.js convention). */
   flipY = true;
   /** Generate + encode a full mip chain. Default false. */
@@ -1781,6 +1944,7 @@ var GputexLoader = class extends Loader {
       hint: this.hint,
       preferredFormat: this.preferredFormat,
       colorSpace: this.colorSpace,
+      svgSize: this.svgSize,
       flipY: this.flipY,
       mipmaps: this.mipmaps,
       quality: this.quality,
@@ -1836,6 +2000,7 @@ export {
   getSharedWebGLContext,
   isWebGLAvailable,
   padToBlockMultiple,
+  rasterizeSvg,
   selectFormat,
   selectWebGLFormat,
   threeFormatFor

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gputex",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "license": "MIT",
   "files": [
     "dist"