Beispiel #1
0
        protected override void OnEnabledInHierarchyChanged()
        {
            base.OnEnabledInHierarchyChanged();

            if (EnabledInHierarchy)
            {
                //get free camera initial settings
                if (EngineApp.ApplicationType == EngineApp.ApplicationTypeEnum.Simulation)
                {
                    var scene = Parent as Component_Scene;
                    if (scene != null)
                    {
                        Component_Camera camera = scene.CameraDefault;
                        if (camera == null)
                        {
                            camera = scene.Mode.Value == Component_Scene.ModeEnum._2D ? scene.CameraEditor2D : scene.CameraEditor;
                        }

                        if (camera != null)
                        {
                            var tr = camera.TransformV;
                            freeCameraPosition  = tr.Position;
                            freeCameraDirection = SphericalDirection.FromVector(tr.Rotation.GetForward());
                        }
                    }
                }
            }
        }
Beispiel #2
0
            //

            public CameraSettingsClass(Viewport viewport, Component_Camera camera, bool frustumCullingTest = false)
            {
                //!!!!reflection

                Transform t = camera.Transform;

                Init(viewport, /*camera, */ frustumCullingTest, camera.AspectRatio, camera.FieldOfView, camera.NearClipPlane, camera.FarClipPlane, t.Position, t.Rotation.GetForward() /* camera.Direction*/, camera.FixedUp, camera.Projection, camera.Height, camera.Exposure, camera.EmissiveFactor, false, new Plane(), camera.RenderingPipelineOverride, true);
            }
Beispiel #3
0
        public virtual Viewport.CameraSettingsClass GetCameraSettings(Viewport viewport, Component_Camera cameraDefault)
        {
            Viewport.CameraSettingsClass result = null;
            GetCameraSettingsEvent?.Invoke(this, viewport, cameraDefault, ref result);

            if (result == null)
            {
                if (FreeCamera)
                {
                    //free camera

                    result = new Viewport.CameraSettingsClass(viewport, cameraDefault.AspectRatio, cameraDefault.FieldOfView, cameraDefault.NearClipPlane, cameraDefault.FarClipPlane, freeCameraPosition, freeCameraDirection.GetVector(), Vector3.ZAxis, ProjectionType.Perspective, 1, cameraDefault.Exposure, cameraDefault.EmissiveFactor);
                }
                else if (UseBuiltInCamera.Value == BuiltInCameraEnum.FirstPerson)
                {
                    //first person camera

                    //Character
                    var character = ObjectControlledByPlayer.Value as Component_Character;
                    if (character != null)
                    {
                        character.GetFirstPersonCameraPosition(out var position, out var forward, out var up);

                        var eyePosition = character.TransformV * character.EyePosition.Value;
                        var direction   = character.LookToDirection.GetVector();

                        result = new Viewport.CameraSettingsClass(viewport, cameraDefault.AspectRatio, cameraDefault.FieldOfView, cameraDefault.NearClipPlane, cameraDefault.FarClipPlane, eyePosition, direction, up, ProjectionType.Perspective, 1, cameraDefault.Exposure, cameraDefault.EmissiveFactor);
                    }
                }
                else if (UseBuiltInCamera.Value == BuiltInCameraEnum.ThirdPerson)
                {
                    //third person camera

                    //Character
                    if (Scene.Mode.Value == Component_Scene.ModeEnum._3D)
                    {
                        var character = ObjectControlledByPlayer.Value as Component_Character;
                        if (character != null)
                        {
                            var lookAt = character.TransformV.Position;

                            var d         = new SphericalDirection(MathEx.DegreeToRadian(ThirdPersonCameraHorizontalAngle.Value), MathEx.DegreeToRadian(ThirdPersonCameraVerticalAngle.Value));
                            var direction = -d.GetVector();

                            var from = lookAt - direction * ThirdPersonCameraDistance.Value;

                            result = new Viewport.CameraSettingsClass(viewport, cameraDefault.AspectRatio, cameraDefault.FieldOfView, cameraDefault.NearClipPlane, cameraDefault.FarClipPlane, from, direction, Vector3.ZAxis, ProjectionType.Perspective, 1, cameraDefault.Exposure, cameraDefault.EmissiveFactor);
                        }
                    }

                    //Character2D
                    if (Scene.Mode.Value == Component_Scene.ModeEnum._2D)
                    {
                        var character = ObjectControlledByPlayer.Value as Component_Character2D;
                        if (character != null)
                        {
                            var lookAt = character.TransformV.Position;
                            var from   = lookAt + new Vector3(0, 0, 10);

                            result = new Viewport.CameraSettingsClass(viewport, cameraDefault.AspectRatio, cameraDefault.FieldOfView, cameraDefault.NearClipPlane, cameraDefault.FarClipPlane, from, -Vector3.ZAxis, Vector3.YAxis, ProjectionType.Orthographic, cameraDefault.Height, cameraDefault.Exposure, cameraDefault.EmissiveFactor);
                        }
                    }
                }
            }

            //Component_CameraManagement
            if (result == null)
            {
                var m = GetCurrentCameraManagement();
                if (m != null)
                {
                    result = m.GetCameraSettings(this, viewport, cameraDefault);
                }
            }

            return(result);
        }
