regcs/alicelg

A Blender add-on for the use of Blender with the Looking Glass holographic displays.

Alice/LG 2.3 - The Blender Add-on for Looking Glass Displays

Let Alice/LG take your Blender artworks through the Looking Glass! This short guide is to get you started.

About the Add-on

This add-on was created for the use of Blender with the Looking Glass holographic displays. I initially developed this add-on privately in my free time because I'm a fan of Blender as well as the amazing new holographic display technology created by the Looking Glass Factory. The version 2.x of Alice/LG was developed in collaboration with the Looking Glass Factory.

Main Features

• integration into the common Blender workflow
• an optional view frustum representing the Looking Glass volume in the scene
• lightfield viewport in the Looking Glass with automatic and manual refresh modes
• render any camera view as single quilt image or quilt animation
• decide if you want to keep the separate view files or just the final quilt
• support for multiple scenes and view layers
• camera & quilt settings are saved with your Blender file
• support for all available Looking Glass displays (including the new Looking Glass Go)
• Experimental feature: Detect incomplete render jobs (see below for details)

System Requirements

• Windows, Linux, or macOS
• Blender 2.93.6 or later
• Looking Glass Bridge or HoloPlay Service (for legacy devices)

Installation

1. Download and install the Looking Glass Bridge (or HoloPlay Service) app on your PC or Mac.

2. Download the zip file of the latest release of this add-on.

3. Install Alice/LG in Blender:

   • Open Blender
   • In the main menu, navigate to Edit → Preferences → Add-ons → Install → Install Add-on
   • Select the downloaded zip file and click "Install"
   • Enable the add-on by activating the check box on the left
   • Expand the preferences of the add-on by clicking on the small arrow next to the checkbox
   • Click the "Install" button to install required Python modules to the add-on directory
   • Restart Blender

How to Use

The following provides some basic information which is going to help you to get started. But make sure, you also check out the Getting Started Guide as well as the very helpful tutorial on the Looking Glass Factory website!

Add-on Controls

After the installation you find a Looking Glass tab in each Blender viewport. Depending on your current selections, the tab shows up to four control panels & subpanels:

• Looking Glass. Contains the Looking Glass display selection, a view resolution selection, and a button to turn on/off the lightfield window. Furthermore, it has two subpanels:

  • Camera Setup. Select one of the cameras in the scene to setup a view for the Looking Glass and the quilt rendering.

  • Quilt Setup & Rendering. Controls for starting a quilt render.

• Light field Window. The light field / hologram is displayed on your Looking Glass display via the Looking Glass Bridge (or HoloPlay Service) app in a separate window. In this category you find options to switch between two different modes for the lightfield Window: Viewport and Quilt Viewer. It has the following sub-panel:

  • Shading & Overlay Settings. If the lightfield window is in Viewport mode, it acts as your holographic Blender viewport. The settings for this (lightfield) viewport are defined here.

Lightfield Window & Viewport

The lightfield window is the place where the hologram is rendered. It can be opened via a click on the button: Looking Glass → Lightfield Window, if you have a Looking Glass connected and Looking Glass Bridge (or HoloPlay Service) is running. The light field window can operate in two modes:

• Viewport. In viewport mode, it basically acts like a normal Blender viewport in the Looking Glass - except that it is holographic. You can choose between Auto and Manual refresh mode: In Auto mode, the hologram is re-rendered everytime something in the scene changes, while in Manual mode the hologram is only rendered if you click the refresh button. NOTE: Due to some limitations of the rendering pipeline of Blender, this mode can be quite slow (< 5 fps). We are working on improving Blender with regard to this and, hopefully, future versions of Blender will increase the live view performance of Alice/LG.

• Quilt Viewer. In the quilt viewer mode, you can load or select a rendered quilt image and display it as a hologram in the Looking Glass. So, this mode is basically here to enjoy the fruits of your work. Playing animations is not supported yet. _NOTE: To display the quilt correctly, the correct quilt preset must be selected under Looking Glass → Resolution

