Feature/ save & load scene (#47)

* save scene
* load scene from url
* load scene can put back the image nodes now
* now saved image nodes retain its tansform perfectly
* can now save and load videonodes in scene saving
* netlify redirect
* save and load text nodes
* fix text styling, fix adding video node via rendering
This commit is contained in:
wil authored and GitHub committed 2024-10-10 22:46:40 -04:00
1 parent c7edfe246a
commit 5a28aecaf6
17 files changed
+582 -95

No files matched your search

+1 -1
View File
@@ -7,4 +7,4 @@
# configuration file.
/login /index.html 200!
/m_* /index.html 200!
+43 -27
View File
@@ -5,6 +5,7 @@ import { ResponseType } from "./WorkerPrimitives/SharedWorkerBase";
import { uiAccess, uiEvents } from "~/signals";
import { SceneManager } from "./SceneManager";
import {
NodesManager,
NodeTransformer,
@@ -15,7 +16,13 @@ import {
SelectorSquare,
} from "./NodesManagers";
import { ImageNode, VideoNode, TextNode } from "./Nodes";
import { MediaNode, Position, TextNodeData, Transformation } from "./types";
import {
EngineOptions,
MediaNode,
Position,
TextNodeData,
Transformation,
} from "./types";
import {
CreateCommand,
@@ -37,6 +44,7 @@ import {
import { AppModes, VideoResolutions } from "./constants";
import { ToolbarMainButtonNames } from "~/components/features/ToolbarMain/enum";
import { NavigateFunction } from "react-router-dom";
// for testing loading files from system
// import { FileUtilities } from "./FileUtilities/FileUtilities";
@@ -54,6 +62,7 @@ export interface RenderingOptions {
}
export class Engine {
private navigateRef: NavigateFunction;
private appMode: AppModes;
private canvasReference: HTMLDivElement;
private stage: Konva.Stage;
@@ -68,14 +77,15 @@ export class Engine {
private selectionManager: SelectionManager;
private selectorSquare: SelectorSquare;
private sceneManager: SceneManager;
private undoStackManager: UndoStackManager;
// signal reference
constructor(canvasReference: HTMLDivElement) {
constructor(canvasReference: HTMLDivElement, options: EngineOptions) {
if (import.meta.env.DEV) {
console.log("Engine Created");
}
this.navigateRef = options.navigate;
this.appMode = AppModes.SELECT;
this.canvasReference = canvasReference;
@@ -98,13 +108,6 @@ export class Engine {
this.selectorSquare = new SelectorSquare();
this.uiLayer.add(this.selectorSquare.getKonvaNode());
// Collection of all Nodes
this.nodesManager = new NodesManager();
// Partial Collection of selected Nodes
this.selectionManager = new SelectionManager({
nodeTransformerRef: this.nodeTransformer,
mediaLayerRef: this.mediaLayer,
});
// Collection of commands for undo-redo
this.undoStackManager = new UndoStackManager();
@@ -130,6 +133,28 @@ export class Engine {
this.onRenderingSystemReceived.bind(this),
});
// Collection of all Nodes
this.nodesManager = new NodesManager();
// Partial Collection of selected Nodes
this.selectionManager = new SelectionManager({
nodeTransformerRef: this.nodeTransformer,
mediaLayerRef: this.mediaLayer,
});
// set up secene manager
this.sceneManager = new SceneManager({
navigateRef: this.navigateRef,
mediaLayerRef: this.mediaLayer,
nodesManagerRef: this.nodesManager,
selectionManagerRef: this.selectionManager,
renderEngineRef: this.renderEngine,
});
// load the scene if there's a scenetoken
if (options.sceneToken) {
this.sceneManager.loadScene(options.sceneToken);
}
// some of the managers has events
// hence, lastly, setup these events
this.setupEventSystem();
}
@@ -173,15 +198,8 @@ export class Engine {
// choose it to be the size of the rendering output, this case its mobile. (1560, 400)
const media_api_base_url = "https://storage.googleapis.com/";
const media_url = `${media_api_base_url}vocodes-public${data.videoUrl}`;
const videoNode = new VideoNode({
mediaLayerRef: this.mediaLayer,
canvasPosition: this.renderEngine.captureCanvas.position(),
canvasSize: this.renderEngine.captureCanvas.size(),
videoURL: media_url,
selectionManagerRef: this.selectionManager,
});
this.renderEngine.addNodes(videoNode);
console.log("Engine got stylized video: " + media_url);
this.addVideo(media_url);
// hide the loader
//this.renderEngine.videoLoadingCanvas.kNode.hide();
uiAccess.toolbarMain.loadingBar.hide();
@@ -271,7 +289,7 @@ export class Engine {
});
uiEvents.onGetStagedVideo((video) => {
console.log("Engine got video: " + video.url);
console.log("Engine got user video: " + video.url);
this.addVideo(video.url);
});
uiEvents.onAddTextToEngine((textdata) => {
@@ -312,7 +330,9 @@ export class Engine {
uiEvents.toolbarMain.UNDO.onClick(() => this.undoStackManager.undo());
uiEvents.toolbarMain.REDO.onClick(() => this.undoStackManager.redo());
uiEvents.toolbarMain.SAVE.onClick(async (/*event*/) => {});
uiEvents.toolbarMain.SAVE.onClick(async (/*event*/) => {
this.sceneManager.saveScene();
});
}
sleep(ms: number): Promise<void> {
@@ -383,12 +403,8 @@ export class Engine {
textNodeData: textNodeData,
mediaLayerRef: this.mediaLayer,
selectionManagerRef: this.selectionManager,
position: {
x: this.renderEngine.captureCanvas.x() + 20,
y:
this.renderEngine.captureCanvas.y() +
this.renderEngine.captureCanvas.height() / 3,
},
canvasPosition: this.renderEngine.captureCanvas.position(),
canvasSize: this.renderEngine.captureCanvas.size(),
});
this.createNode(textNode);
}
+5 -3
View File
@@ -2,12 +2,12 @@ import Konva from "konva";
import { SelectionManager } from "../NodesManagers";
import { highlightStrokeWidth, primaryOrange } from "./constants";
import { NodeData, Position } from "../types";
export class BaseNode {
export abstract class BaseNode {
protected selectionManagerRef: SelectionManager;
public kNode: Konva.Node;
public kNode: Konva.Image | Konva.Group;
protected mediaLayerRef: Konva.Layer;
// protected uuid: string;
// Internal State members
// do not modify internal
@@ -17,6 +17,8 @@ export class BaseNode {
protected _isLocked: boolean = false;
protected _isKEventRef: boolean = false;
abstract getNodeData(captureCanvasPosition: Position): NodeData;
constructor({
selectionManagerRef,
mediaLayerRef,
+88 -21
View File
@@ -2,42 +2,60 @@ import Konva from "konva";
import { MediaFilesApi, MediaUploadApi } from "~/Classes/ApiManager";
import { SelectionManager } from "../NodesManagers";
import { Position, Size } from "../types";
import { Position, Size, NodeData, TransformationData } from "../types";
import { NetworkedNode, UploadStatus } from "./NetworkedNode";
import { minNodeSize, transparent } from "./constants";
import { minNodeSize, NodeType, transparent } from "./constants";
import { NodeUtilities } from "./NodeUtilities";
interface ImageNodeContructor {
canvasPosition: Position;
canvasSize: Size;
imageFile: File;
imageFile?: File;
mediaFileToken?: string;
mediaFileUrl?: string;
transform?: TransformationData;
mediaLayerRef: Konva.Layer;
selectionManagerRef: SelectionManager;
}
export class ImageNode extends NetworkedNode {
public kNode: Konva.Image;
private imageSize: Size;
public imageSize?: Size;
constructor({
canvasPosition,
canvasSize,
imageFile,
mediaFileToken,
mediaFileUrl,
transform: existingTransform,
mediaLayerRef,
selectionManagerRef,
}: ImageNodeContructor) {
// kNodes need to be created first to guaruntee
// that it is not undefined in parent's context
const transform = existingTransform
? {
...existingTransform,
position: {
x: existingTransform.position.x + canvasPosition.x,
y: existingTransform.position.y + canvasPosition.y,
},
fill: transparent,
}
: {
position: NodeUtilities.positionNodeOnCanvasCenter({
canvasOffset: canvasPosition,
componentSize: minNodeSize,
maxSize: canvasSize,
}),
size: minNodeSize,
fill: "gray",
};
const kNode = new Konva.Image({
image: undefined, // to do replace with placeholder
size: minNodeSize,
position: NodeUtilities.positionNodeOnCanvasCenter({
canvasOffset: canvasPosition,
componentSize: minNodeSize,
maxSize: canvasSize,
}),
fill: "gray",
...transform,
draggable: true,
strokeScaleEnabled: false,
});
@@ -48,11 +66,35 @@ export class ImageNode extends NetworkedNode {
localFile: imageFile,
});
this.kNode = kNode;
this.imageSize = minNodeSize;
// this.imageSize = minNodeSize;
this.mediaLayerRef.add(this.kNode);
if (imageFile) {
this.loadImageFromFile({
imageFile: imageFile,
maxSize: canvasSize,
refPosition: canvasPosition,
});
return;
}
if (mediaFileUrl && transform) {
this.mediaFileToken = mediaFileToken;
this.mediaFileUrl = mediaFileUrl;
this.loadImageFromUrl(mediaFileUrl);
return;
}
console.log("image node creation is fucked");
}
private loadImageFromFile({
imageFile,
maxSize,
refPosition,
}: {
imageFile: File;
maxSize: Size;
refPosition: Position;
}) {
const imageComponent = new Image();
imageComponent.onload = () => {
this.setProgress(0, UploadStatus.FILE_STAGED);
this.imageSize = {
@@ -61,12 +103,12 @@ export class ImageNode extends NetworkedNode {
};
const adjustedSize = NodeUtilities.adjustNodeSizeToCanvas({
componentSize: this.imageSize,
maxSize: canvasSize,
maxSize: maxSize,
});
const centerPosition = NodeUtilities.positionNodeOnCanvasCenter({
canvasOffset: canvasPosition,
canvasOffset: refPosition,
componentSize: adjustedSize,
maxSize: canvasSize,
maxSize: maxSize,
});
this.kNode.image(imageComponent);
this.kNode.setSize(adjustedSize);
@@ -82,11 +124,9 @@ export class ImageNode extends NetworkedNode {
};
imageComponent.src = URL.createObjectURL(imageFile);
}
private async updateImage(newImageSrc: string) {
private async loadImageFromUrl(mediaFileUrl: string) {
this.setProgress(75, UploadStatus.LOADING);
const newImage = new Image();
newImage.src = newImageSrc;
newImage.onerror = () => {
this.setProgress(90, UploadStatus.ERROR_ON_LOAD);
};
@@ -96,6 +136,8 @@ export class ImageNode extends NetworkedNode {
this.kNode.draw();
this.setProgress(100, UploadStatus.SUCCESS);
};
newImage.src = mediaFileUrl;
this.listenToBaseKNode();
}
private async uploadImage(imageFile: File) {
@@ -130,12 +172,12 @@ export class ImageNode extends NetworkedNode {
return;
}
this.mediaFileUrl = mediaFileResponse.data.public_bucket_url;
this.updateImage(this.mediaFileUrl);
this.loadImageFromUrl(this.mediaFileUrl);
}
public async retry() {
if (this.mediaFileUrl) {
this.updateImage(this.mediaFileUrl);
this.loadImageFromUrl(this.mediaFileUrl);
return;
}
if (this.mediaFileToken) {
@@ -148,4 +190,29 @@ export class ImageNode extends NetworkedNode {
}
console.warn("Image Node has no data to recontruct itself!");
}
public getNodeData(canvasPostion: Position) {
const data: NodeData = {
type: NodeType.IMAGE,
transform: {
position: {
x: this.kNode.position().x - canvasPostion.x,
y: this.kNode.position().y - canvasPostion.y,
},
size: this.kNode.size(),
rotation: this.kNode.rotation(),
scale: {
x: this.kNode.scaleX(),
y: this.kNode.scaleY(),
},
zIndex: this.kNode.getZIndex(),
},
};
if (this.mediaFileUrl) {
data.mediaFileUrl = this.mediaFileUrl;
}
if (this.mediaFileToken) {
data.mediaFileToken = this.mediaFileToken;
}
return data;
}
}
+3 -7
View File
@@ -16,7 +16,7 @@ export enum UploadStatus {
SUCCESS = "success",
}
export class NetworkedNode extends BaseNode {
export abstract class NetworkedNode extends BaseNode {
public kNode: Konva.Image;
public didFinishLoading: boolean = false;
protected _progress: number = 0;
@@ -25,7 +25,7 @@ export class NetworkedNode extends BaseNode {
protected mediaFileUrl?: string;
protected mediaFileStatus: UploadStatus = UploadStatus.INIT;
public errorMessage?: string;
abstract retry(): void;
constructor({
kNode,
selectionManagerRef,
@@ -61,11 +61,7 @@ export class NetworkedNode extends BaseNode {
];
return errorStatues.includes(this.mediaFileStatus);
}
public retry() {
console.warn(
"Retry function of Networked Node should be overridden by children",
);
}
protected uuidGenerate() {
return uuidv4();
}
+93 -5
View File
@@ -1,8 +1,16 @@
import Konva from "konva";
import { SelectionManager } from "../NodesManagers";
import { BaseNode } from "./BaseNode";
import { Position, Size, TextNodeData } from "../types";
import {
NodeData,
Position,
Size,
TextNodeChildrenTransformData,
TextNodeData,
TransformationData,
} from "../types";
import { NodeUtilities } from "./NodeUtilities";
import { NodeType } from "./constants";
export class TextNode extends BaseNode {
public kNode: Konva.Group;
@@ -17,14 +25,19 @@ export class TextNode extends BaseNode {
textNodeData,
selectionManagerRef,
mediaLayerRef,
position,
canvasPosition,
canvasSize,
transform: existingTransform,
textChildrenTransforms,
}: {
textNodeData: TextNodeData;
selectionManagerRef: SelectionManager;
mediaLayerRef: Konva.Layer;
position: Position;
canvasSize: Size;
canvasPosition: Position;
transform?: TransformationData;
textChildrenTransforms?: TextNodeChildrenTransformData;
}) {
console.log(textNodeData);
const textNode = new Konva.Text({
...textNodeData,
x: 10,
@@ -32,7 +45,14 @@ export class TextNode extends BaseNode {
width: 500,
});
const kNode = new Konva.Group({
position: position,
position: NodeUtilities.positionNodeOnCanvasCenter({
canvasOffset: canvasPosition,
componentSize: {
width: textNode.width() + 20,
height: textNode.height() + 20,
},
maxSize: canvasSize,
}),
width: textNode.width() + 20,
height: textNode.height() + 20,
draggable: true,
@@ -57,6 +77,13 @@ export class TextNode extends BaseNode {
this.rectNode = rectNode;
this.kNode.add(this.rectNode);
this.kNode.add(this.textNode);
if (existingTransform && textChildrenTransforms) {
this.applyTransform({
existingTransform,
textChildrenTransforms,
canvasPosition,
});
}
this.mediaLayerRef.add(this.kNode);
this.originalTextSize = this.textNode.size();
this.listenToBaseKNode();
@@ -95,4 +122,65 @@ export class TextNode extends BaseNode {
this.selectionManagerRef.transformEnd(this);
});
}
public getNodeData(canvasPostion: Position) {
const data: NodeData = {
type: NodeType.TEXT,
transform: {
position: {
x: this.kNode.position().x - canvasPostion.x,
y: this.kNode.position().y - canvasPostion.y,
},
size: this.kNode.size(),
rotation: this.kNode.rotation(),
scale: {
x: this.kNode.scaleX(),
y: this.kNode.scaleY(),
},
zIndex: this.kNode.getZIndex(),
},
textNodeData: this.textNodeData,
textChildrenTransforms: {
wrapperRectTransform: {
position: this.rectNode.position(),
size: this.rectNode.size(),
rotation: this.rectNode.rotation(),
scale: {
x: this.rectNode.scaleX(),
y: this.rectNode.scaleY(),
},
zIndex: this.rectNode.getZIndex(),
},
textNodeTransform: {
position: this.textNode.position(),
size: this.textNode.size(),
rotation: this.textNode.rotation(),
scale: {
x: this.textNode.scaleX(),
y: this.textNode.scaleY(),
},
zIndex: this.textNode.getZIndex(),
},
},
};
return data;
}
private applyTransform({
canvasPosition,
existingTransform,
textChildrenTransforms,
}: {
canvasPosition: Position;
existingTransform: TransformationData;
textChildrenTransforms: TextNodeChildrenTransformData;
}) {
this.kNode.setAttrs({
...existingTransform,
position: {
x: existingTransform.position.x + canvasPosition.x,
y: existingTransform.position.y + canvasPosition.y,
},
});
this.rectNode.setAttrs(textChildrenTransforms.wrapperRectTransform);
this.textNode.setAttrs(textChildrenTransforms.textNodeTransform);
}
}
+68 -25
View File
@@ -1,11 +1,11 @@
import Konva from "konva";
import { NetworkedNode } from "./NetworkedNode";
import { uiAccess } from "~/signals";
import { SelectionManager } from "../NodesManagers";
import { Position, Size } from "../types";
import ChromaWorker from "./ChromaWorker?sharedworker";
import { minNodeSize, transparent } from "./constants";
import { SelectionManager } from "../NodesManagers";
import { Position, Size, NodeData, TransformationData } from "../types";
import { NodeUtilities } from "./NodeUtilities";
import { minNodeSize, transparent, NodeType } from "./constants";
const loadingBar = uiAccess.loadingBar;
@@ -15,6 +15,7 @@ interface VideoNodeContructor {
canvasSize: Size;
videoURL: string;
selectionManagerRef: SelectionManager;
transform?: TransformationData;
}
export class VideoNode extends NetworkedNode {
@@ -34,6 +35,7 @@ export class VideoNode extends NetworkedNode {
drawingCanvas: OffscreenCanvas;
drawingContext: OffscreenCanvasRenderingContext2D | null;
blockSeeking: boolean;
finishedLoadingOnStart?: Promise<void>;
isChroma: boolean;
chromaRed: number = 120;
@@ -97,18 +99,31 @@ export class VideoNode extends NetworkedNode {
canvasSize,
videoURL,
selectionManagerRef,
transform: existingTransform,
}: VideoNodeContructor) {
const transform = existingTransform
? {
...existingTransform,
position: {
x: existingTransform.position.x + canvasPosition.x,
y: existingTransform.position.y + canvasPosition.y,
},
fill: transparent,
}
: {
position: NodeUtilities.positionNodeOnCanvasCenter({
canvasOffset: canvasPosition,
componentSize: minNodeSize,
maxSize: canvasSize,
}),
size: minNodeSize,
fill: "gray",
};
// kNodes need to be created first to guaruntee it is not undefined in parent's context
const kNode = new Konva.Image({
image: undefined,
// to do fix this with placeholder
size: minNodeSize,
position: NodeUtilities.positionNodeOnCanvasCenter({
canvasOffset: canvasPosition,
componentSize: minNodeSize,
maxSize: canvasSize,
}),
fill: "grey",
...transform,
draggable: true,
strokeScaleEnabled: false,
});
@@ -157,23 +172,24 @@ export class VideoNode extends NetworkedNode {
return;
}
const adjustedSize = NodeUtilities.adjustNodeSizeToCanvas({
componentSize: {
width: this.videoComponent.videoWidth,
height: this.videoComponent.videoHeight,
},
maxSize: canvasSize,
});
const centerPosition = NodeUtilities.positionNodeOnCanvasCenter({
canvasOffset: canvasPosition,
componentSize: adjustedSize,
maxSize: canvasSize,
});
if (!existingTransform) {
const adjustedSize = NodeUtilities.adjustNodeSizeToCanvas({
componentSize: {
width: this.videoComponent.videoWidth,
height: this.videoComponent.videoHeight,
},
maxSize: canvasSize,
});
const centerPosition = NodeUtilities.positionNodeOnCanvasCenter({
canvasOffset: canvasPosition,
componentSize: adjustedSize,
maxSize: canvasSize,
});
this.kNode.setSize(adjustedSize);
this.kNode.setPosition(centerPosition);
}
this.kNode.image(this.videoComponent);
this.kNode.setSize(adjustedSize);
this.kNode.setPosition(centerPosition);
this.videoComponent.currentTime = 0; // ensure it shows up on screen
// it might have length here which we will need to trim down to 7 seconds.
console.log(`Video Duration: ${this.videoComponent.duration}`);
@@ -456,4 +472,31 @@ export class VideoNode extends NetworkedNode {
console.log("Video Not Seekable");
}
}
public async retry() {
console.log("Video Node has not implement retry");
}
public getNodeData(canvasPostion: Position) {
const data: NodeData = {
type: NodeType.VIDEO,
transform: {
position: {
x: this.kNode.position().x - canvasPostion.x,
y: this.kNode.position().y - canvasPostion.y,
},
size: this.kNode.size(),
rotation: this.kNode.rotation(),
scale: {
x: this.kNode.scaleX(),
y: this.kNode.scaleY(),
},
zIndex: this.kNode.getZIndex(),
},
};
data.mediaFileUrl = this.videoURL;
if (this.mediaFileToken) {
data.mediaFileToken = this.mediaFileToken;
}
return data;
}
}
+5
View File
@@ -1,3 +1,8 @@
export enum NodeType {
IMAGE = "image",
TEXT = "text",
VIDEO = "video",
}
export const transparent = "rgba(0,0,0,0)";
export const primaryOrange = "rgba(230,100,98,1)";
export const highlightStrokeWidth = 10;
@@ -11,6 +11,7 @@ export class NodesManager {
public getAllNodes() {
return this.allNodes;
}
public getAllZIndices() {
return this.allZIndices;
}
@@ -457,6 +457,7 @@ export class RenderEngine {
}
container.drawScene(offScreenSceneCanvas, undefined, buffer);
// Not a type mistake ... DO NOT FIX
// @ts-ignore
const offscreenCanvas = offScreenSceneCanvas._canvas as OffscreenCanvas;
let result = undefined;
if (config.test) {
+219
View File
@@ -0,0 +1,219 @@
import Konva from "konva";
import { v4 as uuidv4 } from "uuid";
import { MediaFilesApi, MediaUploadApi } from "~/Classes/ApiManager";
import { NodesManager, SelectionManager } from "./NodesManagers";
import { NodeData, TextNodeData, TransformationData } from "./types";
import { uiAccess } from "~/signals";
import { NavigateFunction } from "react-router-dom";
import { NodeType } from "./Nodes/constants";
import { ImageNode, VideoNode, TextNode } from "./Nodes";
import { RenderEngine } from "./RenderingPrimitives/RenderEngine";
export class SceneManager {
private navigateRef: NavigateFunction;
private mediaLayerRef: Konva.Layer;
private nodesManagerRef: NodesManager;
private selectionManagerRef: SelectionManager;
private renderEngineRef: RenderEngine;
private currentSceneToken: string | undefined;
constructor({
navigateRef,
mediaLayerRef,
nodesManagerRef,
selectionManagerRef,
renderEngineRef,
}: {
navigateRef: NavigateFunction;
mediaLayerRef: Konva.Layer;
nodesManagerRef: NodesManager;
selectionManagerRef: SelectionManager;
renderEngineRef: RenderEngine;
}) {
this.navigateRef = navigateRef;
this.mediaLayerRef = mediaLayerRef;
this.nodesManagerRef = nodesManagerRef;
this.selectionManagerRef = selectionManagerRef;
this.renderEngineRef = renderEngineRef;
}
public async saveScene() {
const mediaUploadApi = new MediaUploadApi();
const timestamp = new Date();
const sceneTitle =
"board_" + timestamp.toISOString().substring(0, 19).replace(/\D/g, "");
const saveJson = this.extractAllNodesData();
console.log("save scene", sceneTitle);
console.log("saveJson", saveJson);
const file = new File([saveJson], `${sceneTitle}`, {
type: "application/json",
});
if (!this.currentSceneToken) {
const uploadResponse = await mediaUploadApi.UploadNewScene({
blob: file,
fileName: file.name,
uuid: uuidv4(),
});
console.log(uploadResponse);
if (!uploadResponse.success || !uploadResponse.data) {
uiAccess.dialogError.show({
title: "Save New Scene Error",
message: uploadResponse.errorMessage,
});
return;
}
this.currentSceneToken = uploadResponse.data;
} else {
const uploadResponse = await mediaUploadApi.UploadSavedScene({
blob: file,
fileName: file.name,
uuid: uuidv4(),
mediaToken: this.currentSceneToken,
});
console.log(uploadResponse);
if (!uploadResponse.success || !uploadResponse.data) {
uiAccess.dialogError.show({
title: "Save Scene Error",
message: uploadResponse.errorMessage,
});
return;
}
}
}
public async loadScene(mediaFileToken: string) {
const mediaFileApi = new MediaFilesApi();
const getSceneResponse = await mediaFileApi.GetMediaFileByToken({
mediaFileToken: mediaFileToken,
});
if (!getSceneResponse.success || !getSceneResponse.data) {
uiAccess.dialogError.show({
title: "Load Scene Error",
message: getSceneResponse.errorMessage,
});
return;
}
this.currentSceneToken = mediaFileToken;
console.log(getSceneResponse.data);
console.log(getSceneResponse.data.public_bucket_path);
const fileResponse = await fetch(getSceneResponse.data.public_bucket_url);
if (!fileResponse.ok) {
uiAccess.dialogError.show({
title: "Load Scene Error",
message: "Failed to download Scene File",
});
return;
}
const fileBlob = await fileResponse.blob();
const loadJson: NodeData[] = await new Promise((resolve, reject) => {
const reader = new FileReader();
const readerError = () => {
uiAccess.dialogError.show({
title: "Load Scene Error",
message: "Failed to read Scene File",
});
this.navigateRef("/");
console.log("debug file Response", fileResponse);
console.log("debug file Blob", fileBlob);
reject();
};
reader.onloadend = () => {
try {
resolve(JSON.parse(reader.result as string));
} catch {
readerError();
}
};
reader.onerror = () => {
readerError();
};
reader.readAsText(fileBlob);
});
this.rebuildScene(loadJson);
}
private extractAllNodesData() {
const nodesData: NodeData[] = [];
this.nodesManagerRef.getAllNodes().forEach((node) => {
nodesData.push(
node.getNodeData(this.renderEngineRef.captureCanvas.position()),
);
});
nodesData.sort((a, b) => a.transform.zIndex - b.transform.zIndex);
return JSON.stringify(nodesData);
}
private rebuildScene(nodesData: NodeData[]) {
console.log(nodesData);
nodesData.forEach((nodeDatum) => {
if (nodeDatum.type === NodeType.IMAGE && nodeDatum.mediaFileUrl) {
this.addImage(nodeDatum.mediaFileUrl, nodeDatum.transform);
} else if (nodeDatum.type === NodeType.VIDEO && nodeDatum.mediaFileUrl) {
this.addVideo(nodeDatum.mediaFileUrl, nodeDatum.transform);
} else if (
nodeDatum.type === NodeType.TEXT &&
nodeDatum.textNodeData &&
nodeDatum.textChildrenTransforms
) {
this.addText({
textNodeData: nodeDatum.textNodeData,
textChildrenTransforms: nodeDatum.textChildrenTransforms,
transform: nodeDatum.transform,
});
}
});
}
private addImage(mediaFileUrl: string, transform: TransformationData) {
const imageNode = new ImageNode({
mediaFileUrl: mediaFileUrl,
mediaLayerRef: this.mediaLayerRef,
canvasPosition: this.renderEngineRef.captureCanvas.position(),
canvasSize: this.renderEngineRef.captureCanvas.size(),
transform: transform,
selectionManagerRef: this.selectionManagerRef,
});
this.nodesManagerRef.saveNode(imageNode);
this.renderEngineRef.addNodes(imageNode);
}
private addVideo(mediaFileUrl: string, transform: TransformationData) {
const videoNode = new VideoNode({
videoURL: mediaFileUrl,
mediaLayerRef: this.mediaLayerRef,
canvasPosition: this.renderEngineRef.captureCanvas.position(),
canvasSize: this.renderEngineRef.captureCanvas.size(),
transform: transform,
selectionManagerRef: this.selectionManagerRef,
});
this.nodesManagerRef.saveNode(videoNode);
this.renderEngineRef.addNodes(videoNode);
}
private addText({
textNodeData,
transform,
textChildrenTransforms,
}: {
textNodeData: TextNodeData;
transform: TransformationData;
textChildrenTransforms: {
wrapperRectTransform: TransformationData;
textNodeTransform: TransformationData;
};
}) {
const textNode = new TextNode({
textNodeData: textNodeData,
transform: transform,
textChildrenTransforms: textChildrenTransforms,
mediaLayerRef: this.mediaLayerRef,
canvasPosition: this.renderEngineRef.captureCanvas.position(),
canvasSize: this.renderEngineRef.captureCanvas.size(),
selectionManagerRef: this.selectionManagerRef,
});
this.nodesManagerRef.saveNode(textNode);
this.renderEngineRef.addNodes(textNode);
}
}
+4 -2
View File
@@ -1,8 +1,10 @@
// to do fix https://codesandbox.io/p/sandbox/react-konva-infinite-grid-kkndq?file=%2Fsrc%2Findex.js the dotted background doesn't move when draggable.
import { Engine } from "./Engine";
import { EngineOptions } from "./types";
export { Engine as EngineType };
export const KonvaApp = (element: HTMLDivElement) => {
const engine = new Engine(element);
export const KonvaApp = (element: HTMLDivElement, options: EngineOptions) => {
const engine = new Engine(element, options);
engine.initializeStage("");
return engine;
};
+26
View File
@@ -4,7 +4,13 @@ import { BaseNode } from "./Nodes/BaseNode";
import { VideoNode } from "./Nodes/VideoNode";
import { ImageNode } from "./Nodes/ImageNode";
import { TextNode } from "./Nodes/TextNodes";
import { NodeType } from "./Nodes/constants";
import { NavigateFunction } from "react-router-dom";
export interface EngineOptions {
navigate: NavigateFunction;
sceneToken?: string;
}
export interface TextNodeData {
text: string;
}
@@ -27,3 +33,23 @@ export interface Transformation {
scale: Scale;
rotation: number;
}
export interface TransformationData extends Omit<Transformation, "kNodeId"> {
zIndex: number;
}
export interface TextNodeChildrenTransformData {
wrapperRectTransform: TransformationData;
textNodeTransform: TransformationData;
}
export interface NodeData {
type: NodeType;
transform: TransformationData;
// Image Node / Video Node data
mediaFileUrl?: string;
mediaFileToken?: string;
//Text Node Data
textNodeData?: TextNodeData;
textChildrenTransforms?: TextNodeChildrenTransformData;
}
+14 -2
View File
@@ -20,18 +20,30 @@ import { useLayoutContext } from "./contextSignals/layout";
// common hooks
import { useRenderCounter } from "~/hooks/useRenderCounter";
import { useNavigate } from "react-router-dom";
export const KonvaRootComponent = ({ className }: { className: string }) => {
export const KonvaRootComponent = ({
className,
sceneToken,
}: {
className: string;
sceneToken?: string;
}) => {
// This is a hook that will log the number of times the component has rerendered
// Let's make sure we only log once
useRenderCounter("KonvaRootComponent");
const navigate = useNavigate();
const appUiContext = useAppUiContext();
const layoutContext = useLayoutContext();
const engineRef = useRef<EngineType | null>(null);
const konvaContainerCallbackRef = useCallback((node: HTMLDivElement) => {
if (node !== null && engineRef.current === null) {
engineRef.current = KonvaApp(node);
const options = {
navigate: navigate,
sceneToken: sceneToken,
};
engineRef.current = KonvaApp(node, options);
}
}, []);
+6 -1
View File
@@ -1,3 +1,4 @@
import { useParams } from "react-router-dom";
import { twMerge } from "tailwind-merge";
import { withProtectionRoute } from "~/components/hoc";
import { useRenderCounter } from "~/hooks/useRenderCounter";
@@ -12,10 +13,14 @@ export const Main = withProtectionRoute(() => {
// This is a hook that will log the number of times the component has rerendered
// Let's make sure we only log once
useRenderCounter("Pages/Main");
const { sceneToken } = useParams();
return (
<div className="fixed grid h-full w-full grid-cols-12 grid-rows-12">
<KonvaRootComponent className="col-span-12 col-start-1 row-span-12 row-start-1" />
<KonvaRootComponent
sceneToken={sceneToken}
className="col-span-12 col-start-1 row-span-12 row-start-1"
/>
<div
className={twMerge(
"col-span-8 col-start-5 row-span-1 row-start-1 flex justify-end",
+4
View File
@@ -12,6 +12,10 @@ export const router = createBrowserRouter([
path: "/login",
element: <Login />,
},
{
path: "/:sceneToken",
element: <Main />,
},
// {
// path: "/sandbox",
// element: <Sandbox />,
@@ -57,7 +57,7 @@ export const DialogEditText = ({
textFormatData.fontStyle === FontStyle.NORMAL &&
textFormatData.fontWeight === FontWeight.NORMAL
? "normal"
: `${textFormatData.fontWeight !== FontWeight.NORMAL && textFormatData.fontWeight} ${textFormatData.fontStyle !== FontStyle.NORMAL && textFormatData.fontStyle}`,
: `${textFormatData.fontWeight !== FontWeight.NORMAL ? textFormatData.fontWeight : ""} ${textFormatData.fontStyle !== FontStyle.NORMAL ? textFormatData.fontStyle : ""}`,
textDecoration:
textFormatData.textDecoration === TextDecoration.NONE
? ""