public void Add(Rhino.Geometry.Sphere sphere, RenderMaterial material) { UnsafeNativeMethods.Rdk_CustomMeshes_AddSphere(NonConstPointer(), sphere.Center, sphere.EquitorialPlane.XAxis, sphere.EquitorialPlane.YAxis, sphere.Radius, material.ConstPointer()); }
public void Add(Rhino.Geometry.Box box, RenderMaterial material) { UnsafeNativeMethods.Rdk_CustomMeshes_AddBox(NonConstPointer(), box.Plane.Origin, box.Plane.XAxis, box.Plane.YAxis, box.X.Min, box.X.Max, box.Y.Min, box.Y.Max, box.Z.Min, box.Z.Max, material.ConstPointer()); }
public void Add(Rhino.Geometry.Cone cone, Rhino.Geometry.Plane truncation, RenderMaterial material) { UnsafeNativeMethods.Rdk_CustomMeshes_AddCone(NonConstPointer(), cone.BasePoint, cone.Plane.XAxis, cone.Plane.YAxis, cone.Height, cone.Radius, truncation.Origin, truncation.XAxis, truncation.YAxis, material.ConstPointer()); }
private RenderMaterial GetObjectMaterial(Rhino.DocObjects.RhinoObject rhinoObject) { ObjectMaterialSource source = rhinoObject.Attributes.MaterialSource; Rhino.Render.RenderMaterial renderMaterial = null; if (source == ObjectMaterialSource.MaterialFromObject) { renderMaterial = rhinoObject.RenderMaterial; } else if (source == ObjectMaterialSource.MaterialFromLayer) { int layerIndex = rhinoObject.Attributes.LayerIndex; renderMaterial = GetLayerMaterial(layerIndex); } return(renderMaterial); }
public void Add(Rhino.Geometry.PlaneSurface plane, RenderMaterial material) { UnsafeNativeMethods.Rdk_CustomMeshes_AddPlane(NonConstPointer(), plane.ConstPointer(), material.ConstPointer()); }
/// <summary> /// Add primitive box and material. /// </summary> /// <param name="box">Box to add.</param> /// <param name="material"> /// Material to add, may be null if not needed. /// </param> public void Add(Box box, RenderMaterial material) { var material_pointer = (null == material ? IntPtr.Zero : material.ConstPointer()); var pointer = NonConstPointer(); UnsafeNativeMethods.Rdk_CustomMeshes_AddBox(pointer, box.Plane.Origin, box.Plane.XAxis, box.Plane.YAxis, box.X.Min, box.X.Max, box.Y.Min, box.Y.Max, box.Z.Min, box.Z.Max, material_pointer); }
public void Add(Rhino.Geometry.Mesh mesh, RenderMaterial material) { UnsafeNativeMethods.Rdk_CustomMeshes_AddMesh(NonConstPointer(), mesh.ConstPointer(), material.ConstPointer()); }
/// <summary> /// Add primitive cone and material. /// </summary> /// <param name="cone">Cone to add.</param> /// <param name="truncation"> /// The plane used to cut the cone (the non-apex end is kept). Should be /// equal to cone.plane if not truncated. /// </param> /// <param name="material"> /// Material to add, may be null if not needed. /// </param> public void Add(Cone cone, Plane truncation, RenderMaterial material) { var material_pointer = (null == material ? IntPtr.Zero : material.ConstPointer()); var pointer = NonConstPointer(); UnsafeNativeMethods.Rdk_CustomMeshes_AddCone(pointer, cone.BasePoint, cone.Plane.XAxis, cone.Plane.YAxis, cone.Height, cone.Radius, truncation.Origin, truncation.XAxis, truncation.YAxis, material_pointer); }
/// <summary> /// Add primitive plane and material. /// </summary> /// <param name="plane">Plane to add.</param> /// <param name="material"> /// Material to add, may be null if not needed. /// </param> public void Add(PlaneSurface plane, RenderMaterial material) { var material_pointer = (null == material ? IntPtr.Zero : material.ConstPointer()); var pointer = NonConstPointer(); UnsafeNativeMethods.Rdk_CustomMeshes_AddPlane(pointer, plane.ConstPointer(), material_pointer); }
/// <summary> /// Add mesh and material. /// </summary> /// <param name="mesh">Mesh to add.</param> /// <param name="material"> /// Material to add, may be null if not needed. /// </param> public void Add(Mesh mesh, RenderMaterial material) { var material_pointer = (null == material ? IntPtr.Zero : material.ConstPointer()); var pointer = NonConstPointer(); UnsafeNativeMethods.Rdk_CustomMeshes_AddMesh(pointer, mesh.ConstPointer(), material_pointer); }
/// <summary> /// Add primitive sphere and material. /// </summary> /// <param name="sphere">Sphere to add.</param> /// <param name="material"> /// Material to add, may be null if not needed. /// </param> public void Add(Sphere sphere, RenderMaterial material) { var material_pointer = (null == material ? IntPtr.Zero : material.ConstPointer()); var pointer = NonConstPointer(); UnsafeNativeMethods.Rdk_CustomMeshes_AddSphere(pointer, sphere.Center, sphere.EquitorialPlane.XAxis, sphere.EquitorialPlane.YAxis, sphere.Radius, material_pointer); }
private static void InternalMaterialBitmapFromEvaluator(CyclesShader shader, RenderTexture renderTexture, RenderMaterial.StandardChildSlots textureType, Rhino.Geometry.Transform rhinotfm, uint rId, TextureEvaluator actualEvaluator, TextureProjectionMode projectionMode, TextureEnvironmentMappingMode envProjectionMode) { int pheight; int pwidth; try { int u, v, w; renderTexture.PixelSize(out u, out v, out w); pheight = u; pwidth = v; } catch (Exception) { pheight = 1024; pwidth = 1024; } if (pheight == 0 || pwidth == 0) { pheight = 1024; pwidth = 1024; } Transform t = new Transform( rhinotfm.ToFloatArray(true) ); var isFloat = renderTexture.IsHdrCapable(); var isLinear = renderTexture.IsLinear(); if (isFloat) { var img = RetrieveFloatsImg(rId, pwidth, pheight, actualEvaluator, false, false, isLinear); img.ApplyGamma(shader.Gamma); switch (textureType) { case RenderMaterial.StandardChildSlots.Diffuse: shader.DiffuseTexture.IsLinear = isLinear; shader.DiffuseTexture.TexFloat = img.Data; shader.DiffuseTexture.TexByte = null; break; case RenderMaterial.StandardChildSlots.Bump: shader.BumpTexture.IsLinear = isLinear; shader.BumpTexture.TexFloat = img.Data; shader.BumpTexture.TexByte = null; break; case RenderMaterial.StandardChildSlots.Transparency: shader.TransparencyTexture.IsLinear = isLinear; shader.TransparencyTexture.TexFloat = img.Data; shader.TransparencyTexture.TexByte = null; break; case RenderMaterial.StandardChildSlots.Environment: shader.EnvironmentTexture.IsLinear = isLinear; shader.EnvironmentTexture.TexFloat = img.Data; shader.EnvironmentTexture.TexByte = null; break; } } else { var img = RetrieveBytesImg(rId, pwidth, pheight, actualEvaluator, false, false, isLinear); img.ApplyGamma(shader.Gamma); switch (textureType) { case RenderMaterial.StandardChildSlots.Diffuse: shader.DiffuseTexture.IsLinear = isLinear; shader.DiffuseTexture.TexFloat = null; shader.DiffuseTexture.TexByte = img.Data; break; case RenderMaterial.StandardChildSlots.Bump: shader.BumpTexture.IsLinear = isLinear; shader.BumpTexture.TexFloat = null; shader.BumpTexture.TexByte = img.Data; break; case RenderMaterial.StandardChildSlots.Transparency: shader.TransparencyTexture.IsLinear = isLinear; shader.TransparencyTexture.TexFloat = null; shader.TransparencyTexture.TexByte = img.Data; break; case RenderMaterial.StandardChildSlots.Environment: shader.EnvironmentTexture.IsLinear = isLinear; shader.EnvironmentTexture.TexFloat = null; shader.EnvironmentTexture.TexByte = img.Data; break; } } switch (textureType) { case RenderMaterial.StandardChildSlots.Diffuse: shader.DiffuseTexture.TexWidth = pwidth; shader.DiffuseTexture.TexHeight = pheight; shader.DiffuseTexture.ProjectionMode = projectionMode; shader.DiffuseTexture.EnvProjectionMode = envProjectionMode; shader.DiffuseTexture.Transform = t; shader.DiffuseTexture.Name = rId.ToString(CultureInfo.InvariantCulture); break; case RenderMaterial.StandardChildSlots.Bump: shader.BumpTexture.TexWidth = pwidth; shader.BumpTexture.TexHeight = pheight; shader.BumpTexture.ProjectionMode = projectionMode; shader.BumpTexture.EnvProjectionMode = envProjectionMode; shader.BumpTexture.Transform = t; shader.BumpTexture.Name = rId.ToString(CultureInfo.InvariantCulture); break; case RenderMaterial.StandardChildSlots.Transparency: shader.TransparencyTexture.TexWidth = pwidth; shader.TransparencyTexture.TexHeight = pheight; shader.TransparencyTexture.ProjectionMode = projectionMode; shader.TransparencyTexture.EnvProjectionMode = envProjectionMode; shader.TransparencyTexture.Transform = t; shader.TransparencyTexture.Name = rId.ToString(CultureInfo.InvariantCulture); break; case RenderMaterial.StandardChildSlots.Environment: shader.EnvironmentTexture.TexWidth = pwidth; shader.EnvironmentTexture.TexHeight = pheight; // special texture, always set to Environment/Emap shader.EnvironmentTexture.ProjectionMode = TextureProjectionMode.EnvironmentMap; shader.EnvironmentTexture.EnvProjectionMode = TextureEnvironmentMappingMode.EnvironmentMap; shader.EnvironmentTexture.Transform = t; shader.EnvironmentTexture.Name = rId.ToString(CultureInfo.InvariantCulture); break; } }
/// <summary> /// Get material bitmap from texture evaluator /// </summary> /// <param name="shader"></param> /// <param name="rm"></param> /// <param name="renderTexture"></param> /// <param name="textureType"></param> internal static void MaterialBitmapFromEvaluator(ref CyclesShader shader, RenderMaterial rm, RenderTexture renderTexture, RenderMaterial.StandardChildSlots textureType) { if (renderTexture == null) return; var rId = renderTexture.RenderHashWithoutLocalMapping; var rhinotfm = renderTexture.LocalMappingTransform; var projectionMode = renderTexture.GetProjectionMode(); var envProjectionMode = renderTexture.GetInternalEnvironmentMappingMode(); using (var textureEvaluator = renderTexture.CreateEvaluator(RenderTexture.TextureEvaluatorFlags.DisableLocalMapping)) { SimulatedTexture st = textureEvaluator == null ? renderTexture.SimulatedTexture(RenderTexture.TextureGeneration.Disallow) : null; using ( var actualEvaluator = textureEvaluator ?? RenderTexture.NewBitmapTexture(st).CreateEvaluator(RenderTexture.TextureEvaluatorFlags.Normal)) { InternalMaterialBitmapFromEvaluator(shader, renderTexture, textureType, rhinotfm, rId, actualEvaluator, projectionMode, envProjectionMode); } } }
/// <summary> /// Determine material type using smell, but also querying for /// specific parameters on the RenderMaterial /// </summary> /// <param name="rm"></param> /// <returns>ProbableMaterial</returns> private ProbableMaterial GuessMaterialFromSmell(RenderMaterial rm) { if(rm.SmellsLikePlaster) return ProbableMaterial.Plaster; if(rm.SmellsLikeGem && rm.GetParameter("type")!=null) return ProbableMaterial.Gem; if(rm.SmellsLikeGlass && rm.GetParameter("ior")!=null) return ProbableMaterial.Glass; if(rm.SmellsLikePlastic) return ProbableMaterial.Plastic; if(rm.SmellsLikePaint) return ProbableMaterial.Paint; if(rm.SmellsLikeMetal) return ProbableMaterial.Metal; return ProbableMaterial.Custom; }
private static ProbableMaterial WhatMaterial(RenderMaterial rm, Rhino.DocObjects.Material m) { if (rm.TypeId.Equals(RenderMaterial.PictureMaterialGuid)) { return ProbableMaterial.Picture; } if (rm.TypeId.Equals(RenderMaterial.PlasterMaterialGuid)) { return ProbableMaterial.Plaster; } if (rm.TypeId.Equals(RenderMaterial.GlassMaterialGuid)) { return ProbableMaterial.Glass; } if (rm.TypeId.Equals(RenderMaterial.GemMaterialGuid)) { return ProbableMaterial.Gem; } if (rm.TypeId.Equals(RenderMaterial.PaintMaterialGuid)) { return ProbableMaterial.Paint; } if (rm.TypeId.Equals(RenderMaterial.PlasticMaterialGuid)) { return ProbableMaterial.Plastic; } if (rm.TypeId.Equals(RenderMaterial.MetalMaterialGuid)) { return ProbableMaterial.Metal; } if (rm.SmellsLikePlaster || rm.SmellsLikeTexturedPlaster) { return ProbableMaterial.Plaster; } if (rm.SmellsLikeGlass || rm.SmellsLikeTexturedGlass) { return ProbableMaterial.Glass; } if (rm.SmellsLikeGem || rm.SmellsLikeTexturedGem) { return ProbableMaterial.Gem; } if (rm.SmellsLikePaint || rm.SmellsLikeTexturedPaint) { return ProbableMaterial.Paint; } if (rm.SmellsLikePlastic || rm.SmellsLikeTexturedPlastic) { return ProbableMaterial.Plastic; } if (rm.SmellsLikeMetal || rm.SmellsLikeTexturedMetal) { return ProbableMaterial.Metal; } return ProbableMaterial.Custom; }
/// <summary> /// Create a CyclesShader based on given Material m /// </summary> /// <param name="rm">Material to convert to CyclesShader</param> /// <param name="gamma">gamma to use for this shader</param> /// <returns>The CyclesShader</returns> internal CyclesShader CreateCyclesShader(RenderMaterial rm, float gamma) { var mid = rm.RenderHash; CyclesShader shader = null; var crm = rm as ICyclesMaterial; CyclesShader.CyclesMaterial mattype = CyclesShader.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 = CyclesShader.CyclesMaterial.Diffuse; break; case ProbableMaterial.Glass: case ProbableMaterial.Gem: metalic = 0f; mattype = CyclesShader.CyclesMaterial.Glass; break; case ProbableMaterial.Metal: metalic = 1.0f; mattype = CyclesShader.CyclesMaterial.SimpleMetal; break; case ProbableMaterial.Plastic: polish = reflectivity; shine = polish; reflectivity = 0f; metalic = 0f; mattype = CyclesShader.CyclesMaterial.SimplePlastic; break; case ProbableMaterial.Paint: mattype = CyclesShader.CyclesMaterial.Paint; break; case ProbableMaterial.Custom: metalic = m.FresnelReflections ? 0.0f : reflectivity; 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); shader = new CyclesShader { Id = mid, Type = CyclesShader.Shader.Diffuse, CyclesMaterialType = mattype, Shadeless = m.DisableLighting, DiffuseColor = col, SpecularColor = spec, ReflectionColor = refl, ReflectionRoughness = polish, RefractionColor = refr, RefractionRoughness = (float)m.RefractionGlossiness, TransparencyColor = transp, EmissionColor = emis, FresnelIOR = (float)m.FresnelIndexOfRefraction, IOR = (float)m.IndexOfRefraction, Roughness = (float)m.ReflectionGlossiness, Reflectivity = reflectivity, Metalic = metalic, Transparency = (float)m.Transparency, Shine = shine, Gloss = metalic > 0.0f ? polish : 0.0f, FresnelReflections = m.FresnelReflections, Gamma = gamma, Name = m.Name ?? "" }; shader.DiffuseTexture.Amount = 0.0f; shader.BumpTexture.Amount = 0.0f; shader.TransparencyTexture.Amount = 0.0f; shader.EnvironmentTexture.Amount = 0.0f; if (rm.GetTextureOnFromUsage(RenderMaterial.StandardChildSlots.Diffuse)) { var difftex = rm.GetTextureFromUsage(RenderMaterial.StandardChildSlots.Diffuse); BitmapConverter.MaterialBitmapFromEvaluator(ref shader, rm, difftex, RenderMaterial.StandardChildSlots.Diffuse); if (shader.HasDiffuseTexture) { shader.DiffuseTexture.UseAlpha = difftexAlpha; shader.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 shader, rm, bumptex, RenderMaterial.StandardChildSlots.Bump); if (shader.HasBumpTexture) { shader.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 shader, rm, transtex, RenderMaterial.StandardChildSlots.Transparency); if (shader.HasTransparencyTexture) { shader.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 shader, rm, envtex, RenderMaterial.StandardChildSlots.Environment); if (shader.HasEnvironmentTexture) { shader.EnvironmentTexture.Amount = (float)Math.Min(rm.GetTextureAmountFromUsage(RenderMaterial.StandardChildSlots.Environment) / 100.0f, 1.0f); } } rm.EndChange(); } if (crm != null) { shader = new CyclesShader { Id = mid, CyclesMaterialType = crm.MaterialType, Gamma = gamma, Crm = crm }; } shader.Gamma = gamma; return shader; }