Camera Setup & Quilt Rendering

You can render still scenes and animation frames as complete quilt images. You can render for your currently connected device or for any other Looking Glass:

(1) Rendering for your currently connected device

• select your connected Looking Glass (if not already selected) and a quilt resolution under Looking Glass → Resolution
• select an existing camera in Looking Glass → Camera Setup → Camera or create a new camera by clicking "+" in the same panel
• check the Looking Glass → Quilt Setup & Rendering → Use Device Settings checkbox
• locate the camera to the specific view you would like to render
• adjust the render and post-processing settings in the usual Blender panels (NOTE: Image dimensions are overwritten by the add-on based on your connected Looking Glass or your manual settings under Looking Glass → Quilt Setup & Rendering)
• click on Looking Glass → Quilt Setup & Rendering → Render Quilt or Looking Glass → Quilt Setup & Rendering → Render Animation Quilt in the add-on controls.

(2) Rendering for other Looking Glasses

• select an existing camera in Looking Glass → Camera Setup → Camera or create a new camera by clicking "+" in the same panel
• uncheck the Looking Glass → Quilt Setup & Rendering → Use Device Settings checkbox, if it is checked
• choose the Looking Glass you want to render for from the list Looking Glass → Quilt Setup & Rendering → Device
• choose the quilt preset/resolution you want to render for from the list _Looking Glass → Quilt Setup & Rendering → Quilt
• locate the camera to the specific view you would like to render
• adjust the render and post-processing settings in the usual Blender panels (NOTE: Image dimensions are overwritten by the add-on based on your connected Looking Glass or your manual settings under Looking Glass → Quilt Setup & Rendering)
• click on Looking Glass → Quilt Setup & Rendering → Render Quilt or (if you want to render animation frames) Looking Glass → Quilt Setup & Rendering → Render Animation Quilt in the add-on controls.

The Render Quilt option will render the different views separately. After the last view has been rendered, a quilt will be automatically assembled. For the Render Animation Quilt option, the same will happen for each frame of the animation, which will result in one quilt per frame. After rendering, the created quilt image or animation frames have to be handled in the same way as normal renders. You can still render normal (non-holographic) images in Blender as you usually do.

NOTE: Option (2) can be used even if no Looking Glass is connected.

Incomplete Render Jobs (Experimental)

The add-on attempts to detect Blender crashes during quilt rendering as well as quilt animation rendering and prompts you with an option to continue or to discard an incomplete render job the next time you open the crashed file. The successful detection of an incomplete render job and its continuation requires that:

• the filename of the .blend-file did not change
• the file was saved before starting the render job OR no significant changes happened to the setup (e.g., camera position, render settings, etc.)
• the (temporary) view files of the incomplete render job are still on disk and not corrupted

While the add-on tries to check some basic settings, the user is highly recommended to check if the current render settings fit to the settings used for the incomplete render job before clicking the "Continue" button.

If you decide to discard the incomplete render jobs, the add-on will try to delete the view files of the incomplete render job.

NOTE: This feature is considered to be 'experimental'. It might not detect crashes under all circumstances and might not succeed to continue the rendering always. If you encounter a situation were this feature failed, please submit a detailed bug report.

Renderfarm Implementation (Experimental)

The rendering of still holograms and holographic animations can be a time-consuming task. Therefore, this add-on provides a command line mechanism that was created for render farms which want to support the quilt rendering by Alice/LG on their systems. Since it has not been tested on a render farm environment yet, this feature is considered experimental. If you are working at a render farm and need help to implement this mechanism on your system, please open an issue on the add-on's GitHub repository.

Basic Command Line Calls

As a first prerequisite, Alice/LG needs to be installed and activated on the render farm's Blender installation. If you setting up your own local render farm and need to install the dependencies of the add-on, use the following command:

