Exemplo n.º 1
0
            public MeshRenderRaycastInfo(Ray worldSpaceRay, MeshRenderable renderer)
            {
                this.MeshRenderable = renderer;

                var invertedModelMatrix = new Matrix(renderer.Transform.ModelMatrix);

                invertedModelMatrix.Invert();

                this.ModelSpaceRay = new Ray();

                ModelSpaceRay.Origin = Vector3
                                       .Transform(worldSpaceRay.Origin, invertedModelMatrix);
                ModelSpaceRay.Direction = Vector3
                                          .NormalTransform(worldSpaceRay.Direction, invertedModelMatrix)
                                          .Normalized;

                var modelOriginToCenter         = ModelSpaceRay.Origin - MeshRenderable.Mesh.Bounds.Center;
                var modelDistanceOriginToCenter = modelOriginToCenter.Length;
                var modelDistanceOriginToBounds = modelDistanceOriginToCenter - MeshRenderable.Mesh.Bounds.Radius;

                if (modelDistanceOriginToBounds < 0)
                {
                    DistanceToBounds = 0;
                }
                else
                {
                    var modelCenterToBounds = modelOriginToCenter * (modelDistanceOriginToBounds / modelDistanceOriginToCenter);
                    var worldCenterToBounds = Vector3.NormalTransform(modelCenterToBounds, MeshRenderable.Transform.ModelMatrix);

                    DistanceToBounds = worldCenterToBounds.Length;
                }
            }
Exemplo n.º 2
0
        private MeshRenderRaycastInfo RaycastMeshBounds(MeshRenderable renderer)
        {
            if (renderer.IsRaytracable == false)
            {
                return(null);
            }
            if (renderer.IsEnabled == false)
            {
                return(null);
            }
            if (renderer.Mesh == null)
            {
                return(null);
            }
            if (renderer.Mesh.Bounds == null)
            {
                return(null);
            }
            if (renderer.Mesh.Vertices == null)
            {
                return(null);
            }
            if (renderer.SceneObject.Layer.Intersects(_currentLayer) == false)
            {
                return(null);
            }

            if (renderer.Mesh.Type != PrimitiveType.Triangles)
            {
                Log.Warning(renderer.Mesh.Type + " is not supported for raytracing");
                return(null);
            }

            var result = new MeshRenderRaycastInfo(_worldSpaceRay, renderer);

            if (renderer.Mesh.Bounds.Sphere.FastRaycast(result.ModelSpaceRay))
            {
                return(result);
            }
            else
            {
                return(null);
            }
        }
Exemplo n.º 3
0
        protected override void OnStart()
        {
            base.OnStart();

            SceneObject.Transform.WorldRotation = new Quaternion(Vector3.UnitX, MathF.PIOver2);

            _renderer           = SceneObject.AddComponent <MeshRenderable>();
            _renderer.IsEnabled = true;

            var mesh = Plane.Create(2, 2);

            _renderer.Mesh  = mesh;
            _material       = _renderer.Material = new Material(null, DiscardFrag, RenderQueue.Opaque);
            _material.Color = Vector4.One;
            _material.SetTexture("uniform_DiscardTexture", new Texture2("Resources/Textures/1.png", false));
            _material.SetTexture("uniform_NormalTexture", new Texture2("Resources/Textures/1.png", true));
            _material.MainTexture = new Texture2("Resources/Textures/2.png", false);
            _material.SetValue("uniform_DiscardFactor", 0f);
        }