Looking Glass

https://docs.lookingglassfactory.com
Admin
Looking Glass provides holographic light field displays and associated software for creating,...
Tokens:115,941
Snippets:1,282
Trust Score:9.9
Update:8 months ago
Show doc for...
Tokens:
Raw
### Install Video Depth Anything Locally (Bash)

Source: https://docs.lookingglassfactory.com/community/convert-any-video-into-a-hologram

Installs the Video Depth Anything model locally by cloning the repository and installing its Python dependencies. This requires Git and Python to be pre-installed on the system. The installation process involves cloning the GitHub repository, navigating into the directory, and then installing the required packages using pip.

```bash
git clone https://github.com/DepthAnything/Video-Depth-Anything
cd Video-Depth-Anything
pip install -r requirements.txt
```

--------------------------------

### Install Distill Any Depth Locally (Shell)

Source: https://docs.lookingglassfactory.com/community/convert-any-image-into-a-hologram

Instructions for setting up a Python virtual environment and installing the Distill Any Depth package and its dependencies locally. This process requires Python, Anaconda/Miniconda, and involves creating a conda environment, activating it, and installing packages via pip.

```shell
# Create a new conda environment with Python 3.10
conda create -n distill-any-depth -y python=3.10

# Activate the created environment
conda activate distill-any-depth

# Install the required Python packages
pip install -r requirements.txt

# Navigate to the Detectron2 directory and install it
cd detectron2
pip install -e .

cd ..
pip install -e .
```

--------------------------------

### Install Looking Glass WebXR with npm or yarn

Source: https://docs.lookingglassfactory.com/software/creator-tools/webxr/react-three-fiber

Installs the Looking Glass WebXR library using either the npm or yarn package manager. This is a prerequisite for enabling Looking Glass support in your web project.

```bash
npm install @lookingglass/webxr
```

```bash
yarn install @lookingglass/webxr
```

--------------------------------

### Install Looking Glass WebXR Library via NPM (Shell)

Source: https://docs.lookingglassfactory.com/developer-tools/webxr

Command to install the Looking Glass WebXR library using the npm package manager. This is the standard method for adding the library to your web project's dependencies.

```shell
npm install @lookingglass/webxr
```

--------------------------------

### Install Looking Glass WebXR Library via Yarn (Shell)

Source: https://docs.lookingglassfactory.com/developer-tools/webxr

Command to install the Looking Glass WebXR library using the yarn package manager. This is an alternative to npm for managing project dependencies.

```shell
yarn install @lookingglass/webxr
```

--------------------------------

### Start Media Player Session

Source: https://docs.lookingglassfactory.com/software/looking-glass-bridge-sdk/web-application-integration

Initiates a media player session with a specified orchestration.

```APIDOC
## POST /enter_orchestration

### Description
Initiates a media player session with a specified orchestration.

### Method
POST

### Endpoint
/enter_orchestration

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **name** (string) - Required - The name of the orchestration to start.

### Request Example
```json
{
    "name": "default"
}
```

### Response
#### Success Response (200)
- **orchestration** (object) - Information about the initiated orchestration.
  - **name** (string) - The name of the orchestration field.
  - **type** (string) - The data type of the orchestration value.
  - **value** (string) - The name of the orchestration.
- **payload** (object) - A unique identifier for the session payload.
  - **name** (string) - The name of the payload field.
  - **type** (string) - The data type of the payload value.
  - **value** (string) - The session payload identifier (UUID).
- **status** (object) - The status of the request.
  - **name** (string) - The name of the status field.
  - **type** (string) - The data type of the status value.
  - **value** (string) - The status message (e.g., "Completion").

#### Response Example
```json
{
    "name": "value",
    "orchestration": {
        "name": "orchestration",
        "type": "WSTRING",
        "value": "default"
    },
    "payload": {
        "name": "payload",
        "type": "WSTRING",
        "value": "1a6aed0d-77bf-4129-8e01-71d61c58473d"
    },
    "status": {
        "name": "status",
        "type": "WSTRING",
        "value": "Completion"
    }
}
```
```

--------------------------------

### Renderfarm Implementation (Experimental)