• --alicelg-install: Install the python dependencies of the add-on.

To initiate a quilt rendering from the command line, there are two main calls which are understood by Alice/LG:

• --alicelg-render: Start the rendering of a single quilt.
• --alicelg-render-anim: Start the rendering of a quilt animation.

Both arguments require that Blender is started in background mode (i.e., using the '-b' command line argument) and with a .blend-file specified, which contains all the necessary render settings. Furthermore, both arguments must be preceded by a --. An example, which opens the file 'my_lg_hologram.blend' and starts rendering a single quilt looks like that:

blender -b my_lg_hologram.blend -- --alicelg-render

Additional Parameters

The add-on also understands some additional parameters to fine-tune the rendering process. These parameters are very similar to Blender's internal command line rendering parameters:

• -o or --render-output <path>: Set the render path and file name. Automatically disables the "Add Metadata" option.
• -s or --frame-start <frame>: Set start to frame <frame>, supports +/- for relative frames too.
• -e or --frame-end <frame>: Set end to frame <frame>, supports +/- for relative frames too.
• -j or --frame-jump <frame>: Set number of frames to step forward after each rendered frame
• -f or --render-frame: Specify a single frame to render

It is important that these arguments are specified after the mandatory -- to notify Blender that the arguments are meant for the add-on. An example call which would start Blender in background mode, load the 'my_lg_hologram.blend' file, and render a quilt animation from frame 10 to 24 with the base file name quilt_anim would look like this:

blender -b my_lg_hologram.blend -- --alicelg-render-anim -o /tmp/quilt_anim.png -s 10 -e 24

Another example, which would only render the frame 16 as a single quilt, would like this:

blender -b my_lg_hologram.blend -- --alicelg-render -o /tmp/quilt.png -f 16

License & Dependencies

The Blender add-on part of this project is licensed under the GNU GPL v3 License.

This Blender add-on partially relies on the following GPL-compatible open-source libraries / modules and their dependencies:

• pyLightIO licensed under Apache Software License 2.0

alicelg's Issues

[Uninstall] Clicking Remove on Windows

When removing the add-on, a traceback error occurs on Windows machines:

It's unclear at the moment, if that is still true for newer versions of the add-on.

Rendering results in "cannot create a file when that file already exists"

Viewing a viewport on my looking glass works perfectly, but when I click "Render Quilt", it seems to progress fine up to 97%, and then produces this error:

This is when trying to render Blender's default cube scene.

"No Looking Glass Found" but other programs see it

I'm running Blender 2.92 on Windows 10; HoloPlay Service can see my Looking Glass Portrait, and HoloPlayStudio can display content on it fine. I initially tried the "official" Looking Glass blender plugin, and it worked, but I found it awkward to use, so the people in the Looking Glass discord recommended I try this one instead... However, after installing it and relaunching Blender, the first dropdown in the side panel just says "No Looking Glass Found", even after I click the 'reload' button. (I unchecked the official plugin in the add-ons menu before installing this one.)

[Camera Frustum] Hide when camera is hidden

For next version: When drawing the camera frustum, check if the camera is visible. If not, also hide the frustum.

[Rendering] Setting lower resolution

If the resolution in the render settings is set to 50% and no filename is specified, the Quilt is not assembled correctly and seems to go into an endless loop.

[Quilt Viewer] Automatic detection of quilt type / read quilt suffix

If a quilt is selected in the quilt viewer, the light field may not be rendered correctly, because the wrong view resolution is selected.

Solution: Detect the quilt size and take the orientation (landscape or portrait) from the selected Looking Glass device.

Aborting with ESC does not work

When rendering a single frame or animation, there is no way to abort the rendering process other than closing Blender.

Tested on Windows 10 with Blender 2.93 with 19b8445 and 489ac10 .

See 0:30 onwards in this screencast: https://www.dropbox.com/s/2jr2grmpnrrx0l5/aliceLG_quiltsuffix_render_anim_view_cleanup.mp4?dl=0

