Fixed export offset issue

        const wScale = 2 * area.w / source.totalSize[0] / this.gl.drawingBufferWidth,

            hScale = 2 * area.h / source.totalSize[1] / this.gl.drawingBufferHeight,

            proj = mat4.fromScaling(mat4.create(), [wScale, hScale, 1]);

        mat4.translate(proj, proj, [-area.x, -area.y, 0]);

        this.renderWithProj(source, proj, data);

    }

import {Dataset, TiledDataset} from "../dataset.ts";

import {RelightProgram, RenderData} from "../gl-program.ts";

import {DLBarStatus, DLBarStatusEvent, DownloadManager, ProgFunc} from "../download.ts";

import {Rect} from "../tiling.ts";

import { Dataset, TiledDataset } from '../dataset.ts';

import { RelightProgram, RenderData } from '../gl-program.ts';

import { DLBarStatus, DLBarStatusEvent, DownloadManager, ProgFunc } from '../download.ts';

import { Rect } from '../tiling.ts';

declare var self: DedicatedWorkerGlobalScope;

export type ExportWorkerData = RenderData & {

    dataset: Dataset['data'],

}

    dataset: Dataset['data'];

};

export type ExportWorkerResult = {

    type: "finished",

    imageBlob: Blob,

} | {

    type: "progress",

    status: DLBarStatus,

export type ExportWorkerResult =

    | {

          type: 'finished';

          imageBlob: Blob;

      }

    | {

          type: 'progress';

          status: DLBarStatus;

      };

DownloadManager.setBar(false);

DownloadManager.updateTarget.addEventListener(DownloadManager.updateEventType, (ev) => {

    const status = (ev as DLBarStatusEvent).status;

    self.postMessage({type: "progress", status} as ExportWorkerResult);

    self.postMessage({ type: 'progress', status } as ExportWorkerResult);

});

onmessage = async (e: MessageEvent<ExportWorkerData>) => {

    console.debug("Export worker received", e);

    await new Promise((res) => requestAnimationFrame(res))

    console.debug('Export worker received', e);

    await new Promise((res) => requestAnimationFrame(res));

    let blob = await DownloadManager.withProgressBar(async (prog) => {

        const canvas = await relightWebGL(e.data, prog);

        return canvas.convertToBlob({ type: 'image/png' });

    });

    self.postMessage({type: "finished", imageBlob: blob} as ExportWorkerResult);

    self.postMessage({ type: 'finished', imageBlob: blob } as ExportWorkerResult);

    close();

}

};

// @ts-ignore

async function relightWebGL(data: ExportWorkerData, _prog: ProgFunc): Promise<OffscreenCanvas> {

    const ds = Dataset.fromData(data.dataset);

    if (ds instanceof TiledDataset)

        throw new Error("Not implemented yet"); // TODO implement

    if (ds instanceof TiledDataset) throw new Error('Not implemented yet'); // TODO implement

    const canvas = new OffscreenCanvas(16, 16);

    const gl = canvas.getContext("webgl");

    const gl = canvas.getContext('webgl');

    if (!gl) throw new Error("Couldn't create WebGL context");

    let source = await ds.getTextureSource(gl, () => {

    });

    const area = new Rect(0, 0, ...source.totalSize);

    let source = await ds.getTextureSource(gl, () => {});

    const area = new Rect(source.totalSize[0] / 2, source.totalSize[1] / 2, ...source.totalSize);

    await source.updateTiles(0, area, true);

    [canvas.width, canvas.height] = source.totalSize;

    let relight = new RelightProgram(gl);

    console.debug('Rendering area', area);

    relight.renderArea(source, data, area);

    gl.flush();