示例#1
0
            void Init()
            {
                texture               = ComponentUtility.CreateComponent <Component_Image>(null, true, false);
                texture.CreateType    = Component_Image.TypeEnum._2D;
                texture.CreateSize    = imageSizeRender;             // new Vector2I( imageSizeRender, imageSizeRender );
                texture.CreateMipmaps = false;
                texture.CreateFormat  = imageFormat;
                texture.CreateUsage   = Component_Image.Usages.RenderTarget;
                texture.CreateFSAA    = 0;
                texture.Enabled       = true;

                var renderTexture = texture.Result.GetRenderTarget(0, 0);

                viewport = renderTexture.AddViewport(false, true);
                viewport.AllowRenderScreenLabels = false;

                //viewport.UpdateBegin += Viewport_UpdateBegin;

                textureRead               = ComponentUtility.CreateComponent <Component_Image>(null, true, false);
                textureRead.CreateType    = Component_Image.TypeEnum._2D;
                textureRead.CreateSize    = texture.CreateSize;
                textureRead.CreateMipmaps = false;
                textureRead.CreateFormat  = texture.CreateFormat;
                textureRead.CreateUsage   = Component_Image.Usages.ReadBack | Component_Image.Usages.BlitDestination;
                textureRead.CreateFSAA    = 0;
                textureRead.Enabled       = true;
                //!!!!
                textureRead.Result.PrepareNativeObject();

                var imageDataBytes = PixelFormatUtility.GetNumElemBytes(imageFormat) * imageSizeRender.X * imageSizeRender.Y;

                imageData = NativeUtility.Alloc(NativeUtility.MemoryAllocationType.Utility, imageDataBytes);
            }
示例#2
0
        public static void Scale(byte[] data, Vector2I size, PixelFormat format, Vector2I newSize, Filters filter, out byte[] newData)
        {
            newData = new byte[newSize.X * newSize.Y * PixelFormatUtility.GetNumElemBytes(format)];

            unsafe
            {
                fixed(byte *pData = data, pNewData = newData)
                {
                    OgreImageManager.scale(RenderingSystem.realRoot, (IntPtr)pData, size.X, size.Y, format, newSize.X, newSize.Y, filter, (IntPtr)pNewData);
                }
            }
        }
