VolumeShader.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

namespace visLU.Effects
{
    class VolumeShader: Effect
    {

        #region variables

        GraphicsDevice device;
        Effect effect;

        private EffectParameter worldViewProjection;
        public  EffectParameter world;
        public  EffectParameter cameraPosition;
        private EffectParameter frontFaces;
        private EffectParameter backFaces;
        private EffectParameter transferValues;
        private EffectParameter transferValuesAlpha;
        private EffectParameter CVDtransferValues;
        private EffectParameter volumeTexture;
        private EffectParameter gradientTexture;
        private EffectParameter directLightPosition;
        private EffectParameter stepSize;
        private EffectParameter baseSampleDist;
        private EffectParameter sampleDist;
        private EffectParameter iterations;
        private EffectParameter side;
        private EffectParameter scaleFactor;
        private EffectParameter texSize; //correct the texture coordinates
        private EffectParameter slice;
        // boolean parameters
        private EffectParameter frontToBack; 
        private EffectParameter shading;
        private EffectParameter useAlpha;
        private EffectParameter useTransferColors;
        private EffectParameter useCVDTransferColors;

        // RGB to L*a*b*
        private EffectParameter ep_RGBtoXYZmatrix;
        private EffectParameter ep_rotation;

            // L*a*b* to RGB
        private EffectParameter ep_rotationBack;
        private EffectParameter ep_XYZtoRGBmatrix;

        private Texture3D volume;
        private Texture3D gradients;
        private Texture2D front;
        private Texture2D back;
        private Texture2D transfer;
        private Texture2D cvdTransfer;
        private Texture2D alpha;

        private Matrix rgbToXYZ;
        private Matrix xyzToRGB;

        #endregion

        #region properties

        public Texture3D VolumeTexture
        {
            get { return volume; }
            set { volume = value; }
        }

        public Texture3D GradientTexture
        {
            get { return gradients; }
            set { gradients = value; }
        }

        public Texture2D FrontFacesTexture
        {
            get { return front; }
            set { front = value; Console.WriteLine("frontfacetexture set"); }
        }

        public Texture2D BackFacesTexture
        {
            get { return back; }
            set { back = value; }
        }

        public Texture2D TransferTexture
        {
            get { return transfer; }
            set { transfer = value; }
        }

        public Texture2D TransferTextureAlpha
        {
            get { return alpha; }
            set { alpha = value; }
        }

        public Texture2D CVDTransferTexture
        {
            get { return cvdTransfer; }
            set { cvdTransfer = value; }
        }

        #endregion


