public void Render(Matrix4 viewMatrix, Matrix4 projectionMatrix)
        {
            if (bPostConstructor)
            {
                shader  = PoolProxy.GetResource <ObtainShaderPool, ShaderAllocationPolicy <SkyboxShader>, string, SkyboxShader>(String.Format("{0}{1},{0}{2}", ProjectFolders.ShadersPath, "skyboxVS.glsl", "skyboxFS.glsl"));
                model   = new RawModel(attribs);
                cubemap = ProxyTextureLoader.LoadCubemap(new string[] {
                    ProjectFolders.SkyboxTexturesPath + "/Day/" + "right.bmp",
                    ProjectFolders.SkyboxTexturesPath + "/Day/" + "left.bmp",
                    ProjectFolders.SkyboxTexturesPath + "/Day/" + "top.bmp",
                    ProjectFolders.SkyboxTexturesPath + "/Day/" + "bottom.bmp",
                    ProjectFolders.SkyboxTexturesPath + "/Day/" + "back.bmp",
                    ProjectFolders.SkyboxTexturesPath + "/Day/" + "front.bmp"
                });


                bPostConstructor = false;
            }

            shader.startProgram();
            cubemap.BindTexture(OpenTK.Graphics.OpenGL.TextureUnit.Texture0);
            shader.SetTransformationMatrices(Matrix4.Identity, viewMatrix, projectionMatrix);
            shader.SetCubemap(0);
            VAOManager.renderBuffers(model.Buffer, OpenTK.Graphics.OpenGL.PrimitiveType.Triangles);
            shader.stopProgram();
        }
        public SkyboxRenderer(SkyboxShader _shader, Matrix4 projectionMatrix)
        {
            start           = Settings.GetSetting(Settings.ConfigSettings.SKYBOX_FILE_PREFIX);
            cube            = Loader.LoadToVAO(VERTICES, 3);
            skyboxTextureID = Loader.LoadCubeMap(TEXTURES_FILES, start);

            shader = _shader;
            shader.Start();
            shader.LoadProjectionMatrix(projectionMatrix);
            shader.Stop();
        }
        public Skybox(float size = 10.0f)
        {
            SkyboxVertices = new[] {
                // positions
                -size, size, -size,
                -size, -size, -size,
                size, -size, -size,
                size, -size, -size,
                size, size, -size,
                -size, size, -size,

                -size, -size, size,
                -size, -size, -size,
                -size, size, -size,
                -size, size, -size,
                -size, size, size,
                -size, -size, size,

                size, -size, -size,
                size, -size, size,
                size, size, size,
                size, size, size,
                size, size, -size,
                size, -size, -size,

                -size, -size, size,
                -size, size, size,
                size, size, size,
                size, size, size,
                size, -size, size,
                -size, -size, size,

                -size, size, -size,
                size, size, -size,
                size, size, size,
                size, size, size,
                -size, size, size,
                -size, size, -size,

                -size, -size, -size,
                -size, -size, size,
                size, -size, -size,
                size, -size, -size,
                -size, -size, size,
                size, -size, size
            };

            SkyboxShaders = new SkyboxShader();
            CreateSkybox();
        }
Exemple #4
0
        public void Initiliaze(Camera camera)
        {
            entityShader  = new EntityShader();
            terrainShader = new TerrainShader();
            shaderUI      = new SpriteShader();
            textShader    = new TextShader();
            skyboxShader  = new SkyboxShader();

            entityRenderer  = new EntityRenderer(entityShader);
            terrainRenderer = new TerrainRenderer(terrainShader);
            spriteRenderer  = new SpriteRenderer(shaderUI);
            textRenderer    = new TextRenderer(textShader);
            skyboxRenderer  = new SkyboxRenderer(skyboxShader, camera.GetProjectionMatrix());
        }