示例#3
0
            //

            public Image2D(PixelFormat format, Vector2I size, byte[] data = null)
            {
                this.format = format;
                this.size   = size;
                this.data   = data;

                var sizeInBytes = TotalPixels * PixelFormatUtility.GetNumElemBytes(format);

                if (data != null)
                {
                    if (data.Length != sizeInBytes)
                    {
                        Log.Fatal("ImageUtility: Image2D: Constructor: data.Length != TotalPixels * PixelFormatUtility.GetNumElemBytes( format ).");
                    }
                }
                else
                {
                    this.data = new byte[sizeInBytes];
                }
            }
        public void UpdateCaptureCubemap()
        {
            if (Mode.Value != ModeEnum.Capture)
            {
                return;
            }

            Component_Image texture     = null;
            Component_Image textureRead = null;

            try
            {
                //create

                var resolution = Resolution.Value;
                var hdr        = HDR.Value;

                var size = int.Parse(resolution.ToString().Replace("_", ""));
                //!!!!16 бит достаточно, тогда нужно поддержку для Image2D
                PixelFormat format = hdr ? PixelFormat.Float32RGBA : PixelFormat.A8R8G8B8;
                //PixelFormat format = hdr ? PixelFormat.Float16RGBA : PixelFormat.A8R8G8B8;

                texture               = ComponentUtility.CreateComponent <Component_Image>(null, true, false);
                texture.CreateType    = Component_Image.TypeEnum._2D;
                texture.CreateSize    = new Vector2I(size, size);
                texture.CreateMipmaps = false;
                texture.CreateFormat  = format;
                texture.CreateUsage   = Component_Image.Usages.RenderTarget;
                texture.CreateFSAA    = 0;
                texture.Enabled       = true;

                var renderTexture = texture.Result.GetRenderTarget(0, 0);
                //!!!!
                var viewport = renderTexture.AddViewport(true, false);
                //var viewport = renderTexture.AddViewport( false, false );
                viewport.Mode          = Viewport.ModeEnum.ReflectionProbeCubemap;
                viewport.AttachedScene = ParentScene;

                textureRead               = ComponentUtility.CreateComponent <Component_Image>(null, true, false);
                textureRead.CreateType    = Component_Image.TypeEnum._2D;
                textureRead.CreateSize    = new Vector2I(size, size);
                textureRead.CreateMipmaps = false;
                textureRead.CreateFormat  = format;
                textureRead.CreateUsage   = Component_Image.Usages.ReadBack | Component_Image.Usages.BlitDestination;
                textureRead.CreateFSAA    = 0;
                textureRead.Enabled       = true;
                //!!!!
                textureRead.Result.PrepareNativeObject();

                //render
                var image2D = new ImageUtility.Image2D(PixelFormat.Float32RGB, new Vector2I(size * 4, size * 3));

                var position = Transform.Value.Position;

                for (int face = 0; face < 6; face++)
                {
                    Vector3 dir = Vector3.Zero;
                    Vector3 up  = Vector3.Zero;

                    //flipped
                    switch (face)
                    {
                    case 0: dir = -Vector3.YAxis; up = Vector3.ZAxis; break;

                    case 1: dir = Vector3.YAxis; up = Vector3.ZAxis; break;

                    case 2: dir = Vector3.ZAxis; up = -Vector3.XAxis; break;

                    case 3: dir = -Vector3.ZAxis; up = Vector3.XAxis; break;

                    case 4: dir = Vector3.XAxis; up = Vector3.ZAxis; break;

                    case 5: dir = -Vector3.XAxis; up = Vector3.ZAxis; break;
                    }

                    //!!!!renderingPipelineOverride

                    var scene        = ParentScene;
                    var cameraEditor = scene.Mode.Value == Component_Scene.ModeEnum._2D ? scene.CameraEditor2D.Value : scene.CameraEditor.Value;
                    if (cameraEditor == null)
                    {
                        cameraEditor = new Component_Camera();
                    }

                    var cameraSettings = new Viewport.CameraSettingsClass(viewport, 1, 90, NearClipPlane.Value, FarClipPlane.Value, position, dir, up, ProjectionType.Perspective, 1, cameraEditor.Exposure, cameraEditor.EmissiveFactor, renderSky: RenderSky);

                    viewport.Update(true, cameraSettings);

                    //clear temp data
                    viewport.RenderingContext.MultiRenderTarget_DestroyAll();
                    viewport.RenderingContext.DynamicTexture_DestroyAll();

                    texture.Result.GetRealObject(true).BlitTo(viewport.RenderingContext.CurrentViewNumber, textureRead.Result.GetRealObject(true), 0, 0);

                    //get data
                    var totalBytes = PixelFormatUtility.GetNumElemBytes(format) * size * size;
                    var data       = new byte[totalBytes];
                    unsafe
                    {
                        fixed(byte *pBytes = data)
                        {
                            var demandedFrame = textureRead.Result.GetRealObject(true).Read((IntPtr)pBytes, 0);

                            while (RenderingSystem.CallBgfxFrame() < demandedFrame)
                            {
                            }
                        }
                    }

                    Vector2I index = Vector2I.Zero;
                    switch (face)
                    {
                    case 1: index = new Vector2I(2, 1); break;

                    case 0: index = new Vector2I(0, 1); break;

                    case 2: index = new Vector2I(1, 0); break;

                    case 3: index = new Vector2I(1, 2); break;

                    case 4: index = new Vector2I(1, 1); break;

                    case 5: index = new Vector2I(3, 1); break;
                    }
                    //switch( face )
                    //{
                    //case 0: index = new Vector2I( 2, 1 ); break;
                    //case 1: index = new Vector2I( 0, 1 ); break;
                    //case 2: index = new Vector2I( 1, 0 ); break;
                    //case 3: index = new Vector2I( 1, 2 ); break;
                    //case 4: index = new Vector2I( 1, 1 ); break;
                    //case 5: index = new Vector2I( 3, 1 ); break;
                    //}

                    var faceImage = new ImageUtility.Image2D(format, new Vector2I(size, size), data);

                    //flip by X
                    var faceImageFlip = new ImageUtility.Image2D(format, new Vector2I(size, size));
                    for (int y = 0; y < size; y++)
                    {
                        for (int x = 0; x < size; x++)
                        {
                            var pixel = faceImage.GetPixel(new Vector2I(x, y));
                            faceImageFlip.SetPixel(new Vector2I(size - 1 - x, y), pixel);
                        }
                    }

                    image2D.Blit(index * size, faceImageFlip);
                }

                //reset alpha channel
                for (int y = 0; y < image2D.Size.Y; y++)
                {
                    for (int x = 0; x < image2D.Size.X; x++)
                    {
                        var pixel = image2D.GetPixel(new Vector2I(x, y));
                        pixel.W = 1.0f;
                        image2D.SetPixel(new Vector2I(x, y), pixel);
                    }
                }

                var destRealFileName = VirtualPathUtility.GetRealPathByVirtual(GetDestVirtualFileName());

                if (!Directory.Exists(Path.GetDirectoryName(destRealFileName)))
                {
                    Directory.CreateDirectory(Path.GetDirectoryName(destRealFileName));
                }

                if (!ImageUtility.Save(destRealFileName, image2D.Data, image2D.Size, 1, image2D.Format, 1, 0, out var error))
                {
                    throw new Exception(error);
                }

                //delete Gen files
                var names = new string[] { "_Gen.info", "_GenEnv.dds", "_GenIrr.dds" };
                foreach (var name in names)
                {
                    var fileName2 = VirtualPathUtility.GetRealPathByVirtual(destRealFileName + name);
                    if (File.Exists(fileName2))
                    {
                        File.Delete(fileName2);
                    }
                }
            }
            catch (Exception e)
            {
                Log.Error(e.Message);
            }
            finally
            {
                texture?.Dispose();
                textureRead?.Dispose();
            }

            processedCubemapNeedUpdate = true;
        }