Source: https://docs.lookingglassfactory.com/software/creator-tools/index-1

This section provides instructions on how to set up and use the Alice/LG add-on for Blender on renderfarm systems to perform quilt rendering for still holograms and holographic animations. It is considered experimental as it has not yet been tested in a production renderfarm environment.

```APIDOC
## Renderfarm Implementation (Experimental)

This add-on provides a command line mechanism for renderfarms to support quilt rendering by Alice/LG. This feature is experimental.

### Basic Command Line Calls

Prerequisites: Alice/LG must be installed and activated on the renderfarm's Blender installation.

*   `-alicelg-render`: Starts the rendering of a single quilt.
*   `-alicelg-render-anim`: Starts the rendering of a quilt animation.

Both arguments require Blender to be started in background mode (`-b`) with a specified `.blend` file containing render settings. Both arguments must be preceded by `--`.

**Example for single quilt rendering:**
```bash
blender -b my_lg_hologram.blend -- -alicelg-render
```

### Additional Parameters

These parameters are similar to Blender's internal command line rendering parameters and must be specified *after* the mandatory `--`.

*   `-o` or `--render-output <path>`: Sets the render path and file name. Automatically disables the "Add Metadata" option.
*   `-s` or `--frame-start <frame>`: Sets the start frame. Supports `+/-` for relative frames.
*   `-e` or `--frame-end <frame>`: Sets the end frame. Supports `+/-` for relative frames.
*   `-j` or `--frame-jump <frame>`: Sets the number of frames to step forward after each rendered frame.
*   `-f` or `--render-frame <frame>`: Specifies a single frame to render.

**Example for quilt animation rendering (frames 10-24):**
```bash
blender -b my_lg_hologram.blend -- -alicelg-render-anim -o /tmp/quilt_anim.png -s 10 -e 24
```

**Example for rendering a single frame (frame 16):**
```bash
blender -b my_lg_hologram.blend -- -alicelg-render -o /tmp/quilt.png -f 16
```

### Support and Issues

*   **GitHub Repository:** [https://github.com/regcs/AliceLG/issues](https://github.com/regcs/AliceLG/issues)
*   **Email:** developer@lookingglassfactory.com
```

--------------------------------

### Initialize WebXR Session with Looking Glass SDK

Source: https://docs.lookingglassfactory.com/software/creator-tools/webxr/playcanvas

This JavaScript code initializes the WebXR session for the Looking Glass Factory project. It listens for the 'lookingGlassSdkReady' event and creates a 'VRButton' to toggle XR mode. The button's click event handles starting and ending the XR session, including making the WebGL context XR compatible.

```javascript
var Main = pc.createScript('main');

Main.attributes.add('cameraEntity', {
    type: 'entity',
    description: 'Entity for the camera to focus on. If blank, then the camera will use the whole scene'
});

Main.prototype.initialize = function () {
    const onLookingGlassSdkReady = () => {
        this.app.xr._deviceAvailabilityCheck();
    };

    if (window.lookingGlassSdkReady) {
        onLookingGlassSdkReady();
    } else {
        this.app.once('lookingGlassSdkReady', onLookingGlassSdkReady);
    }

    var vrButton = document.createElement('button');
    function stylizeElement(element) {

        element.style.position = 'absolute';
        element.style.bottom = '20px';
        element.style.padding = '12px 6px';
        element.style.border = '1px solid #fff';
        element.style.borderRadius = '4px';
        element.style.background = 'rgba(0,0,0,0.1)';
        element.style.color = '#fff';
        element.style.font = 'normal 13px sans-serif';
        element.style.textAlign = 'center';
        element.style.opacity = '0.5';
        element.style.outline = 'none';
        element.style.zIndex = '999';
        element.textContent = "Looking Glass";

    }
    vrButton.id = "VRButton"; 
    document.body.appendChild(vrButton);

    stylizeElement(vrButton);

    vrButton.addEventListener("click", (ev) => {
        if (this.app.xr.active) {
            this.cameraEntity.camera.endXr();
        } else {
            let canvas = this.app.graphicsDevice.canvas;
            const gl = canvas.getContext('webgl2');
            gl.makeXRCompatible();
            this.cameraEntity.camera.startXr(pc.XRTYPE_VR, pc.XRSPACE_LOCAL, {
                callback: function (err) {
                    if (err) {
                        console.log(err);
                    }
                }
            });    
        }
    });
};

```