Exemple #5
0
        public SkyboxRenderer()
        {
            List <RawQuad> quads = new List <RawQuad>();

            for (int i = 0; i < VERTICES.Length; i += 18)
            {
                float[] vertices = new float[18];

                for (int j = 0; j < 18; j++)
                {
                    vertices[j] = VERTICES[i + j];
                }

                quads.Add(new RawQuad(vertices));
            }

            cube    = GraphicsManager.loadModelToVAO(quads, 3);
            texture = GraphicsManager.loadCubeMap();
            shader  = new SkyboxShader();
        }
        public void Render(Matrix4 viewMatrix, Matrix4 projectionMatrix)
        {
            if (bPostConstructor)
            {
                model   = new RawModel(attribs);
                shader  = new SkyboxShader(Environment.CurrentDirectory + "/../../Shaders/skyboxVS.glsl", Environment.CurrentDirectory + "/../../Shaders/skyboxFS.glsl");
                cubemap = ProxyTextureLoader.LoadCubemap(new string[] {
                    Environment.CurrentDirectory + "/../../Textures/Right.bmp",
                    Environment.CurrentDirectory + "/../../Textures/Left.bmp",
                    Environment.CurrentDirectory + "/../../Textures/top.bmp",
                    Environment.CurrentDirectory + "/../../Textures/bottom.bmp",
                    Environment.CurrentDirectory + "/../../Textures/Back.bmp",
                    Environment.CurrentDirectory + "/../../Textures/Front.bmp"
                });
                bPostConstructor = false;
            }

            shader.startProgram();
            cubemap.BindTexture(OpenTK.Graphics.OpenGL.TextureUnit.Texture0);
            shader.SetTransformationMatrices(viewMatrix, projectionMatrix);
            shader.SetCubemap(0);
            VAOManager.renderBuffers(model.Buffer, OpenTK.Graphics.OpenGL.PrimitiveType.Triangles);
            shader.stopProgram();
        }
Exemple #7
0
        /// <summary>
        /// Отрисовка скайбокса
        /// </summary>
        internal void Render()
        {
            // Создание массивов
            if (vertices == null || coords == null || indices == null)
            {
                // Вершины
                vertices = new float[] {
                    -5f, 5f, -5f,
                    5f, 5f, -5f,
                    -5f, -5f, -5f,
                    5f, -5f, -5f
                };

                // Текстурные координаты
                coords = new float[] {
                    0f, 0f,
                    1f, 0f,
                    0f, 1f,
                    1f, 1f
                };

                // Индексы
                indices = new ushort[] {
                    2, 1, 0,
                    2, 3, 1
                };

                // Проверка буфферов
                if (GraphicalCaps.ShaderPipeline)
                {
                    // Индексный буффер
                    if (indexBuffer == 0)
                    {
                        indexBuffer = GL.GenBuffer();
                        GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexBuffer);
                        GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(indices.Length * 2), indices, BufferUsageHint.StaticDraw);
                        GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
                    }

                    // Вершинный буффер
                    if (vertexBuffer == 0)
                    {
                        vertexBuffer = GL.GenBuffer();
                        GL.BindBuffer(BufferTarget.ArrayBuffer, vertexBuffer);
                        GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * 4), vertices, BufferUsageHint.StaticDraw);
                        GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
                    }

                    // Координатный буффер
                    if (texCoordBuffer == 0)
                    {
                        texCoordBuffer = GL.GenBuffer();
                        GL.BindBuffer(BufferTarget.ArrayBuffer, texCoordBuffer);
                        GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(coords.Length * 4), coords, BufferUsageHint.StaticDraw);
                        GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
                    }
                }
            }

            // Установка данных
            if (GraphicalCaps.ShaderPipeline)
            {
                // Включение шейдера
                SkyboxShader shader = SkyboxShader.Shader;
                shader.DiffuseColor = Diffuse;
                shader.Bind();

                // Включение буфферов
                GL.BindBuffer(BufferTarget.ArrayBuffer, vertexBuffer);
                GL.VertexAttribPointer(shader.VertexBufferLocation, 3, VertexAttribPointerType.Float, false, 0, 0);
                GL.BindBuffer(BufferTarget.ArrayBuffer, texCoordBuffer);
                GL.VertexAttribPointer(shader.TexCoordBufferLocation, 2, VertexAttribPointerType.Float, false, 0, 0);
                GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexBuffer);

                for (int i = 0; i < 6; i++)
                {
                    if (textures[i] != null)
                    {
                        ShaderSystem.EntityMatrix = matrices[i];
                        textures[i].Bind();
                        shader.Bind();
                        GL.DrawElements(BeginMode.Triangles, indices.Length, DrawElementsType.UnsignedShort, 0);
                    }
                }

                // Отключение шейдера
                shader.Unbind();
            }
            else
            {
                // Включение массивов
                GL.EnableClientState(ArrayCap.VertexArray);
                GL.EnableClientState(ArrayCap.TextureCoordArray);

                GL.VertexPointer(3, VertexPointerType.Float, 0, vertices);
                GL.TexCoordPointer(2, TexCoordPointerType.Float, 0, coords);

                // Отрисовка сторон
                GL.Color3(Diffuse);
                for (int i = 0; i < 6; i++)
                {
                    if (textures[i] != null)
                    {
                        textures[i].Bind();
                        GL.PushMatrix();
                        GL.MultMatrix(ref matrices[i]);
                        GL.DrawElements(BeginMode.Triangles, indices.Length, DrawElementsType.UnsignedShort, indices);
                        GL.PopMatrix();
                    }
                }

                // Отключение массивов
                GL.DisableClientState(ArrayCap.TextureCoordArray);
                GL.DisableClientState(ArrayCap.VertexArray);
            }
        }
