示例#1
0
        void SetMaterial(MSceneObject mo, string sMaterialID)
        {
            if (sMaterialID == null)
            {
                sMaterialID = MMaterial.DEFAULT_MATERIAL;
            }
            //MSceneObject mo = (MSceneObject)MScene.ModelRoot.FindModuleByInstanceID(e.InstanceID);
            MObject   o   = MScene.MaterialRoot.FindModuleByName(sMaterialID);
            MMaterial mat = null;

            if (o != null && o.Type == MObject.EType.Material)
            {
                mat = (MMaterial)o;
                if (mat != null)
                {
                    mo.SetMaterial(mat);
                    mat.MaterialID = sMaterialID;
                }
            }

            if (MassiveTools.IsURL(sMaterialID))
            {
                mat = (MMaterial) new MMaterial("URLShader");
                MShader DefaultShader = (MShader)MScene.MaterialRoot.FindModuleByName(MShader.DEFAULT_SHADER);
                mat.AddShader(DefaultShader);
                mat.ReplaceTexture(Globals.TexturePool.GetTexture(sMaterialID));
                mat.MaterialID = sMaterialID;
                MScene.MaterialRoot.Add(mat);
                mo.SetMaterial(mat);
                mo.material.Setup();
            }
        }
示例#2
0
        private void Network_TextureHandler(object sender, Massive.Events.TextureEvent e)
        {
            MSceneObject mo = (MSceneObject)MScene.ModelRoot.FindModuleByInstanceID(e.InstanceID);
            MObject      o  = MScene.MaterialRoot.FindModuleByName(e.TextureID);

            if (o != null && o.Type == MObject.EType.Material)
            {
                MMaterial mat = (MMaterial)o;
                mo.SetMaterial(mat);
            }
            else
            {
                if (MassiveTools.IsURL(e.TextureID))
                {
                    MMaterial mat           = (MMaterial) new MMaterial("URLShader");
                    MShader   DefaultShader = (MShader)MScene.MaterialRoot.FindModuleByName(MShader.DEFAULT_SHADER);
                    mat.AddShader(DefaultShader);
                    mat.ReplaceTexture(Globals.TexturePool.GetTexture(e.TextureID));
                    MScene.MaterialRoot.Add(mat);
                    mo.SetMaterial(mat);
                    mo.material.Setup();
                    MMessageBus.ChangedTexture(this, e.InstanceID, e.TextureID);
                }
                else
                {
                    Console.WriteLine("Object " + e.InstanceID + " was null");
                    MMessageBus.Error(this, "Could not find Material:" + e.TextureID);
                }
            }
        }
示例#3
0
        void SetupMaterials()
        {
            MShader BasicShader = new MShader("BasicShader");

            BasicShader.Load("default_v.glsl",
                             "default_f.glsl",
                             "Terrain\\eval.glsl",
                             "Terrain\\control.glsl"
                             );
            BasicShader.Bind();
            BasicShader.SetInt("material.diffuse", MShader.LOCATION_DIFFUSE);
            BasicShader.SetInt("material.specular", MShader.LOCATION_SPECULAR);
            BasicShader.SetInt("material.multitex", MShader.LOCATION_MULTITEX);
            BasicShader.SetInt("material.normalmap", MShader.LOCATION_NORMALMAP);
            BasicShader.SetInt("material.shadowMap", MShader.LOCATION_SHADOWMAP);

            MShader BoneShader = new MShader("AnimatedShader");
            string  sVertFile  = "Animation\\animated_vs.glsl";
            string  sFragPath  = "Animation\\animated_fs.glsl";

            BoneShader.Load(sVertFile,
                            sFragPath,
                            "",
                            ""
                            );
            BoneShader.Bind();
            BoneShader.SetInt("material.diffuse", MShader.LOCATION_DIFFUSE);
            BoneShader.SetInt("material.specular", MShader.LOCATION_SPECULAR);
            BoneShader.SetInt("material.multitex", MShader.LOCATION_MULTITEX);
            BoneShader.SetInt("material.normalmap", MShader.LOCATION_NORMALMAP);
            BoneShader.SetInt("material.shadowMap", MShader.LOCATION_SHADOWMAP);

            foreach (KeyValuePair <string, MBuildingBlock> k in Blocks)
            {
                MBuildingBlock b = k.Value;
                if (b.Type == "MMaterial")
                {
                    MMaterial MATM = new MMaterial(b.MaterialID);
                    MATM.AddShader(BasicShader);
                    MATM.SetDiffuseTexture(Globals.TexturePool.GetTexture(b.Path));
                    MScene.MaterialRoot.Add(MATM);
                }
                else
                if (b.Type == "MBoneMaterial")
                {
                    MMaterial MATM = new MMaterial(b.MaterialID);
                    MATM.AddShader(BoneShader);
                    MATM.SetDiffuseTexture(Globals.TexturePool.GetTexture(b.Path));
                    MScene.MaterialRoot.Add(MATM);
                }
            }
        }
示例#4
0
 public MGrass() : base(EType.Grass, "Grass")
 {
     grassShader = new MShader("GrassShader");
 }
示例#5
0
        public void Render()
        {
            _terminableTaskExecutor.CancelCurrentAndRun(
                (ctIn) =>
            {
                // reset shader
                MShader.Reset();

                // stop if new render is requested
                ctIn.ThrowIfCancellationRequested();

                // as we only render one layer at a time
                // choose the closest layer in the recipe tree
                var layer = GetClosestLayer();

                if (layer != null)
                {
                    // extract device's absolute transform
                    var baseTransform = MRecipe.GetRelativeTransform(RecipeVm, layer);

                    // calculate layer's transform
                    var transform = GeometricArithmeticModule.CombineTransformations(
                        baseTransform,
                        layer.TransformInfo.ToMatrix4x4()
                        );

                    // fetch pattern
                    var pattern = FetchDXF(layer);

                    for (int j = 0; j < pattern?.Count; j++)
                    {
                        // get copy of geometry
                        var geometry = (IMarkGeometry)pattern[j].Clone();

                        // apply transform to geometry
                        geometry.Transform(transform);

                        // add geometry
                        MShader.AddDefault(geometry);
                    }

                    // overlay tiles
                    foreach (var tile in layer.TileDescriptions)
                    {
                        var rect = (MarkGeometryRectangle)tile;

                        // apply transform to rect
                        rect.Transform(transform);

                        // add geometry
                        MShader.AddDefault(rect, MGLShader.Violet);
                    }
                }

                // stop if new render is requested
                ctIn.ThrowIfCancellationRequested();

                MShader.Render();
                UpdateStats();
            }
                );
        }