# 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
startFrame = 1
endFrame = 20
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 updateNextFrameRenderView(renderer, startFrame):
# Next frame to be updated
frameToUpdate = renderer.frame + 1 if renderer.frame > 0 else startFrame + 1
# t corresponds to the time of the next frame to be rendered
t = frameToUpdate / renderer.classes.SettingsOutput.getInstanceOrCreate().frames_per_second
# Obtain a reference to the 'RenderView' plugin.
renderView = renderer.classes.RenderView.getInstanceOrCreate()
# Obtain a copy of the renderView transform at time t.
updatedTransform = renderView.getValue('transform', t)
# Modify the copy of the renderView transform.
# The changes do not affect the scene directly since updatedTransform is a copy of the actual transform.
updatedTransform = updatedTransform.replaceOffset(updatedTransform.offset + vray.Vector(0, 0, 3 * t))
# Update the transform value in renderView at time t (applying the changes above).
# NOTE: Animation2 API is particularly useful, in the case when
# applying changes to animated parameter values during rendering.
# In this case, there's no need to change the current time/frame with renderer.time = t
renderView.setValue('transform', updatedTransform, t)
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:
# Prepare the renderView of the next frame to be rendered
updateNextFrameRenderView(renderer, startFrame)
# 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)
# NOTE: 'useAnimatedValues' is not necessary to be set, in case only Animation2 API is used
# renderer.useAnimatedValues = True
# Prepare the renderView of the next frame to be rendered
updateNextFrameRenderView(renderer, startFrame)
# Set 'start' and 'end' of the sequence. 'step' is omitted and defaults to 1.
# For all possible use cases of 'renderSequence' check the documentation for VRayRenderer.renderSequence.
renderer.renderSequence({'start': startFrame, 'end': endFrame})
# 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";
const int startFrame = 1;
const int endFrame = 20;
void updateNextFrameRenderView(VRayRenderer &renderer, const int startFrame) {
const int currentFrame = renderer.getCurrentFrame();
// Next frame to be updated
const int frameToUpdate = (currentFrame > 0) ? (currentFrame + 1) : (startFrame + 1);
// t corresponds to the time of the next frame to be rendered
const double t = frameToUpdate / renderer.getInstanceOrCreate<SettingsOutput>().get_frames_per_second();
// Obtain a reference to the 'RenderView' plugin.
RenderView renderView = renderer.getInstanceOrCreate<RenderView>();
// Obtain a copy of the renderView transform at time t.
Transform updatedTransform = renderView.get_transform(t);
// Modify the copy of the renderView transform.
// The changes do not affect the scene directly since updatedTransform is a copy of the actual transform.
updatedTransform.offset += Vector(0.0, 0.0, 3 * t);
// Update the transform value in renderView at time t (applying the changes above).
// NOTE: Animation2 API is particularly useful, in the case when
// applying changes to animated parameter values during rendering.
// In this case, there's no need to change the current time/frame with renderer.setCurrentTime(t)
renderView.set_transform(updatedTransform, t);
}
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) {
// Prepare the renderView of the next frame to be rendered
updateNextFrameRenderView(renderer, startFrame);
// 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);
// NOTE: 'useAnimatedValues' is not necessary to be set, in case only Animation2 API is used
// renderer.useAnimatedValues(true);
// Prepare the renderView of the next frame to be rendered
updateNextFrameRenderView(renderer, startFrame);
// Set 'start' and 'end' of the sequence.
// For all possible use cases of 'renderSequence' check the documentation for VRayRenderer.renderSequence.
SubSequenceDesc subSequenceDescriptions[1];
subSequenceDescriptions[0].start = startFrame;
subSequenceDescriptions[0].end = endFrame;
subSequenceDescriptions[0].step = 1;
renderer.renderSequence(subSequenceDescriptions, 1);
// Wait until the entire sequence has finished rendering.
renderer.waitForSequenceEnd();
return 0;
} |
|
using System;
using System.IO;
using VRay;
using VRay.Plugins;
namespace _03_animation2_api
{
class Program
{
const int startFrame = 1;
const int endFrame = 20;
static void UpdateNextFrameRenderView(VRayRenderer renderer, int startFrame)
{
// Next frame to be updated
int frameToUpdate = (renderer.Frame > 0) ? (renderer.Frame + 1) : (startFrame + 1);
// t corresponds to the time of the next frame to be rendered
double t = frameToUpdate / renderer.GetInstanceOrCreate<SettingsOutput>().FramesPerSecond;
// Obtain a reference to the 'RenderView' plugin.
RenderView renderView = renderer.GetInstanceOrCreate<RenderView>();
// Obtain a copy of the renderView transform at time t.
Transform updatedTransform = renderView.Get_Transform(t);
// Modify the copy of the renderView transform.
// The changes do not affect the scene directly since updatedTransform is a copy of the actual transform.
updatedTransform = updatedTransform.ReplaceOffset(updatedTransform.Offset + new Vector(0, 0, 3 * t));
// Update the transform value in renderView at time t (applying the changes above).
// NOTE: Animation2 API is particularly useful, in the case when
// applying changes to animated parameter values during rendering.
// In this case, there's no need to change the current time/frame with renderer.Time = t
renderView.Set_Transform(updatedTransform, t);
}
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 || e.NewState == VRayRenderer.RendererState.IDLE_DONE)
{
Console.WriteLine("Image Ready, frame " + renderer.Frame + " (sequenceEnded = " + renderer.IsSequenceEnded + ")");
// Prepare the renderView of the next frame to be rendered
UpdateNextFrameRenderView(renderer, startFrame);
// 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);
// NOTE: 'UseAnimatedValues' is not necessary to be set, in case only Animation2 API is used
// renderer.UseAnimatedValues = true;
// Prepare the renderView of the next frame to be rendered
UpdateNextFrameRenderView(renderer, startFrame);
// Set 'start' and 'end' of the sequence. 'step' is omitted and defaults to 1.
// For all possible use cases of 'renderSequence' check the documentation for VRayRenderer.renderSequence.
renderer.RenderSequence(new SubSequenceDesc[] { new SubSequenceDesc(startFrame, endFrame) });
// 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');
const startFrame = 1;
const endFrame = 20;
function updateNextFrameRenderView(renderer, startFrame) {
// Next frame to be updated
var frameToUpdate = (renderer.frame > 0) ? (renderer.frame + 1) : (startFrame + 1);
// t corresponds to the time of the next frame to be rendered
var t = frameToUpdate / renderer.classes.SettingsOutput.getInstanceOrCreate().frames_per_second;
// Obtain a reference to the 'RenderView' plugin.
var renderView = renderer.classes.RenderView.getInstanceOrCreate()
// Obtain a copy of the renderView transform at time t.
var updatedTransform = renderView.getValue("transform", t);
// Modify the copy of the renderView transform.
// The changes do not affect the scene directly since updatedTransform is a copy of the actual transform.
updatedTransform = updatedTransform.replaceOffset(updatedTransform.offset.add(vray.Vector(0, 0, 3 * t)));
// Update the transform value in renderView at time t (applying the changes above).
// NOTE: Animation2 API is particularly useful, in the case when
// applying changes to animated parameter values during rendering.
// In this case, there's no need to change the current time/frame with renderer.time = t
renderView.setValue("transform", updatedTransform, t);
}
// 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") {
// Closes the renderer.
renderer.close();
} else {
// Prepare the renderView of the next frame to be rendered
updateNextFrameRenderView(renderer, startFrame);
// 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);
// NOTE: "useAnimatedValues" is not necessary to be set, in case only Animation2 API is used
// renderer.useAnimatedValues = true;
// Prepare the renderView of the next frame to be rendered
updateNextFrameRenderView(renderer, startFrame);
// Set "start" and "end" of the sequence.
// "step" is omitted and defaults to 1.
// For all possible use cases of "renderSequence" check the documentation
renderer.renderSequence({ "start": startFrame, "end": endFrame });
// Prevent garbage collection and exiting nodejs until the renderer is closed.
renderer.keepAlive();
}); |
|
|