# Planner Callbacks

RoomleCore interface

# requestCatalogItem

CatalogItemPtr getCatalogItem(std::string aCatalogName, std::string anIdString);

requestCatalogItem(_catalogItemId: string)

# handlerSwitchedPlans

void handlerSwitchedPlans(PlanPtr oldPlan, PlanPtr newPlan);

handlerSwitchedPlans(fromPlan: Plan, toPlan: Plan) : void;

# planElementAdded

void planElementAdded(PlanCPtr aPlan, roomle::PlanElementPtr anElement);

planElementAdded(plan: Plan, element: PlanElement) : void;

# planElementChanged


void planElementChanged(PlanCPtr aPlan, roomle::PlanElementPtr anElement);

planElementChanged(plan: Plan, planObject: PlanElementViewModel): void;

# planElement3dMeshChanged

void planElement3dMeshChanged(PlanCPtr aPlan, roomle::PlanElementPtr anElement);

planElement3dMeshChanged(plan: Plan, element: PlanElement) : void;

# planObjectConfigurationLoaded

void planObjectConfigurationLoaded(PlanCPtr aPlan, roomle::PlanObjectPtr anObject,bool success);

planObjectConfigurationLoaded(plan: Plan, element: PlanElement, success: boolean): void

# planObjectConfigurationCreated

void planObjectConfigurationCreated(PlanCPtr aPlan, roomle::PlanObjectPtr anObject);

Empty implementation in frontend.

planObjectConfigurationCreated(_plan: Plan, _element: PlanObject)

# planObjectConfigurationRemoved

void planObjectConfigurationRemoved(PlanCPtr aPlan, roomle::PlanObjectPtr anObject);

planObjectConfigurationRemoved is not implemented in frontend.

# planBoundsChanged

void planBoundsChanged(PlanCPtr aPlan, const Cube &newBounds);

planBoundsChanged(): void;

# planHistoryStateChanged

void planHistoryStateChanged(PlanCPtr aPlan);

planHistoryStateChanged() : void;

# planElementRemoved

void planElementRemoved(roomle::PlanElementPtr anElement);

planElementRemoved(element: PlanElement) : void;

# startedDrawing

void startedDrawing(PlanPtr aPlan);

startedDrawing() : void;

# stoppedDrawing

void stoppedDrawing(PlanPtr aPlan);

requestCatalogItem(_catalogItemId: string) : void;

# planCompletelyLoaded

void planCompletelyLoaded(PlanPtr aPlan);

planCompletelyLoaded(plan: Plan) : void;

# planCleared

void planCleared(PlanPtr aPlan);

planCleared() : void

# updateMesh2d

void updateMesh2d(PlanElementPtr anElement, Vector2f vertices[], size_t vertexCount, indices_t indices[], size_t indexCount );

beginConstruction() : void;

# beginConstruction

        void beginConstruction(PlanElementPtr anElement) {
            callPlannerCallback("beginConstruction",anElement);
        }

# endConstruction

void endConstruction(PlanElementPtr anElement);

endConstruction() : void;

# addMesh

void addMesh(PlanElementPtr anElement, BaseMaterialCPtr material, std::vector<roomle::Vector3f> vertices,
            std::vector<indices_t> indices, std::vector<Vector2f> uvs, std::vector<roomle::Vector3f> normals);

addMesh(planElement: PlanElement, material: any, vertices: Int32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array) : void;

# beginPlanConstruction

void beginPlanConstruction(PlanPtr aPlan);

beginPlanConstruction(plan: Plan) : void;

# endPlanConstruction

void endPlanConstruction(PlanPtr aPlan);

endPlanConstruction(plan: Plan) : void;

# addPlanMesh

void addPlanMesh(
        PlanPtr aPlan, BaseMaterialCPtr material, std::vector<roomle::Vector3f> vertices,
        std::vector<indices_t> indices, std::vector<Vector2f> uvs, std::vector<roomle::Vector3f> normals, PlanElement::Type type);

addPlanMesh(plan: Plan, material: any, vertices: Int32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, type: KernelEnum) : void;

← Planner Interface Script Tools Interface →