--------------------------------

### Basic Command Line Calls for Alice/LG Quilt Rendering

Source: https://docs.lookingglassfactory.com/software/creator-tools/index-1

Initiates the rendering of a single quilt or a quilt animation using the Alice/LG add-on in Blender. Requires Blender to be run in background mode with a specified .blend file and the mandatory '--' separator before Alice/LG arguments.

```bash
blender -b my_lg_hologram.blend -- -alicelg-render
blender -b my_lg_hologram.blend -- -alicelg-render-anim
```

--------------------------------

### Install Looking Glass Bridge on Linux

Source: https://docs.lookingglassfactory.com/software/looking-glass-bridge

Commands to install the Looking Glass Bridge on Linux after extracting the archive. This involves making the script executable and then running it. Ensure you are using a supported Ubuntu distribution.

```shell
chmod +x lookingglassbridge.sh
./lookingglassbridge.sh
```

--------------------------------

### Advanced Command Line Parameters for Alice/LG Rendering

Source: https://docs.lookingglassfactory.com/software/creator-tools/index-1

Provides advanced options for controlling Alice/LG quilt rendering, such as setting output paths, frame ranges, and render frame steps. These parameters must follow the '--' separator and are similar to Blender's native rendering arguments.

```bash
blender -b my_lg_hologram.blend -- -alicelg-render-anim -o /tmp/quilt_anim.png -s 10 -e 24
blender -b my_lg_hologram.blend -- -alicelg-render -o /tmp/quilt.png -f 16
```

--------------------------------

### Run Video Depth Anything for Depth Map Generation (Bash)

Source: https://docs.lookingglassfactory.com/community/convert-any-video-into-a-hologram

Executes the Video Depth Anything script to generate depth maps from a video file. This command requires the input video path, an output directory, and optionally specifies the encoder model and whether to output grayscale depth maps. The `--grayscale` flag is crucial for generating RGBD-compatible depth maps.

```bash
python3 run.py \
  --input_video path/to/your/video.mp4 \
  --output_dir ./outputs \
  --encoder vitl \
  --grayscale
```

--------------------------------

### Get Display Indices - C

Source: https://docs.lookingglassfactory.com/software/looking-glass-bridge-sdk/native-function-reference

Retrieves the indices of displays attached to the host. The caller must allocate the index array. The function can be called twice: first to get the size, and then to populate the array.

```c
bool get_displays(int* number_of_indices, unsigned long* indices);
```

--------------------------------

### Scripting Inter-Process Communication (IPC) in Unity

Source: https://docs.lookingglassfactory.com/software/index/prefabs/dual-monitor-application

This C# code demonstrates how to send and receive data between two Unity applications using the InterProcessCommunicator. It covers adding references, sending data from a sender, and receiving and processing data in a receiver.

```csharp
using UnityEngine;

public class SenderScript : MonoBehaviour
{
    public InterProcessCommunicator ipc;

    void Start()
    {
        // Assuming ipc is assigned in the inspector or found via GameObject.Find
        if (ipc == null)
        {
            ipc = FindObjectOfType<InterProcessCommunicator>();
        }
    }

    public void SendMyData(string message)
    {
        if (ipc != null)
        {
            ipc.SendData(message);
            Debug.Log("Sent: " + message);
        }
        else
        {
            Debug.LogError("InterProcessCommunicator not found!");
        }
    }
}

public class ReceiverScript : MonoBehaviour
{
    public InterProcessCommunicator ipc;

    void Start()
    {
        // Assuming ipc is assigned in the inspector or found via GameObject.Find
        if (ipc == null)
        {
            ipc = FindObjectOfType<InterProcessCommunicator>();
        }
    }

    // This function will be automatically called by the IPC when a message is received
    public void ReceiveMessage(string message)
    {
        Debug.Log("Received: " + message);
        // Add your logic here to handle the received message
        if (message == "Hello")
        {
            Debug.Log("Received a greeting!");
        }
    }
}
```

