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();
}
