Gaussian Splats

# Compatibility with Python 2.7.
from __future__ import print_function

# The directory containing the vray shared object should be
# present in the PYTHONPATH environment variable.
# Try to import the vray module from VRAY_SDK/python, if it is not in PYTHONPATH
import sys, os
VRAY_SDK = os.environ.get('VRAY_SDK')
if VRAY_SDK:
    sys.path.append(os.path.join(VRAY_SDK, 'python'))
import vray

SCENE_PATH = os.path.join(VRAY_SDK, 'scenes', 'geom')
# Change process working directory to SCENE_PATH in order to be able to load relative scene resources.
os.chdir(SCENE_PATH)

# Create an instance of VRayRenderer with default options.
# The renderer is automatically closed after the `with` block.
with vray.VRayRenderer() as renderer:
    # Register a simple log callback. Always useful for debugging.
    def dumpMsg(renderer, message, level, instant):
        if level == vray.LOGLEVEL_ERROR:
            print("[ERROR]", message)
        elif level == vray.LOGLEVEL_WARNING:
            print("[Warning]", message)
        elif level == vray.LOGLEVEL_INFO:
            print("[info]", message)
        # Uncomment for testing, but you might want to ignore these in real code
        #else: print("[debug]", message)
    renderer.setOnLogMessage(dumpMsg)

    # Load scene from a file.
    renderer.load("gaussians_flowers.vrscene")

    # With the following API the gaussian data could be read and a preview of the model
    # could be generated using the bounding box, point cloud or another method
    previewBoundingBox, positions, colors = vray.GeomUtils.readGaussianData(renderer.plugins["flowers"])
    numPrimitives = len(positions)
    for i in range(numPrimitives):
        position = positions[i]
        color = colors[i]

    # Start rendering.
    renderer.startSync()

    # Wait for rendering to end.
    renderer.waitForRenderEnd()

#define VRAY_RUNTIME_LOAD_PRIMARY
#include "vraysdk.hpp"
#include "utils.h"

using namespace VRay;
using namespace std;

const char* BASE_PATH = getenv("VRAY_SDK");
string SCENE_PATH = (BASE_PATH ? string(BASE_PATH) : string(".")) + PATH_DELIMITER + "scenes" + PATH_DELIMITER + "geom";

int main(int argc, char* argv[]) {
	// Change process working directory to SCENE_PATH in order to be able to load relative scene resources.
	changeCurrentDir(SCENE_PATH.c_str());
	// Load V-Ray SDK library.
	VRayInit init(NULL, true);
	// Create an instance of VRayRenderer with default options.
	// The renderer is automatically closed at the end of the current scope.
	VRayRenderer renderer;
	// It's recommended to always have a console log
	renderer.setOnLogMessage(logMessage);
	// Load scene from a file
	renderer.load("gaussians_flowers.vrscene");

	// With the following API the gaussian data could be read and a preview of the model
	// could be generated using the bounding box, point cloud or another method
	GaussianReadData readData;
	GeomUtils::readGaussianData(renderer.getPlugin("flowers"), readData);
	Box previewBoundingBox = readData.getPreviewBoundingBox();
	const unsigned numPrimitives = readData.getGaussianPrimitivesCount();
	for (unsigned i = 0; i < numPrimitives; i++) {
		Vector position = readData.getPosition(i);
		Color color = readData.getAverageColor(i);
	}

	// Start rendering.
	renderer.startSync();
	// Wait for rendering to end.
	renderer.waitForRenderEnd();
	return 0;
}

using System;
using System.IO;
using VRay;
using static VRay.Proxy;

class Program
{
    static void Main(string[] args)
    {
        string SCENE_PATH = Path.Combine(Environment.GetEnvironmentVariable("VRAY_SDK"), "scenes", "geom");
        // Change process working directory to SCENE_PATH in order to be able to load relative scene resources.
        Directory.SetCurrentDirectory(SCENE_PATH);
        // Create an instance of VRayRenderer with default options.
        // The renderer is automatically closed after the `using` block.
        using (VRayRenderer renderer = new VRayRenderer())
        {
            // Add a listener for any type of log message.
            renderer.LogMessage += new EventHandler<MessageEventArgs>((source, e) =>
            {
                // You can remove the if for testing, but you might want to ignore Debug in real code
                if (e.LogLevel != LogLevelType.Debug)
                {
                    Console.WriteLine(String.Format("[{0}] {1}", e.LogLevel.ToString(), e.Message));
                }
            });
            // Load scene from a file.
            renderer.Load("gaussians_flowers.vrscene");

            // With the following API the generated scatter transforms and topology could be read
            // and applied to various forms (dots, bounding box, low-poly model, etc.) as a preview
            GeomUtils.GaussianReadData readData = GeomUtils.ReadGaussianData(renderer.GetPlugin("flowers"));
            Box previewBoundingBox = readData.GetPreviewBoundingBox();
            long numPrimitives = readData.GetGaussianPrimitivesCount();
            for (long i = 0; i < numPrimitives; i++)
            {
                Vector position = readData.GetPosition(i);
                Color color = readData.GetAverageColor(i);
            }

            // Start rendering.
            renderer.StartSync();
            // Wait for rendering to end.
            renderer.WaitForRenderEnd();
        }
    }
}

var path = require("path");
var vray = require(path.join(process.env.VRAY_SDK, "node", "vray"));
var SCENE_PATH = path.join(process.env.VRAY_SDK, "scenes", "geom");
// Change process working directory to SCENE_PATH in order to be able to load relative scene resources.
process.chdir(SCENE_PATH);

// Create an instance of VRayRenderer with default options.
var renderer = vray.VRayRenderer();
// It's recommended to always have a console log callback
renderer.on("logMessage", function(message, level, instant) {
	if (level == vray.LOGLEVEL_ERROR)
		console.log("[ERROR] ", message);
	else if (level == vray.LOGLEVEL_WARNING)
		console.log("[Warning] ", message);
	else if (level == vray.LOGLEVEL_INFO)
		console.log("[info] ", message);
	// Uncomment for testing, but you might want to ignore these in real code
	//else console.log("[debug] ", message);
});

// Load scene from a file asynchronously.
renderer.load("gaussians_flowers.vrscene", function(err) {
	if (err) throw err;

	// With the following API the gaussian data could be read and a preview of the model
	// could be generated using the bounding box, point cloud or another method
	var readData = vray.GeomUtils.readGaussianDataSync(renderer.plugins["flowers"]);
	var previewBoundingBox = readData.bbox;
	var numPrimitives = readData.positions.count;
	for (var i = 0; i < numPrimitives; i++) {
		var position = readData.positions.getVector(i);
		var color = readData.colors.getColor(i);
	}

	// Start rendering.
	renderer.start(function(err) {
		if (err) throw err;
		// Wait for rendering to end.
		renderer.waitForRenderEnd(function() {
			// Closes the renderer.
			// The renderer object is unusable after closing since its resources
			// are freed. It should be released for garbage collection.
			renderer.close();
		});
	});
});