code-editor/outputframe-app/elements/render-canvas/render-canvas.ts

import { BaseElement } from '../../../shared/_base';
import './render-canvas.less';

export class RenderCanvas extends BaseElement {
    public canvas: HTMLCanvasElement | null = null;
    public ctx: CanvasRenderingContext2D | null = null;
    public width: number = 0;
    public height: number = 0;
    public units = {
        width: 400,
        height: 400
    }
    public drawCount: number = 0;
    public drawQueue: { points: { x: number, y: number }[], color?: string }[] = [];

    public prefersDarkScheme = window.matchMedia("(prefers-color-scheme: dark)");

    onInit(): void {
        this.canvas = document.createElement("canvas");
        this.ctx = <CanvasRenderingContext2D>this.canvas.getContext("2d");
        this.appendChild(this.canvas);
        this.canvas.style.display = "none";

        window.addEventListener("resize", () => {
            this.handleCanvasResize();
        });

        this.handleCanvasResize();
    }

    private handleCanvasResize() {
        if (this.parentElement && this.canvas) {
            this.width = Math.floor(this.parentElement.clientWidth - 20);
            this.height = Math.floor(this.parentElement.clientHeight - 20);

            var smallest = Math.min(this.width, this.height);

            this.canvas.style.width = smallest + "px";
            this.canvas.style.height = smallest + "px";
            this.canvas.setAttribute("width", smallest.toString());
            this.canvas.setAttribute("height", smallest.toString());
        }
    }

    drawPoly(points: { x: number, y: number }[], color?: string) {
        if (this.ctx && this.canvas) {
            this.canvas.style.display = "block";
            this.ctx.fillStyle = this.getColor(true);
            this.ctx.strokeStyle = this.getColor(false, color);
            this.ctx.beginPath();

            for (var i = 0; i < points.length; i++) {
                var point = points[i];

                if (i === 0) {
                    this.ctx.moveTo(this.unitsToPx(point.x), this.unitsToPx(point.y));
                }
                else {
                    this.ctx.lineTo(this.unitsToPx(point.x), this.unitsToPx(point.y));
                }
            }

            this.ctx.closePath();
            this.ctx.fill();
            this.ctx.stroke();
        }
    }

    centerOf(points: { x: number, y: number }[]) {
        var x = 0,
            y = 0,
            i,
            j,
            f,
            point1,
            point2;

        for (i = 0, j = points.length - 1; i < points.length; j = i, i++) {
            point1 = points[i];
            point2 = points[j];
            f = point1.x * point2.y - point2.x * point1.y;
            x += (point1.x + point2.x) * f;
            y += (point1.y + point2.y) * f;
        }

        f = this.areaOf(points) * 6;

        return { x: x / f, y: y / f };
    };

    areaOf(points: { x: number, y: number }[]) {
        var area = 0,
            i,
            j,
            point1,
            point2;

        for (i = 0, j = points.length - 1; i < points.length; j = i, i++) {
            point1 = points[i];
            point2 = points[j];
            area += point1.x * point2.y;
            area -= point1.y * point2.x;
        }
        area /= 2;

        return area;
    };

    executeDrawQueue() {
        let prevShape: any | null = null;
        for (let i = 0; i < this.drawQueue.length; i++) {
            const shape = this.drawQueue[i];

            if (prevShape != null) {
                var prevCenter = this.centerOf(prevShape.points);
                var thisCenter = this.centerOf(shape.points);

                var middle = {
                    x: (prevCenter.x + thisCenter.x) / 2,
                    y: (prevCenter.y + thisCenter.y) / 2
                };

                this.drawPoly([prevCenter, middle], prevShape.color);
                this.drawPoly([middle, thisCenter], shape.color);
            }

            prevShape = shape;
        }

        for (let i = 0; i < this.drawQueue.length; i++) {
            const shape = this.drawQueue[i];
            this.drawPoly(shape.points, shape.color);
            var thisCenter = this.centerOf(shape.points);
            this.drawText(thisCenter.x, thisCenter.y, (i + 1).toString(), shape.points[1].x - shape.points[0].x, shape.color);
        }
    }

    drawText(x: number, y: number, text: string, size: number = 20, color?: string) {
        if (this.ctx && this.canvas) {
            this.ctx.moveTo(x, y);
            this.ctx.fillStyle = this.getColor(false, color);
            this.ctx.textAlign = 'center';
            this.ctx.textBaseline = 'middle';
            this.ctx.font = "200 " + size + "px Segoe UI";
            this.ctx.fillText(text, this.unitsToPx(x), this.unitsToPx(y));
        }
    }

    getColor(invert: boolean = false, color?: string) {
        return color ? color : ((invert ? !this.prefersDarkScheme.matches : this.prefersDarkScheme.matches) ? 'rgba(255,255,255,1)' : 'rgba(44,44,44,1)');
    }

    drawRect(x: number, y: number, width: number, height: number, color?: string) {
        this.drawPoly([{ x: x, y: y }, { x: x + width, y: y }, { x: x + width, y: y + height }, { x: x, y: y + height }], color);
    }

    queuePoly(points: { x: number, y: number }[], color?: string) {
        this.drawQueue.push({ points: points, color: color });
    }

    queueRect(x: number, y: number, width: number, height: number, color?: string) {
        this.drawQueue.push({ points: [{ x: x, y: y }, { x: x + width, y: y }, { x: x + width, y: y + height }, { x: x, y: y + height }], color: color });
    }

    unitsToPx(unitNumber: number) {
        var newPPU = Math.min(this.width, this.height) / this.units.width;
        return unitNumber * newPPU;
    }
}