ofxLaser openFrameworks Library

All API interactions are managed through the ofxLaser::Manager object.

Lifecycle Workflow

1. Declaration: Declare an instance of ofxLaser::Manager in your ofApp.h file. It will be automatically initialized.
2. Update: Call ofxLaser::Manager::update() inside your ofApp::update() method to prepare the system for new graphics.
3. Drawing: Call your desired drawing methods (e.g., drawLine, drawDot) inside ofApp::draw(). Note that these methods respect standard openFrameworks transformations like ofTranslate, ofRotate, and ofScale.
4. Sending: Once drawing is complete, call ofxLaser::Manager::send() in ofApp::draw() to transmit the frames to the laser(s).
5. UI: Use ofxLaser::Manager::drawUI() to render the laser management interface.

Important: All drawing methods must be called in the sequence: update() $\rightarrow$ draw methods $\rightarrow$ send().

// In ofApp.h
ofxLaser::Manager laserManager;

// In ofApp.cpp
void ofApp::update() {
    laserManager.update();
}

void ofApp::draw() {
    laserManager.drawLine(ofPoint(0,0), ofPoint(100,100), ofColor::Red);
    laserManager.send();
    laserManager.drawUI();
}

The ofxLaser::Graphic class is a container for managing collections of polylines and colors intended for laser drawing. It provides methods to import vector data (SVG), manipulate shapes via boolean operations (subtraction, intersection), and transform the entire graphic.

Key capabilities include:

• SVG Import: Load graphics from files, strings, or ofxSVG objects.
• Shape Manipulation: Subtract polylines from existing shapes, intersect paths, and join touching polylines.
• Transformations: Translate the graphic, auto-center it, or apply transformations to individual polylines.
• Serialization: Save and load graphic data using ofJson objects.

ofxLaser::Graphic graphic;
// Add shapes
graphic.addSvg("path/to/file.svg");
graphic.addPolyline(myPolyline, ofColor(255, 0, 0));

// Manipulate
graphic.translate(glm::vec3(10, 10, 0));

// Serialize
ofJson json;
graphic.serialize(json);

The ofxLaser message bus uses a variant-based pattern to communicate between the Controller and the ManagerBase.

To send a message, you wrap a specific message struct (from the ofxLaser::LaserMsg namespace) inside a LaserAppMsg variant, and then wrap that variant in a LaserMsgEnvelope. The envelope includes a time field (float) used for latency compensation.

When receiving messages, you should use std::visit with an overloaded helper to handle the different message types.

```cpp
// Example of creating and sending a message
using namespace ofxLaser;

LaserMsgEnvelope envelope;
envelope.time = ofGetElapsedTime();
envelope.payload = LaserMsg::SetGlobalBrightness{ 0.8f };

// On the receiving end (ManagerBase):
std::visit(overloaded {
    [&](const LaserMsg::SetGlobalBrightness& msg) { /* handle brightness change */ },
    [&](const LaserMsg::AddLaser& msg) { /* handle adding laser */ },
    // ... handle other types
}, envelope.payload);

The ofxLaser::TransformationManager class manages a coordinate system for laser mapping using a transformation matrix. It allows you to apply translations, rotations, and scaling to a global coordinate system.

When you call transformation methods (like translate, rotateDeg, or scale), the currentMatrix is updated. Any points passed through getTransformed() will be mapped from their local coordinates to the transformed coordinate system.

To prevent transformations from accumulating indefinitely or affecting subsequent drawing operations, use a matrix stack pattern with pushMatrix() and popMatrix(). This allows you to save the current state, apply a set of transformations, and then restore the previous state.

// Example of using the matrix stack to isolate transformations
transformationManager.pushMatrix();
    transformationManager.translate(100, 100, 0);
    transformationManager.rotateZDeg(45);
    
    // Transform a point to the new coordinate system
    auto transformedPoint = transformationManager.getTransformed(myPoint);
    // Draw using transformedPoint...

transformationManager.popMatrix();
// The coordinate system is now back to its previous state

Clipper supports multiple polygon filling rules and orientation behaviors:

• Fill Types: Supports EvenOdd (alternate) and NonZero (winding) rules. Newer versions (v4.6+) also support Positive and Negative polygon fill types.
• Orientation:
  • The Orientation function is used to determine the direction of polygon vertices.
  • In typical Windows applications (where the Y-axis is positive downwards), outer polygons are oriented clockwise, and inner polygons (holes) have the opposite orientation.
  • The Area function returns a signed value representing the area and orientation.
• Performance Optimization: If the orientation of output polygons is not important for your application, you can potentially speed up clipping routines (historically by up to 60%) by setting IgnoreOrientation to true (Note: this property was removed in v4.0; check your specific version's API).