[Rendering] Custom quilt presets: Internal preparations

This is connected to #15 and #21. In future versions of Alice/LG, the view resolutions should be freely adjustable by the user. It would be reasonable to give the user the ability to save presets.

It would be reasonable to have a preset folder in the add-on directory tree. Herein, we save preset files (is Blenders preset mechanism helpful here?), which are reloaded on start up of Blender. Users might then add presets from the plugin UI either for the session or as preset file.

[Linux] Lightfield viewport after re-opening blend file

The lightfield window might not be properly re-initialized after re-opening a blend file, which had the lightfield viewport open.

[Rendering] Slow down during rendering animations

https://discord.com/channels/573562186597662720/601839543825465344/847574500220731463

[Linux] Lightfield viewport opens in wrong window on Linux

Probably some timing issue with xdotools, which does not see the correct active window.

[Python API] Replace deprecated BGL calls

Since Blender BGL will be deprecated with Blender 3.0, we should replace it in the add-on. There are not too many occurrences and it will be required for future versions anyway.

Add multiview renderer option to camera

We want to add an additional modality to the camera that leverages Blender's built-in multiview rendering system.

Build instructions?

Are there instructions somewhere on how to produce a build of the latest commit, in between official releases?

[Lightfield Window] Click "hangs" after pressing the "Lightfield Window" button

