/// <summary> /// Initializes the radar behavior /// </summary> protected override void Initialize() { base.Initialize(); this.screenplay = this.EntityManager.Find("ScreenplayManager").FindComponent <ScreenplayManager>(); foreach (var fighter in this.screenplay.FighterList) { if (fighter.State == FighterState.Player) { continue; } Transform3D radarTickTransform; BasicMaterial radarTickMaterial; Entity radarTick = new Entity() .AddComponent(radarTickTransform = new Transform3D()) .AddComponent(new Model("Content/Models/Hud/HudRadarTick.FBX")) .AddComponent(new ModelRenderer()) .AddComponent(new MaterialsMap(radarTickMaterial = new BasicMaterial("Content/Textures/Hud/RadarTick.png", typeof(CockpitAdditiveLayer)) { DiffuseColor = colors[(int)fighter.State] })) ; radarTick.Enabled = false; this.Owner.AddChild(radarTick); this.radarTicks.Add(radarTickTransform); this.radarTickMaterials.Add(radarTickMaterial); } }
public IEnumerator VolumeWhenVideoCreatedWithUserInScene() { // We disable SceneController monobehaviour to avoid its current scene id update sceneController.enabled = false; // Set current scene with this scene's id CommonScriptableObjects.sceneID.Set(scene.sceneData.id); DCLVideoTexture videoTexture = CreateDCLVideoTexture(scene, "it-wont-load-during-test"); yield return(videoTexture.routine); DecentralandEntity ent1 = TestHelpers.CreateSceneEntity(scene); BasicMaterial ent1Mat = TestHelpers.SharedComponentCreate <BasicMaterial, BasicMaterial.Model>(scene, CLASS_ID.BASIC_MATERIAL, new BasicMaterial.Model() { texture = videoTexture.id }); TestHelpers.SharedComponentAttach(ent1Mat, ent1); yield return(ent1Mat.routine); BoxShape ent1Shape = TestHelpers.SharedComponentCreate <BoxShape, BoxShape.Model>(scene, CLASS_ID.BOX_SHAPE, new BoxShape.Model()); yield return(ent1Shape.routine); TestHelpers.SharedComponentAttach(ent1Shape, ent1); yield return(new WaitForAllMessagesProcessed()); // Check the volume Assert.AreEqual(videoTexture.GetVolume(), videoTexture.texturePlayer.volume); }
public CommandSet <VisualizerControl.Visualizer> Initialization() { int counter = 0; var set = new VisualizerCommandSet(); foreach (var projectile in projectiles) { // Start it off in the right place var obj = new ObjectPrototype(projectile.Shape, new BasicMaterial(projectile.Color, .05, .3), projectile.Position, new Vector3D(projectile.Size, projectile.Size, projectile.Size)); set.AddCommand(new AddObject(obj, counter++)); } foreach (var tetrahedron in gravStruct.GetTetrahedra()) { var newShape = new Tetrahedron3D(ConvertToVector3D(tetrahedron.Points[0]), ConvertToVector3D(tetrahedron.Points[1]), ConvertToVector3D(tetrahedron.Points[2]), ConvertToVector3D(tetrahedron.Points[3])); var newMaterial = new BasicMaterial(ConvertColor(tetrahedron.Color), tetrahedron.Fresnel, tetrahedron.Roughness); var newobj = new ObjectPrototype(newShape, newMaterial); set.AddCommand(new AddObject(newobj, counter++)); } return(set); }
public IEnumerator VideoTextureIsAttachedAndDetachedCorrectly() { DCLVideoTexture videoTexture = CreateDCLVideoTexture(scene, "it-wont-load-during-test"); yield return(videoTexture.routine); Assert.IsTrue(videoTexture.attachedMaterials.Count == 0, "DCLVideoTexture started with attachedMaterials != 0"); BasicMaterial mat2 = TestHelpers.SharedComponentCreate <BasicMaterial, BasicMaterial.Model> (scene, CLASS_ID.BASIC_MATERIAL, new BasicMaterial.Model { texture = videoTexture.id }); yield return(mat2.routine); Assert.IsTrue(videoTexture.attachedMaterials.Count == 1, $"did DCLVideoTexture attach to material? {videoTexture.attachedMaterials.Count} expected 1"); // TEST: DCLVideoTexture detach on material disposed mat2.Dispose(); Assert.IsTrue(videoTexture.attachedMaterials.Count == 0, $"did DCLVideoTexture detach from material? {videoTexture.attachedMaterials.Count} expected 0"); videoTexture.Dispose(); yield return(null); Assert.IsTrue(videoTexture.texture == null, "DCLVideoTexture didn't dispose correctly?"); }
public IEnumerator NotDestroySharedTextureWhenDisposed() { DCLTexture texture = TestHelpers.CreateDCLTexture(scene, Utils.GetTestsAssetsPath() + "/Images/atlas.png"); yield return(texture.routine); BasicMaterial mat = TestHelpers.CreateEntityWithBasicMaterial(scene, new BasicMaterial.Model { texture = texture.id, alphaTest = 1, }, out DecentralandEntity entity1); yield return(mat.routine); BasicMaterial mat2 = TestHelpers.CreateEntityWithBasicMaterial(scene, new BasicMaterial.Model { texture = texture.id, alphaTest = 1, }, out DecentralandEntity entity2); yield return(mat2.routine); TestHelpers.SharedComponentDispose(mat); Assert.IsTrue(texture.texture != null, "Texture should persist because is used by the other material!!"); }
/// <summary> /// Initializes the radar behavior /// </summary> protected override void Initialize() { base.Initialize(); this.screenplay = this.EntityManager.Find("ScreenplayManager").FindComponent<ScreenplayManager>(); foreach (var fighter in this.screenplay.FighterList) { if (fighter.State == FighterState.Player) { continue; } Transform3D radarTickTransform; BasicMaterial radarTickMaterial; Entity radarTick = new Entity() .AddComponent(radarTickTransform = new Transform3D()) .AddComponent(new Model("Content/Models/Hud/HudRadarTick.FBX")) .AddComponent(new ModelRenderer()) .AddComponent(new MaterialsMap(radarTickMaterial = new BasicMaterial("Content/Textures/Hud/RadarTick.png", typeof(CockpitAdditiveLayer)) { DiffuseColor = colors[(int)fighter.State] })) ; radarTick.Enabled = false; this.Owner.AddChild(radarTick); this.radarTicks.Add(radarTickTransform); this.radarTickMaterials.Add(radarTickMaterial); } }
public IEnumerator VideoTextureVisibleStateIsSetCorrectlyWhenEntityIsRemoved() { DCLVideoTexture videoTexture = CreateDCLVideoTexture(scene, "it-wont-load-during-test"); yield return(videoTexture.routine); DecentralandEntity ent1 = TestHelpers.CreateSceneEntity(scene); BasicMaterial ent1Mat = TestHelpers.SharedComponentCreate <BasicMaterial, BasicMaterial.Model>(scene, CLASS_ID.BASIC_MATERIAL, new BasicMaterial.Model() { texture = videoTexture.id }); TestHelpers.SharedComponentAttach(ent1Mat, ent1); yield return(ent1Mat.routine); BoxShape ent1Shape = TestHelpers.SharedComponentCreate <BoxShape, BoxShape.Model>(scene, CLASS_ID.BOX_SHAPE, new BoxShape.Model()); yield return(ent1Shape.routine); TestHelpers.SharedComponentAttach(ent1Shape, ent1); yield return(new WaitForAllMessagesProcessed()); Assert.IsTrue(videoTexture.isVisible, "DCLVideoTexture should be visible"); scene.RemoveEntity(ent1.entityId, true); yield return(new WaitForAllMessagesProcessed()); Assert.IsTrue(!videoTexture.isVisible, "DCLVideoTexture should not be visible "); }
/// <summary> /// Update model effect /// </summary> /// <param name="meshEffect">An effect</param> protected virtual void UpdateModelEffects(Effect meshEffect) { if (meshEffect is BasicEffect) { var effect = meshEffect as BasicEffect; if (_material == null) { effect.LightingEnabled = true; // Mesh color light effect.AmbientLightColor = Color.White.ToVector3(); effect.DiffuseColor = Color.White.ToVector3(); effect.EmissiveColor = Color.White.ToVector3() * 0.5f; effect.SpecularColor = Color.Black.ToVector3(); effect.Alpha = 1; } else { BasicMaterial material = (BasicMaterial)_material; if (material != null) { UpdateEffect(effect, material); } } } }
public IEnumerator DefaultMissingValuesPropertyOnUpdate() { // 1. Create component with non-default configs BasicMaterial basicMaterialComponent = TestHelpers.SharedComponentCreate <BasicMaterial, BasicMaterial.Model>(scene, CLASS_ID.BASIC_MATERIAL, new BasicMaterial.Model { alphaTest = 1f }); yield return(basicMaterialComponent.routine); // 2. Check configured values Assert.AreEqual(1f, basicMaterialComponent.model.alphaTest); // 3. Update component with missing values scene.SharedComponentUpdate(basicMaterialComponent.id, JsonUtility.ToJson(new BasicMaterial.Model { })); yield return(basicMaterialComponent.routine); // 4. Check defaulted values Assert.AreEqual(0.5f, basicMaterialComponent.model.alphaTest); }
/// <summary> /// Update the current effect. This method will change. /// </summary> /// <param name="effect"></param> /// <param name="material"></param> private void UpdateEffect(BasicEffect effect, BasicMaterial material) { effect.Alpha = material.AlphaColor; effect.AmbientLightColor = material.AmbientColor * material.AmbientIntensity; effect.DiffuseColor = material.DiffuseColor * material.DiffuseIntensity; effect.EmissiveColor = material.EmissiveColor * material.EmissiveIntensity; effect.FogColor = material.FogColor; effect.FogEnabled = material.EnableFog; effect.FogStart = material.FogStart; effect.FogEnd = material.FogEnd; effect.LightingEnabled = true; if (material.EnableDefaultLighting) { effect.EnableDefaultLighting(); } effect.PreferPerPixelLighting = material.EnabledPerPixelLighting; effect.SpecularColor = material.SpecularColor * material.SpecularIntensity; effect.VertexColorEnabled = material.EnableVertexColor; SceneLight light = (SceneLight)material.Light; if (light != null) { StockMaterial.UpdateLighting(effect, light); effect.AmbientLightColor *= light.AmbientColor * light.AmbientIntensity; } }
public IEnumerator VideoTextureReplaceOtherTextureCorrectly() { DCLVideoTexture videoTexture = CreateDCLVideoTexture(scene, "it-wont-load-during-test"); yield return(videoTexture.routine); Assert.IsTrue(videoTexture.attachedMaterials.Count == 0, "DCLVideoTexture started with attachedMaterials != 0"); DCLTexture dclTexture = TestHelpers.CreateDCLTexture( scene, Utils.GetTestsAssetsPath() + "/Images/atlas.png", DCLTexture.BabylonWrapMode.CLAMP, FilterMode.Bilinear); yield return(dclTexture.routine); BasicMaterial mat = TestHelpers.SharedComponentCreate <BasicMaterial, BasicMaterial.Model> (scene, CLASS_ID.BASIC_MATERIAL, new BasicMaterial.Model { texture = dclTexture.id }); yield return(mat.routine); yield return(TestHelpers.SharedComponentUpdate <BasicMaterial, BasicMaterial.Model>(mat, new BasicMaterial.Model() { texture = videoTexture.id })); Assert.IsTrue(videoTexture.attachedMaterials.Count == 1, $"did DCLVideoTexture attach to material? {videoTexture.attachedMaterials.Count} expected 1"); }
/// <summary> /// Gets material used by the model. /// </summary> /// <returns>An array of material used by the model.</returns> public BaseMaterial[] GetModelMaterial() { List <BaseMaterial> materials = new List <BaseMaterial>(); BaseMaterial material = null; foreach (ModelMesh mesh in _model.Meshes) { foreach (ModelMeshPart part in mesh.MeshParts) { material = new BasicMaterial(); var effect = part.Effect as BasicEffect; if (effect != null) { material.Texture = effect.Texture; material.Effect = effect; } materials.Add(material); } } return(materials.ToArray()); }
public IEnumerator WorkCorrectlyWhenAttachedBeforeShape() { DecentralandEntity entity = TestHelpers.CreateSceneEntity(scene); DCLTexture dclTexture = TestHelpers.CreateDCLTexture( scene, Utils.GetTestsAssetsPath() + "/Images/atlas.png", DCLTexture.BabylonWrapMode.CLAMP, FilterMode.Bilinear); yield return(dclTexture.routine); BasicMaterial mat = TestHelpers.SharedComponentCreate <BasicMaterial, BasicMaterial.Model> (scene, CLASS_ID.BASIC_MATERIAL, new BasicMaterial.Model { texture = dclTexture.id, alphaTest = 0.5f }); yield return(mat.routine); TestHelpers.SharedComponentAttach(mat, entity); SphereShape shape = TestHelpers.SharedComponentCreate <SphereShape, SphereShape.Model>(scene, CLASS_ID.SPHERE_SHAPE, new SphereShape.Model { }); TestHelpers.SharedComponentAttach(shape, entity); Assert.IsTrue(entity.meshRootGameObject != null); Assert.IsTrue(entity.meshRootGameObject.GetComponent <MeshRenderer>() != null); Assert.AreEqual(entity.meshRootGameObject.GetComponent <MeshRenderer>().sharedMaterial, mat.material); }
public void Create(RenderControl render) { // 随便构造些点 float offset = 10.0f; for (int ii = 0; ii < 10; ++ii) { for (int jj = 0; jj < ii; ++jj) { mPoints.Add(new Vector3(jj * offset, 100, ii * offset)); } } mMotionTrail = new ParticleSceneNode((uint)mPoints.Count, ColorTable.Green, 3.0f); mCurrentIdx = 0; render.ShowSceneNode(mMotionTrail); var lineMaterial = BasicMaterial.Create("myline"); lineMaterial.SetColor(ColorTable.Hex(0xFF0000)); var line = GeometryBuilder.CreateLine(Vector3.Zero, new Vector3(1, 0, 0)); mLineNode = new PrimitiveSceneNode(line, lineMaterial); mLineNode.SetTransform(MakeTransform(mStart, mPoints[0])); mLineNode.RequstUpdate(); render.ShowSceneNode(mLineNode); }
public IEnumerator VideoTextureVisibleStateIsSetCorrectly() { DCLVideoTexture videoTexture = CreateDCLVideoTexture(scene, "it-wont-load-during-test"); yield return(videoTexture.routine); DecentralandEntity ent1 = TestHelpers.CreateSceneEntity(scene); BasicMaterial ent1Mat = TestHelpers.SharedComponentCreate <BasicMaterial, BasicMaterial.Model>(scene, CLASS_ID.BASIC_MATERIAL, new BasicMaterial.Model() { texture = videoTexture.id }); TestHelpers.SharedComponentAttach(ent1Mat, ent1); yield return(ent1Mat.routine); BoxShape ent1Shape = TestHelpers.SharedComponentCreate <BoxShape, BoxShape.Model>(scene, CLASS_ID.BOX_SHAPE, new BoxShape.Model()); yield return(ent1Shape.routine); TestHelpers.SharedComponentAttach(ent1Shape, ent1); yield return(null); //a frame to wait DCLVideoTexture update Assert.IsTrue(videoTexture.isVisible, "DCLVideoTexture should be visible"); yield return(TestHelpers.SharedComponentUpdate <BoxShape, BoxShape.Model>(ent1Shape, new BoxShape.Model() { visible = false })); yield return(null); //a frame to wait DCLVideoTexture update Assert.IsTrue(!videoTexture.isVisible, "DCLVideoTexture should not be visible "); }
public override void Run(RenderControl render) { // 1. Make face with a hole. var c1 = SketchBuilder.MakeCircle(GP.Origin(), 30, GP.DZ()); var c2 = SketchBuilder.MakeCircle(GP.Origin(), 100, GP.DZ()); var face = SketchBuilder.MakePlanarFace(c2); var face2 = SketchBuilder.MakePlanarFace(c1); var shape = BooleanTool.Cut(face, face2); //render.ShowShape(shape, ColorTable.Blue); var faces = shape.GetChildren(EnumTopoShapeType.Topo_FACE); // 2. Hatch the face. foreach (var item in faces) { HatchHatcher hh = new HatchHatcher(item); hh.Build(); var material = BasicMaterial.Create("line"); material.SetColor(new Vector3(0.5f, 0.5f, 1.0f)); var node = hh.Create(material); // 3. Show the hatching lines. render.ShowSceneNode(node); } }
/// <summary> /// Updates the behavior. Place each radar ticks /// </summary> /// <param name="gameTime"></param> protected override void Update(TimeSpan gameTime) { for (int i = 0; i < this.radarTicks.Count; i++) { var fighter = this.screenplay.FighterList[i]; Transform3D fighterTransform = fighter.Transform; Transform3D radarTransform = this.radarTicks[i]; Vector3 distance = fighterTransform.Position - this.transform.Position; float distanceLength = distance.Length(); if (distanceLength < radarRange) { BasicMaterial material = radarTickMaterials[i]; if (!radarTransform.Owner.Enabled) { radarTransform.Owner.Enabled = true; } float lerp = distanceLength / radarRange; float atenuationColor = (lerp < decay) ? 1 : 1 - ((lerp - decay) / decayInv); Color color = this.colors[(int)fighter.State] * atenuationColor; radarTransform.LocalPosition = (distance / radarRange) * radarSize; material.DiffuseColor = color; } else if (radarTransform.Owner.Enabled) { radarTransform.Owner.Enabled = false; } } }
public override void Run(RenderControl renderer) { OpenFileDialog dialog = new OpenFileDialog(); dialog.Filter = "IGES (*.igs;*.iges)|*.igs;*.iges|STEP (*.stp;*.step)|*.stp;*.step|Brep (*.brep)|*.brep"; if (dialog.ShowDialog() != DialogResult.OK) { return; } var shape = ShapeIO.Open(dialog.FileName); if (shape == null) { return; } var bs = new BufferShape(shape, null, null, 0); bs.Build(); // 1. Compute var holeExp = new HoleExplor(); if (!holeExp.Initialize(bs)) { return; } var dir = holeExp.ComputeDirection(); holeExp.Compute(dir); var defaultMaterial = MeshPhongMaterial.Create("face-x"); defaultMaterial.SetFaceSide(EnumFaceSide.DoubleSide); bs.SetFaceMaterial(defaultMaterial); // 2. Set hole faces with red color var material = BasicMaterial.Create("hole-face"); material.SetFaceSide(EnumFaceSide.DoubleSide); material.SetColor(new Vector3(0.5f, 0, 0)); var holeNumber = holeExp.GetHoleCount(); for (uint ii = 0; ii < holeNumber; ++ii) { var faceIDs = holeExp.GetHoleFaces(ii); foreach (var faceIdx in faceIDs) { bs.SetFaceMaterial(faceIdx, material); } } // 2. Show the faces var shapeNode = new BrepSceneNode(bs); renderer.ShowSceneNode(shapeNode); }
public YnBillboard(string textureName, float width, float height) { _material = new BasicMaterial(textureName); _rotation = new Vector3(-MathHelper.PiOver2, 0, MathHelper.Pi); _width = width; _height = height; _isFixed = true; }
public void UpgradeCraft(BasicMaterial mat) { if (Inventory.inventory.Gold >= mat.UpgradeCurrentPrice) { Inventory.inventory.Gold -= mat.UpgradeCurrentPrice; mat.UpgradeCurrentPrice = (int)(mat.upgradeMultiplicator * mat.UpgradeCurrentPrice); mat.timePerUnit = (float)(mat.timePerUnit / 1.2); } }
public BasicShaderName( int worldCount, int lightCount, BasicMaterial material ) { BasicLayer[] layers = material.Layers; int texCount = (layers.Length <= 3) ? layers.Length : 3; // bool texAnim = material.UseTexAnim; bool a_useTexAnim = false; // basic int a_lightCount = 0; LightingType a_lightType = LightingType.kLIGHTING_NONE; NormalMapType a_normalMapType = NormalMapType.kNORMALMAP_NONE; if( material.LightEnable != 0 ){ a_lightCount = lightCount; a_lightType = LightingType.kLIGHTING_FLAGMENT; a_normalMapType = NormalMapType.kNORMALMAP_NONE; } int[] texCoords = { 0, 0, 0 }; TexType[] texTypes = { 0, 0, 0 }; TexBlendFunc[] texBlendFuncs = { 0, 0, 0 }; int layerCount = (layers.Length <= 3) ? layers.Length : 3; for( int i = 0; i < layerCount; i++ ){ BasicLayer layer = layers[ i ]; // ここが無駄 if( (TexType)layer.TexType != TexType.kTEXTYPE_NONE ){ if( (TexType)layer.TexType == TexType.kTEXTYPE_VERTEXNORMAL ){ a_normalMapType = NormalMapType.kNORMALMAP_VERTEX; }else if( (TexType)layer.TexType == TexType.kTEXTYPE_IMAGENORMALL ){ a_normalMapType = NormalMapType.kNORMALMAP_IMAGE; } } texCoords[ i ] = layer.TexCoord; texTypes[ i ] = (TexType)layer.TexType; texBlendFuncs[ i ] = (TexBlendFunc)layer.TexBlendFunc; if( layer.TexAnimBoneIdx >= 0 ){ a_useTexAnim = true; } } this.Set( worldCount, material.VertexColorEnable != 0, texCount, a_useTexAnim, a_lightCount, a_lightType, a_normalMapType, texCoords, texTypes, texBlendFuncs, material.AlphaThreshold > 0.0f ); }
public void SurfaceDrawTest() { var material = new BasicMaterial(GraphicsDevice); var surface = new Surface(GraphicsDevice, new Heightmap(1, 2, 2), 2); var context = new DrawingContext(GraphicsDevice); foreach (var patch in surface.Patches) { patch.Draw(context, material); } }
public BasicBody(IDynamicBody dynamics, IElectroMag eMProps, BasicMaterial material, IEdgeIntersector collisionShape, IVolume shape, IOverlapable boundVolume) { Dynamics = dynamics; EMProps = eMProps; Material = material; CollisionShape = collisionShape; Shape = shape; BoundVolume = boundVolume; Dynamics.FrameFinished += (sender, e) => FrameFinished?.Invoke(sender, e); }
public static BasicMaterial CreateEntityWithBasicMaterial(ParcelScene scene, BasicMaterial.Model model, Vector3 position, out DecentralandEntity entity) { InstantiateEntityWithShape <BoxShape, BoxShape.Model>(scene, DCL.Models.CLASS_ID.BOX_SHAPE, position, out entity); BasicMaterial material = SharedComponentCreate <BasicMaterial, BasicMaterial.Model>(scene, CLASS_ID.BASIC_MATERIAL, model); SharedComponentAttach(material, entity); return(material); }
public IEnumerator ProcessCastShadowProperty_False() { BasicMaterial basicMaterialComponent = TestHelpers.CreateEntityWithBasicMaterial(scene, new BasicMaterial.Model { alphaTest = 1f, castShadows = false }, out DecentralandEntity entity); yield return(basicMaterialComponent.routine); Assert.AreEqual(false, basicMaterialComponent.model.castShadows); Assert.AreEqual(ShadowCastingMode.Off, entity.meshRootGameObject.GetComponent <MeshRenderer>().shadowCastingMode); }
public IEnumerator ProcessCastShadowProperty_True() { BasicMaterial basicMaterialComponent = TestHelpers.CreateEntityWithBasicMaterial(scene, new BasicMaterial.Model { alphaTest = 1f, castShadows = true }, out IDCLEntity entity); yield return(basicMaterialComponent.routine); Assert.AreEqual(true, basicMaterialComponent.GetModel().castShadows); Assert.AreEqual(ShadowCastingMode.On, entity.meshRootGameObject.GetComponent <MeshRenderer>().shadowCastingMode); }
private void CreateCube3D() { Entity cube = new Entity("Cube") .AddComponent(new Transform3D()) .AddComponent(Model.CreateCube()) .AddComponent(new MaterialsMap(new BasicMaterial("Content/crate.jpg"))) .AddComponent(new ModelRenderer()); this.cubeTransform = cube.FindComponent <Transform3D>(); this.cubeMaterial = (BasicMaterial)cube.FindComponent <MaterialsMap>().DefaultMaterial; EntityManager.Add(cube); }
internal static async Task <Multipatch> MakeFishnetRingMultiPatchAsync(Polygon inputPoly) { Envelope envPoly = inputPoly.Extent; var interval = GetFishnetIntervalDistance(envPoly); var mColor = System.Windows.Media.Colors.LightCyan; var materialRed = new BasicMaterial { Color = mColor, EdgeColor = mColor, EdgeWidth = 0 }; // create the multipatchBuilderEx object var mpb = new MultipatchBuilderEx(); // create a list of patch objects var patches = new List <Patch>(); var first = true; for (var dX = envPoly.XMin; dX < envPoly.XMax + interval; dX += interval) { for (var dY = envPoly.YMin; dY < envPoly.YMax + interval; dY += interval) { var cutEnv = EnvelopeBuilder.CreateEnvelope(dX, dY, dX + interval, dY + interval, envPoly.SpatialReference); if (GeometryEngine.Instance.Intersects(cutEnv, inputPoly)) { var addPolygonPart = GeometryEngine.Instance.Clip(inputPoly, cutEnv) as Polygon; if (addPolygonPart.Area < 0) { System.Diagnostics.Debug.WriteLine($@"area: {addPolygonPart.Area}"); } var result = await Module1.CurrentMapView.Map.GetZsFromSurfaceAsync(addPolygonPart); if (result.Status == SurfaceZsResultStatus.Ok) { addPolygonPart = GeometryEngine.Instance.Move(result.Geometry, 0, 0, Module1.Elevation) as Polygon; } var patch = mpb.MakePatch(first ? esriPatchType.FirstRing : esriPatchType.Ring); first = false; patch.InsertPoints(0, addPolygonPart.Points); patch.Material = materialRed; patches.Add(patch); } } } // assign the patches to the multipatchBuilder mpb.Patches = patches; // call ToGeometry to get the multipatch return(mpb.ToGeometry() as Multipatch); }
public BoxMesh() { _builder = new BoxBuilder(10, 10, 10); _mat = BasicMaterial.CreateDefaultMaterial("boxMaterial"); //VertexPositionColor[] vertexes = new VertexPositionColor[_builder.Vertices.Length]; //for (int i = 0; i < vertexes.Length; i++) //{ // vertexes[i] = new VertexPositionColor(_builder.Vertices[i].Position, new Color4(1, 1, 0, 0)); //} var device = GraphicDeviceFactory.Device; _vb = device.CreateVertexBuffer(data: _builder.Vertices); _ib = device.CreateIndexBuffer(data: _builder.Indices); _mat.Diffuse = new Vector3(1, 1, 1); _mat.DiffuseMap = device.CreateTexture2DFromFile(@"I:\Pictures\lufy.png"); _mat.SpecularIntensity = 0; _mat.EmisiveIntensity = 0; _mat.Alpha = 1f; IsTransparent = _mat.ContainsTrasparency; SetRender <DefaultTechnique, BasicMeshEffect>((box, render) => { var effect = render.Effect; //effect.Constants.gId = new Vector4(1, 1, 0, 0); //effect.U.World = Matrix.Identity; //map.World = Matrix.Identity; device.PrimitiveTopology = IAPrimitive.TriangleList; device.SetVertexBuffer(0, _vb, 0); device.SetIndexBuffer(_ib, 0); render.Bind(_mat); foreach (var pass in effect.Passes(0)) { effect.Apply(pass); device.DrawIndexed(_builder.Indices.Length, 0, 0); } effect.EndPasses(); }); //.BindWith(new CameraBinding()) //.BindWith(new MeshMaterialBinding()) //.BindWith(new LightBinding()) //.BindWith(new AmbientLightBinding()) //.BindWith(new PixelClippingBinding()); }
protected override void CreateResources(ResourceFactory factory) { var texture = TextureLoader.Load("v:checker").GetAwaiter().GetResult(); basicMaterial = new BasicMaterial(DrawingContext, texture, true); // var shape1 = new Cube(new Vector3(0, 0, 0), new Vector3(1, 1, 1)); // var shape2 = new Cube(new Vector3(0.8f, 0.8f, 0), new Vector3(1, 1, 1)); // var shape = shape1.Do(ShapeOperation.Intersect, shape2); var shape = new Teapot(); shapeGeometry = new ShapeGeometry(DrawingContext, shape); commandList = factory.CreateCommandList(); }
private Multipatch ApplyMaterialsToMultipatch(Multipatch source) { // create material for the top face patch BasicMaterial topFaceMaterial = new BasicMaterial(); topFaceMaterial.Color = Color.FromRgb(203, 65, 84); topFaceMaterial.Shininess = 150; topFaceMaterial.TransparencyPercent = 50; topFaceMaterial.EdgeWidth = 20; // create material for the bottom face patch BasicMaterial bottomFaceMaterial = new BasicMaterial(); bottomFaceMaterial.Color = Color.FromRgb(203, 65, 84); bottomFaceMaterial.EdgeWidth = 20; // create material for the sides face BasicMaterial sidesFaceMaterial = new BasicMaterial(); sidesFaceMaterial.Color = Color.FromRgb(133, 94, 66); sidesFaceMaterial.Shininess = 0; sidesFaceMaterial.EdgeWidth = 20; // create a builder using the source multipatch var cubeMultipatchBuilderEx = new MultipatchBuilderEx(source); // set material to the top face patch var topFacePatch = cubeMultipatchBuilderEx.Patches[0]; topFacePatch.Material = topFaceMaterial; // set material to the bottom face patch var bottomFacePatch = cubeMultipatchBuilderEx.Patches[1]; bottomFacePatch.Material = bottomFaceMaterial; // set material to the sides face patch var sidesFacePatch = cubeMultipatchBuilderEx.Patches[2]; sidesFacePatch.Material = sidesFaceMaterial; // create the geometry Multipatch cubeMultipatchWithMaterials = cubeMultipatchBuilderEx.ToGeometry() as Multipatch; return(cubeMultipatchWithMaterials); }
public IEnumerator VideoTextureVisibleStateIsSetCorrectlyWhenAddedToAMaterialNotAttachedToShape() { DCLVideoTexture videoTexture = CreateDCLVideoTexture(scene, "it-wont-load-during-test"); yield return(videoTexture.routine); DecentralandEntity ent1 = TestHelpers.CreateSceneEntity(scene); BasicMaterial ent1Mat = TestHelpers.SharedComponentCreate <BasicMaterial, BasicMaterial.Model>(scene, CLASS_ID.BASIC_MATERIAL, new BasicMaterial.Model() { texture = videoTexture.id }); TestHelpers.SharedComponentAttach(ent1Mat, ent1); yield return(ent1Mat.routine); Assert.IsTrue(!videoTexture.isVisible, "DCLVideoTexture should not be visible without a shape"); }
private void CreateCube3D() { Entity cube = new Entity("Cube") .AddComponent(new Transform3D()) .AddComponent(Model.CreateCube()) .AddComponent(new MaterialsMap(new BasicMaterial("Content/crate.jpg"))) .AddComponent(new ModelRenderer()); this.cubeTransform = cube.FindComponent<Transform3D>(); this.cubeMaterial = (BasicMaterial)cube.FindComponent<MaterialsMap>().DefaultMaterial; EntityManager.Add(cube); }
/// <summary> /// Create a BasicMaterial from a "<material>". /// <param name="material">The "<material>" element to be converted.</param> /// <param name="context"> The current context for the COLLADA Processor</param> /// </summary> public BasicMaterial CreateBasicMaterial(Model model, Document.Material material) { Document doc = model.Doc; uint textureChannel = 0; Dictionary<string, uint> textureBinding = new Dictionary<string, uint>(); textureBindings[material.id] = textureBinding; BasicMaterial materialContent = new BasicMaterial(); Document.Effect effect = (Document.Effect)doc.dic[material.instanceEffect.Fragment]; if (effect == null) throw new Exception("cannot find effect#" + material.instanceEffect.Fragment); // search common profile with correct asset.... Document.ProfileCOMMON profile; foreach (Document.IProfile tmpProfile in effect.profiles) { if (tmpProfile is Document.ProfileCOMMON) { profile = (Document.ProfileCOMMON)tmpProfile; goto Found; } } throw new Exception("Could not find profile_COMMON in effect" + effect.ToString()); Found: // read params // Dictionary<string, string> samplerBind = new Dictionary<string, string>(); // Dictionary<string, string> imageBind = new Dictionary<string, string>(); // Read Technique Document.SimpleShader shader = ((Document.ProfileCOMMON)profile).technique.shader; materialContent.Name = material.name; // BasicShader only accept texture for the diffuse channel if (shader.diffuse is Document.Texture) { string sampler = ((Document.Texture)shader.diffuse).texture; string surface; string image; if (profile.newParams.ContainsKey(sampler)) { surface = ((Document.Sampler2D)profile.newParams[sampler].param).source; image = ((Document.Surface)profile.newParams[surface].param).initFrom; } else { image = sampler; // TODO: emit serious warning - invalid content } // now find image string imagePath = ((Document.Image)doc.dic[image]).init_from.Uri.LocalPath; // here associate 1 texture binding per texture in material textureBinding[((Document.Texture)shader.diffuse).texcoord] = textureChannel++; materialContent.Texture = imagePath; } else if (shader.diffuse is Document.Color) { Document.Color color = (Document.Color)shader.diffuse; // TODO: manage color[3] in transparency materialContent.DiffuseColor = new Vector3(color[0], color[1], color[2]); } if (shader.ambient is Document.Texture) { // Basic Material does not accept texture on ambient channel COLLADAUtil.Log("Ambient channel not supported in BasicMaterial."); /* string sampler = ((Document.Texture)shader.ambient).texture; string surface = ((Document.Sampler2D)profile.newParams[sampler].param).source; string image = ((Document.Surface)profile.newParams[surface].param).initFrom; // now find image string imagePath = ((Document.Image)doc.dic[image]).init_from.Uri.LocalPath; // here associate 1 texture binding per texture in material textureBinding[((Document.Texture)shader.ambient).texcoord] = textureChannel++; materialContent.Texture = new ExternalReference<TextureContent>(imagePath); */ } else if (shader.ambient is Document.Color) { // XNA BasicMaterial has no ambient COLLADAUtil.Log("Ambient channel not supported in BasicMaterial."); } if (shader.emission is Document.Texture) { // XNA BasicMaterial does not accept texture for emmision COLLADAUtil.Log("BasicMaterial does not accept texture for emmision."); /* string sampler = ((Document.Texture)shader.emission).texture; string surface = ((Document.Sampler2D)profile.newParams[sampler].param).source; string image = ((Document.Surface)profile.newParams[surface].param).initFrom; // now find image string imagePath = ((Document.Image)doc.dic[image]).init_from.Uri.LocalPath; // here associate 1 texture binding per texture in material textureBinding[((Document.Texture)shader.emission).texcoord] = textureChannel++; materialContent.Texture = new ExternalReference<TextureContent>(imagePath); */ } else if (shader.emission is Document.Color) { Document.Color color = (Document.Color)shader.emission; materialContent.EmissiveColor = new Vector3(color[0], color[1], color[2]); } if (shader.specular is Document.Texture) { // XNA BasicMaterial does not accept texture for specular COLLADAUtil.Log("BasicMaterial does not accept texture for specular."); /* string sampler = ((Document.Texture)shader.specular).texture; string surface = ((Document.Sampler2D)profile.newParams[sampler].param).source; string image = ((Document.Surface)profile.newParams[surface].param).initFrom; // now find image string imagePath = ((Document.Image)doc.dic[image]).init_from.Uri.LocalPath; // here associate 1 texture binding per texture in material textureBinding[((Document.Texture)shader.specular).texcoord] = textureChannel++; materialContent.Texture = new ExternalReference<TextureContent>(imagePath); */ } else if (shader.specular is Document.Color) { Document.Color color = (Document.Color)shader.specular; materialContent.SpecularColor = new Vector3(color[0], color[1], color[2]); if (shader.shininess is Document.Float) materialContent.SpecularPower = ((Document.Float)shader.shininess).theFloat; } if (shader.transparency is Document.Texture) { // XNA Basic Shader does not accept a texture for the transparency channel COLLADAUtil.Log("BasicMaterial does not accept texture for transparency channel."); /* string sampler = ((Document.Texture)shader.transparency).texture; string surface = ((Document.Sampler2D)profile.newParams[sampler].param).source; string image = ((Document.Surface)profile.newParams[surface].param).initFrom; // now find image string imagePath = ((Document.Image)doc.dic[image]).init_from.Uri.LocalPath; // here associate 1 texture binding per texture in material textureBinding[((Document.Texture)shader.transparency).texcoord] = textureChannel++; materialContent.Texture = new ExternalReference<TextureContent>(imagePath); */ } else if (shader.transparency is Document.Float) { materialContent.Alpha = ((Document.Float)shader.transparency).theFloat; } return materialContent; }
/// <summary> /// Initializes the shockwave behavior /// </summary> protected override void Initialize() { base.Initialize(); this.material = this.materials.DefaultMaterial as BasicMaterial; }