TFWeightsShader.cs

#region Using Statements
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;
#endregion

namespace visLU.Effects
{
    class TFWeightsShader : Effect
    {
        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 volumeTexture;
        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;
        private EffectParameter prevControlPoint;
        private EffectParameter currControlPoint;
        private EffectParameter nextControlPoint;
        //boolean parameters
        private EffectParameter frontToBack;
        private EffectParameter shading;

        private EffectParameter useAlpha; 
        private EffectParameter useTransferColors;

        private EffectParameter selectedPos; 


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

        public TFWeightsShader(GraphicsDevice _device, Effect _effect)
            : base(_effect)
        {
            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"];

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

            //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"];

            currControlPoint = this.Parameters["currentControlPoint"];
            prevControlPoint = this.Parameters["prevControlPoint"];
            nextControlPoint = this.Parameters["nextControlPoint"];

            frontToBack = this.Parameters["frontToBack"];

            shading = this.Parameters["shading"];

            useAlpha = this.Parameters["useAlpha"];

            useTransferColors = this.Parameters["useTransferColors"];

            selectedPos = this.Parameters["selectedPositions"];

            if (GameProperties.Instance.debugOutput)
            {
                Console.WriteLine("TFWeights Shader Created");
            }
        }

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

        public Texture2D FrontFacesTexture
        {
            get { return front; }
            set
            {
                front = value; if (GameProperties.Instance.debugOutput)
                { 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; }
        }

        #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(float _currControlPoint, float _prevControlPoint, float _nextControlPoint)
        {
            this.currControlPoint.SetValue(_currControlPoint);
            this.prevControlPoint.SetValue(_prevControlPoint);
            this.nextControlPoint.SetValue(_nextControlPoint);
        }

        public void SetEffectParameter(Texture2D _selectedPos)
        {
            this.selectedPos.SetValue(_selectedPos);
        }

        //set by the data itself
        public void SetEffectParameter(Texture3D _volumeTexture,
            Vector3 _directLightPosition,
            Vector3 _stepSize,
            float _baseSampleDist,
            float _sampleDist,
            int _iterations,
            int _side,
            Vector4 _scaleFactor,
            Vector2 _texSize,
            float _slice)
        {
            this.volumeTexture.SetValue(_volumeTexture);
            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);

            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);
            }
            this.slice.SetValue(_slice);
            //extended
            this.directLightPosition.SetValue(_directLightPosition);
            this.baseSampleDist.SetValue(_baseSampleDist);
            this.sampleDist.SetValue(_sampleDist);
            this.texSize.SetValue(_texSize);
        }
        #endregion
    }
}