Esempio n. 1
0
        void SetupMaterial()
        {
            MMaterial InstanceMat = new MMaterial("InstanceGrassMaterial");
            MShader   shader      = new MShader("InstanceGrassShader");

            //shader.LoadFromString(sVertexShader, sFragmentShader);
            shader.Load("instanced_v.glsl",
                        "instanced_f.glsl",
                        "", ""
                        );
            shader.Bind();
            shader.SetFloat("Fade", 68);
            shader.SetInt("material.diffuse", MShader.LOCATION_DIFFUSE);
            shader.SetInt("material.specular", MShader.LOCATION_SPECULAR);
            shader.SetInt("material.multitex", MShader.LOCATION_MULTITEX);
            shader.SetInt("material.normalmap", MShader.LOCATION_NORMALMAP);
            shader.SetInt("material.shadowMap", MShader.LOCATION_SHADOWMAP);
            InstanceMat.AddShader(shader);
            MTexture GrassTex = Globals.TexturePool.GetTexture(TreeTexture);

            GrassTex._TextureWrapMode = TextureWrapMode.ClampToBorder;
            GrassTex.DoAssign         = true;
            InstanceMat.SetDiffuseTexture(GrassTex);
            this.SetMaterial(InstanceMat);
            grass.SetMaterial(InstanceMat);
            MScene.MaterialRoot.Add(InstanceMat);
        }
Esempio n. 2
0
        void AddBackdrop()
        {
            Helper.CheckGLError(this, "TestPoint 3a");
            MShader BackgroundShader = new MShader("BackgroundShader");

            BackgroundShader.Load("default_v.glsl",
                                  "unlit_f.glsl",
                                  "Terrain\\eval.glsl", "Terrain\\control.glsl"
                                  );

            BackgroundShader.Bind();
            BackgroundShader.SetInt("material.diffuse", MShader.LOCATION_DIFFUSE);
            Helper.CheckGLError(this, "TestPoint 3b");
            //SkyShader.SetInt("shadowMap", 2);

            MMaterial BGMat = new MMaterial("BackgroundMaterial");

            BGMat.AddShader(BackgroundShader);
            Helper.CheckGLError(this, "TestPoint 4a");
            MTexture BackgroundTexure = new MTexture("BackgroundT");

            Helper.CheckGLError(this, "TestPoint 4b");
            BackgroundTexure.LoadTextureData(MFileSystem.ProjectPath + "Assets\\Textures\\Planets\\8k_stars_milky_way.jpg");
            BackgroundTexure.DoAssign = true;

            MaterialRoot.Add(BGMat);
            BGMat.SetDiffuseTexture(BackgroundTexure);
            backdrop = new MSky();
            backdrop.AddMaterial(BGMat);
            UtilityRoot.Add(backdrop);
        }
Esempio n. 3
0
        public override void Render(Matrix4d viewproj, Matrix4d parentmodel)
        {
            if (Settings.DrawGrass == false)
            {
                return;
            }
            //if (Globals.ShaderOverride != null) return;
            if (Globals.Avatar.DistanceToSurface > HeightThreshold)
            {
                return;
            }
            if (grass != null)
            {
                grass.transform.Position = this.transform.Position;
            }

            //GL.Enable(EnableCap.Blend);
            // GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);

            if (material == null)
            {
                return;
            }
            CalculateDrawMatrices(viewproj, parentmodel);

            MShader temp = material.shader;

            if (Globals.ShaderOverride != null)
            {
                temp = Globals.ShaderOverride;
                temp.SetInt("HasBones", 0);
            }
            else
            {
                material.IsUsed = true;
                material.Render(viewproj, parentmodel);
                material.Bind();
                material.shader.SetFloat("Fade", 68);
                //49 6

                temp.SetBool("ShadowEnabled", CastsShadow);
            }
            temp.SetMat4("mvp", mvp);
            temp.SetMat4("model", modelMatrix);

            GL.BindVertexArray(treemesh.VAO);
            lock (matlocker)
            {
                UploadBufferFull();
            }

            GL.DrawArraysInstanced(PrimitiveType.Triangles, 0, treemesh.Indices.Length, TotalInstances);
            // Helper.CheckGLError(this);
            GL.BindVertexArray(0);
            if (Globals.ShaderOverride == null)
            {
                material.UnBind();
            }
            //base.Render(viewproj, parentmodel);
        }
