Physical Camera - Depth of Field and Motion Blur

# 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(os.environ.get('VRAY_SDK'), 'scenes')
# Change process working directory to SCENE_PATH in order to be able to load relative scene resources.
os.chdir(SCENE_PATH)

def onStateChanged(renderer, oldState, newState, instant):
    if newState == vray.RENDERER_STATE_IDLE_FRAME_DONE or newState == vray.RENDERER_STATE_IDLE_DONE:
        print("Image Ready, frame " + str(renderer.frame) + " (sequenceEnd = " + str(renderer.sequenceEnded) + ")")
        if newState == vray.RENDERER_STATE_IDLE_FRAME_DONE:
            # If the sequence has NOT finished - continue with next frame.
            renderer.continueSequence()

# 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)

    # Add a listener for the renderer state change event.
    # We will use it to detect when a frame is completed and allow the next one to start.
    renderer.setOnStateChanged(onStateChanged)
    # Load scene from a file.
    renderer.load(os.path.join(SCENE_PATH, 'animation.vrscene'))
    # Maximum paths per pixel for interactive mode. Set a low sample level to complete rendering faster.
    # The default value is unlimited. We have to call this *after* loading the scene.
    renderer.setInteractiveSampleLevel(1)
    # Enable depth of field and apply parameters
    settingsDof = renderer.classes.SettingsCameraDof.getInstanceOrCreate()
    settingsDof.on = True
    settingsDof.aperture = 6       # f/6
    settingsDof.focal_dist = 100   # focus distance in scene units
    # The default V-Ray camera is a simple pinhole camera. To enable advanced effects like 
    # depth of field, motion blur, shaped bokeh, vignetting etc. you need to add this plugin.
    camera = renderer.classes.CameraPhysical.getInstanceOrCreate()
    # Specify the focal length of the camera lens.
    camera.focal_length = 55
    # Specify the width of the camera aperture.
    # If "exposure = True" - changing the 'f_number' will affect the image brightness.
    camera.f_number = 12
    # Specify the shutter speed, in inverse seconds, for the still photographic camera ("type = 0").
    # For example, shutter speed of 1/30 s corresponds to "shutter_speed=30".
    camera.shutter_speed = 40
    # Specify the film sensitivity.
    # If "exposure = True", changing the "ISO" will affect the image brightness.
    # Smaller values make the image darker, while larger values make it brighter.
    camera.ISO = 800
    # The distance between the camera and the current target position
    # If "specify_focus=0" this value will be used as focus distance.
    camera.target_distance = 23.72558
    # Enables motion blur effect controlled by the camera parameters.
    # This setting could also be toggled using the 'on' property of the 'SettingsMotionBlur' plugin.
    camera.use_moblur = True
    # Start rendering a sequence of frames (animation).
    renderer.renderSequence()
    # Wait until the entire sequence has finished rendering.
    renderer.waitForSequenceEnd()

#define VRAY_RUNTIME_LOAD_PRIMARY

#include "vraysdk.hpp"
#include "vrayplugins.hpp"
#include "utils.h"

using namespace VRay;
using namespace VRay::Plugins;
using namespace std;

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

void onStateChanged(VRayRenderer &renderer, RendererState oldState, RendererState newState, double instant, void* userData) {
	if (newState == IDLE_FRAME_DONE || newState == IDLE_DONE) {
		printf("Image Ready, frame %d (sequenceEnded = %d)\n", renderer.getCurrentFrame(), renderer.isSequenceEnded());
		if (newState == IDLE_FRAME_DONE) {
			// If the sequence has NOT finished - continue with next frame.
			renderer.continueSequence();
		}
	}
}

int main() {
	// 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);
	// Add a listener for the renderer state change event.
	// We will use it to detect when a frame is completed and allow the next one to start.
	renderer.setOnStateChanged(onStateChanged);
	// Load scene from a file.
	renderer.load("animation.vrscene");
	// Maximum paths per pixel for interactive mode. Set a low sample level to complete rendering faster.
	// The default value is unlimited. We have to call this *after* loading the scene.
	renderer.setInteractiveSampleLevel(1);
	// Enable depth of field and apply parameters
	SettingsCameraDof settingsDof = renderer.getInstanceOrCreate<SettingsCameraDof>();
	settingsDof.set_on(true);
	settingsDof.set_aperture(6);        // f/6
	settingsDof.set_focal_dist(100);    // focus distance in scene units
	// The default V-Ray camera is a simple pinhole camera. To enable advanced effects like 
	// depth of field, motion blur, shaped bokeh, vignetting etc. you need to add this plugin.
	CameraPhysical camera = renderer.getInstanceOrCreate<CameraPhysical>();
	// Specify the focal length of the camera lens.
	camera.set_focal_length(55);
	// Specify the width of the camera aperture.
	// If "exposure = true" - changing the 'f_number' will affect the image brightness.
	camera.set_f_number(12);
	// Specify the shutter speed, in inverse seconds, for the still photographic camera("type = 0").
	// For example, shutter speed of 1 / 30 s corresponds to "shutter_speed=30".
	camera.set_shutter_speed(40);
	// Specify the film sensitivity. If "exposure = True", changing the "ISO" will affect the image brightness.
	// Smaller values make the image darker, while larger values make it brighter.
	camera.set_ISO(800);
	// The distance between the camera and the current target position.
	// If "specify_focus=0" this value will be used as focus distance.
	camera.set_target_distance(23.72558f);
	// Enables motion blur effect controlled by the camera parameters.
	// This setting could also be toggled using the 'on' property of the 'SettingsMotionBlur' plugin.
	camera.set_use_moblur(true);
	// Start rendering a sequence of frames (animation).
	renderer.renderSequence();
	// Wait until the entire sequence has finished rendering.
	renderer.waitForSequenceEnd();

	return 0;
}