Maybe change the type of the button from bool to operator. ab8d16d (didn't help)
Seems to have to do with the main window loosing focus upon creation of the lightfield window.

[Render Quilt & Animation] Camera with "track to" constraints

If the camera has a "track to" constraint attached, its position is not calculated correctly during quilt rendering.

[Render Animation Quilt] Delete views of finished quilts

At the moment all views are deleted at the end of the complete animation rendering. This is inefficient when it comes to storage space, so rather delete all views at the end of a frame quilt rendering.

Refactor to factory paradigm

This is a refactor to improve stability and scalability of new features.

Feature request: automatically close Looking Glass window when it's the last window open

No matter how many times I remind myself, somehow I nearly always wind up forgetting to close the Blender window open on my Looking Glass when I'm done in Blender; I just alt-F4 the window on my desktop, and go on with my day, forgetting that Blender is still running because that one last window is still open.

[Render Quilt] Blender does not render on macOS

Blender 2.93.1 Release Candidate (5 June 2021)
Alice/LG Beta 6
macOS 11.4 Big Sur
AMD Radeon Pro 560 4 GB

Blender does not render a quilt using Alice/LG on macOS. When clicking on the “Render Quilt” button, the “Blender Render” window appears as expected, but it just shows an empty image in the “Render Result” slot. The render progress on the “Render Quilt” button and in the status bar stays at 0%. Cancelling the rendering also does not seem to work. I have to force quit Blender in order to stop it.

[Rendering] Implement render farm support

Currently, rendering quilts on a render farm seems not to work. We need to look into that.

[PyPI colorIO] There is a python implementation for OpenColorIO

Note for later:

I discovered that there is a python package called "colorio" which enables colorspace transformations and seems to use numpy. That might be useful to work around the current Blender limitations with respect to colorspace manipulations.

https://github.com/nschloe/colorio

[Render Quilt & Animation] Camera parented to Empty

If the camera is parented to an object that is rotating during an animation, the camera positions for the views are broken.

Get clip/focal settings from active camera

I have a scene with several cameras, that I want to make separate renders from, and I've just finally noticed that while changing the clip settings in the Looking Glass panel changes them on the camera too, switching to a new camera does NOT update the Looking Glass panel's clip values to match! (Similarly, it doesn't get the focal point value either, but as I noted in a separate issue #29 , that doesn't go in either direction... but, in light of this, the data should probably go in the opposite direction of what I'd requested in that thread!)

Basically, all three values are already stored on the camera that Alice is being attached to, so why does Alice store its own copy rather than just looking at the value set on the current camera? That way I wouldn't have to copy the values over manually every time I change cameras...

Changing noise pattern on a per-view basis to reduce percieved noise due to overlapping of views

Changing the noise seed that is changable under the Render -> Sampling -> Advanced every view that is rendered could dramatically reduce the samples necessary to render due to multiple views being seen at once and optically overlapped.

[Open File] If a light field window was open

If a light field window was open while other windows were closed, the lightfieldWindowIndex variable is not updated. If the file is then saved and reopened, the light field window is not correctly initialized.

[Camera] Make the LookingGlass Camera picker animatable

Not sure yet, if that makes sense. But maybe it would be helpful in some situations to make this picker "animatable", that is, being able to choose different cameras in different frames for rendering.

If anybody thinks that this is useful, please give this issue a thumbs up.

[Rendering] Re-render Single views

In some cases small glitches in the geometries or reflections can cause one particular view angle to be corrupted. It would be useful for the user to have the opportunity to render one particular view again after correcting the cause in the scene.

[Lightfield Window] Add PyObjC for the optional packages.

For macOS

Add the PyObjC library to the additional packages, which can be installed for the add-on. This enables automatic detection of the Looking Glass during opening the lightfield window. That way, the user would not need to manually place the lightfield window, but it would directly open in the Looking Glass.

[Quilt Presets] Default preset per device type

It would be good if the default quilt preset would be chosen based on the connected device type.

Product definition for lightfield / holographic cursor

The lightfield cursor in Alice/LG prior to version 2.0 is a yellow circle that is overlaid on top of each view and is projected on the 3d surface of the objects in the scene. The user was able to navigate with the mouse in the Looking Glass and click on objects.

In version 2.0 due to the change from a separate Blender window to HoloPlay Service as the renderer for the lightfield on the Looking Glass this mechanism doesn't work anymore. The user can't navigate the mosue in the LG anymore and click on objects, since there is no Blender window in the Looking Glass display anymore. Furthermore, since HoPS will render the quilt, we can't use OpenGL calls to draw the cursor ourselves. This would be now required to be done in HoPS (i.e., calculate the cursor position in Blender, send coordinates of the cursor to HoPS, and request overlay drawing). Note: Although it would technically be possible to draw the cursor in Blender on the views before they are send to HoPS, the latter step might be to slow to get a fluent navigation.

The question is: Do we still try to keep this cursor or do we deprecate this functionality with Alice/LG 2.0?

If yes and the the quilt transfer from Alice/LG to HoPS is not possible in realtime we need to make at least the following changes in HoPS:

• implement a "receive cursor geometry" command
• implement a "overlay" drawing call that calls the received cursor geometry information and draws it on each view

[Pre-Release] Clean up code and make a experimental release of Alice 2.0

This release is for internal tests and for community members that want to beta test the new version in order to find issues early in the development stage.

[Operator Panels] Blender crashes when using operator panels on macOS

Blender 2.93 – 3.0
Alice/LG 1.1.4
macOS 11.4 Big Sur

When Alice/LG is enabled, Blender crashes when switching between value input fields in the panels (in the bottom left of the 3D View) of operators like “Add Plane”, “Add Cube” etc.

At first, I thought it is a Blender bug, that is why I reported it on Blender Developer, but it turns out that the crash only occurs when Alice/LG is enabled.

Can't run addon in Blender 2.92 on Ubuntu 20.04

I get this error every time i try to enable the addon in Blender 2.92 in Ubuntu 20.04

Read prefs: /home/patricio/.config/blender/2.92/config/userpref.blend
Traceback (most recent call last):
  File "/usr/share/blender/2.92/scripts/modules/addon_utils.py", line 351, in enable
    mod = __import__(module_name)
  File "/home/patricio/.config/blender/2.92/scripts/addons/AliceLG-beta7/__init__.py", line 66, in <module>
    from .operators import libHoloPlayCore
  File "/home/patricio/.config/blender/2.92/scripts/addons/AliceLG-beta7/operators/libHoloPlayCore.py", line 53, in <module>
    import hid as hidapi
  File "/home/patricio/.config/blender/2.92/scripts/addons/AliceLG-beta7/lib/hid/__init__.py", line 50, in <module>
    raise ImportError(error)
ImportError: Unable to load any of the following libraries:libhidapi-hidraw.so libhidapi-hidraw.so.0 libhidapi-libusb.so libhidapi-libusb.so.0 libhidapi-iohidmanager.so libhidapi-iohidmanager.so.0 libhidapi.0.dylib libhidapi.dylib hidapi.dll libhidapi-0.dll

[Rendering] Custom quilt presets: UI

This is a continuation of #25.

While it is now possible to just add specific quilt definitions to the new "presets" folder in the add-on directory, it is of course better to have a UI that would take care of that. This should be added in future versions of Alice/LG.

[MacOS] Installing Alice/LG on the new M1 chip fails

There might be some issue with installing the add-on on macOS with hardware that uses Apple's new M1 chip. Still need some confirmation and error logs.

GPL Licensing

The system library exception seems not to apply to HoloPlay Core SDK at all.

The GPL explicitly defines the exception like this (GPL v3):

The “System Libraries” of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A “Major Component”, in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs

In our case, the work is the add-on and the Major Component of the operating system is not existing in this context. Does the definition (a) and (b) apply to HoloPlay Core SDK? It seems not, because:

(a) The HoloPlay Core SDK is not included in any Major Component of the operating system in the normal form of packaging. It is not part of any operating system.

(b) The HoloPlay Core SDK enables use of the work [= add-on] with the Looking Glass Display. The operating system can run without the display. The work [= add-on] can work with any Major Component of the operating system without the HoloPlay Core SDK. The display is not an essential major component of the operating system. Therefore, the HoloPlay Core SDK serves not to enable use of the work [= add-on] with any Major Component of the operating system. Also see MadHatters explanation concerning my question on stackexchange.

Linking add-on to the HoloPlay Core SDK and let the user download the SDK separately

In my current understanding it is - unfortunately - not allowed by the GPL to do this. The question by Iwan Aucamp and his own answer on stackexchange explains and summarizes the important cases of linking a GPL software and a proprietary library pretty well and clear. He also adheres to the license text. I highly recommend reading it completely. But the main point for us is that the GPL states that:

You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:
[...]
c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.
[...]

Each add-on relying on Blenders Python API (bpy) has to be considered a modified version of that API. If we distribute / convey such an add-on we have to convey the whole of the work, and all its parts, regardless of how they are packaged under the terms of the GPL. The whole work is the add-on + HoloPlay Core SDK. Its parts are: (1) the python script of the add-on and (2) the HoloPlay Core SDK. Regardless of how they are packaged means, it doesn't matter how they find their way together on the users system. This FAQ statement of the FSF further underlines that interpretation:

Linking a GPL covered work statically or dynamically with other modules is making a combined work based on the GPL covered work. Thus, the terms and conditions of the GNU General Public License cover the whole combination

It is the mere linking of a library with GPL software and not the kind of distribution, which makes the HoloPlay Core SDK and the add-on a combined work which is to be put under the GPL as a whole. Since HoloPlay Core SDK is non-GPL, the add-on distribution violates the GPL, if not all its parts are distributed under GPL compatible licenses.

Even the Lesser GPL explicitly states on the very same question:

(2) If you dynamically link against an LGPLed library already present on the user's computer, you need not convey the library's source. On the other hand, if you yourself convey the executable LGPLed library along with your application, whether linked with statically or dynamically, you must also convey the library's sources, in one of the ways for which the LGPL provides.

So, the LGPL was created to allow linking of a LGPL library with proprietary software. The opposite way of linking a proprietary library with GPL software would still be forbidden, it seems. You may also want to read my second question and the corresponding answer on stackexchange to the linking question.

And as a final argument, which might be easier to grasp: Let's assume, providing both parts separately would be allowed by the GPL. This would be a general mechanism which could be easily exploited by anyone to circumvent the GPL. You could simply take any GPL software and make modifications to it. You could then put these modifications into a proprietary library, load that library into the GPL code, and provide that proprietary library separately. The GPL would be pointless and fail its obvious aim to keep free software free.

Defining Licence Exceptions

The GPL allows copyright-holders to define linking exceptions in addition to the normal GPL license text. That would allow an otherwise GPL'ed software to link to a proprietary library. The FSF elaborates on this in another FAQ entry:

If you want your program to link against a library not covered by the system library exception, you need to provide permission to do that.
[...] Only the copyright holders for the program can legally release their software under these terms. [...] But if you want to use parts of other GPL-covered programs by other authors in your code, you cannot authorize the exception for them. You have to get the approval of the copyright holders of those programs.

First of all, that further underlines that one may not link against a non-GPL library in purely GPL-licensed software - no matter if it is already on the user's computer or not. Second, any Blender add-on that uses the Blender Python API, is a modified version of that API. While we are copyright holders of the modifications (i.e., the add-on) we are not the copyright-holder of the Blender Python API. We are, therefore, not allowed to define such an exception. The only one allowed to do that, would be the Blender Foundation and/or the author(s) of the Blender Python API.

Summary / Conclusion

• The HoloPlay Core SDK does not fulfill the definition of a system library.

• Linking a modified version of GPL'ed software to a non-GPL library is forbidden, if not explicitly allowed by the copyright-holder of that software

• Any Blender add-on that uses the Blender Python API (BPY) is a modified version of that API. BPY is released under GPL v2 or later and, consequently, any add-on that uses BPY has to be released under the same license. While the Blender Foundation as the copyright-holder of BPY is not restricted by the GPL and could license a modified version of BPY under any condition (i.e., including a linking exception for the HoloPlay Core SDK), add-on authors don't have this right. This is, because add-on developers essentially distribute a modified version of BPY rather than a completely new software. They are therefore bound by the terms of the GPL including any exceptions defined by the Blender Foundation.

I am afraid that this is an issue, which can only be solved from Looking Glass Factory side (i.e., by providing GPL-compatible API) or Blender Foundation side (i.e., by defining a license exception for HoloPlay Core SDK). The latter won't happen, because Blender is free software on purpose.

Feature request: override "depth of field distance" with "focal plane" value

I just tried adapting a shot from an existing scene to render a quilt, but the results were coming out very blurred, even though I had the Looking Glass "focal plane" value set exactly where it should be... It took me a moment to realise that the camera also had "depth of field" enabled, and its distance value was still set to something very different from the looking glass "focal plane" value.

Now that I know to do so, it's admittedly not too hard to just copy the value from the "focal plane" field to the "distance" field before rendering, but it would be handy if the "distance" field could automatically be set to match the focal plane when rendering.

[Rendering] Lightfield photosets with arbitrary resolution

It would be good to give the user the possibility to render out lightfield photosets with high resolutions for the individual views. That would allow a better cropping, zooming, etc. in HoloPlay Studio since quilt resolution is limited by graphic memory.

[Lightfield Viewport] Add different render modes for speed-up

For later versions of Alice/LG we should have different preview modes for the live view renderer, which will enable a better/faster experience during scene updates:

1. Low-resolution quilts (this is already present).
2. Only update the lightfield when scene updates are finished (e.g., if the user is moving the camera, don't update the LG content until the camera movement is finished)
3. Only update half of the views during scene updates and render the rest if the scene update is finished (e.g., for 32 view, only update the center 16 and leave the rest blank -> the user sitting in front of the display most-likely won't recognize that views are missing)

This could be a task for version 2.1 or later.

Add detailed logger mechanism

Instead of printing everything to the console, create log files. This has already been started with a45164f but needs to be implemented in all areas of the code base and will be done during the refactoring for version 2.0.

[Lightfield Viewport] Color space conversion for off-screen rendering

Currently, the lightfield viewport ("live view") renders the wrong color space.

[HoloPlay Service] How to determine if window was closed?

When displaying quilts / lightfields via HoPS the user has the option to close the overlay window, which displays the lightfield. In Alice/LG that has the impact that the "Lightfield Window" toggle button can end up in the wrong state.

Check, if there is a way to determine if the window was closed.

Parallax is significantly different between viewport and render

Here is a screenshot of the viewport image sent to my Looking Glass; note that even at the extremes of its parallax, the front face of the grey cube never leaves the middle column of blue squares:

Here is the quilt that is produced when I click 'Render Quilt'; in the top-right and bottom-left views, the cube extends well into the next columns!

Viewport isn't centered on Looking Glass

I've been feeling for a while like my shots weren't quite lining up the same on my screen as they were on the looking glass, so I made a test and found that I was right:

The test texture:

The blender scene:

The blender window being shown on my Looking Glass:

Everything looks fine so far, but a photograph of my actual Looking Glass:

Notice the total lack of green at the bottom.

It's also shaving a little off the sides too -- the yellow and green margins should be the same thickness -- but the lack of centering is the bigger problem, to me.

To be honest, I'm not certain whether this is an Alice problem or a HoloPlayService problem, but I thought I'd at least bring it up here.

[Lightfield Window] Speed up offscreen rendering in Blender

Currently in Blender 2.8 and 2.9, offscreen rendering is much slower than in Blender 2.79. We want to improve this as much as possible.

See here for more details: https://developer.blender.org/T89204

Rebuild live view renderer as separate process

We want to rebuild this to be a separate process that gets sent quilt textures via TCP/IP.

Error that requires relaunch on (nearly) every undo

This has been happening from the start, but I keep forgetting to report it: hitting 'undo' causes various errors, some of which require relaunching Blender.

1. Create a new scene
2. Put the Looking Glass window onto your Looking Glass
3. Move the default cube
4. Hit 'undo'

It gives this error:

Python: Traceback (most recent call last):
  File "C:\Users\Hazel\AppData\Roaming\Blender Foundation\Blender\2.92\scripts\addons\AliceLG-master\operators\looking_glass_viewport.py", line 566, in modal
    if self.settings.ShowLightfieldWindow != LookingGlassAddon.LightfieldWindowInvoker.settings.ShowLightfieldWindow:
ReferenceError: StructRNA of type Scene has been removed

location: <unknown location>:-1

So far it isn't a breaking problem, but then:

5. Move the cube again
6. Hit 'undo' again

and now, the Looking Glass display turns flat.
Worse: trying to close and re-open the Looking Glass window at this point causes Blender to crash altogether.

I'm on Windows 10, Blender 2.92.

[Log Files] Add preference to set log levels

This is a continuation of #24.

What is left to do is the preference toggle button, which allows to turn on/off detailed logging. However, this is a minor improvement which we should take care of in later versions. For now, all details will be always written.

[Lightfield Viewport] Separate lightfield viewport from the Camera

LamerDeluxe/Milan requested to implement a functionality for the Lightfield Viewport which mirrors the Blender functionality to "zoom/frame-fit" a specific object of a scene in the main window (Select Object -> Press Numpad '.').

Basically, we would need to introduce an option, which enables switching between "Camera Mode" and "Viewport Mode" for the Lightfield Viewport. That would make sense, since it would make the Lightfield Viewport more Blender'ish. This should be achieveable by manipulating the view and perspective matrices for the offscreen rendering in a proper way. However, it also requires a lot of work probably.