Beispiel #4
0
            protected virtual void Scene_ViewportUpdateGetCameraSettings(Component_Scene scene, Viewport viewport, ref bool processed)
            {
                //copy from Mesh document window code

                //var camera = scene.CameraEditor.Value;
                var bounds       = scene.CalculateTotalBoundsOfObjectsInSpace();
                var cameraLookTo = bounds.GetCenter();

                double maxGararite = Math.Max(Math.Max(bounds.GetSize().X, bounds.GetSize().Y), bounds.GetSize().Z);
                double distance    = maxGararite * 2;             // 2.3;

                if (distance < 2)
                {
                    distance = 2;
                }

                double             cameraZoomFactor = 1;
                SphericalDirection cameraDirection  = new SphericalDirection(-3.83, -.47);

                var cameraPosition = cameraLookTo - cameraDirection.GetVector() * distance * cameraZoomFactor;
                var center         = cameraLookTo; // GetSceneCenter();

                Vector3 from = cameraPosition;     //center + cameraDirection.GetVector() * cameraDistance;
                Vector3 to   = center;
                Degree  fov  = 65;                 // 75;

                var camera = new Component_Camera();

                //camera.AspectRatio = (double)ViewportControl.Viewport.SizeInPixels.X / (double)ViewportControl.Viewport.SizeInPixels.Y;
                camera.FieldOfView   = fov;
                camera.NearClipPlane = Math.Max(distance / 10000, 0.01);                  //.1;
                camera.FarClipPlane  = Math.Max(1000, distance * 2);

                if (mesh.EditorCameraTransform != null)
                {
                    camera.Transform = mesh.EditorCameraTransform;
                }
                else
                {
                    camera.Transform = new Transform(from, Quaternion.LookAt((to - from).GetNormalize(), Vector3.ZAxis));
                }
                camera.FixedUp = Vector3.ZAxis;

                viewport.CameraSettings = new Viewport.CameraSettingsClass(viewport, camera);


                //if( !cameraMode2D )
                //{

                //var cameraPosition = cameraLookTo - cameraDirection.GetVector() * cameraDistance;
                //var center = cameraLookTo;

                //Vector3 from = cameraPosition;//center + cameraDirection.GetVector() * cameraDistance;
                //Vector3 to = center;
                //Degree fov = 40;//!!!! 65;// 75;

                ////!!!!
                //Component_Camera camera = new Component_Camera();
                //camera.AspectRatio = (double)viewport.SizeInPixels.X / (double)viewport.SizeInPixels.Y;
                //camera.FieldOfView = fov;
                //camera.NearClipPlane = Math.Max( cameraDistance / 10000, 0.01 );//.1;
                //camera.FarClipPlane = Math.Max( 1000, cameraDistance * 2 );

                //camera.Transform = new Transform( from, Quaternion.LookAt( ( to - from ).GetNormalize(), Vector3.ZAxis ) );
                ////camera.Position = from;
                ////camera.Direction = ( to - from ).GetNormalize();

                //camera.FixedUp = Vector3.ZAxis;
                //viewport.CameraSettings = new Viewport.CameraSettingsClass( viewport, camera );

                ////!!!!в методе больше параметров
                //double aspect = (double)viewport.SizeInPixels.X / (double)viewport.SizeInPixels.Y;
                //var settings = new Viewport.CameraSettingsClass( viewport, aspect, fov, .1f, 1000, from, ( to - from ).GetNormalize(), Vec3.ZAxis );
                //viewport.CameraSettings = settings;

                //}
                //else
                //{
                //	var from = cameraLookTo + new Vector3( 0, 0, scene.CameraEditor2DPositionZ );
                //	var to = cameraLookTo;

                //	Component_Camera camera = new Component_Camera();
                //	camera.AspectRatio = (double)viewport.SizeInPixels.X / (double)viewport.SizeInPixels.Y;
                //	camera.NearClipPlane = 0.01;// Math.Max( cameraInitialDistance / 10000, 0.01 );//.1;
                //	camera.FarClipPlane = 1000;// Math.Max( 1000, cameraInitialDistance * 2 );
                //	camera.Transform = new Transform( from, Quaternion.LookAt( ( to - from ).GetNormalize(), Vector3.YAxis ) );
                //	camera.Projection = ProjectionType.Orthographic;
                //	camera.FixedUp = Vector3.YAxis;
                //	//!!!!need consider size by X
                //	camera.Height = cameraInitBounds.GetSize().Y * 1.4;

                //	viewport.CameraSettings = new Viewport.CameraSettingsClass( viewport, camera );
                //}

                processed = true;
            }
        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;
        }
        public virtual Viewport.CameraSettingsClass GetCameraSettings(Component_GameMode gameMode, Viewport viewport, Component_Camera cameraDefault)
        {
            //event
            Viewport.CameraSettingsClass result = null;
            GetCameraSettingsEvent?.Invoke(this, gameMode, viewport, cameraDefault, ref result);

            //default behavior
            if (result == null)
            {
                result = new Viewport.CameraSettingsClass(viewport, cameraDefault.AspectRatio, cameraDefault.FieldOfView, cameraDefault.NearClipPlane, cameraDefault.FarClipPlane, gameMode.FreeCameraPosition, gameMode.FreeCameraDirection.GetVector(), Vector3.ZAxis, ProjectionType.Perspective, 1, cameraDefault.Exposure, cameraDefault.EmissiveFactor);
            }

            return(result);
        }