using System;
using System.IO;
using VRay;
using VRay.Plugins;

namespace _05_motion_blur
{
	class Program
	{
		static void Main(string[] args)
		{
			string SCENE_PATH = Path.Combine(Environment.GetEnvironmentVariable("VRAY_SDK"), "scenes");
			// 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));
					}
				});

				// Add a listener for state changes. It is invoked when the renderer prepares for rendering, renders, finishes or fails.
				renderer.StateChanged += new EventHandler<StateChangedEventArgs>((source, e) =>
				{
					if (e.NewState == VRayRenderer.RendererState.IDLE_FRAME_DONE)
					{
						Console.WriteLine("Image Ready, frame " + renderer.Frame +
							" (sequenceEnded = " + renderer.IsSequenceEnded + ")");

						// If the sequence has NOT finished - continue with next frame.
						renderer.ContinueSequence();
					}
				});
				// Load scene from a file.
				renderer.Load("animation.vrscene");
				// Maximum paths per pixel for interactive mode. Set a low sample level to complete rendering faster.
				// The default value is unlimited. We have to call this *after* loading the scene.
				renderer.SetInteractiveSampleLevel(1);
				// Enable depth of field and apply parameters
				SettingsCameraDof settingsDof = renderer.GetInstanceOrCreate<SettingsCameraDof>();
				settingsDof.On = true;
				settingsDof.Aperture = 6;      // f/6
				settingsDof.FocalDist = 100;   // focus distance in scene units
				// The default V-Ray camera is a simple pinhole camera. To enable advanced effects like 
				// depth of field, motion blur, shaped bokeh, vignetting etc. you need to add this plugin.
				CameraPhysical camera = renderer.GetInstanceOrCreate<CameraPhysical>();
				// Specify the focal length of the camera lens.
				camera.FocalLength = 55;
				// Specify the width of the camera aperture.
				// If "Exposure = true" - changing the 'FNumber' will affect the image brightness.
				camera.FNumber = 12;
				// Specify the shutter speed, in inverse seconds, for the still photographic camera ("type = 0").
				// For example, shutter speed of 1/30 s corresponds to "shutter_speed=30".
				camera.ShutterSpeed = 40;
				// Specify the film sensitivity.
				// If "Exposure = true", changing the "ISO" will affect the image brightness.
				// Smaller values make the image darker, while larger values make it brighter.
				camera.ISO = 800;
				// The distance between the camera and the current target position
				// If "SpecifyFocus = 0" this value will be used as focus distance.
				camera.TargetDistance = 23.72558F;
				// Enables motion blur effect controlled by the camera parameters.
				// This setting could also be toggled using the 'on' property of the 'SettingsMotionBlur' plugin.
				camera.UseMoblur = true;
				// Start rendering a sequence of frames (animation).
				renderer.RenderSequence();
				// Wait until the entire sequence has finished rendering.
				renderer.WaitForSequenceEnd();
			}
		}
	}
}

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');

// 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);
});

// Add a listener for the renderer state change event.
// We will use it to detect when a frame is completed and allow the next one to start.
renderer.on("stateChanged", function(oldState, newState, instant) {
	if (newState == "idleFrameDone" || newState == "idleDone") {
		console.log("Image Ready, frame " + renderer.frame + " (sequenceEnd = " + renderer.sequenceEnded + ")");
		// Check if the sequence has finished rendering.
		if (newState == "idleDone") {
			renderer.close();
		} else {
			// If the sequence has NOT finished - continue with next frame.
			renderer.continueSequence();
		}
	} else if (newState.startsWith("idle")) {
		console.log("Unexpected end of render sequence: ", newState);
		renderer.close();
	}
});

// Load scene from a file asynchronously.
renderer.load("animation.vrscene", function(err) {
	if (err) throw err;
	// Maximum paths per pixel for interactive mode. Set a low sample level to complete rendering faster.
	// The default value is unlimited. We have to call this *after* loading the scene.
	renderer.setInteractiveSampleLevel(1);
	// Enable depth of field and apply parameters
	settingsDof = renderer.classes.SettingsCameraDof.getInstanceOrCreate();
	settingsDof.on = true;
	settingsDof.aperture = 6;       // f/6
	settingsDof.focal_dist = 100;   // focus distance in scene units
	// The default V-Ray camera is a simple pinhole camera. To enable advanced effects like 
	// depth of field, motion blur, shaped bokeh, vignetting etc. you need to add this plugin.
	var camera = renderer.classes.CameraPhysical.getInstanceOrCreate();
	// Specify the focal length of the camera lens.
	camera.focal_length = 55;
	// Specify the width of the camera aperture.
	// If "exposure = true" - changing the 'f_number' will affect the image brightness.
	camera.f_number = 12;
	// Specify the shutter speed, in inverse seconds, for the still photographic camera ("type = 0").
	// For example, shutter speed of 1/30 s corresponds to "shutter_speed=30".
	camera.shutter_speed = 40;
	// Specify the film sensitivity.
	// If "exposure = true", changing the "ISO" will affect the image brightness.
	// Smaller values make the image darker, while larger values make it brighter.
	camera.ISO = 800;
	// The distance between the camera and the current target position.
	// If "specify_focus=0" this value will be used as focus distance.
	camera.target_distance = 23.72558;
	// Enables motion blur effect controlled by the camera parameters.
	// This setting could also be toggled using the 'on' property of the 'SettingsMotionBlur' plugin.
	camera.use_moblur = true;
	// Start rendering a sequence of frames (animation).
	renderer.renderSequence();
});