/// <summary>
/// Add a Shader to Scene, assigning it a scene specific ID.
/// </summary>
/// <param name="shader">The Shader to add to the Scene</param>
/// <returns>Scene-specific ID for the Shader</returns>
public uint AddShader(Shader shader)
{
var shader_in_scene_id = CSycles.scene_add_shader(Client.Id, Id, shader.Id);
m_shader_in_scene_ids.Add(shader, shader_in_scene_id);
return(shader_in_scene_id);
}
/// <summary>
/// Create a new scene with the given SceneParameters and Device
/// </summary>
/// <param name="client">The client from C[CS]ycles API</param>
/// <param name="sceneParams">The SceneParameters to create scene with</param>
/// <param name="device">The Device to create scene for</param>
public Scene(Client client, SceneParameters sceneParams, Device device)
{
Client = client;
Id = CSycles.scene_create(Client.Id, sceneParams.Id, device.Id);
Background = new Background(this);
Camera = new Camera(this);
Integrator = new Integrator(this);
Film = new Film(this);
Device = device;
/* add simple wrappers for shadermanager created default shaders */
var surface = Shader.WrapDefaultSurfaceShader(client);
var light = Shader.WrapDefaultLightShader(client);
var background = Shader.WrapDefaultBackgroundShader(client);
var empty = Shader.WrapDefaultEmptyShader(client);
/* register the wrapped shaders with scene */
m_shader_in_scene_ids.Add(surface, surface.Id);
m_shader_in_scene_ids.Add(background, background.Id);
m_shader_in_scene_ids.Add(light, light.Id);
m_shader_in_scene_ids.Add(empty, empty.Id);
DefaultSurface = surface;
// set ourself to client as reference
client.Scene = this;
}
/// <summary>
/// Clear the shader graph for this node, so it can be repopulated.
/// </summary>
public void Recreate()
{
CSycles.shader_new_graph(Client.Id, Id);
m_nodes.Clear();
Output = new OutputNode();
AddNode(Output);
}
/// <summary>
/// Create a new shader for client.
/// </summary>
/// <param name="client">Client ID for C[CS]ycles API.</param>
/// <param name="type">The type of shader to create</param>
public Shader(Client client, ShaderType type)
{
Client = client;
Type = type;
Id = CSycles.create_shader(Client.Id);
Output = new OutputNode();
AddNode(Output);
created_in_cycles = false;
Verbose = false;
}
/// <summary>
/// Make the actual connection between nodes.
/// </summary>
/// <param name="from"></param>
/// <param name="fromout"></param>
/// <param name="to"></param>
/// <param name="toin"></param>
private void Connect(ShaderNode from, string fromout, ShaderNode to, string toin)
{
if (m_nodes.Contains(from) && m_nodes.Contains(to))
{
CSycles.shader_connect_nodes(Client.Id, Id, from.Id, fromout, to.Id, toin);
}
else
{
throw new ArgumentException(String.Format("Cannot connect {0} to {1}", from, to));
}
}
/// <summary>
/// Get the device with specified index
/// </summary>
/// <param name="idx"></param>
/// <returns></returns>
static public Device GetDevice(int idx)
{
return(new Device
{
Id = (uint)idx,
Description = CSycles.device_decription(idx),
Name = CSycles.DeviceId(idx),
Num = CSycles.device_num(idx),
Type = CSycles.device_type(idx),
AdvancedShading = CSycles.device_advanced_shading(idx),
DisplayDevice = CSycles.device_display_device(idx),
PackImages = CSycles.device_pack_images(idx)
});
}
/// <summary>
/// Add a ShaderNode to the shader. This will create the node in Cycles, set
/// any values for sockets and direct members.
/// </summary>
/// <param name="node">ShaderNode to add</param>
public void AddNode(ShaderNode node)
{
if (node is OutputNode)
{
node.Id = CSycles.OUTPUT_SHADERNODE_ID;
m_nodes.Add(node);
return;
}
if (created_in_cycles)
{
m_nodes.Add(node);
return;
}
var nodeid = CSycles.add_shader_node(Client.Id, Id, node.Type);
node.Id = nodeid;
m_nodes.Add(node);
}
/// <summary>
/// Release lock.
/// </summary>
public void Unlock()
{
CSycles.scene_unlock(Client.Id, Id);
}
/// <summary>
/// True if any of the available devices is a CUDA device
/// </summary>
/// <returns></returns>
static public bool CudaAvailable()
{
return(CSycles.number_cuda_devices() > 0);
}
/// <summary>
/// Tag the camera for update.
/// </summary>
public void Update()
{
CSycles.camera_update(Scene.Client.Id, Scene.Id);
}
/// <summary>
/// Compute auto view plane.
/// </summary>
public void ComputeAutoViewPlane()
{
CSycles.camera_compute_auto_viewplane(Scene.Client.Id, Scene.Id);
}
/// <summary>
/// Set view plane
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <param name="top"></param>
/// <param name="bottom"></param>
public void SetViewPlane(float left, float right, float top, float bottom)
{
CSycles.camera_set_viewplane(Scene.Client.Id, Scene.Id, left, right, top, bottom);
}
/// <summary>
/// Tag shader for device update
/// </summary>
public void Tag()
{
CSycles.scene_tag_shader(Client.Id, Client.Scene.Id, Id);
}
/// <summary>
/// Tag the film for update.
/// </summary>
public void Update()
{
CSycles.film_tag_update(Scene.Client.Id, Scene.Id);
}
public void ReadNodeGraph(ref Shader shader, XmlReader xmlNode)
{
var nodes = new Dictionary <string, ShaderNode> {
{ "output", shader.Output }
};
while (xmlNode.Read())
{
ShaderNode shader_node = null;
if (!xmlNode.IsStartElement())
{
continue;
}
var nodename = xmlNode.GetAttribute("name");
if (string.IsNullOrEmpty(nodename) && xmlNode.Name != "connect")
{
continue;
}
if (string.IsNullOrEmpty(nodename))
{
nodename = "";
}
switch (xmlNode.Name)
{
case "connect":
var fromstring = xmlNode.GetAttribute("from");
var tostring = xmlNode.GetAttribute("to");
if (fromstring != null && tostring != null)
{
var from = fromstring.Split(' ');
var to = tostring.Split(' ');
if (!nodes.ContainsKey(from[0]))
{
throw new KeyNotFoundException(string.Format("'from' node [{0}] not defined prior to connection.", from[0]));
}
var fromnode = nodes[from[0]];
var fromsocket = fromnode.outputs.Socket(from[1]);
if (!nodes.ContainsKey(to[0]))
{
throw new KeyNotFoundException(string.Format("'to' node [{0}] not defined prior to connection.", to[0]));
}
var tonode = nodes[to[0]];
var tosocket = tonode.inputs.Socket(to[1]);
fromsocket.Connect(tosocket);
}
break;
default:
shader_node = CSycles.CreateShaderNode(xmlNode.Name, nodename);
break;
}
if (shader_node != null)
{
shader_node.ParseXml(xmlNode);
nodes.Add(nodename, shader_node);
shader.AddNode(shader_node);
}
}
shader.FinalizeGraph();
}
/// <summary>
/// Aqcuire lock on scene mutex blocking.
/// </summary>
public void Lock()
{
CSycles.scene_lock(Client.Id, Id);
}
/// <summary>
/// Try aqcuire lock on scene mutex non-blocking.
/// </summary>
/// <returns>True if lock was acquired, false otherwise</returns>
public bool TryLock()
{
return(CSycles.scene_try_lock(Client.Id, Id));
}
//public static uint scene_create(uint scene_params_id, uint deviceid)
//public static uint scene_add_object(uint scene_id)
//public static uint scene_add_mesh(uint scene_id, uint object_id, uint shader_id)
//public static void scene_set_default_surface_shader(uint scene_id, uint shader_id)
/// <summary>
/// Reset the scene, forcing update and device update in Cycles.
/// </summary>
public void Reset()
{
CSycles.scene_reset(Client.Id, Id);
}
/// <summary>
/// Create session parameters using <c>Device</c>
/// </summary>
/// <param name="dev">The device to create session parameters for</param>
public SessionParameters(Client client, Device dev)
{
Client = client;
_device = dev;
Id = CSycles.session_params_create(Client.Id, (uint)dev.Id);
}
/// <summary>
/// Set film filter type and width
/// </summary>
/// <param name="filterType">Box or Gaussian</param>
/// <param name="filterWidth">for proper Box use 1.0f</param>
public void SetFilter(FilterType filterType, float filterWidth)
{
CSycles.film_set_filter(Scene.Client.Id, Scene.Id, filterType, filterWidth);
}