public static void CreateLightmapTexture(GLContext control, AglLightMap aglLightMap,
                                                 EnvironmentGraphics environmentSettings, string name, GLTextureCube output)
        {
            var lightMapEnv = aglLightMap.LightAreas.FirstOrDefault(x => x.Settings.Name == name);

            if (lightMapEnv == null)
            {
                return;
            }

            //Force generate mipmaps to update the mip allocation so mips can be assigned.
            output.Bind();
            GL.GenerateMipmap(GenerateMipmapTarget.TextureCubeMap);
            GL.BindTexture(TextureTarget.TextureCubeMap, 0);
            GL.Enable(EnableCap.TextureCubeMapSeamless);

            if (FilterLevel0 == null)
            {
                Init(output.Width);
            }

            int CUBE_SIZE = output.Width;

            FilterLevel0.Bind();
            LoadCubemapLevel(control, CUBE_SIZE, 0, aglLightMap, environmentSettings, lightMapEnv, output.ID);
            FilterLevel0.Unbind();

            FilterLevel1.Bind();
            LoadCubemapLevel(control, CUBE_SIZE / 2, 1, aglLightMap, environmentSettings, lightMapEnv, output.ID);
            FilterLevel1.Unbind();

            output.SaveDDS($"LIGHTMAP{name}.dds");
        }
        //Update all existing cubemap uint objects
        public static void GenerateCubemaps(List <GenericRenderer> targetModels, bool isWiiU)
        {
            var texture = isWiiU ? CubeMapTextureArray : CubeMapTexture;

            if (texture != null)
            {
                texture.Dispose();
            }

            if (isWiiU)
            {
                texture = GLTexture2DArray.CreateUncompressedTexture(CUBEMAP_SIZE, CUBEMAP_SIZE, MAX_LAYER_COUNT * 6, MAX_MIP_LEVEL,
                                                                     PixelInternalFormat.Rgba16f, PixelFormat.Rgba, PixelType.Float);
            }
            else
            {
                texture = GLTextureCubeArray.CreateEmptyCubemap(CUBEMAP_SIZE, MAX_LAYER_COUNT, MAX_MIP_LEVEL,
                                                                PixelInternalFormat.Rgba16f, PixelFormat.Rgba, PixelType.Float);
            }

            GLTextureCube cubemapTexture = GLTextureCube.CreateEmptyCubemap(
                CUBEMAP_UPSCALE_SIZE, PixelInternalFormat.Rgba16f, PixelFormat.Rgba, PixelType.Float, 9);

            //Get a list of cubemaps in the scene
            //The lighting engine has cube map objects with the object placement to draw
            var lightingEngine   = LightingEngine.LightSettings;
            var cubemapEnvParams = lightingEngine.Resources.CubeMapFiles.FirstOrDefault().Value;
            var cubeMapUints     = cubemapEnvParams.CubeMapObjects;
            int layer            = 0;

            foreach (var cubeMap in cubeMapUints)
            {
                var cUint = cubeMap.CubeMapUint;
                //Cubemap has no area assigned skip it
                if (cubeMap.CubeMapUint.Name == string.Empty)
                {
                    continue;
                }

                //Setup the camera to render the cube map faces
                CubemapCamera camera = new CubemapCamera(
                    new Vector3(cUint.Position.X, cUint.Position.Y, cUint.Position.Z)
                    * GLContext.PreviewScale, cUint.Near, cUint.Far);

                var context = new GLContext();
                context.Camera = camera;

                GenerateCubemap(context, cubemapTexture, camera, targetModels, MAX_MIP_LEVEL);

                cubemapTexture.Bind();
                cubemapTexture.GenerateMipmaps();
                cubemapTexture.Unbind();

                //HDR encode and output into the array
                CubemapHDREncodeRT.CreateCubemap(cubemapTexture, texture, layer, MAX_MIP_LEVEL, false, true);

                if (SAVE_TO_DISK)
                {
                    cubemapTexture.SaveDDS(cubeMap.Name + "default.dds");
                }

                layer++;
            }

            cubemapTexture.Dispose();

            //Just generate mips to keep things easier
            texture.Bind();
            texture.GenerateMipmaps();
            texture.Unbind();

            if (SAVE_TO_DISK)
            {
                texture.SaveDDS("Cubemap_Array_HDR.dds");
            }

            if (isWiiU)
            {
                CubeMapTextureArray = texture;
            }
            else
            {
                CubeMapTexture = texture;
            }
        }