// Write sample material to .sample file (only bool values )
public override bool Write(string pathToFile, RenderContent renderContent, CreatePreviewEventArgs previewArgs)
{
List <string> lines = new List <string>();
foreach (Field field in renderContent.Fields)
{
Type type = field.GetType();
// Bool fields
if (type == typeof(BoolField))
{
string key = field.Name;
string prompt = field.Name;
bool bool_value = false;
renderContent.Fields.TryGetValue(key, out bool_value);
string value = bool_value.ToString();
lines.Add("type=bool," + "key=" + key + ",value=" + value + "," + "prompt=" + prompt);
}
}
// Write all lines to .sample file
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(pathToFile))
{
foreach (string line in lines)
{
file.WriteLine(line);
}
file.Close();
}
return(true);
}
/// <summary>
/// Handler for rendering preview thumbnails.
///
/// The CreatePreviewEventArgs parameter contains a simple
/// scene description to be rendered. It contains a set of meshes
/// and lights. Meshes have RenderMaterials attached to them.
/// </summary>
/// <param name="scene">The scene description to render, along with the requested quality setting</param>
protected override void CreatePreview(CreatePreviewEventArgs scene)
{
scene.SkipInitialisation();
if (scene.Quality == PreviewSceneQuality.Low)
{
scene.PreviewImage = null;
return;
}
AsyncRenderContext a_rc = new PreviewRenderEngine(scene, Id);
var engine = (PreviewRenderEngine)a_rc;
engine.RenderDimension = scene.PreviewImageSize;
/* create a window-less, non-document controlled render window */
engine.RenderWindow = Rhino.Render.RenderWindow.Create(scene.PreviewImageSize);
engine.Database.RenderDimension = engine.RenderDimension;
engine.SetFloatTextureAsByteTexture(false);
engine.CreateWorld();
/* render the preview scene */
PreviewRenderEngine.Renderer(engine);
/* set final preview bitmap, or null if cancelled */
scene.PreviewImage = engine.RenderWindow.GetBitmap();
#if DEBUG
var prev = $"{Environment.GetEnvironmentVariable("TEMP")}\\previmg.jpg";
scene.PreviewImage.Save(prev, System.Drawing.Imaging.ImageFormat.Jpeg);
#endif
}
protected override void CreatePreview(CreatePreviewEventArgs args)
{
foreach (var o in args.Objects)
{
RhinoApp.WriteLine($"{o.Material.Name}: {o.Material.TypeName} | {o.Material.TypeId} | {o.Material.TypeDescription}");
}
args.PreviewImage = null;
}
public RenderEngine(Guid pluginId, CreatePreviewEventArgs previewEventArgs, bool interactive)
{
SetKernelFlags();
SupportClippingPlanes = RcCore.It.EngineSettings.RaytracedClippingPlanes;
PreviewEventArgs = previewEventArgs;
Database = new ChangeDatabase(pluginId, this, PreviewEventArgs)
{
SupportClippingPlanes = SupportClippingPlanes
};
RegisterEventHandler();
}
Bitmap BitmapForScene(CreatePreviewEventArgs scene, Color4f color)
{
var bitmap = new Bitmap(scene.PreviewImageSize.Width, scene.PreviewImageSize.Height, PixelFormat.Format24bppRgb);
// Fill the bitmap using the computed color
using (var g = Graphics.FromImage(bitmap))
{
g.Clear(Color.FromArgb(255, color.AsSystemColor()));
g.DrawRectangle(Pens.Black, 0, 0, bitmap.Width - 1, bitmap.Height - 1);
}
return(bitmap);
}
/// <summary>
/// Construct a render engine for preview rendering
/// </summary>
/// <param name="createPreviewEventArgs"></param>
/// <param name="pluginId">Id of the plugin for which the render engine is created</param>
public PreviewRenderEngine(CreatePreviewEventArgs createPreviewEventArgs, Guid pluginId) : base(pluginId, createPreviewEventArgs, false)
{
Client = new Client();
State = State.Rendering;
#region create callbacks for Cycles
m_update_callback = UpdateCallback;
m_update_render_tile_callback = PreviewRendererUpdateRenderTileCallback;
m_write_render_tile_callback = PreviewRendererWriteRenderTileCallback;
m_test_cancel_callback = TestCancel;
CSycles.log_to_stdout(false);
#endregion
}
protected override void CreatePreview(CreatePreviewEventArgs scene)
{
if (scene.Quality == PreviewSceneQuality.Low)
{
// Use built in image for quick preview so we don't slow the UI down.
scene.PreviewImage = new Bitmap(Properties.Resources.AtoZ, scene.PreviewImageSize);
return;
}
// New preview bitmap
Bitmap bitmap = null;
// If previewing a custom environment
if (scene.ContentKind == RenderContentKind.Environment)
{
Color4f color;
if (scene.Environment.Fields.TryGetValue("background", out color) ||
scene.Environment.Fields.TryGetValue("color", out color) ||
scene.Environment.Fields.TryGetValue("background-color", out color))
{
bitmap = BitmapForScene(scene, color);
}
}
else if (scene.ContentKind == RenderContentKind.Material)
{
// Make sure the content is a material
RenderMaterial render_material = null;
foreach (var obj in scene.Objects)
{
render_material = obj.Material;
if (render_material != null)
{
break;
}
}
if (null != render_material)
{
Color4f color;
// First try to get the value of the custom color field, if it is not found
// then look for the RDK "diffuse" color field
if (!render_material.Fields.TryGetValue("color", out color) &&
!render_material.Fields.TryGetValue(RenderMaterial.BasicMaterialParameterNames.Diffuse, out color))
{
color = Color4f.Black; // Could not find either of the color fields
}
// Create preview bitmap of requested size
bitmap = BitmapForScene(scene, color);
}
}
scene.PreviewImage = bitmap ?? new Bitmap(Properties.Resources.AtoZ, scene.PreviewImageSize);
}
