Пример #1
0
 // ######################## FUNCTIONALITY ######################## //
 private void UpdateVolumes()
 {
     foreach (Object t in targets)
     {
         ClipVolume v = t as ClipVolume;
         v.UpdateShaderValues();
     }
 }
Пример #2
0
        /// <summary>
        /// Funkce pro obnoveni obrazu
        /// </summary>
        public void UpdateLook()
        {
            if (GraphicCore.GetInitializator().IsDeviceLost())
            {
                return;
            }

            matrixProjection = Matrix.PerspectiveFovLH((float)(Math.PI / 4f), (float)dev.PresentationParameters.DeviceWindow.Width / (float)dev.PresentationParameters.DeviceWindow.Height, 5f, farDistance);
            matrixView       = Matrix.LookAtLH(position, lookAt, up);

            matrixViewProjection = matrixView * matrixProjection;

            clipVolume = ComputeClipVolume();
        }
Пример #3
0
        /// <summary>
        /// Funkce pocitaci orezavaci roviny
        /// </summary>
        /// <returns>Vraci strukturu s popisem orezavacich rovin</returns>
        private ClipVolume ComputeClipVolume()
        {
            ClipVolume clvol    = new ClipVolume();
            Matrix     multiply = Matrix.Multiply(matrixView, matrixProjection);

            //Near plane
            clvol.pNear.A = multiply.M14 + multiply.M13;
            clvol.pNear.B = multiply.M24 + multiply.M23;
            clvol.pNear.C = multiply.M34 + multiply.M33;
            clvol.pNear.D = multiply.M44 + multiply.M43;
            clvol.pNear.Normalize();

            //Far plane
            clvol.pFar.A = multiply.M14 - multiply.M13;
            clvol.pFar.B = multiply.M24 - multiply.M23;
            clvol.pFar.C = multiply.M34 - multiply.M33;
            clvol.pFar.D = multiply.M44 - multiply.M43;
            clvol.pFar.Normalize();

            //Left plane
            clvol.pLeft.A = multiply.M14 + multiply.M11;
            clvol.pLeft.B = multiply.M24 + multiply.M21;
            clvol.pLeft.C = multiply.M34 + multiply.M31;
            clvol.pLeft.D = multiply.M44 + multiply.M41;
            clvol.pLeft.Normalize();

            //Right plane
            clvol.pRight.A = multiply.M14 - multiply.M11;
            clvol.pRight.B = multiply.M24 - multiply.M21;
            clvol.pRight.C = multiply.M34 - multiply.M31;
            clvol.pRight.D = multiply.M44 - multiply.M41;
            clvol.pRight.Normalize();

            //Top plane
            clvol.pTop.A = multiply.M14 - multiply.M12;
            clvol.pTop.B = multiply.M24 - multiply.M22;
            clvol.pTop.C = multiply.M34 - multiply.M32;
            clvol.pTop.D = multiply.M44 - multiply.M42;
            clvol.pTop.Normalize();

            //Bottom plane
            clvol.pBottom.A = multiply.M14 + multiply.M12;
            clvol.pBottom.B = multiply.M24 + multiply.M22;
            clvol.pBottom.C = multiply.M34 + multiply.M32;
            clvol.pBottom.D = multiply.M44 + multiply.M42;
            clvol.pBottom.Normalize();

            return(clvol);
        }
            public bool ComputeVisibility(ISceneCamera camera)
            {
                if (camera == null)
                {
                    this.visible = true;
                    return(true);
                }

                ClipVolume cv = camera.GetClipVolume();

                Plane[] p = new Plane[] { cv.pNear, cv.pFar, cv.pLeft, cv.pRight, cv.pTop, cv.pBottom };

                for (int k = 0; k < p.Length; k++)
                {
                    if (p[k].Dot(this.boundingSphereCenter) + this.radius < 0)
                    {
                        this.visible = false;
                        return(this.visible);
                    }
                }

                this.visible = true;
                return(this.visible);
            }