public void CreateMaterialRender(GLContext control, GenericPickableMesh mesh,
                                         RenderObject renderObject, EventHandler thumbnailUpdated, int width = 50, int height = 50)
        {
            ShaderProgram shader = this.GetShader();

            if (shader == null)
            {
                return;
            }

            Framebuffer frameBuffer = new Framebuffer(FramebufferTarget.Framebuffer, width, height);

            frameBuffer.Bind();

            //Create a simple mvp matrix to render the material data
            Matrix4 modelMatrix = Matrix4.CreateTranslation(0, 0, -12);
            Matrix4 viewMatrix  = Matrix4.Identity;
            Matrix4 mtxProj     = Matrix4.CreatePerspectiveFieldOfView(MathHelper.DegreesToRadians(90), 1.0f, 1.0f, 1000f);
            Matrix4 viewProj    = mtxProj * viewMatrix;

            GL.UseProgram(shader.program);
            shader.SetMatrix4x4("mtxCam", ref viewProj);
            shader.SetMatrix4x4("mtxMdl", ref modelMatrix);
            shader.SetVector3("camPosition", control.Camera.TargetPosition);
            shader.SetVector2("iResolution", new Vector2(control.Width, control.Height));
            shader.SetInt("materialRenderDisplay", 1);

            GL.ClearColor(0, 0, 0, 0);
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
            GL.Viewport(0, 0, width, height);

            //Render material data onto a textured sphere
            Render(control, shader, mesh);

            GL.Enable(EnableCap.Blend);
            GL.BlendFuncSeparate(
                BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha,
                BlendingFactorSrc.One, BlendingFactorDest.OneMinusSrcAlpha);

            //Draw the model to render onto
            switch (renderObject)
            {
            case RenderObject.Sphere:
                DrawSphere(control);
                break;

            case RenderObject.Plane:
                DrawPlane(control);
                break;
            }

            //Disable the uniform data
            shader.SetInt("materialRenderDisplay", 0);

            //Disable shader and textures
            GL.UseProgram(0);
            GL.BindTexture(TextureTarget.Texture2D, 0);

            var thumbnail = frameBuffer.ReadImagePixels(true);

            //Dispose frame buffer
            frameBuffer.Dispoe();
            frameBuffer.DisposeRenderBuffer();

            this.Thumbnail = thumbnail;
            thumbnailUpdated?.Invoke(this, EventArgs.Empty);
        }
        public static GLTexture2D CreateTextureRender(GLTexture texture, int arrayLevel, int mipLevel, bool force = false)
        {
            if (!force && cubemapCache.ContainsKey(texture.ID.ToString()))
            {
                return(cubemapCache[texture.ID.ToString()]);
            }
            else
            {
                if (cubemapCache.ContainsKey(texture.ID.ToString()))
                {
                    cubemapCache[texture.ID.ToString()]?.Dispose();
                }
            }

            int width  = texture.Width * 4;
            int height = texture.Height * 3;

            width  = 512;
            height = 256;

            var shader        = GlobalShaders.GetShader("EQUIRECTANGULAR");
            var textureOutput = GLTexture2D.CreateUncompressedTexture(width, height, PixelInternalFormat.Rgba32f);

            textureOutput.MipCount = texture.MipCount;

            texture.Bind();

            textureOutput.Bind();
            textureOutput.GenerateMipmaps();
            textureOutput.Unbind();

            Framebuffer frameBuffer = new Framebuffer(FramebufferTarget.Framebuffer, width, height);

            frameBuffer.Bind();

            GL.Disable(EnableCap.Blend);

            shader.Enable();
            shader.SetBoolToInt("is_array", texture is GLTextureCubeArray);

            if (texture is GLTextureCubeArray)
            {
                GL.ActiveTexture(TextureUnit.Texture1);
                texture.Bind();
                shader.SetInt("dynamic_texture_array", 1);
            }
            else
            {
                GL.ActiveTexture(TextureUnit.Texture1);
                texture.Bind();
                shader.SetInt("dynamic_texture", 1);
            }

            for (int i = 0; i < textureOutput.MipCount; i++)
            {
                int mipWidth  = (int)(width * Math.Pow(0.5, i));
                int mipHeight = (int)(height * Math.Pow(0.5, i));
                frameBuffer.Resize(mipWidth, mipHeight);

                GL.FramebufferTexture(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0,
                                      textureOutput.ID, i);

                shader.SetInt("arrayLevel", arrayLevel);
                shader.SetInt("mipLevel", mipLevel);

                GL.ClearColor(0, 0, 0, 0);
                GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
                GL.Viewport(0, 0, mipWidth, mipHeight);

                //Draw the texture onto the framebuffer
                ScreenQuadRender.Draw();

                break;
            }

            //Disable shader and textures
            GL.UseProgram(0);
            GL.BindTexture(TextureTarget.Texture2D, 0);

            if (cubemapCache.ContainsKey(texture.ID.ToString()))
            {
                cubemapCache[texture.ID.ToString()] = textureOutput;
            }
            else
            {
                cubemapCache.Add(texture.ID.ToString(), textureOutput);
            }
            return(textureOutput);
        }
예제 #3
0
 public void Attach(FramebufferAttachment attachment, Framebuffer target)
 {
     target.Bind();
     GL.FramebufferRenderbuffer(target.Target, attachment, RenderbufferTarget.Renderbuffer, ID);
 }
예제 #4
0
 public virtual void Attach(FramebufferAttachment attachment, Framebuffer target)
 {
     target.Bind();
     GL.FramebufferTexture(target.Target, attachment, ID, 0);
 }