Esempio n. 4
0
        public override void Setup()
        {
            FXShader.LoadFromString(vs, fs);
            FXShader.SetInt("screenTexture", 0);

            GL.Enable(EnableCap.Blend);
            GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);

            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.LinearMipmapLinear);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);

            //GL.PatchParameter(PatchParameterInt.PatchVertices, 3);
            Helper.CheckGLError(this);



            //screen quad
            // screen quad VAO to render on
            GL.GenVertexArrays(1, out quadVAO);
            GL.GenBuffers(1, out quadVBO);
            GL.BindVertexArray(quadVAO);
            GL.BindBuffer(BufferTarget.ArrayBuffer, quadVBO);
            GL.BufferData(BufferTarget.ArrayBuffer, sizeof(float) * quadVertices.Length, quadVertices, BufferUsageHint.StaticDraw);
            GL.EnableVertexAttribArray(0);
            GL.VertexAttribPointer(0, 2, VertexAttribPointerType.Float, false, 4 * sizeof(float), 0);
            GL.EnableVertexAttribArray(1);
            GL.VertexAttribPointer(1, 2, VertexAttribPointerType.Float, false, 4 * sizeof(float), (2 * sizeof(float)));
            //return;

            GL.ClearColor(ClearColor);
            //   GL.DepthFunc(DepthFunction.Greater);
            GL.Enable(EnableCap.DepthTest);
            GL.DepthFunc(DepthFunction.Less);

            //  Helper.CheckGLError(this);

            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.LinearMipmapLinear);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
            GL.ActiveTexture(TextureUnit.Texture0);

            GL.Enable(EnableCap.Blend);
            GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);

            //gamma correction
            //GL.Enable(EnableCap.FramebufferSrgb);

            GL.Enable(EnableCap.Multisample);
            GL.PatchParameter(PatchParameterInt.PatchVertices, 3);
            float[] innerLevel = new float[] { 5 };
            float[] outerLevel = new float[] { 3, 3, 3 };
            GL.PatchParameter(PatchParameterFloat.PatchDefaultOuterLevel, outerLevel);
            GL.PatchParameter(PatchParameterFloat.PatchDefaultInnerLevel, innerLevel);

            // GL.PatchParameter(PatchParameterInt.PatchVertices, 3);

            //setup fbos

            Resize(MScreen.Width, MScreen.Height);
        }
Esempio n. 5
0
        void SetupMaterial()
        {
            /*
             * MShader TreeShader = new MShader("TreeShader");
             * TreeShader.Load("default_v.glsl",
             * "default_f.glsl",
             * "",
             * ""
             * );
             * TreeShader.Bind();
             * TreeShader.SetInt("material.diffuse", MShader.LOCATION_DIFFUSE);
             * TreeShader.SetInt("material.specular", MShader.LOCATION_SPECULAR);
             * TreeShader.SetInt("material.multitex", MShader.LOCATION_MULTITEX);
             * TreeShader.SetInt("material.normalmap", MShader.LOCATION_NORMALMAP);
             * TreeShader.SetInt("material.shadowMap", MShader.LOCATION_SHADOWMAP);
             *
             * MMaterial Avatar1Mat = new MMaterial("TREE01M");
             * Avatar1Mat.AddShader(TreeShader);
             * Avatar1Mat.SetDiffuseTexture(Globals.TexturePool.GetTexture("Textures\\avatar01.jpg"));
             * MScene.MaterialRoot.Add(Avatar1Mat);
             */

            MMaterial InstanceMat = new MMaterial("ForestMaterialInstanced");
            MShader   shader      = (MShader)MScene.MaterialRoot.FindModuleByName("ForestShaderInstanced");

            if (shader == null)
            {
                shader = new MShader("ForestShaderInstanced");
                //shader.LoadFromString(sVertexShader, sFragmentShader);
                shader.Load("instanced_v.glsl",
                            "instanced_f.glsl",
                            "", ""
                            );
                shader.Bind();
                shader.SetInt("material.diffuse", MShader.LOCATION_DIFFUSE);
                shader.SetInt("material.specular", MShader.LOCATION_SPECULAR);
                shader.SetInt("material.multitex", MShader.LOCATION_MULTITEX);
                shader.SetInt("material.normalmap", MShader.LOCATION_NORMALMAP);
                shader.SetInt("material.shadowMap", MShader.LOCATION_SHADOWMAP);
            }
            InstanceMat.AddShader(shader);
            InstanceMat.SetDiffuseTexture(Globals.TexturePool.GetTexture(TreeTexture));
            this.SetMaterial(InstanceMat);
            tree.SetMaterial(InstanceMat);
            MScene.MaterialRoot.Add(InstanceMat);
        }