Exemple #8
0
        static void Main(string[] args)
        {
            Window w = new Window(1920, 1080);

            EngineCore.AddImage("default.png", "default");

            DefaultShader ds            = new DefaultShader("default.vert", "default.frag");
            String        defaultShader = EngineCore.AddShader(ds, "Default");

            GUIShader gui       = new GUIShader("gui.vert", "gui.frag");
            String    guiShader = EngineCore.AddShader(gui, "GUI");

            WaterShader water       = new WaterShader("water.vert", "water.frag");
            String      waterShader = EngineCore.AddShader(water, "Water");

            SkyboxShader skybox       = new SkyboxShader("skybox.vert", "skybox.frag");
            String       skyboxShader = EngineCore.AddShader(skybox, "Skybox");

            ShadowShader shadow       = new ShadowShader("shadow.vert", "shadow.frag");
            String       shadowShader = EngineCore.AddShader(shadow, "Shadow");

            TerrainShader terrain       = new TerrainShader("terrain.vert", "terrain.frag");
            String        terrainShader = EngineCore.AddShader(terrain, "Terrain");


            String cubeModel    = EngineCore.AddModel("cubeything.obj", "cube");
            String terrainModel = EngineCore.AddModel("terrain.obj", "terrain");
            String quad         = EngineCore.AddModel("quad.obj", "Quad");
            String cubeObj      = EngineCore.AddModel("cube.obj", "Cube");

            EngineCore.AddModel("tree.obj", "tree");
            EngineCore.AddModel("rock.obj", "rock");



            Light l = new Light(new Vector3(0, 3, 0), System.Drawing.Color.White);

            ds.lights.Add(l);
            terrain.lights.Add(l);

            Light l2 = new Light(new Vector3(0, 10, 0), System.Drawing.Color.White);

            water.lights.Add(l2);

            EngineCore.AddImage("tree.png", "treeImg");
            EngineCore.AddImage("rock.png", "rockImg");

            String boatObj = EngineCore.AddModel("boat.obj", "Boat");

            EngineCore.AddImage("boards.jpg", "Boards");
            Boat boat = new Boat(new Vector3(2, 0.2f, 2), new Vector3(0, 34, 0), new Vector3(0.25f, 0.25f, 0.25f), "Boards");

            EngineCore.AddObject("Boat", boat);

            String  ground     = EngineCore.AddImage("grass.jpg", "Ground");
            Terrain terrainObj = new Terrain("New Terrain", "Ground", "heightMap.png");

            EngineCore.AddObject("Terrain", terrainObj);

            EngineCore.AddImage("dudv.png", "DuDvMap");
            EngineCore.AddImage("normal.png", "NormalMap");
            Water waterObj = new Water(new Vector3(0, 0.25f, 0), System.Drawing.Color.Blue, new Vector2(1920, 1080), "DuDvMap", new Vector3(10, 10, 10));

            waterObj.AttachNormalMap("NormalMap");
            EngineCore.AddObject("water", waterObj);

            EngineCore.AddSkybox(new string[] { "Skybox/xpos.png",
                                                "Skybox/xneg.png",
                                                "Skybox/ypos.png",
                                                "Skybox/yneg.png",
                                                "Skybox/zpos.png",
                                                "Skybox/zneg.png" }, "Skybox", 500);

            w.Run();
        }