        public VolumeShader(GraphicsDevice _device, Effect _effect, bool CVDon)
            : base(_effect)
        {
            if (!CVDon)
            {
                #region create normal volume shader

                Console.WriteLine("creating shader");
                device = _device;
                effect = _effect;

                // WorldViewProjection
                worldViewProjection = this.Parameters["myWorldViewProjectionMatrix"];

                // WorldProjection
                world = this.Parameters["myWorldMatrix"];

                // Position of Camera
                cameraPosition = this.Parameters["CameraPosition"];

                // Texture for FrontFaces
                frontFaces = this.Parameters["Front"];

                // Texture for Backfaces
                backFaces = this.Parameters["Back"];

                // Texture for Transferfunction
                transferValues = this.Parameters["Transfer"];

                // Texture for Transferfunction
                transferValuesAlpha = this.Parameters["TransferAlpha"];

                // Texture for the CVD Transferfunction
                CVDtransferValues = this.Parameters["CVDTransfer"];

                // 3D Texture Volume
                volumeTexture = this.Parameters["Volume"];

                // 3D Texture Volume
                gradientTexture = this.Parameters["Gradients"];

                //direct light position
                directLightPosition = this.Parameters["DirectLightVector"];

                // stepSize
                stepSize = this.Parameters["StepSize"];

                //base sample distance for the dataset
                baseSampleDist = this.Parameters["baseSampleDist"];

                //current sample distance tha we use
                sampleDist = this.Parameters["sampleDist"];

                // number of iterations to be done
                iterations = this.Parameters["Iterations"];

                // side TODO: find better name
                side = this.Parameters["Side"];

                // scaleFactor
                scaleFactor = this.Parameters["ScaleFactor"];

                //texture size
                texSize = this.Parameters["textureSize"];

                // slice
                slice = this.Parameters["Slice"];

                frontToBack = this.Parameters["frontToBack"];

                shading = this.Parameters["shading"];

                useAlpha = this.Parameters["useAlpha"];

                useTransferColors = this.Parameters["useTransferColors"];

                useCVDTransferColors = this.Parameters["useCVDTransferColors"];

                Console.WriteLine("SHADER CREATED");
                #endregion
            }
            else
            {
                #region create CVD volume shader

                Console.WriteLine("creating shader");
                device = _device;
                effect = _effect;

                // WorldViewProjection
                worldViewProjection = this.Parameters["myWorldViewProjectionMatrix"];

                // WorldProjection
                world = this.Parameters["myWorldMatrix"];

                // Position of Camera
                cameraPosition = this.Parameters["CameraPosition"];

                // Texture for FrontFaces
                frontFaces = this.Parameters["Front"];

                // Texture for Backfaces
                backFaces = this.Parameters["Back"];
                
                // Texture for Transferfunction
                transferValuesAlpha = this.Parameters["TransferAlpha"];

                // Texture for the CVD Transferfunction
                CVDtransferValues = this.Parameters["CVDTransfer"];

                // 3D Texture Volume
                volumeTexture = this.Parameters["Volume"];

                // 3D Texture Volume
                gradientTexture = this.Parameters["Gradients"];

                //direct light position
                directLightPosition = this.Parameters["DirectLightVector"];

                // stepSize
                stepSize = this.Parameters["StepSize"];

                //base sample distance for the dataset
                baseSampleDist = this.Parameters["baseSampleDist"];

                //current sample distance tha we use
                sampleDist = this.Parameters["sampleDist"];

                // number of iterations to be done
                iterations = this.Parameters["Iterations"];
                
                // scaleFactor
                scaleFactor = this.Parameters["ScaleFactor"];

                //texture size
                texSize = this.Parameters["textureSize"];
                
                frontToBack = this.Parameters["frontToBack"];

                shading = this.Parameters["shading"];

                useAlpha = this.Parameters["useAlpha"];
                
                useCVDTransferColors = this.Parameters["useCVDTransferColors"];

                // RGB to L*a*b*

                //Adobe RGB (1998) D50:
                rgbToXYZ = new Matrix(0.6097559f, 0.2052401f, 0.1492240f, 0.0f,
                                0.3111242f, 0.6256560f, 0.0632197f, 0.0f,
                                0.0194811f, 0.0608902f, 0.7448387f, 0.0f,
                                0.0f, 0.0f, 0.0f, 1.0f);

                ep_RGBtoXYZmatrix = this.Parameters["mRGBtoXYZ"];
                ep_rotation = this.Parameters["rotmat"];

                // L*a*b* to RGB

                //Adobe RGB (1998) D50:
                xyzToRGB = new Matrix(1.9624274f, -0.6105343f, -0.3413404f, 0.0f,
                                -0.9787684f, 1.9161415f, 0.0334540f, 0.0f,
                                0.0286869f, -0.1406752f, 1.3487655f, 0.0f,
                                0.0f, 0.0f, 0.0f, 1.0f);

                ep_rotationBack = this.Parameters["rotmatBack"];
                ep_XYZtoRGBmatrix = this.Parameters["mXYZtoRGB"];

                Console.WriteLine("CVD SHADER CREATED");

                #endregion
            }
        }


        #region SetEffectParameter
        

        //set by the engine:
        public void SetEffectParameter(Matrix _worldViewProjection, Matrix _world)
        {
            this.worldViewProjection.SetValue(_worldViewProjection);
            this.world.SetValue(_world);
        }

        public void SetEffectParameter(Vector3 _cameraPosition)
        {
            this.cameraPosition.SetValue(_cameraPosition);
        }
        