Esempio n. 6
0
        public static MShader CreateShader(string sName)
        {
            MShader WallShader = new MShader(sName);

            WallShader.Load("default_v.glsl",
                            "default_f.glsl",
                            "Terrain\\eval.glsl",
                            "Terrain\\control.glsl"
                            );
            WallShader.Bind();
            WallShader.SetInt("material.diffuse", MShader.LOCATION_DIFFUSE);
            WallShader.SetInt("material.specular", MShader.LOCATION_SPECULAR);
            WallShader.SetInt("material.multitex", MShader.LOCATION_MULTITEX);
            WallShader.SetInt("material.normalmap", MShader.LOCATION_NORMALMAP);
            WallShader.SetInt("material.shadowMap", MShader.LOCATION_SHADOWMAP);
            return(WallShader);
        }
Esempio n. 7
0
        void CreateShaders()
        {
            MShader SkyShader = Helper.CreateShader("SkyShader");

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

            MSkyMaterial = new MMaterial("SKY01M");
            MSkyMaterial.AddShader(SkyShader);
            MSkyMaterial.SetDiffuseTexture(Globals.TexturePool.GetTexture(SkyTexURL));
            MScene.MaterialRoot.Add(MSkyMaterial);
        }
Esempio n. 8
0
        void SetupMaterial()
        {
            MMaterial InstanceMat = new MMaterial("InstanceMaterial");
            MShader   shader      = new MShader("InstanceShader");

            //shader.LoadFromString(sVertexShader, sFragmentShader);
            shader.Load("instanced_v.glsl",
                        "instanced_f.glsl",
                        "", ""
                        );
            shader.Bind();
            shader.SetInt("material.diffuse", MShader.LOCATION_DIFFUSE);
            shader.SetInt("material.specular", MShader.LOCATION_SPECULAR);
            shader.SetInt("material.multitex", MShader.LOCATION_MULTITEX);
            shader.SetInt("material.normalmap", MShader.LOCATION_NORMALMAP);
            shader.SetInt("material.shadowMap", MShader.LOCATION_SHADOWMAP);
            InstanceMat.AddShader(shader);
            InstanceMat.SetDiffuseTexture(Globals.TexturePool.GetTexture(MeshTexture));
            this.SetMaterial(InstanceMat);
            material = InstanceMat;
        }
Esempio n. 9
0
        public void Setup(MAstroBody b)
        {
            CurrentBody = b;

            // TerrainShader = Helper.CreateShader(MShader.TERRAIN_SHADER);

            TerrainShader = new MShader(MShader.TERRAIN_SHADER);
            TerrainShader.Load("default_v.glsl",
                               "Terrain\\terrain_f.glsl",
                               "",
                               ""
                               );
            TerrainShader.Bind();
            TerrainShader.SetInt("material.diffuse", MShader.LOCATION_DIFFUSE);
            TerrainShader.SetInt("material.specular", MShader.LOCATION_SPECULAR);
            TerrainShader.SetInt("material.multitex", MShader.LOCATION_MULTITEX);
            TerrainShader.SetInt("material.normalmap", MShader.LOCATION_NORMALMAP);
            TerrainShader.SetInt("material.shadowMap", MShader.LOCATION_SHADOWMAP);

            base.Setup();
        }
