public void RenderMaterial_OSDFromToTest() { RenderMaterial mat = new RenderMaterial(UUID.Zero, UUID.Zero); OSD map = mat.GetOSD(); RenderMaterial matFromOSD = RenderMaterial.FromOSD(map); Assert.That(mat, Is.EqualTo(matFromOSD)); Assert.That(matFromOSD.NormalID, Is.EqualTo(UUID.Zero)); Assert.That(matFromOSD.NormalOffsetX, Is.EqualTo(0.0f)); Assert.That(matFromOSD.NormalOffsetY, Is.EqualTo(0.0f)); Assert.That(matFromOSD.NormalRepeatX, Is.EqualTo(1.0f)); Assert.That(matFromOSD.NormalRepeatY, Is.EqualTo(1.0f)); Assert.That(matFromOSD.NormalRotation, Is.EqualTo(0.0f)); Assert.That(matFromOSD.SpecularID, Is.EqualTo(UUID.Zero)); Assert.That(matFromOSD.SpecularOffsetX, Is.EqualTo(0.0f)); Assert.That(matFromOSD.SpecularOffsetY, Is.EqualTo(0.0f)); Assert.That(matFromOSD.SpecularRepeatX, Is.EqualTo(1.0f)); Assert.That(matFromOSD.SpecularRepeatY, Is.EqualTo(1.0f)); Assert.That(matFromOSD.SpecularRotation, Is.EqualTo(0.0f)); Assert.That(matFromOSD.SpecularLightColorR, Is.EqualTo(255)); Assert.That(matFromOSD.SpecularLightColorG, Is.EqualTo(255)); Assert.That(matFromOSD.SpecularLightColorB, Is.EqualTo(255)); Assert.That(matFromOSD.SpecularLightColorA, Is.EqualTo(255)); Assert.That(matFromOSD.SpecularLightExponent, Is.EqualTo(RenderMaterial.DEFAULT_SPECULAR_LIGHT_EXPONENT)); Assert.That(matFromOSD.EnvironmentIntensity, Is.EqualTo(RenderMaterial.DEFAULT_ENV_INTENSITY)); Assert.That(matFromOSD.DiffuseAlphaMode, Is.EqualTo((byte)RenderMaterial.eDiffuseAlphaMode.DIFFUSE_ALPHA_MODE_BLEND)); Assert.That(matFromOSD.AlphaMaskCutoff, Is.EqualTo(0)); }
public void RenderMaterial_SerializationPreservesValues() { RenderMaterial mat = new RenderMaterial(); mat.NormalID = UUID.Random(); mat.NormalOffsetX = 2.0f; mat.NormalOffsetY = 2.0f; mat.NormalRepeatX = 2.0f; mat.NormalRepeatY = 2.0f; mat.NormalRotation = 180.0f; mat.SpecularID = UUID.Random(); mat.SpecularOffsetX = 2.0f; mat.SpecularOffsetY = 2.0f; mat.SpecularRepeatX = 2.0f; mat.SpecularRepeatY = 2.0f; mat.SpecularRotation = 180.0f; mat.SpecularLightColorR = 127; mat.SpecularLightColorG = 127; mat.SpecularLightColorB = 127; mat.SpecularLightColorA = 255; mat.SpecularLightExponent = 2; mat.EnvironmentIntensity = 2; mat.DiffuseAlphaMode = (byte)RenderMaterial.eDiffuseAlphaMode.DIFFUSE_ALPHA_MODE_MASK; mat.AlphaMaskCutoff = 2; byte[] bytes = mat.ToBytes(); RenderMaterial newmat = RenderMaterial.FromBytes(bytes, 0, bytes.Length); Assert.That(newmat, Is.EqualTo(mat)); }
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 BoxObject Weiter() { RenderMaterial render = new RenderMaterial(); render.Texture = Core.Content.Load<Texture2D>("weiter2"); render.Diffuse = Color.White.ToVector4(); BoxObject weiter = LoadBox(new Vector3(-20,2,-2f), new Vector3(0.4f, 0.2f, 0), 0f); weiter.RenderMaterial = render; return weiter; }
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 BoxObject LoadObjWafC() { BoxObject changer = LoadBox(new Vector3(0, 2.0f, -6), new Vector3(1, 0.8f, 0), 0f); RenderMaterial bild = new RenderMaterial(); bild.Texture = Core.Content.Load<Texture2D>("ChangerDummy"); bild.Diffuse = Color.White.ToVector4(); changer.RenderMaterial = bild; //scene.Add(changer); return changer; }
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()); }
public BoxObject LeftHand() { RenderMaterial rot = new RenderMaterial(); rot.Diffuse = Color.Red.ToVector4(); BoxObject leftHand = new BoxObject(new Vector3(0, 0, 0), new Vector3(0.1f, 0.1f, 0f), 0f); leftHand.RenderMaterial = rot; leftHand.RenderMaterial.Transparency = 0.3f; scene.Add(leftHand); return leftHand; }
public BoxObject RightHand() { RenderMaterial gruen = new RenderMaterial(); gruen.Diffuse = Color.Green.ToVector4(); BoxObject rightHand = new BoxObject(new Vector3(0, 0, 0), new Vector3(0.1f, 0.1f, 0f), 0f); rightHand.RenderMaterial = gruen; rightHand.RenderMaterial.Transparency = 0.3f; scene.Add(rightHand); return rightHand; }
private void LoadBackground(string bildname) { RenderMaterial hintergrundsbild = new RenderMaterial(); hintergrund = new BoxObject(pos, new Vector3(110, 35, 0), 0f); hintergrundsbild.Texture = Core.Content.Load<Texture2D>(bildname); hintergrundsbild.Diffuse = Color.White.ToVector4(); hintergrundsbild.EnableGlow = false; hintergrund.RenderMaterial = hintergrundsbild; scene.Add(hintergrund); }
public BoxObject showObjects(string bild) { Vector3 vector = new Vector3(0, 2.0f, -6); RenderMaterial bildobjekte = new RenderMaterial(); BoxObject blende = new BoxObject(vector, new Vector3(4, 0.8f, 0), 0f); bildobjekte.Texture = Core.Content.Load<Texture2D>(bild); bildobjekte.Diffuse = Color.White.ToVector4(); blende.RenderMaterial = bildobjekte; scene.Add(blende); return blende; }
public void setMaterial(String bild) { materialString = bild; if (bild.Equals("blank")) { material = new RenderMaterial(); material.Diffuse = Color.Gray.ToVector4(); } else { material.Texture = Core.Content.Load<Texture2D>(bild); material.Diffuse = Color.White.ToVector4(); } objekt.RenderMaterial = material; }
public Base ConvertToSpeckle(object @object) { RenderMaterial material = null; Base @base = null; Base schema = null; if (@object is RhinoObject ro) { material = GetMaterial(ro); if (ro.Attributes.GetUserString(SpeckleSchemaKey) != null) // schema check - this will change in the near future { schema = ConvertToSpeckleBE(ro); } if (!(@object is InstanceObject)) // block instance check { @object = ro.Geometry; } } switch (@object) { case Point3d o: @base = PointToSpeckle(o); break; case Rhino.Geometry.Point o: @base = PointToSpeckle(o); break; case PointCloud o: @base = PointcloudToSpeckle(o); break; case Vector3d o: @base = VectorToSpeckle(o); break; case RH.Interval o: @base = IntervalToSpeckle(o); break; case UVInterval o: @base = Interval2dToSpeckle(o); break; case RH.Line o: @base = LineToSpeckle(o); break; case LineCurve o: @base = LineToSpeckle(o); break; case RH.Plane o: @base = PlaneToSpeckle(o); break; case Rectangle3d o: @base = PolylineToSpeckle(o); break; case RH.Circle o: @base = CircleToSpeckle(o); break; case RH.Arc o: @base = ArcToSpeckle(o); break; case ArcCurve o: @base = ArcToSpeckle(o); break; case RH.Ellipse o: @base = EllipseToSpeckle(o); break; case RH.Polyline o: @base = PolylineToSpeckle(o) as Base; break; case NurbsCurve o: @base = CurveToSpeckle(o) as Base; break; case PolylineCurve o: @base = PolylineToSpeckle(o); break; case PolyCurve o: @base = PolycurveToSpeckle(o); break; case RH.Box o: @base = BoxToSpeckle(o); break; case RH.Mesh o: @base = MeshToSpeckle(o); break; case RH.Extrusion o: @base = BrepToSpeckle(o); break; case RH.Brep o: @base = BrepToSpeckle(o.DuplicateBrep()); break; case NurbsSurface o: @base = SurfaceToSpeckle(o); break; case ViewInfo o: @base = ViewToSpeckle(o); break; case InstanceDefinition o: @base = BlockDefinitionToSpeckle(o); break; case InstanceObject o: @base = BlockInstanceToSpeckle(o); break; default: throw new NotSupportedException(); } if (material != null) { @base["renderMaterial"] = material; } if (schema != null) { schema["renderMaterial"] = material; @base["@SpeckleSchema"] = schema; } return(@base); }
public virtual void Initialize() { if (isBasic) { var bm = new BasicMaterial(type); _rmat = bm; //set up material bm.Dc = Dc; bm.OcEnabled = Oc.HasValue; if (Oc.HasValue) { bm.Oc = Oc.Value; } bm.Ec = Ec; bm.DtSampler = DtName; bm.DtFlags = (SamplerFlags)DtFlags; bm.EtSampler = etName; bm.EtFlags = (SamplerFlags)EtFlags; bm.Library = textureLibrary; if (type.Contains("Ot")) { bm.AlphaEnabled = true; } if (type.Contains("Two")) { bm.DoubleSided = true; } if (type.Contains("Et")) { bm.EtEnabled = true; } } else { switch (type) { case "Nebula": case "NebulaTwo": var nb = new NebulaMaterial(); if (type == "NebulaTwo") { nb.DoubleSided = true; } _rmat = nb; nb.DtSampler = DtName; nb.DtFlags = (SamplerFlags)DtFlags; nb.Library = textureLibrary; break; case "AtmosphereMaterial": var am = new AtmosphereMaterial(); _rmat = am; am.Dc = Dc; am.Ac = Ac; am.Alpha = Alpha; am.Fade = Fade; am.Scale = Scale; am.DtSampler = DtName; am.DtFlags = (SamplerFlags)DtFlags; am.Library = textureLibrary; break; case "Masked2DetailMapMaterial": var m2 = new Masked2DetailMapMaterial(); _rmat = m2; m2.Dc = Dc; m2.Ac = Ac; m2.TileRate0 = TileRate0; m2.TileRate1 = TileRate1; m2.FlipU = FlipU; m2.FlipV = FlipV; m2.DtSampler = DtName; m2.DtFlags = (SamplerFlags)DtFlags; m2.Dm0Sampler = dm0Name; m2.Dm0Flags = (SamplerFlags)Dm0Flags; m2.Dm1Sampler = dm1Name; m2.Dm1Flags = (SamplerFlags)Dm1Flags; m2.Library = textureLibrary; break; case "IllumDetailMapMaterial": var ilm = new IllumDetailMapMaterial(); _rmat = ilm; ilm.Dc = Dc; ilm.Ac = Ac; ilm.TileRate0 = TileRate0; ilm.TileRate1 = TileRate1; ilm.FlipU = FlipU; ilm.FlipV = FlipV; ilm.DtSampler = DtName; ilm.DtFlags = (SamplerFlags)DtFlags; ilm.Dm0Sampler = dm0Name; ilm.Dm0Flags = (SamplerFlags)Dm0Flags; ilm.Dm1Sampler = dm1Name; ilm.Dm1Flags = (SamplerFlags)Dm1Flags; ilm.Library = textureLibrary; break; case "DetailMap2Dm1Msk2PassMaterial": var dm2p = new DetailMap2Dm1Msk2PassMaterial(); _rmat = dm2p; dm2p.Dc = Dc; dm2p.Ac = Ac; dm2p.FlipU = FlipU; dm2p.FlipV = FlipV; dm2p.TileRate = TileRate; dm2p.DtSampler = DtName; dm2p.DtFlags = (SamplerFlags)DtFlags; dm2p.Dm1Sampler = dm1Name; dm2p.Dm1Flags = (SamplerFlags)Dm1Flags; dm2p.Library = textureLibrary; break; case "NomadMaterialNoBendy": case "NomadMaterial": var nmd = new NomadMaterial(); _rmat = nmd; nmd.Dc = Dc; nmd.BtSampler = btName; nmd.BtFlags = (SamplerFlags)BtFlags; nmd.DtSampler = DtName; nmd.DtFlags = (SamplerFlags)DtFlags; nmd.NtFlags = (SamplerFlags)NtFlags; nmd.NtSampler = NtName; nmd.Oc = Oc ?? 1f; nmd.Library = textureLibrary; break; case "DetailMapMaterial": var dm = new DetailMapMaterial(); _rmat = dm; dm.Dc = Dc; dm.Ac = Ac; dm.FlipU = FlipU; dm.FlipV = FlipV; dm.TileRate = TileRate;; dm.DmSampler = dmName; dm.DmFlags = (SamplerFlags)DmFlags; dm.DtSampler = DtName; dm.DtFlags = (SamplerFlags)DtFlags; dm.Library = textureLibrary; break; default: throw new NotImplementedException(); } } }
private void overblend(BoxObject box, string bild) { if (box.RenderMaterial.Texture.Name != bild) { RenderMaterial xmenu = new RenderMaterial(); xmenu.Texture = Core.Content.Load<Texture2D>(bild); xmenu.Diffuse = Color.Gray.ToVector4(); box.RenderMaterial = xmenu; } }
protected override Result RunCommand(RhinoDoc doc, RunMode mode) { // A properties of a Rhino material define what is required to draw an // object using OpenGL. Most rendering plug-ins require a much richer // defintion than this. And, not all rendering plug-ins support the // same material properties. This is where Render materials come in. // An Render material is an abstract material - one that is defined // by the the owning render plug-in. But a basic Render material does // share some properties with a Rhino material. // This example demonstrates how to create a basic Render material. // This material will appear in Rhino's Materials panel. It it called // basic material because it does not target any particular rendering // plug-in. // 1.) Create some Rhino materials var red_material = new Material { DiffuseColor = Color.Red, Name = "Red" }; var green_material = new Material { DiffuseColor = Color.Green, Name = "Green" }; var blue_material = new Material { DiffuseColor = Color.Blue, Name = "Blue" }; // 2.) Create basic Render materials from Rhino materials var red_render_material = RenderMaterial.CreateBasicMaterial(red_material); var green_render_material = RenderMaterial.CreateBasicMaterial(green_material); var blue_render_material = RenderMaterial.CreateBasicMaterial(blue_material); // 3.) Add basic Render materials to the RDK document doc.RenderMaterials.Add(red_render_material); doc.RenderMaterials.Add(green_render_material); doc.RenderMaterials.Add(blue_render_material); // At this point, you will see render materials show up in Rhino's // Materials panel. Note, doc.Materials.Count will equal 0. This is // because we have not added any Rhino materials. We've only added // Render materials. When you assign a Render material to an object // or a layer, a compatible Rhino material will be added doc.Materials, // and this materiall will be referenced by the Render material. // Note, it is possible to add Rhino materials to the document. However, // they will not appear in the Materials panel until they are assigned // to objects or layers. Here is an example of this. // 1.) Create a Rhino material var magenta_material = new Material { DiffuseColor = Color.Magenta, Name = "Magenta" }; // 2.) Add the Rhino material to the document var magenta_material_index = doc.Materials.Add(magenta_material); // 3.) Create an object and assign the Rhino material to it. var sphere = new Sphere(Plane.WorldXY, 5); var attributes = doc.CreateDefaultAttributes(); attributes.MaterialSource = ObjectMaterialSource.MaterialFromObject; attributes.MaterialIndex = magenta_material_index; doc.Objects.AddSphere(sphere, attributes); doc.Views.Redraw(); return(Result.Success); }
public void Add(Rhino.Geometry.PlaneSurface plane, RenderMaterial material) { UnsafeNativeMethods.Rdk_CustomMeshes_AddPlane(NonConstPointer(), plane.ConstPointer(), material.ConstPointer()); }
/// <summary> /// creates a player for level. /// reads an player information file(.spec) and configures the player class. /// The read player class is stored in the list. /// </summary> /// <param name="info">player information for level</param> /// <param name="sceneParent">3D scene parent node</param> /// <returns>player class for the game</returns> protected GamePlayer CreatePlayer(ref PlayerInLevel info, NodeBase sceneParent) { GamePlayer player = null; GamePlayerSpec spec = LoadPlayerSpec(ref info); switch (PlayerCountInLevel) { case 0: player = new GamePlayer(ref spec, PlayerIndex.One); break; case 1: player = new GamePlayer(ref spec, PlayerIndex.Two); break; default: throw new InvalidOperationException( "Added player count is overflow"); } // adds a player to list. AddPlayer(player); // entries a player in parent scene node. sceneParent.AddChild(player); // sets to rotation axis. Matrix rot = Matrix.CreateRotationX(MathHelper.ToRadians(-90.0f)); player.SetRootAxis(rot); // sets the material. RenderMaterial material = new RenderMaterial(); material.alpha = 1.0f; material.diffuseColor = new Color((byte)info.MaterialDiffuseColor.X, (byte)info.MaterialDiffuseColor.Y, (byte)info.MaterialDiffuseColor.Z); material.specularColor = new Color((byte)info.MaterialSpecularColor.X, (byte)info.MaterialSpecularColor.Y, (byte)info.MaterialSpecularColor.Z); material.emissiveColor = new Color((byte)info.MaterialEmissiveColor.X, (byte)info.MaterialEmissiveColor.Y, (byte)info.MaterialEmissiveColor.Z); material.specularPower = info.MaterialSpecularPower; material.vertexColorEnabled = false; material.preferPerPixelLighting = false; player.Material = material; player.ActiveFog = true; player.ActiveLighting = true; // creates a collision data. Vector3 centerPos = Vector3.Transform( new Vector3(0.0f, spec.MechRadius, 0.0f), Matrix.Invert(rot)); CollideSphere collide = new CollideSphere(centerPos, spec.MechRadius); player.EnableCulling = true; player.SetCollide(collide); player.ActionIdle(); player.SpawnPoint = Matrix.CreateRotationY(MathHelper.ToRadians(info.SpawnAngle)) * Matrix.CreateTranslation(info.SpawnPoint); return(player); }
protected override Result RunCommand(RhinoDoc doc, RunMode mode) { double tolerance = doc.ModelAbsoluteTolerance; List <Curve> icur = new List <Curve>(); GetObject gcr = new Rhino.Input.Custom.GetObject(); gcr.SetCommandPrompt("Select reference circles for stones. (No curves)"); gcr.GeometryFilter = Rhino.DocObjects.ObjectType.Curve; gcr.GroupSelect = true; gcr.SubObjectSelect = true; gcr.DeselectAllBeforePostSelect = true; gcr.OneByOnePostSelect = false; gcr.GetMultiple(1, 0); for (int ie = 0; ie < gcr.ObjectCount; ie++) { Rhino.DocObjects.ObjRef objref = gcr.Object(ie); Rhino.DocObjects.RhinoObject obj = objref.Object(); if (obj == null) { return(Result.Failure); } Curve refcr = objref.Curve(); if (refcr == null) { return(Result.Failure); } obj.Select(false); icur.Add(refcr); } var rm = FindMaterial(doc, "Diamond"); if (null == rm) { //Didn't find the material - create one and carry on. //Create a basic material var custom = new Rhino.DocObjects.Material(); custom.Reflectivity = 1; custom.Transparency = 0.2; custom.SetEnvironmentTexture(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "/Free Jewels Rhino Plug-Ins/Dia3.jpg"); custom.Name = "Diamond"; custom.CommitChanges(); rm = RenderMaterial.CreateBasicMaterial(custom); var docMats = doc.RenderMaterials; //docMats.BeginChange(RenderContent.ChangeContexts.Program); docMats.Add(rm); //docMats.EndChange(); } // Create Stone Mesh Rhino.Geometry.Mesh mesh = new Rhino.Geometry.Mesh(); mesh.Vertices.Add(0.0, 0.0, -0.44); //0 mesh.Vertices.Add(0.0, 0.097, -0.363); //1 mesh.Vertices.Add(0.069, 0.069, -0.363); //2 mesh.Vertices.Add(0.097, 0.0, -0.363); //3 mesh.Vertices.Add(0.0, 0.5, -0.013); //4 mesh.Vertices.Add(0.098, 0.49, -0.005); //5 mesh.Vertices.Add(0.191, 0.462, -0.013); //6 mesh.Vertices.Add(0.278, 0.416, -0.005); //7 mesh.Vertices.Add(0.354, 0.354, -0.013); //8 mesh.Vertices.Add(0.416, 0.278, -0.005); //9 mesh.Vertices.Add(0.462, 0.191, -0.013); //10 mesh.Vertices.Add(0.49, 0.098, -0.005); //11 mesh.Vertices.Add(0.5, 0.0, -0.013); //12 mesh.Vertices.Add(0.0, 0.5, 0.013); //13 mesh.Vertices.Add(0.098, 0.49, 0.005); //14 mesh.Vertices.Add(0.191, 0.462, 0.013); //15 mesh.Vertices.Add(0.278, 0.416, 0.005); //16 mesh.Vertices.Add(0.354, 0.354, 0.013); //17 mesh.Vertices.Add(0.416, 0.278, 0.005); //18 mesh.Vertices.Add(0.462, 0.191, 0.013); //19 mesh.Vertices.Add(0.49, 0.098, 0.005); //20 mesh.Vertices.Add(0.5, 0.0, 0.013); //21 mesh.Vertices.Add(0.0, 0.372, 0.12); //22 mesh.Vertices.Add(0.263, 0.263, 0.12); //23 mesh.Vertices.Add(0.372, 0.0, 0.12); //24 mesh.Vertices.Add(0.263, -0.263, 0.12); //25 mesh.Vertices.Add(0.0, -0.372, 0.12); //26 mesh.Vertices.Add(-0.263, -0.263, 0.12); //27 mesh.Vertices.Add(-0.372, 0.0, 0.12); //28 mesh.Vertices.Add(-0.263, 0.263, 0.12); //29 mesh.Vertices.Add(0.109, 0.263, 0.16); //30 mesh.Vertices.Add(0.263, 0.109, 0.16); //31 mesh.Vertices.Add(0.263, -0.109, 0.16); //32 mesh.Vertices.Add(0.109, -0.263, 0.16); //33 mesh.Vertices.Add(-0.109, -0.263, 0.16); //34 mesh.Vertices.Add(-0.263, -0.109, 0.16); //35 mesh.Vertices.Add(-0.263, 0.109, 0.16); //36 mesh.Vertices.Add(-0.109, 0.263, 0.16); //37 mesh.Vertices.Add(0.0, 0.0, 0.16); //38 mesh.Faces.AddFace(0, 1, 6, 2); mesh.Faces.AddFace(0, 2, 10, 3); mesh.Faces.AddFace(1, 4, 5, 6); mesh.Faces.AddFace(2, 6, 7, 8); mesh.Faces.AddFace(2, 8, 9, 10); mesh.Faces.AddFace(3, 10, 11, 12); mesh.Faces.AddFace(4, 13, 14, 5); mesh.Faces.AddFace(5, 14, 15, 6); mesh.Faces.AddFace(6, 15, 16, 7); mesh.Faces.AddFace(7, 16, 17, 8); mesh.Faces.AddFace(8, 17, 18, 9); mesh.Faces.AddFace(9, 18, 19, 10); mesh.Faces.AddFace(10, 19, 20, 11); mesh.Faces.AddFace(11, 20, 21, 12); mesh.Faces.AddFace(13, 22, 15, 14); mesh.Faces.AddFace(15, 23, 17, 16); mesh.Faces.AddFace(17, 23, 19, 18); mesh.Faces.AddFace(19, 24, 21, 20); mesh.Faces.AddFace(15, 22, 30, 23); mesh.Faces.AddFace(19, 23, 31, 24); mesh.Faces.AddFace(23, 30, 31); mesh.Faces.AddFace(24, 31, 32); mesh.Faces.AddFace(32, 31, 30, 38); mesh.Unweld(0.001, false); Mesh meshAll = new Mesh(); for (int i = 0; i < 4; i++) { meshAll.Append(mesh); Point3d center = new Point3d(0.0, 0.0, 0.0); Vector3d rotVec = new Vector3d(0.0, 0.0, 1.0); mesh.Rotate(Math.PI / 2, rotVec, center); } meshAll.Compact(); meshAll.Weld(0.001); //Get object Guid to apply render material var meshGuid = doc.Objects.AddMesh(meshAll); ObjRef objre = new ObjRef(meshGuid); RhinoObject obje = objre.Object(); obje.RenderMaterial = rm; obje.CommitChanges(); //Make InstanceDefinition string instDefCount = DateTime.Now.ToString("ddMMyyyyHHmmss"); var geometry = new System.Collections.Generic.List <Rhino.Geometry.GeometryBase>() { obje.Geometry }; var attributes = new System.Collections.Generic.List <Rhino.DocObjects.ObjectAttributes>() { obje.Attributes }; var stoneIndex = doc.InstanceDefinitions.Add("Stone" + instDefCount, "StoneMesh 1mm", Point3d.Origin, geometry, attributes); List <InstanceReferenceGeometry> meshPave = new List <InstanceReferenceGeometry>(); foreach (Curve c in icur) { Circle circle1 = new Circle(); c.TryGetCircle(out circle1, tolerance); double radius = circle1.Diameter; Point3d center = circle1.Center; Vector3d moveV = new Vector3d(center); Vector3d zaxis = new Vector3d(0.0, 0.0, 1.0); Plane planeOr = new Plane(center, zaxis); Plane planeNew = circle1.Plane; var transform1 = Transform.Translation(moveV); var transform2 = Transform.Scale(center, radius); var transform3 = Transform.PlaneToPlane(planeOr, planeNew); var stoneA = doc.Objects.AddInstanceObject(stoneIndex, transform1); var stoneB = doc.Objects.Transform(stoneA, transform2, true); var stoneC = doc.Objects.Transform(stoneB, transform3, true); ids.Add(stoneC); } doc.Groups.Add(ids); doc.Objects.Delete(obje); doc.Views.Redraw(); return(Result.Success); }
public void RenderMaterial_CopiedMaterialGeneratesTheSameMaterialID() { RenderMaterial mat = new RenderMaterial(); RenderMaterial matCopy = (RenderMaterial)mat.Clone(); UUID matID = RenderMaterial.GenerateMaterialID(mat); UUID matCopyID = RenderMaterial.GenerateMaterialID(matCopy); Assert.That(mat, Is.EqualTo(matCopy)); Assert.That(matID, Is.EqualTo(matCopyID)); }
public void RenderMaterial_DefaultConstructedMaterialsGeneratesTheSameMaterialID() { RenderMaterial mat = new RenderMaterial(); RenderMaterial mat2 = new RenderMaterial(); UUID matID = RenderMaterial.GenerateMaterialID(mat); UUID mat2ID = RenderMaterial.GenerateMaterialID(mat2); Assert.That(mat, Is.EqualTo(mat2)); Assert.That(matID, Is.EqualTo(mat2ID)); }
public void RenderMaterial_ColorValueToFromMaterialTest() { RenderMaterial mat = new RenderMaterial(); mat.SpecularLightColorR = 127; mat.SpecularLightColorG = 127; mat.SpecularLightColorB = 127; mat.SpecularLightColorA = 255; byte[] bytes = mat.ToBytes(); RenderMaterial newmat = RenderMaterial.FromBytes(bytes, 0, bytes.Length); Assert.That(mat, Is.EqualTo(newmat)); Assert.That(mat.SpecularLightColorR, Is.EqualTo(127)); Assert.That(mat.SpecularLightColorG, Is.EqualTo(127)); Assert.That(mat.SpecularLightColorB, Is.EqualTo(127)); Assert.That(mat.SpecularLightColorA, Is.EqualTo(255)); }
public static void TexturedSlot(RenderMaterial rm, string slotname, Color4f defaultColor, string prompt) { rm.Fields.AddTextured(slotname, defaultColor, prompt); }
public void RenderMaterial_ToFromBinaryTest() { RenderMaterial mat = new RenderMaterial(); RenderMaterials mats = new RenderMaterials(); UUID key = mats.AddMaterial(mat); byte[] bytes = mats.ToBytes(); RenderMaterials newmats = RenderMaterials.FromBytes(bytes, 0); Assert.DoesNotThrow(() => { RenderMaterial newmat = newmats.GetMaterial(key); Assert.That(mat, Is.EqualTo(newmat)); }); }
public void AppendRenderGeometry(GH_RenderArgs args, RenderMaterial material) { Value.AppendRenderGeometry(args, material); }
protected override OpenGLGeometryBufferBase CreateGeometryBufferImpl(RenderMaterial renderMaterial) { return(new OpenGLGeometryBuffer(this, renderMaterial)); }
public OpenGLGeometryBuffer(OpenGLRenderer owner, RenderMaterial renderMaterial) : base(owner, renderMaterial) { }
public void RenderMaterial_SerializedMaterialGeneratesTheSameMaterialID() { RenderMaterial mat = new RenderMaterial(); UUID matID = new UUID(mat.ComputeMD5Hash(), 0); byte[] matData = mat.ToBytes(); RenderMaterial newmat = RenderMaterial.FromBytes(matData, 0, matData.Length); UUID newmatID = RenderMaterial.GenerateMaterialID(newmat); Assert.That(mat, Is.EqualTo(newmat)); Assert.That(matID, Is.EqualTo(newmatID)); }
public override bool BuildCustomMeshes(ViewportInfo vp, RhinoDoc doc, RenderPrimitiveList objMeshes, Guid requestingPlugIn, DisplayPipelineAttributes attrs) { if (!WillBuildCustomMeshes(vp, objMeshes.RhinoObject, doc, requestingPlugIn, attrs)) { return(false); } var obj = objMeshes.RhinoObject; if (obj == null) { Sphere sphere = new Sphere(new Point3d(0.0, 0.0, 0.0), 10.0); objMeshes.Add(Rhino.Geometry.Mesh.CreateFromSphere(sphere, 100, 100), RenderMaterial.CreateBasicMaterial(Rhino.DocObjects.Material.DefaultMaterial)); } else { var sphere = SphereFromObject(obj); objMeshes.Add(Mesh.CreateFromSphere(sphere, 100, 100), obj.RenderMaterial); } return(true); }
public void RenderMaterial_SerializedMaterialsDataGeneratesTheSameMaterialID() { RenderMaterials materials = new RenderMaterials(); RenderMaterial mat = new RenderMaterial(); UUID matID = materials.AddMaterial(mat); byte[] matData = materials.ToBytes(); RenderMaterials newMaterials = RenderMaterials.FromBytes(matData, 0, matData.Length); Assert.That(materials, Is.EqualTo(newMaterials)); Assert.DoesNotThrow(() => { RenderMaterial newmat = newMaterials.GetMaterial(matID); UUID newmatID = RenderMaterial.GenerateMaterialID(newmat); Assert.That(mat, Is.EqualTo(newmat)); Assert.That(matID, Is.EqualTo(newmatID)); }); }
protected override Result RunCommand(RhinoDoc doc, RunMode mode) { int currIntOption = 0; var gi = new GetOption(); gi.SetCommandPrompt("Material Index"); gi.AcceptNumber(true, true); var resgi = gi.Get(); if (resgi == GetResult.Number) { currIntOption = Convert.ToInt32(gi.Number()); } Rhino.Input.Custom.GetObject go = new Rhino.Input.Custom.GetObject(); go.SetCommandPrompt("Select objects to apply material"); go.GroupSelect = true; go.SubObjectSelect = false; go.EnableClearObjectsOnEntry(false); go.EnableUnselectObjectsOnExit(false); go.DeselectAllBeforePostSelect = false; go.GetMultiple(1, 0); //Nothing to do - get out quick. if (go.ObjectCount == 0) { return(Result.Success); } var rm = FindMaterial(doc, matName[currIntOption]); if (null == rm) { //Didn't find the material - create one and carry on. //Create a basic material var custom = new Rhino.DocObjects.Material(); custom.Name = matName[currIntOption]; if (currIntOption == 13) { custom.SetEnvironmentTexture(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "/Free Jewels Rhino Plug-Ins/Dia3.jpg"); } custom.CommitChanges(); rm = RenderMaterial.CreateBasicMaterial(custom); rm.BeginChange(RenderContent.ChangeContexts.Program); rm.SetParameter("diffuse", System.Drawing.Color.Black); rm.SetParameter("reflectivity", 1.0); rm.SetParameter("reflectivity-color", System.Drawing.Color.FromArgb(r[currIntOption], g[currIntOption], b[currIntOption])); rm.SetParameter("transparency", fjMatTrans[currIntOption]); rm.SetParameter("shine", fjMatShine[currIntOption]); rm.SetParameter("polish-amount", fjMatShine[currIntOption]); rm.EndChange(); var docMats = doc.RenderMaterials; docMats.Add(rm); } //Now we always have a material to assign, this part is easy for (int i = 0; i < go.ObjectCount; i++) { var obj = go.Object(i).Object(); obj.RenderMaterial = rm; obj.CommitChanges(); } doc.Views.Redraw(); return(Result.Success); }
public void SetPass2(int _ = 0) { RenderMaterial.SetPass(_); }
public void Add(Rhino.Geometry.Mesh mesh, RenderMaterial material) { UnsafeNativeMethods.Rdk_CustomMeshes_AddMesh(NonConstPointer(), mesh.ConstPointer(), material.ConstPointer()); }
public RenderMaterialEntry(RenderMaterial mat, uint partId) { material = mat; partIds = new List <uint>(); partIds.Add(partId); }
private void LoadCoint() { RenderMaterial gold = new RenderMaterial(); gold.Diffuse = Color.Gold.ToVector4(); coint.RenderMaterial = gold; Scene.Add(coint); }
public AssetPackage(RenderMaterial material, IEnumerable <GeometryInformation> infos) { Material = material; Infos = infos; }
public RhinoMaterialGltfConverter(glTFExportOptions options, bool binary, gltfSchemaDummy dummy, List <byte> binaryBuffer, RenderMaterial renderMaterial, LinearWorkflow workflow) { this.options = options; this.binary = binary; this.dummy = dummy; this.binaryBuffer = binaryBuffer; this.rhinoMaterial = renderMaterial.SimulatedMaterial(RenderTexture.TextureGeneration.Allow); this.renderMaterial = renderMaterial; this.workflow = workflow; }
/// <summary> /// Tries to find a document assigned version of the given render material /// </summary> /// <param name="material"></param> /// <returns></returns> private RenderMaterial TryFindDocumentMaterial(RenderMaterial material) { return(_doc.RenderMaterials.First(m => m.Name == material.Name)); }
public override void Init() { if (!ObjectPrivate.TryGetFirstComponent(out Mesh)) { Log.Write(LogLevel.Error, LogTag, "No MeshComponent found! Aborting."); return; } else { List <RenderMaterial> materials = Mesh.GetRenderMaterials().ToList(); if (materials.Count == 0) { Log.Write(LogLevel.Error, LogTag, "GetRenderMaterials() == null! Aborting."); return; } else { foreach (RenderMaterial material in materials) { if (material == null) { Log.Write(LogTag, "Material is null"); } else { Log.Write(LogTag, material.Name); Log.Write(LogTag, material.ToString()); } } } Log.Write(LogTag, $"Mesh.IsScriptable={Mesh.IsScriptable}"); if (!Mesh.IsScriptable) { Log.Write(LogLevel.Warning, LogTag, $"MeshComponent {Mesh.Name} is not scriptable"); } SubscribeToScriptEvent(AbsorptionCommand, (ScriptEventData data) => { ISimpleData idata = data.Data.AsInterface <ISimpleData>(); RenderMaterial m = Mesh.GetRenderMaterial(materials[0].Name); MaterialProperties p = m.GetProperties(); p.Absorption = Absorption; m.SetProperties(p, Duration, InterpolationModeParse(Interpolation)); }); SubscribeToScriptEvent(BrightnessCommand, (ScriptEventData data) => { ISimpleData idata = data.Data.AsInterface <ISimpleData>(); RenderMaterial m = Mesh.GetRenderMaterial(materials[0].Name); MaterialProperties p = m.GetProperties(); p.Brightness = Brightness; m.SetProperties(p, Duration, InterpolationModeParse(Interpolation)); }); SubscribeToScriptEvent(TintCommand, (ScriptEventData data) => { ISimpleData idata = data.Data.AsInterface <ISimpleData>(); RenderMaterial m = Mesh.GetRenderMaterial(materials[0].Name); MaterialProperties p = m.GetProperties(); if (!Sansar.Color.TryParse(tint.ToRGBA(), out p.Tint)) { Log.Write(LogLevel.Error, LogTag, "TintCommand: Failed to parse as Sansar.Color"); return; } m.SetProperties(p, Duration, InterpolationModeParse(Interpolation)); }); SubscribeToScriptEvent(EmissiveCommand, (ScriptEventData data) => { ISimpleData idata = data.Data.AsInterface <ISimpleData>(); RenderMaterial m = Mesh.GetRenderMaterial(materials[0].Name); MaterialProperties p = m.GetProperties(); p.EmissiveIntensity = EmissiveIntensity; m.SetProperties(p, Duration, InterpolationModeParse(Interpolation)); }); SubscribeToScriptEvent(FlipbookCommand, (ScriptEventData data) => { ISimpleData idata = data.Data.AsInterface <ISimpleData>(); RenderMaterial m = Mesh.GetRenderMaterial(materials[0].Name); MaterialProperties p = m.GetProperties(); p.FlipbookFrame = Frames; m.SetProperties(p, Duration, InterpolationModeParse(Interpolation)); }); } }
/// <summary> /// return some appropriate OpenGLGeometryBufferBase subclass instance. /// </summary> /// <param name="renderMaterial"></param> /// <returns></returns> protected abstract OpenGLGeometryBufferBase CreateGeometryBufferImpl(RenderMaterial renderMaterial);
protected override Result RunCommand(RhinoDoc doc, RunMode mode) { // Allow to select one of these if (RhinoDoc.ActiveDoc.RenderMaterials.Count < 1) { MessageBox.Show(@"Please, apply at least one material.", @"Mitsuba Render", MessageBoxButtons.OK, MessageBoxIcon.Error); return(Result.Failure); } RenderMaterial renderMaterial = null; if (RhinoDoc.ActiveDoc.RenderMaterials.Count == 1) { renderMaterial = RhinoDoc.ActiveDoc.RenderMaterials.First(); } else { var materialName = RhinoDoc.ActiveDoc.RenderMaterials.Select(material => material.Name).ToList(); var userSelectedMaterial = Dialogs.ShowComboListBox("Materials", "Select one material", materialName); if (userSelectedMaterial != null) { foreach (var material in RhinoDoc.ActiveDoc.RenderMaterials.Where(material => material.Name == userSelectedMaterial.ToString())) { renderMaterial = material; } } } if (renderMaterial == null) { return(Result.Failure); } XmlElement materialXml; var mitsubaMaterial = renderMaterial as MitsubaMaterial; // Create the material XML if (mitsubaMaterial != null) { materialXml = MitsubaXml.CreateMaterialXml(mitsubaMaterial); } else { MessageBox.Show(@"Please, select a Mitsuba material", @"Mitsuba Render", MessageBoxButtons.OK, MessageBoxIcon.Error); return(Result.Failure); } // Create the files in a temp folder var tmpFolder = Path.Combine(Path.GetTempPath(), "Mitsuba"); if (!Directory.Exists(tmpFolder)) { Directory.CreateDirectory(tmpFolder); } // Copy model var modelFileName = Path.Combine(tmpFolder, "matpreview.serialized"); File.WriteAllBytes(modelFileName, Resources.matpreview); // Copy HDRI var envFileName = Path.Combine(tmpFolder, "envmap.exr"); File.WriteAllBytes(envFileName, Resources.envmap); // Copy the project var projectFileName = Path.Combine(tmpFolder, "mitsubaproject.xml"); var project = Resources.mitsubaproject; project = project.Replace("[MATERIAL]", materialXml.OuterXml); File.WriteAllText(projectFileName, project); MitsubaRenderPlugIn.ExecuteMitsuba(projectFileName, tmpFolder); return(Result.Success); }
public bool CreateBackShader(RenderMaterial rm, float gamma) { _back = new ShaderBody(Id); return(CreateShaderPart(_back, rm, gamma)); }
public Rhino.Render.RenderMaterial Convert() { RenderMaterial pbr = RenderContentType.NewContentFromTypeId(ContentUuids.PhysicallyBasedMaterialType, doc) as RenderMaterial; pbr.BeginChange(RenderContent.ChangeContexts.Program); pbr.Name = converter.GetUniqueName(material.Name); if (material.PbrMetallicRoughness != null) { Rhino.Display.Color4f baseColor = material.PbrMetallicRoughness.BaseColorFactor.ToColor4f(); if (material.PbrMetallicRoughness.BaseColorTexture != null) { int index = material.PbrMetallicRoughness.BaseColorTexture.Index; RenderTexture texture = converter.GetRenderTexture(index, baseColor); pbr.SetChild(texture, Rhino.Render.ParameterNames.PhysicallyBased.BaseColor); pbr.SetChildSlotOn(Rhino.Render.ParameterNames.PhysicallyBased.BaseColor, true, RenderContent.ChangeContexts.Program); } baseColor = GltfUtils.UnapplyGamma(baseColor); pbr.SetParameter(PhysicallyBased.BaseColor, baseColor); double roughness = material.PbrMetallicRoughness.RoughnessFactor; double metalness = material.PbrMetallicRoughness.MetallicFactor; if (material.PbrMetallicRoughness.MetallicRoughnessTexture != null) { int index = material.PbrMetallicRoughness.MetallicRoughnessTexture.Index; RhinoGltfMetallicRoughnessConverter metallicRoughness = converter.GetMetallicRoughnessTexture(index); pbr.SetChild(metallicRoughness.MetallicTexture, PhysicallyBased.Metallic); pbr.SetChildSlotOn(PhysicallyBased.Metallic, true, RenderContent.ChangeContexts.Program); pbr.SetChildSlotAmount(PhysicallyBased.Metallic, metalness * 100.0, RenderContent.ChangeContexts.Program); pbr.SetChild(metallicRoughness.RoughnessTexture, PhysicallyBased.Roughness); pbr.SetChildSlotOn(PhysicallyBased.Roughness, true, RenderContent.ChangeContexts.Program); pbr.SetChildSlotAmount(PhysicallyBased.Roughness, roughness * 100.0, RenderContent.ChangeContexts.Program); } else { pbr.SetParameter(PhysicallyBased.Roughness, roughness); pbr.SetParameter(PhysicallyBased.Metallic, metalness); } } Rhino.Display.Color4f emissionColor = material.EmissiveFactor.ToColor4f(); emissionColor = GltfUtils.UnapplyGamma(emissionColor); pbr.SetParameter(PhysicallyBased.Emission, emissionColor); if (material.EmissiveTexture != null) { RenderTexture emissiveTexture = converter.GetRenderTexture(material.EmissiveTexture.Index); pbr.SetChild(emissiveTexture, PhysicallyBased.Emission); pbr.SetChildSlotOn(PhysicallyBased.Emission, true, RenderContent.ChangeContexts.Program); } if (material.OcclusionTexture != null) { RenderTexture occlusionTexture = converter.GetRenderTexture(material.OcclusionTexture.Index); pbr.SetChild(occlusionTexture, PhysicallyBased.AmbientOcclusion); pbr.SetChildSlotOn(PhysicallyBased.AmbientOcclusion, true, RenderContent.ChangeContexts.Program); pbr.SetChildSlotAmount(PhysicallyBased.AmbientOcclusion, material.OcclusionTexture.Strength * 100.0, RenderContent.ChangeContexts.Program); } if (material.NormalTexture != null) { RenderTexture normalTexture = converter.GetRenderTexture(material.NormalTexture.Index); pbr.SetChild(normalTexture, PhysicallyBased.Bump); pbr.SetChildSlotOn(PhysicallyBased.Bump, true, RenderContent.ChangeContexts.Program); } string clearcoatText = ""; string transmissionText = ""; string iorText = ""; string specularText = ""; if (material.Extensions != null) { if (material.Extensions.TryGetValue(glTFExtensions.KHR_materials_clearcoat.Tag, out object clearcoatValue)) { clearcoatText = clearcoatValue.ToString(); } if (material.Extensions.TryGetValue(glTFExtensions.KHR_materials_transmission.Tag, out object transmissionValue)) { transmissionText = transmissionValue.ToString(); } if (material.Extensions.TryGetValue(glTFExtensions.KHR_materials_ior.Tag, out object iorValue)) { iorText = iorValue.ToString(); } if (material.Extensions.TryGetValue(glTFExtensions.KHR_materials_specular.Tag, out object specularValue)) { specularText = specularValue.ToString(); } } HandleClearcoat(clearcoatText, pbr); HandleTransmission(transmissionText, pbr); HandleIor(iorText, pbr); HandleSpecular(specularText, pbr); pbr.EndChange(); doc.RenderMaterials.BeginChange(RenderContent.ChangeContexts.Program); doc.RenderMaterials.Add(pbr); doc.RenderMaterials.EndChange(); return(pbr); }
/// <summary> /// creates an enemy for level. /// reads an enemy information file(.spec) and configures the enemy class. /// The read enemy class is stored in the list. /// </summary> /// <param name="info">enemy information for level</param> /// <param name="sceneParent">3D scene parent node</param> protected void CreateSpawnEnemy(ref EnemyInLevel info, NodeBase sceneParent) { GameEnemy enemy = null; GameEnemySpec spec = LoadEnemySpec(ref info); // creates an enemy by unit type switch (spec.UnitClass) { case UnitClassId.Tank: enemy = new EnemyTank(ref spec); break; case UnitClassId.LightMech: case UnitClassId.HeavyMech: enemy = new EnemyMech(ref spec); break; case UnitClassId.Boss: enemy = new EnemyBoss(ref spec); break; default: throw new NotSupportedException( "Not supported unit type : " + spec.UnitType); } // sets the material RenderMaterial material = new RenderMaterial(); material.alpha = 1.0f; material.diffuseColor = new Color((byte)info.MaterialDiffuseColor.X, (byte)info.MaterialDiffuseColor.Y, (byte)info.MaterialDiffuseColor.Z); material.specularColor = new Color((byte)info.MaterialSpecularColor.X, (byte)info.MaterialSpecularColor.Y, (byte)info.MaterialSpecularColor.Z); material.emissiveColor = new Color((byte)info.MaterialEmissiveColor.X, (byte)info.MaterialEmissiveColor.Y, (byte)info.MaterialEmissiveColor.Z); material.specularPower = info.MaterialSpecularPower; material.vertexColorEnabled = false; material.preferPerPixelLighting = false; enemy.Material = material; enemy.ActiveFog = true; enemy.ActiveLighting = true; // adds this to the list. enemyList.Add(enemy); // entries this in parent scene node. sceneParent.AddChild(enemy); // sets to rotate axis. if (spec.UnitType == UnitTypeId.Tiger) { enemy.SetRootAxis( Matrix.CreateRotationX(MathHelper.ToRadians(-90.0f)) * Matrix.CreateRotationZ(MathHelper.ToRadians(90.0f))); } else { enemy.SetRootAxis(Matrix.CreateRotationX(MathHelper.ToRadians(-90.0f))); } // sets to stage spawn position. enemy.SpawnPoint = Matrix.CreateRotationY(MathHelper.ToRadians(info.SpawnAngle)) * Matrix.CreateTranslation(info.SpawnPoint); // activate draw culling. enemy.EnableCulling = true; // creates a collision data. { Vector3 centerPos = Vector3.Transform( new Vector3(0.0f, spec.MechRadius, 0.0f), Matrix.Invert(enemy.RootAxis)); CollideSphere collide = new CollideSphere(centerPos, spec.MechRadius); enemy.SetCollide(collide); } // creates a game event. switch (info.SpawnType) { case SpawnTypeId.Time: { FrameworkCore.GameEventManager.AddEvent( new GameTimeEvent(info.SpawnTime, enemy, false)); } break; case SpawnTypeId.Area: { FrameworkCore.GameEventManager.AddEvent( new GameAreaEvent(info.SpawnPoint, info.SpawnRadius, enemy, false)); } break; } // sets start A.I. enemy.SetStartAI(info.StartAi, info.StartAiTime); }
public void RenderMaterial_DifferentMaterialsGeneratesDifferentMaterialID() { RenderMaterial mat = new RenderMaterial(); RenderMaterial mat2 = new RenderMaterial(); mat2.NormalID = UUID.Random(); Assert.AreNotEqual(mat, mat2); UUID matID = RenderMaterial.GenerateMaterialID(mat); UUID mat2ID = RenderMaterial.GenerateMaterialID(mat2); Assert.AreNotEqual(matID, mat2ID); }
public static void TexturedSlot(RenderMaterial rm, string slotname, float defaultValue, string prompt) { rm.Fields.AddTextured(slotname, defaultValue, prompt); }
/// <summary> /// Assign a single material value. Based on the values passed we'll either set (or clear) the materials for a SOP. /// </summary> /// <param name="sop">The SOP being affected.</param> /// <param name="face">The face to assign, or -1 if the default texture is being set.</param> /// <param name="id">The ID assigned to this material. Setting a Zero UUID clears it.</param> /// <param name="material">If not null, the material to set. Otherwise we are clearing.</param> private void AssignSingleMaterial(SceneObjectPart sop, int face, OSDMap matData) { /// Get a copy of the texture entry so we can make changes. var te = new Primitive.TextureEntry(sop.Shape.TextureEntry, 0, sop.Shape.TextureEntry.Length); if (te == null) { m_log.Warn("[RenderMaterials]: null TextureEntry for localId: " + sop.LocalId.ToString()); return; } lock (m_knownMaterials) { UUID id = UUID.Zero; // Record what we currently have var currentMaterialIDs = getMaterialIDsFromTextureEntry(te); // If there is a material being set see if we've seen it before. // If not we'll add it to the region cache if (matData != null) { RenderMaterial material = RenderMaterial.FromOSD(matData); id = sop.Shape.RenderMaterials.AddMaterial(material); if (m_knownMaterials.ContainsKey(id)) { material = m_knownMaterials[id].material; var entry = m_knownMaterials[id]; if (entry.partIds.Contains(sop.LocalId) == false) { entry.partIds.Add(sop.LocalId); } } else { m_knownMaterials[id] = new RenderMaterialEntry(material, sop.LocalId); } m_log.DebugFormat("[RenderMaterials]: SOP {0}, Face {1}, Adding RenderMaterial {2}", sop.LocalId, face, material.ToString()); } // Set the Material ID in the sop texture entry. If there's a face defined // use that else use the Default entry. ID can either be a material ID // we set from the lookup above or Zero when we are clearing a material. if (face < 0) { te.DefaultTexture.MaterialID = id; } else { var faceEntry = te.CreateFace((uint)face); faceEntry.MaterialID = id; } // Get the updated list of Materials from the TextureEntry. We will // Use that to rebuild the RenderMaterials for the part. We'll also get a list // of entries that have been removed based on what we fetched initially so we // can clean that up in our cache. var newMaterialIDs = getMaterialIDsFromTextureEntry(te); // If there was an update and the material id has changed, clean up the old value. // Have to be careful here. It might still be in use in another slot. So we build // a list of keys and walk the texture entries subtracting keys in use. Whatever // is left are candidates to clean up. foreach (var entry in newMaterialIDs) { if (currentMaterialIDs.Contains(entry)) { currentMaterialIDs.Remove(entry); } if (sop.Shape.RenderMaterials.ContainsMaterial(entry) == false) { m_log.WarnFormat("[RenderMaterials]: SOP {0}, Face {1}, RenderMaterials {2} should be present but isn't!", sop.LocalId, face, entry.ToString()); } } // currentMaterialsIDs contains orphans if any. Remove them from the sop.Shape and the cache (if needed) foreach (var entry in currentMaterialIDs) { if (sop.Shape.RenderMaterials.ContainsMaterial(entry) == true) { m_log.DebugFormat("[RenderMaterials]: SOP {0}, Face {1}, Removing unused RenderMaterials {2} from shape.", sop.LocalId, face, entry.ToString()); sop.Shape.RenderMaterials.RemoveMaterial(entry); } else { m_log.WarnFormat("[RenderMaterials]: SOP {0}, Face {1}, ORPHANED RenderMaterials {2} should be present but isn't!", sop.LocalId, face, entry.ToString()); } if (m_knownMaterials.ContainsKey(entry)) { m_knownMaterials[entry].partIds.Remove(sop.LocalId); if (m_knownMaterials[entry].partIds.Count <= 0) { m_log.DebugFormat("[RenderMaterials]: Removing unused RenderMaterials {0} from region cache.", entry.ToString()); m_knownMaterials.Remove(entry); } } } } // Update the texture entry which will force an update to connected clients sop.UpdateTextureEntry(te.GetBytes()); }
public void RenderMaterials_CopiedMaterialsGeneratesTheSameMaterialID() { RenderMaterial mat = new RenderMaterial(); RenderMaterials mats = new RenderMaterials(); UUID matID = mats.AddMaterial(mat); RenderMaterials matsCopy = mats.Copy(); Assert.True(mats.ContainsMaterial(matID)); Assert.True(matsCopy.ContainsMaterial(matID)); }
/// <summary> /// creates a player character. /// </summary> /// <param name="specFileName">player spec file(.spec)</param> /// <param name="sceneParent">3D scene parent node</param> protected void CreatePlayer(string specFileName, NodeBase sceneParent) { GamePlayerSpec spec = new GamePlayerSpec(); spec = (GamePlayerSpec)GameDataSpecManager.Load(specFileName, spec.GetType()); GamePlayer player = null; switch (GameLevel.PlayerCountInLevel) { case 0: { player = new GamePlayer(ref spec, PlayerIndex.One); RobotGameGame.SinglePlayer = player; FrameworkCore.GameEventManager.TargetScene = player; } break; case 1: { player = new GamePlayer(ref spec, PlayerIndex.Two); } break; default: throw new InvalidOperationException( "Added player count is overflow"); } // Entry enemies in 3D Scene root node sceneParent.AddChild(player); // Create rotation axis Matrix rot = Matrix.CreateRotationX(MathHelper.ToRadians(-90.0f)); player.SetRootAxis(rot); // Set material RenderMaterial material = new RenderMaterial(); material.alpha = 1.0f; material.diffuseColor = new Color(210, 210, 210); material.specularColor = new Color(60, 60, 60); material.emissiveColor = new Color(30, 30, 30); material.specularPower = 24; material.vertexColorEnabled = false; material.preferPerPixelLighting = false; player.Material = material; player.ActiveFog = true; player.ActiveLighting = true; // Create collision data Vector3 centerPos = Vector3.Transform( new Vector3(0.0f, spec.MechRadius, 0.0f), Matrix.Invert(rot)); CollideSphere collide = new CollideSphere(centerPos, spec.MechRadius); player.EnableCulling = true; player.SetCollide(collide); player.ActionIdle(); // Add collide RobotGameGame.CurrentGameLevel.CollisionVersusTeam[ GameLevel.PlayerCountInLevel].AddCollide(collide); RobotGameGame.CurrentGameLevel.CollisionLayerAllMech.AddCollide(collide); // Set the respawn position if (player.PlayerIndex == PlayerIndex.One) { int count = GameLevel.Info.RespawnInLevelList.Count; int rndIndex = HelperMath.Randomi(0, count); RespawnInLevel respawn = GameLevel.Info.RespawnInLevelList[rndIndex]; player.SpawnPoint = Matrix.CreateRotationY(MathHelper.ToRadians(respawn.SpawnAngle)) * Matrix.CreateTranslation(respawn.SpawnPoint); } else if (player.PlayerIndex == PlayerIndex.Two) { GamePlayer gamePlayerOne = GameLevel.GetPlayerInLevel(0); RespawnInLevel respawn = GameLevel.FindRespawnMostFar(gamePlayerOne.SpawnPoint.Translation); player.SpawnPoint = Matrix.CreateRotationY(MathHelper.ToRadians(respawn.SpawnAngle)) * Matrix.CreateTranslation(respawn.SpawnPoint); } GameLevel.AddPlayer(player); }
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); }
/// <summary> /// Assigns a <see cref="RenderMaterial"/> to a <see cref="RhinoObject"/> /// </summary> /// <param name="material"></param> /// <param name="obj"></param> private void AssignMaterialToObject(RenderMaterial material, RhinoObject obj) { obj.Attributes.MaterialSource = ObjectMaterialSource.MaterialFromObject; obj.RenderMaterial = material; obj.CommitChanges(); }
public bool CreateFrontShader(RenderMaterial rm, float gamma) { _front = new ShaderBody(Id); return(CreateShaderPart(_front, rm, gamma)); }
/// <summary> /// Converts a Speckle mesh to a GameObject with a mesh renderer /// </summary> /// <param name="speckleMesh">Mesh to convert</param> /// <param name="renderMaterial">If provided will override the renderMaterial on the mesh itself</param> /// <param name="properties">If provided will override the properties on the mesh itself</param> /// <returns></returns> public GameObject MeshToNative( Mesh speckleMesh, RenderMaterial renderMaterial = null, Dictionary <string, object> properties = null ) { if (speckleMesh.vertices.Count == 0 || speckleMesh.faces.Count == 0) { return(null); } var recenterMeshTransforms = true; //TODO: figure out how best to change this? var verts = ArrayToPoints(speckleMesh.vertices, speckleMesh.units); //convert speckleMesh.faces into triangle array List <int> tris = new List <int>(); int i = 0; // TODO: Check if this is causing issues with normals for mesh while (i < speckleMesh.faces.Count) { if (speckleMesh.faces[i] == 0) { //Triangles tris.Add(speckleMesh.faces[i + 1]); tris.Add(speckleMesh.faces[i + 3]); tris.Add(speckleMesh.faces[i + 2]); i += 4; } else { //Quads to triangles tris.Add(speckleMesh.faces[i + 1]); tris.Add(speckleMesh.faces[i + 3]); tris.Add(speckleMesh.faces[i + 2]); tris.Add(speckleMesh.faces[i + 1]); tris.Add(speckleMesh.faces[i + 4]); tris.Add(speckleMesh.faces[i + 3]); i += 5; } } var go = new GameObject { name = speckleMesh.speckle_type }; var mesh = new UnityEngine.Mesh { name = speckleMesh.speckle_type }; if (verts.Length >= 65535) { mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32; } // center transform pivot according to the bounds of the model if (recenterMeshTransforms) { Bounds meshBounds = new Bounds { center = verts[0] }; foreach (var vert in verts) { meshBounds.Encapsulate(vert); } go.transform.position = meshBounds.center; // offset mesh vertices for (int l = 0; l < verts.Length; l++) { verts[l] -= meshBounds.center; } } mesh.SetVertices(verts); mesh.SetTriangles(tris, 0); if (speckleMesh.bbox != null) { var uv = GenerateUV(verts, (float)speckleMesh.bbox.xSize.Length, (float)speckleMesh.bbox.ySize.Length).ToList(); mesh.SetUVs(0, uv); } // BUG: causing some funky issues with meshes // mesh.RecalculateNormals( ); mesh.Optimize(); // Setting mesh to filter once all mesh modifying is done go.SafeMeshSet(mesh, true); var meshRenderer = go.AddComponent <MeshRenderer>(); var speckleMaterial = renderMaterial ?? (RenderMaterial)speckleMesh["renderMaterial"]; meshRenderer.sharedMaterial = GetMaterial(speckleMaterial); //Add mesh collider // MeshCollider mc = go.AddComponent<MeshCollider>( ); // mc.sharedMesh = mesh; //mc.convex = true; //attach properties on this very mesh //means the mesh originated in Rhino or similar if (properties == null) { var meshprops = typeof(Mesh).GetProperties(BindingFlags.Instance | BindingFlags.Public).Select(x => x.Name) .ToList(); properties = speckleMesh.GetMembers() .Where(x => !meshprops.Contains(x.Key)) .ToDictionary(x => x.Key, x => x.Value); } AttachSpeckleProperties(go, properties); return(go); }
public virtual void Initialize() { Material = RenderMaterial.DefaultMaterial; OnTransformed(); }