        public void SetEffectParameter_CVD(Texture3D _volumeTexture,
            Texture3D _gradientTexture,
            Vector3 _stepSize,
            int _iterations,
            Vector4 _scaleFactor,
            Vector2 _texSize,
            Matrix _rotateToLMS,
            Matrix _rotateFromLMS)
        {
            this.volumeTexture.SetValue(_volumeTexture);
            this.gradientTexture.SetValue(_gradientTexture);
            this.stepSize.SetValue(_stepSize);
            this.iterations.SetValue(_iterations);
            this.scaleFactor.SetValue(_scaleFactor);
            this.texSize.SetValue(_texSize);

            this.frontToBack.SetValue(GameProperties.Instance.enableFrontToBackBlend);
            this.shading.SetValue(GameProperties.Instance.enableShading);
            this.useAlpha.SetValue(GameProperties.Instance.enableTransferAlphaValues);
            this.useCVDTransferColors.SetValue(GameProperties.Instance.enableCVDView && GameProperties.Instance.cvdView);
            this.directLightPosition.SetValue(GameProperties.Instance.directLightPos);

            // RGB to L*a*b*
            this.ep_RGBtoXYZmatrix.SetValue(rgbToXYZ);
            this.ep_rotation.SetValue(_rotateToLMS);

            // L*a*b* to RGB
            this.ep_rotationBack.SetValue(_rotateFromLMS);
            this.ep_XYZtoRGBmatrix.SetValue(xyzToRGB);

            // TODO: set these to shader:
            if (front != null)
            {
                this.frontFaces.SetValue(front);
            }
            if (back != null)
            {
                this.backFaces.SetValue(back);
            }
            if (alpha != null)
            {
                this.transferValuesAlpha.SetValue(alpha);
            }
            if (cvdTransfer != null)
            {
                this.CVDtransferValues.SetValue(cvdTransfer);
            }

        }

        //set by the data itself
        public void SetEffectParameter(Texture3D _volumeTexture,
            Texture3D _gradientTexture,
            Vector3 _stepSize,
            int _iterations,
            int _side,
            Vector4 _scaleFactor,
            float _slice)
        {
            this.volumeTexture.SetValue(_volumeTexture);
            this.gradientTexture.SetValue(_gradientTexture);
            this.stepSize.SetValue(_stepSize);
            this.iterations.SetValue(_iterations);
            this.side.SetValue(_side);
            this.scaleFactor.SetValue(_scaleFactor);
            this.frontToBack.SetValue(GameProperties.Instance.enableFrontToBackBlend);
            this.shading.SetValue(GameProperties.Instance.enableShading);
            this.useAlpha.SetValue(GameProperties.Instance.enableTransferAlphaValues);
            this.useTransferColors.SetValue(GameProperties.Instance.enableTransferFunction);
            this.useCVDTransferColors.SetValue(GameProperties.Instance.enableCVDView && GameProperties.Instance.cvdView);

            //device.SetRenderTarget(null);
            if (front != null)
            {
                this.frontFaces.SetValue(front);
            }
            if (back != null)
            {
                this.backFaces.SetValue(back);
            }
            if (transfer != null)
            {
                this.transferValues.SetValue(transfer);
            }
            if (alpha != null)
            {
                this.transferValuesAlpha.SetValue(alpha);
            }
            if (cvdTransfer != null)
            {
                this.CVDtransferValues.SetValue(cvdTransfer);
            }
            this.slice.SetValue(_slice);
        }

        public void SetEffectParameter(Texture3D _volumeTexture,
            Texture3D _gradientTexture,
            Vector3 _directLightPosition,
            Vector3 _stepSize,
            float _baseSampleDist,
            float _sampleDist,
            int _iterations,
            int _side,
            Vector4 _scaleFactor,
            Vector2 _texSize,
            float _slice)
        {
            this.volumeTexture.SetValue(_volumeTexture);
            this.gradientTexture.SetValue(_gradientTexture);
            this.stepSize.SetValue(_stepSize);
            this.iterations.SetValue(_iterations);
            this.side.SetValue(_side);
            this.scaleFactor.SetValue(_scaleFactor);
            this.frontToBack.SetValue(GameProperties.Instance.enableFrontToBackBlend);
            this.shading.SetValue(GameProperties.Instance.enableShading);
            this.useAlpha.SetValue(GameProperties.Instance.enableTransferAlphaValues);
            this.useTransferColors.SetValue(GameProperties.Instance.enableTransferFunction);
            this.useCVDTransferColors.SetValue(GameProperties.Instance.enableCVDView && GameProperties.Instance.cvdView);

            //device.SetRenderTarget(null);
            if (front != null)
            {
                this.frontFaces.SetValue(front);
            }
            if (back != null)
            {
                this.backFaces.SetValue(back);
            }
            if (transfer != null)
            {
                this.transferValues.SetValue(transfer);
            }
            if (alpha != null)
            {
                this.transferValuesAlpha.SetValue(alpha);
            }
            if (cvdTransfer != null)
            {
                this.CVDtransferValues.SetValue(cvdTransfer);
            }
            this.slice.SetValue(_slice);

            //extended
            this.directLightPosition.SetValue(_directLightPosition);
            this.baseSampleDist.SetValue(_baseSampleDist);
            this.sampleDist.SetValue(_sampleDist);
            this.texSize.SetValue(_texSize);
        }
        #endregion
    }
}