--------------------------------

### LKGDisplaySystem - Get Display

Source: https://docs.lookingglassfactory.com/software/index/script-reference/lkgdisplaysystem

Retrieves a copy of a Looking Glass display based on its index.

```APIDOC
## GET /websites/lookingglassfactory/LKGDisplaySystem

### Description
Gets a copy of the LKG display in the array of connected displays that are found to be currently connected.

### Method
GET

### Endpoint
/websites/lookingglassfactory/LKGDisplaySystem

### Parameters
#### Query Parameters
- **index** (int) - Required - An arbitrary index for the display. Should not be relied on for persistence.

### Response
#### Success Response (200)
- **display** (LookingGlass.Toolkit.Display) - A copy of the specified Looking Glass display.

#### Response Example
```json
{
  "display": {
    "width": 2560,
    "height": 1440,
    "depth": 128,
    "tileDepth": 128,
    "num_layers": 45,
    "frequency": 120,
    "serial_number": "LKG-00000000",
    "firmware_version": "1.2.3",
    "display_type": "15.6",
    "device_id": "LKG-00000000"
  }
}
```
```

--------------------------------

### Configure GPU Rendering Context with GLFW and GLAD

Source: https://docs.lookingglassfactory.com/software/looking-glass-bridge-sdk/integrating-native-applications

Initializes GLFW and creates a core profile OpenGL context for a preview window. This is the first step in setting up a shared GPU rendering context for the Bridge SDK. It requires GLFW and GLAD libraries.

```cpp
// initialize glfw
if (!glfwInit()) return -1;

// create preview windowglfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
GLFWwindow* window = glfwCreateWindow(800, 800, "Bridge SDK example", nullptr, nullptr);

if (!window) {
glfwTerminate();
	return -1;
}glfwMakeContextCurrent(window);
```

--------------------------------

### Get Device Serial for Display - C

Source: https://docs.lookingglassfactory.com/software/looking-glass-bridge-sdk/native-function-reference

Retrieves the serial number for a given display index. Similar to getting the device name, the caller is responsible for allocating the buffer for the serial number. The function can be called once to determine the buffer size and again to populate it. It returns the size in wide characters and success status.

```c
bool get_device_serial_for_display(unsigned long display_index, 
                                   int* number_of_serial_wchars, 
                                   wchar_t* serial);
```

--------------------------------

### Get Device Serial Number (C)

Source: https://docs.lookingglassfactory.com/software/looking-glass-bridge-sdk/native-function-reference

Retrieves the serial number of the device associated with a window handle. Similar to `get_device_name`, the caller is responsible for allocating the buffer for the serial number. Call with a null `serial` pointer to get the required buffer size. A valid buffer pointer will then be populated with the serial number.

```c
bool get_device_serial(WINDOW_HANDLE wnd, 
                       int* number_of_serial_wchars, 
                       wchar_t* serial);

```

--------------------------------

### Combine Videos Side-by-Side with FFmpeg

Source: https://docs.lookingglassfactory.com/community/convert-any-video-into-a-hologram

This command uses FFmpeg to horizontally stack two input videos, placing the first input (color video) on the left and the second input (depth video) on the right. Ensure FFmpeg is installed and the input video files are accessible. The output is a single video file with combined visual data.

```bash
ffmpeg -i original_video.mp4 -i depth_video.mp4 -filter_complex hstack output_rgbd.mp4
```

--------------------------------

### Get Device Name for Display - C

Source: https://docs.lookingglassfactory.com/software/looking-glass-bridge-sdk/native-function-reference

Fetches the device name for a specified display index. The caller must allocate the buffer for the device name. The function can be called twice: first with a null buffer to get the required size, and then with an allocated buffer to retrieve the name. It returns the size in wide characters and indicates success.

```c
bool get_device_name_for_display(unsigned long display_index, 
                                 int* number_of_device_name_wchars, 
                                 wchar_t* device_name);
```
Tokens:
Raw