private bool CreateShaderPart(ShaderBody shb, RenderMaterial rm, float gamma)
{
var crm = rm as ICyclesMaterial;
ShaderBody.CyclesMaterial mattype = ShaderBody.CyclesMaterial.No;
if (crm == null)
{
// always simulate material, need to know now myself
// what to read out from the simulated material to
// populate my own material descriptions.
var m = rm.SimulateMaterial(true);
// figure out what type of material we are.
//var probemat = GuessMaterialFromSmell(rm);
var probemat = WhatMaterial(rm, m);
rm.BeginChange(RenderContent.ChangeContexts.Ignore);
var dcl = m.DiffuseColor;
var scl = m.SpecularColor;
var rcl = m.ReflectionColor;
var rfcl = m.TransparentColor;
var emcl = m.EmissionColor;
var polish = (float)m.ReflectionGlossiness;
var reflectivity = (float)m.Reflectivity;
var metalic = 0f;
var shine = (float)(m.Shine / Material.MaxShine);
switch (probemat)
{
case ProbableMaterial.Plaster:
mattype = ShaderBody.CyclesMaterial.Diffuse;
break;
case ProbableMaterial.Glass:
case ProbableMaterial.Gem:
metalic = 0f;
mattype = ShaderBody.CyclesMaterial.Glass;
break;
case ProbableMaterial.Metal:
metalic = 1.0f;
mattype = ShaderBody.CyclesMaterial.SimpleMetal;
break;
case ProbableMaterial.Plastic:
//polish = reflectivity;
//shine = polish;
//reflectivity = 0f;
metalic = 0f;
mattype = ShaderBody.CyclesMaterial.SimplePlastic;
break;
case ProbableMaterial.Paint:
mattype = ShaderBody.CyclesMaterial.Paint;
break;
case ProbableMaterial.Custom:
mattype = ShaderBody.CyclesMaterial.No;
break;
}
var difftexAlpha = m.AlphaTransparency;
var col = RenderEngine.CreateFloat4(dcl.R, dcl.G, dcl.B, 255);
var spec = RenderEngine.CreateFloat4(scl.R, scl.G, scl.B, 255);
var refl = RenderEngine.CreateFloat4(rcl.R, rcl.G, rcl.B, 255);
var transp = RenderEngine.CreateFloat4(rfcl.R, rfcl.G, rfcl.B, 255);
var refr = RenderEngine.CreateFloat4(rfcl.R, rfcl.G, rfcl.B, 255);
var emis = RenderEngine.CreateFloat4(emcl.R, emcl.G, emcl.B, 255);
//shb.Type = CyclesShader.Shader.Diffuse,
shb.CyclesMaterialType = mattype;
shb.Shadeless = m.DisableLighting;
shb.DiffuseColor = col;
shb.SpecularColor = spec;
shb.ReflectionColor = refl;
shb.ReflectionRoughness = (float)m.ReflectionGlossiness; // polish;
shb.RefractionColor = refr;
shb.RefractionRoughness = (float)m.RefractionGlossiness;
shb.TransparencyColor = transp;
shb.EmissionColor = emis;
shb.FresnelIOR = (float)m.FresnelIndexOfRefraction;
shb.IOR = (float)m.IndexOfRefraction;
shb.Roughness = (float)m.ReflectionGlossiness;
shb.Reflectivity = reflectivity;
shb.Metalic = metalic;
shb.Transparency = (float)m.Transparency;
shb.Shine = shine;
shb.Gloss = (float)m.ReflectionGlossiness;
shb.FresnelReflections = m.FresnelReflections;
shb.Gamma = gamma;
shb.Name = m.Name ?? "";
shb.DiffuseTexture.Amount = 0.0f;
shb.BumpTexture.Amount = 0.0f;
shb.TransparencyTexture.Amount = 0.0f;
shb.EnvironmentTexture.Amount = 0.0f;
if (rm.GetTextureOnFromUsage(RenderMaterial.StandardChildSlots.Diffuse))
{
var difftex = rm.GetTextureFromUsage(RenderMaterial.StandardChildSlots.Diffuse);
BitmapConverter.MaterialBitmapFromEvaluator(ref shb, rm, difftex, RenderMaterial.StandardChildSlots.Diffuse);
if (shb.HasDiffuseTexture)
{
shb.DiffuseTexture.UseAlpha = difftexAlpha;
shb.DiffuseTexture.Amount = (float)Math.Min(rm.GetTextureAmountFromUsage(RenderMaterial.StandardChildSlots.Diffuse) / 100.0f, 1.0f);
}
}
if (rm.GetTextureOnFromUsage(RenderMaterial.StandardChildSlots.Bump))
{
var bumptex = rm.GetTextureFromUsage(RenderMaterial.StandardChildSlots.Bump);
BitmapConverter.MaterialBitmapFromEvaluator(ref shb, rm, bumptex, RenderMaterial.StandardChildSlots.Bump);
if (shb.HasBumpTexture)
{
shb.BumpTexture.Amount = (float)Math.Min(rm.GetTextureAmountFromUsage(RenderMaterial.StandardChildSlots.Bump) / 100.0f, 1.0f);
}
}
if (rm.GetTextureOnFromUsage(RenderMaterial.StandardChildSlots.Transparency))
{
var transtex = rm.GetTextureFromUsage(RenderMaterial.StandardChildSlots.Transparency);
BitmapConverter.MaterialBitmapFromEvaluator(ref shb, rm, transtex,
RenderMaterial.StandardChildSlots.Transparency);
if (shb.HasTransparencyTexture)
{
shb.TransparencyTexture.Amount = (float)Math.Min(rm.GetTextureAmountFromUsage(RenderMaterial.StandardChildSlots.Transparency) / 100.0f, 1.0f);
}
}
if (rm.GetTextureOnFromUsage(RenderMaterial.StandardChildSlots.Environment))
{
var envtex = rm.GetTextureFromUsage(RenderMaterial.StandardChildSlots.Environment);
BitmapConverter.MaterialBitmapFromEvaluator(ref shb, rm, envtex,
RenderMaterial.StandardChildSlots.Environment);
if (shb.HasEnvironmentTexture)
{
shb.EnvironmentTexture.Amount = (float)Math.Min(rm.GetTextureAmountFromUsage(RenderMaterial.StandardChildSlots.Environment) / 100.0f, 1.0f);
}
}
rm.EndChange();
}
else
{
crm.BakeParameters();
shb.Crm = crm;
shb.CyclesMaterialType = ShaderBody.CyclesMaterial.Xml;
shb.Gamma = gamma;
shb.Name = rm.Name ?? "some cycles material";
}
return(true);
}
private void Mre_StatusTextUpdated(object sender, RenderEngine.StatusTextEventArgs e)
{
_progress = e.Progress;
}
void CyclesStatusTextUpdated(object sender, RenderEngine.StatusTextEventArgs e)
{
_samples = e.Samples;
_status = _samples < 0 ? "Updating Engine" : "";
}
private void CyclesSamplesChanged(object sender, RenderEngine.SamplesChangedEventArgs e)
{
ChangeSamples(e.Count);
}
/// <summary>
/// create a ccl.Scene
/// </summary>
/// <param name="client">Client to create scene for</param>
/// <param name="render_device">Render device to use</param>
/// <param name="cycles_engine">Engine instance to create for</param>
/// <returns></returns>
protected static Scene CreateScene(Client client, Device render_device,
RenderEngine cycles_engine)
{
#region set up scene parameters
var scene_params = new SceneParameters(client, ShadingSystem.SVM, BvhType.Static, false, render_device.IsCpu, false);
#endregion
#region create scene
var scene = new Scene(client, scene_params, render_device)
{
#region integrator settings
Integrator =
{
MaxBounce = RcCore.It.EngineSettings.MaxBounce,
TransparentMaxBounce = RcCore.It.EngineSettings.TransparentMaxBounce,
MaxDiffuseBounce = RcCore.It.EngineSettings.MaxDiffuseBounce,
MaxGlossyBounce = RcCore.It.EngineSettings.MaxGlossyBounce,
MaxTransmissionBounce = RcCore.It.EngineSettings.MaxTransmissionBounce,
MaxVolumeBounce = RcCore.It.EngineSettings.MaxVolumeBounce,
NoCaustics = RcCore.It.EngineSettings.NoCaustics,
DiffuseSamples = RcCore.It.EngineSettings.DiffuseSamples,
GlossySamples = RcCore.It.EngineSettings.GlossySamples,
TransmissionSamples = RcCore.It.EngineSettings.TransmissionSamples,
AoSamples = RcCore.It.EngineSettings.AoSamples,
MeshLightSamples = RcCore.It.EngineSettings.MeshLightSamples,
SubsurfaceSamples = RcCore.It.EngineSettings.SubsurfaceSamples,
VolumeSamples = RcCore.It.EngineSettings.VolumeSamples,
AaSamples = RcCore.It.EngineSettings.AaSamples,
FilterGlossy = RcCore.It.EngineSettings.FilterGlossy,
IntegratorMethod = RcCore.It.EngineSettings.IntegratorMethod,
SampleAllLightsDirect = RcCore.It.EngineSettings.SampleAllLights,
SampleAllLightsIndirect = RcCore.It.EngineSettings.SampleAllLightsIndirect,
SampleClampDirect = RcCore.It.EngineSettings.SampleClampDirect,
SampleClampIndirect = RcCore.It.EngineSettings.SampleClampIndirect,
LightSamplingThreshold = RcCore.It.EngineSettings.LightSamplingThreshold,
SamplingPattern = SamplingPattern.CMJ,
Seed = RcCore.It.EngineSettings.Seed,
NoShadows = RcCore.It.EngineSettings.NoShadows,
}
#endregion
};
scene.Film.SetFilter(FilterType.Gaussian, 1.5f);
scene.Film.Exposure = 1.0f;
scene.Film.Update();
#endregion
#region background shader
// we add here a simple background shader. This will be repopulated with
// other nodes whenever background changes are detected.
var background_shader = new Shader(client, Shader.ShaderType.World)
{
Name = "Rhino Background"
};
var bgnode = new BackgroundNode("orig bg");
bgnode.ins.Color.Value = new float4(0.7f);
bgnode.ins.Strength.Value = 1.0f;
background_shader.AddNode(bgnode);
bgnode.outs.Background.Connect(background_shader.Output.ins.Surface);
background_shader.FinalizeGraph();
scene.AddShader(background_shader);
scene.Background.Shader = background_shader;
scene.Background.AoDistance = 0.0f;
scene.Background.AoFactor = 0.0f;
scene.Background.Visibility = PathRay.AllVisibility;
#endregion
return(scene);
}
/// <summary>
/// create a ccl.Scene
/// </summary>
/// <param name="client">Client to create scene for</param>
/// <param name="render_device">Render device to use</param>
/// <param name="cycles_engine">Engine instance to create for</param>
/// <returns></returns>
protected static Scene CreateScene(Client client, Device render_device,
RenderEngine cycles_engine)
{
#region set up scene parameters
var scene_params = new SceneParameters(client, ShadingSystem.SVM, BvhType.Dynamic, false, false, false);
#endregion
#region create scene
var scene = new Scene(client, scene_params, render_device)
{
#region integrator settings
Integrator =
{
MaxBounce = cycles_engine.Settings.MaxBounce,
MinBounce = cycles_engine.Settings.MinBounce,
TransparentMinBounce = cycles_engine.Settings.TransparentMinBounce,
TransparentMaxBounce = cycles_engine.Settings.TransparentMaxBounce,
MaxDiffuseBounce = cycles_engine.Settings.MaxDiffuseBounce,
MaxGlossyBounce = cycles_engine.Settings.MaxGlossyBounce,
MaxTransmissionBounce = cycles_engine.Settings.MaxTransmissionBounce,
MaxVolumeBounce = cycles_engine.Settings.MaxVolumeBounce,
NoCaustics = cycles_engine.Settings.NoCaustics,
TransparentShadows = cycles_engine.Settings.TransparentShadows,
DiffuseSamples = cycles_engine.Settings.DiffuseSamples,
GlossySamples = cycles_engine.Settings.GlossySamples,
TransmissionSamples = cycles_engine.Settings.TransmissionSamples,
AoSamples = cycles_engine.Settings.AoSamples,
MeshLightSamples = cycles_engine.Settings.MeshLightSamples,
SubsurfaceSamples = cycles_engine.Settings.SubsurfaceSamples,
VolumeSamples = cycles_engine.Settings.VolumeSamples,
AaSamples = cycles_engine.Settings.AaSamples,
FilterGlossy = cycles_engine.Settings.FilterGlossy,
IntegratorMethod = cycles_engine.Settings.IntegratorMethod,
SampleAllLightsDirect = cycles_engine.Settings.SampleAllLights,
SampleAllLightsIndirect = cycles_engine.Settings.SampleAllLightsIndirect,
SampleClampDirect = cycles_engine.Settings.SampleClampDirect,
SampleClampIndirect = cycles_engine.Settings.SampleClampIndirect,
SamplingPattern = SamplingPattern.CMJ,
Seed = cycles_engine.Settings.Seed
}
#endregion
};
scene.Film.SetFilter(FilterType.Gaussian, 1.5f);
scene.Film.Exposure = 1.0f;
scene.Film.Update();
#endregion
#region background shader
// we add here a simple background shader. This will be repopulated with
// other nodes whenever background changes are detected.
var background_shader = new Shader(client, Shader.ShaderType.World)
{
Name = "Rhino Background"
};
var bgnode = new BackgroundNode("orig bg");
bgnode.ins.Color.Value = new float4(0.7f);
bgnode.ins.Strength.Value = 1.0f;
background_shader.AddNode(bgnode);
bgnode.outs.Background.Connect(background_shader.Output.ins.Surface);
background_shader.FinalizeGraph();
scene.AddShader(background_shader);
scene.Background.Shader = background_shader;
scene.Background.AoDistance = 0.0f;
scene.Background.AoFactor = 0.0f;
scene.Background.Visibility = PathRay.AllVisibility;
#endregion
return scene;
}