Esempio n. 10
0
        /// <summary>
        /// The main setup point for the initial scene graph and tools
        /// </summary>
        public void SetupInitialObjects()
        {
            Root = new MObject(MObject.EType.Null, "Root");
            //Root.Deletable = false;

            TemplateRoot = new MObject(MObject.EType.Null, "TemplateRoot");
            Root.Add(TemplateRoot);
            TemplateRoot.Enabled = false; //disable updates

            SelectionRoot = new MObject(MObject.EType.Null, "Selection");
            Root.Add(SelectionRoot);

            UtilityRoot           = new MObject(MObject.EType.Null, "Utility");
            UtilityRoot.Deletable = false;
            Root.Add(UtilityRoot);
            time = new Time();
            UtilityRoot.Add(time);

            LightRoot = new MObject(MObject.EType.Null, "LightRoot");
            Root.Add(LightRoot);

            Globals.ScriptHost = new MScriptHost();
            UtilityRoot.Add(Globals.ScriptHost);
            MSystemScript sc = new MSystemScript("Massive.Main", Root);

            sc.SetActivator(Globals.ScriptHost.GetMainActivator());
            Root.Add(sc);

            Globals.TexturePool = new TexturePool();
            UtilityRoot.Add(Globals.TexturePool);

            Renderer = new MRenderer();
            UtilityRoot.Add(Renderer);

            DefaultShader = new MShader(MShader.DEFAULT_SHADER);
            DefaultShader.Load("default_v.glsl",
                               "default_f.glsl",
                               "Terrain\\eval.glsl", "Terrain\\control.glsl");
            DefaultShader.Bind();
            DefaultShader.SetInt("material.diffuse", MShader.LOCATION_DIFFUSE);
            DefaultShader.SetInt("material.specular", MShader.LOCATION_SPECULAR);
            DefaultShader.SetInt("material.multitex", MShader.LOCATION_MULTITEX);
            DefaultShader.SetInt("material.normalmap", MShader.LOCATION_NORMALMAP);
            DefaultShader.SetInt("material.shadowMap", MShader.LOCATION_SHADOWMAP);
            //DefaultShader.Deletable = false;
            Helper.CheckGLError(this, "TestPoint 1");

            // MShader GUIShader = new MShader("DefaultGUIShader");
            // GUIShader.Load("gui_v.glsl", "gui_f.glsl");
            //GUIShader.Bind();
            //GUIShader.Deletable = false;

            MaterialRoot = new MObject(MObject.EType.Null, "MaterialRoot");
            //MaterialRoot.Deletable = false;
            Root.Add(MaterialRoot);
            Helper.CheckGLError(this);
            if (Physics != null)
            {
                Physics.Dispose();
            }
            Physics = new MPhysics();
            Physics.Setup(); //only need to do this once
            //Physics.Deletable = false;
            UtilityRoot.Add(Physics);
            Helper.CheckGLError(this, "TestPoint 2");
            //UtilityRoot.Add(Globals.Network);
            //Globals.Network.Deletable = false;

            DistanceClipper = new MDistanceClipper();
            UtilityRoot.Add(DistanceClipper);
            FrustrumCuller = new MFrustrumCuller();
            UtilityRoot.Add(FrustrumCuller);

            Globals.Avatar = new MAvatar("Player1");
            UtilityRoot.Add(Globals.Avatar);

            Background = new MObject(MObject.EType.Null, "Background");
            Root.Add(Background);
            Background2 = new MObject(MObject.EType.Null, "Background2");
            Root.Add(Background2);

            ModelRoot = new MObject(MObject.EType.Null, "ModelRoot");
            Root.Add(ModelRoot);
            ModelRoot.Deletable = false;

            AstroRoot = new MObject(MObject.EType.Null, "AstroRoot");
            //ModelRoot.Add(AstroRoot);
            UtilityRoot.Add(AstroRoot);
            AstroRoot.Deletable = false;

            if (Settings.DrawPlanets == true)
            {
                MPlanetHandler mpi = new MPlanetHandler();
                UtilityRoot.Add(mpi);
                MGrass grass = new MGrass();
                Background2.Add(grass);
            }

            Priority1 = new MObject(MObject.EType.Null, "Priority1");
            ModelRoot.Add(Priority1);
            Priority2 = new MObject(MObject.EType.Null, "Priority2");
            ModelRoot.Add(Priority2);
            Overlay = new MObject(MObject.EType.Null, "Overlay");
            //ModelRoot.Add(Overlay); //manually drawn in render


            if (Settings.DrawBackdrop == true)
            {
                AddBackdrop();
            }

            Fog = new MFog();
            UtilityRoot.Add(Fog);

            DefaultMaterial           = new MMaterial(MMaterial.DEFAULT_MATERIAL);
            DefaultMaterial.Deletable = false;
            DefaultMaterial.AddShader(DefaultShader);
            //DefaultMaterial.SetDiffuseTexture(Globals.TexturePool.GetTexture("Textures\\default.jpg"));
            MaterialRoot.Add(DefaultMaterial);

            MTexture DefaultTexture = new MTexture(MTexture.DEFAULT_TEXTURE);

            DefaultTexture.LoadTextureData(MFileSystem.ProjectPath + "Assets\\Textures\\default.jpg");
            DefaultTexture.DoAssign = true;
            DefaultMaterial.SetDiffuseTexture(DefaultTexture);


            MMaterial GUIMat = new MMaterial("DefaultGUIMaterial");
            //GUIMat.Deletable = false;
            //GUIMat.AddShader(GUIShader);
            //GUIMat.SetDiffuseTexture(Globals.TexturePool.GetTexture("Textures\\unwrap_helper_1024.jpg"));
            //MaterialRoot.Add(GUIMat);

            MMaterial DepthMaterial = new MMaterial("Depth");

            DepthMaterial.Deletable = false;
            simpleDepthShader       = new MShader("simpleDepthShader");
            simpleDepthShader.Load("shadow_mapping_depth_v.glsl",
                                   "shadow_mapping_depth_f.glsl",
                                   "", "")
            ;
            DepthMaterial.shader = simpleDepthShader;
            DepthMaterial.Add(simpleDepthShader);
            MaterialRoot.Add(DepthMaterial);
            Helper.CheckGLError(this, "TestPoint 5");


            //UtilityRoot.Add(audioListener);
            //audioListener.Deletable = false;

            Camera                    = new MCamera("MainCam");
            Camera.OwnerID            = MObject.OWNER_SYSTEM;
            Camera.transform.Position = new Vector3d(9, 5, 9);
            UtilityRoot.Add(Camera);
            audioListener = new MAudioListener();
            Camera.Add(audioListener);
            // Camera.Deletable = false;

            light                    = new MLight("DirLight");
            light.OwnerID            = MObject.OWNER_SYSTEM;
            light.transform.Position = new Vector3d(-10, 20.0f, -10.0f);
            UtilityRoot.Add(light);
            //light.Deletable = false;

            ScreenPick = new MScreenPick();
            // ScreenPick.Setup();
            UtilityRoot.Add(ScreenPick);
            // ScreenPick.Deletable = false;

            MShader debugDepthQuad = new MShader("debugDepthQuad");

            debugDepthQuad.Load("debug_quad_v.glsl",
                                "debug_quad_f.glsl",
                                "Terrain\\eval.glsl", "Terrain\\control.glsl");
            debugDepthQuad.Bind();
            debugDepthQuad.SetInt("depthMap", 0);
            //debugDepthQuad.SetFloat("near_plane", light.NearPlane);
            //debugDepthQuad.SetFloat("far_plane", light.FarPlane);
            UtilityRoot.Add(debugDepthQuad);
            debugDepthQuad.Deletable = false;

            MMaterial debugmat = new MMaterial("DEBUG");

            debugmat.shader = debugDepthQuad;
            //debugmat.Deletable = false;
            debugQuad          = new DebugQuad("DEBUGQUAD");
            debugQuad.material = debugmat;
            UtilityRoot.Add(debugQuad);
            debugQuad.Deletable = false;

            GUIRoot = new MGUI();
            Root.Add(GUIRoot);
            Helper.CheckGLError(this, "TestPoint 6");
        }