Page 1 sur 1

Unity 3D aide memoire scripts

Publié : mer. janv. 19, 2011 1:27 am
par yann.minh
Camera Switcher

attention d'affecter le tagg main camera aux cameras devant etre activée
attention, la caméra qui est déja affectée à une RenderTexture, pour écran vidéo ne peut etre aussi affectée au rendu dans le caméra switcher.

Re: Unity 3D aide memoire scripts

Publié : jeu. mars 03, 2011 4:00 pm
par yann.minh
Scripts BootCamp


-----------------------------------------
Scripts de la camera à la 3me personne qui suit le personnage.

soldiercamera

Code : Tout sélectionner

#pragma strict
#pragma implicit
#pragma downcast

class SoldierCamera extends MonoBehaviour
{
   public var target : Transform;
   public var soldier : Transform;
   
   public var speed : Vector2 = new Vector2(135.0, 135.0);
   public var aimSpeed : Vector2 = new Vector2(70.0, 70.0);
   public var maxSpeed : Vector2 = new Vector2(100.0, 100.0);

   public var yMinLimit = -90;
   public var yMaxLimit = 90;
   
   public var normalFOV = 60;
   public var zoomFOV = 30;
   
   public var lerpSpeed = 8.0;
   
   private var distance = 10.0;

   private var x = 0.0;
   public var y = 0.0;
   
   private var camTransform : Transform;
   private var rotation : Quaternion;
   private var position : Vector3;
   private var deltaTime : float;
   private var originalSoldierRotation : Quaternion;
   
   private var soldierController : SoldierController;
   
   public var orbit : boolean;
   
   public var hitLayer : LayerMask;
   
   private var cPos : Vector3;
   
   public var normalDirection : Vector3;
   public var aimDirection : Vector3;
   public var crouchDirection : Vector3;
   public var aimCrouchDirection : Vector3;
   
   public var positionLerp : float;
   
   public var normalHeight : float;
   public var crouchHeight : float;
   public var normalAimHeight : float;
   public var crouchAimHeight : float;
   public var minHeight : float;
   public var maxHeight : float;
   
   public var normalDistance : float;
   public var crouchDistance : float;
   public var normalAimDistance : float;
   public var crouchAimDistance : float;
   public var minDistance : float;
   public var maxDistance : float;
   
   private var targetDistance : float;
   private var camDir : Vector3;
   private var targetHeight : float;
   
   
   public var minShakeSpeed : float;
   public var maxShakeSpeed : float;
   
   public var minShake : float;
   public var maxShake : float = 2.0;
   
   public var minShakeTimes : int;
   public var maxShakeTimes : int;
   
   public var maxShakeDistance : float;
   
   private var shake : boolean;
   private var shakeSpeed : float = 2.0;
   private var cShakePos : float;
   private var shakeTimes : int = 8;
   private var cShake : float;
   private var cShakeSpeed : float;
   private var cShakeTimes : int;
   
   public var radar : Transform;
   public var radarCamera : Transform;

    private var _depthOfFieldEffect : DepthOfField;
   
   function Start () 
   {   
      cShakeTimes = 0;
      cShake = 0.0;
      cShakeSpeed = shakeSpeed;
      
        _depthOfFieldEffect = gameObject.GetComponent("DepthOfField") as DepthOfField;

      if(target == null || soldier == null)
      { 
         Destroy(this);
         return;
      }
      
      target.parent = null;
      
      camTransform = transform;
      
      var angles = camTransform.eulerAngles;
      x = angles.y;
       y = angles.x;
       
       originalSoldierRotation = soldier.rotation;
       
       soldierController = soldier.GetComponent("SoldierController");
       
       targetDistance = normalDistance;
       
       cPos = soldier.position + new Vector3(0, normalHeight, 0);
   }
   
   function GoToOrbitMode(state : boolean)
   {
      orbit = state;
      
      soldierController.idleTimer = 0.0;
   }
   
   function Update()
   {
      if(GameManager.pause || GameManager.scores) return;
      //if(GameManager.scores) return;

      if(orbit && (Input.GetKeyDown(KeyCode.O) || Input.GetAxis("Horizontal") != 0.0 || Input.GetAxis("Vertical") != 0.0 || soldierController.aim || soldierController.fire))
      {
         GoToOrbitMode(false);
      }
      
      if(!orbit && soldierController.idleTimer > 0.1)
      {
         GoToOrbitMode(true);
      }
   }
   
   function LateUpdate () 
   {
      //if(GameManager.pause || GameManager.scores) return;
      if(GameManager.scores) return;

      deltaTime = Time.deltaTime;
      
      GetInput();
      
      RotateSoldier();

      CameraMovement();

        DepthOfFieldControl();
   }
   
   function CameraMovement()
   {
      if(soldierController.aim)
      {
         (camera.GetComponent(DepthOfField) as DepthOfField).enabled = true;
         camera.fieldOfView = Mathf.Lerp(camera.fieldOfView, zoomFOV, deltaTime * lerpSpeed);
         
         if(soldierController.crouch)
         {
            camDir = (aimCrouchDirection.x * target.forward) + (aimCrouchDirection.z * target.right);
            targetHeight = crouchAimHeight;
            targetDistance = crouchAimDistance;
         }
         else
         {
            camDir = (aimDirection.x * target.forward) + (aimDirection.z * target.right);
            targetHeight = normalAimHeight;
            targetDistance = normalAimDistance;
         }
      }
      else
      {
         (camera.GetComponent(DepthOfField) as DepthOfField).enabled = false;
         camera.fieldOfView = Mathf.Lerp(camera.fieldOfView, normalFOV, deltaTime * lerpSpeed);
         
         if(soldierController.crouch)
         {
            camDir = (crouchDirection.x * target.forward) + (crouchDirection.z * target.right);
            targetHeight = crouchHeight;
            targetDistance = crouchDistance;
         }
         else
         {
            camDir = (normalDirection.x * target.forward) + (normalDirection.z * target.right);
            targetHeight = normalHeight;
            targetDistance = normalDistance;
         }
      }
      
      camDir = camDir.normalized;
      
      HandleCameraShake();
      
      cPos = soldier.position + new Vector3(0, targetHeight, 0);
      
      var hit : RaycastHit;
      if(Physics.Raycast(cPos, camDir, hit, targetDistance + 0.2, hitLayer))
      {
         var t : float = hit.distance - 0.1;
         t -= minDistance;
         t /= (targetDistance - minDistance);

         targetHeight = Mathf.Lerp(maxHeight, targetHeight, Mathf.Clamp(t, 0.0, 1.0));
         cPos = soldier.position + new Vector3(0, targetHeight, 0); 
      }
      
      if(Physics.Raycast(cPos, camDir, hit, targetDistance + 0.2, hitLayer))
      {
         targetDistance = hit.distance - 0.1;
      }
      if(radar != null)
      {
         radar.position = cPos;
         radarCamera.rotation = Quaternion.Euler(90, x, 0);
      }
      
      var lookPoint : Vector3 = cPos;
      lookPoint += (target.right * Vector3.Dot(camDir * targetDistance, target.right));

      camTransform.position = cPos + (camDir * targetDistance);
      camTransform.LookAt(lookPoint);
      
      target.position = cPos;
      target.rotation = Quaternion.Euler(y, x, 0);
   }
   
   function HandleCameraShake()
   {
      if(shake)
      {
         cShake += cShakeSpeed * deltaTime;
         
         if(Mathf.Abs(cShake) > cShakePos)
         {
            cShakeSpeed *= -1.0;
            cShakeTimes++;
            
            if(cShakeTimes >= shakeTimes)
            {
               shake = false;
            }
            
            if(cShake > 0.0)
            {
               cShake = maxShake;
            }
            else
            {
               cShake = -maxShake;
            }
         }
         
         targetHeight += cShake;
      }
   }
   
   function StartShake(distance : float)
   {
      var proximity : float = distance / maxShakeDistance;
      
      if(proximity > 1.0) return;
      
      proximity = Mathf.Clamp(proximity, 0.0, 1.0);
      
      proximity = 1.0 - proximity;
      
      cShakeSpeed = Mathf.Lerp(minShakeSpeed, maxShakeSpeed, proximity);
      shakeTimes = Mathf.Lerp(minShakeTimes, maxShakeTimes, proximity);
      cShakeTimes = 0;
      cShakePos = Mathf.Lerp(minShake, maxShake, proximity);
      
      shake = true;
   }

   function GetInput()
   {
      var a : Vector2 = soldierController.aim ? aimSpeed : speed;
      x += Mathf.Clamp(Input.GetAxis("Mouse X") * a.x, -maxSpeed.x, maxSpeed.x) * deltaTime;
      y -= Mathf.Clamp(Input.GetAxis("Mouse Y") * a.y, -maxSpeed.y, maxSpeed.y) * deltaTime;
      y = ClampAngle(y, yMinLimit, yMaxLimit);
   }

    function DepthOfFieldControl()
    {
        if(_depthOfFieldEffect == null) return;
        if(soldierController == null) return;
        
        if(soldierController.aim && GameQualitySettings.depthOfField)
        {
            if(!_depthOfFieldEffect.enabled)
            {
                _depthOfFieldEffect.enabled = true;
            }
        }
        else
        {
            if(_depthOfFieldEffect.enabled)
            {
                _depthOfFieldEffect.enabled = false;
            }
        }
    }
   
   function RotateSoldier()
   {
      if(!orbit)
         soldierController.targetYRotation = x;
   }
   
   static function ClampAngle(angle : float, min : float, max : float) : float
   {
      if (angle < -360)
      {
         angle += 360;
      }
      
      if (angle > 360)
      {
         angle -= 360;
      }
      
      return Mathf.Clamp (angle, min, max);
   }
}
Effets :
Bloom&Flares

Code : Tout sélectionner

// general settings

public var bloomThisTag : String;

public var sepBlurSpread : float = 1.5;
public var useSrcAlphaAsMask : float = 0.5;

// bloom settings

public var bloomIntensity : float = 1.0;
public var bloomThreshhold : float = 0.4;
public var bloomBlurIterations : int = 3;

// lens flare settings

enum LensflareStyle {
   Ghosting = 0,
   Hollywood = 1,
   Combined = 2,
}

enum TweakMode {
   Simple = 0,
   Advanced = 1,
}

public var tweakMode : TweakMode = 1;

public var lensflares : boolean = true;
public var hollywoodFlareBlurIterations : int = 4;
public var lensflareMode : LensflareStyle = 0;
public var hollyStretchWidth : float = 2.5;
public var lensflareIntensity : float = 0.75;
public var lensflareThreshhold : float = 0.5;
public var flareColorA : Color = Color(0.4,0.4,0.8,0.75);
public var flareColorB : Color = Color(0.4,0.8,0.8,0.75);
public var flareColorC : Color = Color(0.8,0.4,0.8,0.75);
public var flareColorD : Color = Color(0.8,0.4,0.0,0.75);
public var blurWidth : float = 1.0;

@script ExecuteInEditMode

@script RequireComponent (Camera)
@script AddComponentMenu ("Image Effects/Bloom and Flares")
            
class BloomAndFlares extends PostEffectsBase 
{
   
   // needed shaders & materials ...
   
   public var addAlphaHackShader : Shader;
   
   private var _alphaAddMaterial : Material;
   
   public var lensFlareShader : Shader; 
   private var _lensFlareMaterial : Material;
   
   public var vignetteShader : Shader;
   private var _vignetteMaterial : Material;
   
   public var separableBlurShader : Shader;
   private var _separableBlurMaterial : Material;
   
   public var addBrightStuffOneOneShader: Shader;
   private var _addBrightStuffBlendOneOneMaterial : Material;
   
   public var hollywoodFlareBlurShader: Shader;
   private var _hollywoodFlareBlurMaterial : Material;
   
   public var hollywoodFlareStretchShader: Shader;   
   private var _hollywoodFlareStretchMaterial : Material;   
   
   public var brightPassFilterShader : Shader;
   private var _brightPassFilterMaterial : Material;
   
   
   function Start () {
      CreateMaterials ();   
   }
   
   function CreateMaterials () {
      
      if(!_lensFlareMaterial) {
         if(!CheckShader(lensFlareShader)) {
            enabled = false;
            return;
         }
         _lensFlareMaterial = new Material (lensFlareShader);
         _lensFlareMaterial.hideFlags = HideFlags.HideAndDontSave; 
      }            
      
      if (!_vignetteMaterial) {
         if(!CheckShader(vignetteShader)) {
            enabled = false;
            return;
         }
         _vignetteMaterial = new Material (vignetteShader);
         _vignetteMaterial.hideFlags = HideFlags.HideAndDontSave; 
      }
            
      if (!_separableBlurMaterial) {
         if(!CheckShader(separableBlurShader)) {
            enabled = false;
            return;
         }
         _separableBlurMaterial = new Material (separableBlurShader);
         _separableBlurMaterial.hideFlags = HideFlags.HideAndDontSave; 
      }

      if (!_addBrightStuffBlendOneOneMaterial) {
         if(!CheckShader(addBrightStuffOneOneShader)) {
            enabled = false;
            return;
         }
         _addBrightStuffBlendOneOneMaterial = new Material (addBrightStuffOneOneShader);   
         _addBrightStuffBlendOneOneMaterial.hideFlags = HideFlags.HideAndDontSave; 
      } 
      
      if (!_hollywoodFlareBlurMaterial) {
         if(!CheckShader(hollywoodFlareBlurShader)) {
            enabled = false;
            return;
         }
         _hollywoodFlareBlurMaterial = new Material (hollywoodFlareBlurShader);
         _hollywoodFlareBlurMaterial.hideFlags = HideFlags.HideAndDontSave; 
      } 
      
      if (!_hollywoodFlareStretchMaterial) {
         if(!CheckShader(hollywoodFlareStretchShader)) {
            enabled = false;
            return;
         }
         _hollywoodFlareStretchMaterial = new Material (hollywoodFlareStretchShader);
         _hollywoodFlareStretchMaterial.hideFlags = HideFlags.HideAndDontSave; 
      }       
      
      if (!_brightPassFilterMaterial) {
         if(!CheckShader(brightPassFilterShader)) {
            enabled = false;
            return;
         }
         _brightPassFilterMaterial = new Material (brightPassFilterShader);
         _brightPassFilterMaterial.hideFlags = HideFlags.HideAndDontSave;
      }               
      
      if(!_alphaAddMaterial) {
         if(!CheckShader(addAlphaHackShader)) {
            enabled = false;
            return;            
         }
         _alphaAddMaterial = new Material(addAlphaHackShader);      
         _alphaAddMaterial.hideFlags = HideFlags.HideAndDontSave;      
      }            
   }
   
   function OnEnable() {
      if( !CheckSupport() ) {
         enabled = false;
         return;   
      }      
   }

   function OnPreCull () 
   {
      if(bloomThisTag && bloomThisTag != "Untagged") {
         
         var gos : GameObject[] = GameObject.FindGameObjectsWithTag(bloomThisTag);
         
         for (var go : GameObject in gos) {
            if(go.GetComponent(MeshFilter)) {
               var mesh : Mesh = (go.GetComponent(MeshFilter) as MeshFilter).sharedMesh;
               Graphics.DrawMesh(mesh,go.transform.localToWorldMatrix,_alphaAddMaterial,0,camera);
            }
         }      
      }      
   }

   function OnRenderImage2 (source : RenderTexture, destination : RenderTexture)
    {
        Graphics.Blit (source, destination);
        OnRenderImage3 (destination, null);
   }
    function PreferRenderImage3() : boolean { return true; }
    
    function OnRenderImage3 (sourceAndDestination : RenderTexture, temp : RenderTexture)
   {
        var source : RenderTexture = sourceAndDestination;
        var destination : RenderTexture = sourceAndDestination;
      
        CreateMaterials ();   
            
      // needed render targets
      var halfRezColor : RenderTexture = RenderTexture.GetTemporary(source.width / 2.0, source.height / 2.0, 0);         
      var quarterRezColor : RenderTexture = RenderTexture.GetTemporary(source.width / 4.0, source.height / 4.0, 0);   
      var secondQuarterRezColor : RenderTexture = RenderTexture.GetTemporary(source.width / 4.0, source.height / 4.0, 0);   
      var thirdQuarterRezColor : RenderTexture = RenderTexture.GetTemporary(source.width / 4.0, source.height / 4.0, 0);   
      
      // at this point, we have massaged the alpha channel enough to start downsampling process for bloom   
      Graphics.Blit (source, halfRezColor);
      Graphics.Blit (halfRezColor, quarterRezColor);      

      // cut colors (threshholding)         
      _brightPassFilterMaterial.SetVector ("threshhold", Vector4 (bloomThreshhold, 1.0/(1.0-bloomThreshhold), 0.0, 0.0));
      _brightPassFilterMaterial.SetFloat ("useSrcAlphaAsMask", useSrcAlphaAsMask);
      Graphics.Blit (quarterRezColor, secondQuarterRezColor, _brightPassFilterMaterial);      
            
      // blurring
      if (bloomBlurIterations < 1)
         bloomBlurIterations = 1;   
            
      // blur the result to get a nicer bloom radius
        Graphics.Blit(secondQuarterRezColor, quarterRezColor);
      for (var iter : int = 0; iter < bloomBlurIterations; iter++ ) {
         _separableBlurMaterial.SetVector ("offsets", Vector4 (0.0, (sepBlurSpread * 1.0) / quarterRezColor.height, 0.0, 0.0));   
         Graphics.Blit (quarterRezColor, thirdQuarterRezColor, _separableBlurMaterial); 
         _separableBlurMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));   
         Graphics.Blit (thirdQuarterRezColor, quarterRezColor, _separableBlurMaterial);      
      }

      // operate on lens flares now
      if (lensflares) {
         
         if(lensflareMode == 0) // ghosting
         {
            // lens flare fun: cut some additional values and normalize
            _brightPassFilterMaterial.SetVector ("threshhold", Vector4 (lensflareThreshhold, 1.0 / (1.0-lensflareThreshhold), 0.0, 0.0));
            _brightPassFilterMaterial.SetFloat ("useSrcAlphaAsMask", 0.0);
            Graphics.Blit (quarterRezColor, thirdQuarterRezColor, _brightPassFilterMaterial);    
      
            _separableBlurMaterial.SetVector ("offsets", Vector4 (0.0, (sepBlurSpread * 1.0) / quarterRezColor.height, 0.0, 0.0));   
            Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _separableBlurMaterial);            
            _separableBlurMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));   
            Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _separableBlurMaterial); 
            
            // vignette for lens flares
            _vignetteMaterial.SetFloat ("vignetteIntensity", 1.0);
            Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _vignetteMaterial); 
            
            // creating the flares
            // _lensFlareMaterial has One One Blend
            _lensFlareMaterial.SetVector ("color0", Vector4(0.0,0.0,0.0,0.0) * lensflareIntensity);
            _lensFlareMaterial.SetVector ("colorA", Vector4(flareColorA.r,flareColorA.g,flareColorA.b,flareColorA.a) * lensflareIntensity);
            _lensFlareMaterial.SetVector ("colorB", Vector4(flareColorB.r,flareColorB.g,flareColorB.b,flareColorB.a) * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorC", Vector4(flareColorC.r,flareColorC.g,flareColorC.b,flareColorC.a) * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorD", Vector4(flareColorD.r,flareColorD.g,flareColorD.b,flareColorD.a) * lensflareIntensity);
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _lensFlareMaterial);

_addBrightStuffBlendOneOneMaterial.SetFloat ("intensity", 1.0);
Graphics.Blit (thirdQuarterRezColor, quarterRezColor, _addBrightStuffBlendOneOneMaterial);

}
else if(lensflareMode == 1) // hollywood flares
{
// lens flare fun: cut some additional values
_brightPassFilterMaterial.SetVector ("threshhold", Vector4 (lensflareThreshhold, 1.0 / (1.0-lensflareThreshhold), 0.0, 0.0));
_brightPassFilterMaterial.SetFloat ("useSrcAlphaAsMask", 0.0);
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _brightPassFilterMaterial);

// ole: NEW and AWESOME new feature for hollyflares
// narrow down the size that creates on of these lines
_hollywoodFlareBlurMaterial.SetVector ("offsets", Vector4(0.0, (sepBlurSpread * 1.0) / quarterRezColor.height, 0.0, 0.0));
_hollywoodFlareBlurMaterial.SetTexture("_NonBlurredTex", quarterRezColor);
_hollywoodFlareBlurMaterial.SetVector ("tintColor", Vector4(flareColorA.r,flareColorA.g,flareColorA.b,flareColorA.a) * flareColorA.a * lensflareIntensity);
Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _hollywoodFlareBlurMaterial);

_hollywoodFlareStretchMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
_hollywoodFlareStretchMaterial.SetFloat("stretchWidth", hollyStretchWidth);
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _hollywoodFlareStretchMaterial);

for (var itera : int = 0; itera < hollywoodFlareBlurIterations; itera++ ) {

_separableBlurMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _separableBlurMaterial);

_separableBlurMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _separableBlurMaterial);

}

_addBrightStuffBlendOneOneMaterial.SetFloat ("intensity", 1.0);
Graphics.Blit (thirdQuarterRezColor, quarterRezColor, _addBrightStuffBlendOneOneMaterial);
}
else // 'both' flares :)
{
// lens flare fun: cut some additional values
_brightPassFilterMaterial.SetVector ("threshhold", Vector4 (lensflareThreshhold, 1.0 / (1.0-lensflareThreshhold), 0.0, 0.0));
_brightPassFilterMaterial.SetFloat ("useSrcAlphaAsMask", 0.0);
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _brightPassFilterMaterial);

// ole: NEW and AWESOME new feature for hollyflares
// narrow down the size that creates on of these lines
_hollywoodFlareBlurMaterial.SetVector ("offsets", Vector4(0.0, (sepBlurSpread * 1.0) / quarterRezColor.height, 0.0, 0.0));
_hollywoodFlareBlurMaterial.SetTexture("_NonBlurredTex", quarterRezColor);
_hollywoodFlareBlurMaterial.SetVector ("tintColor", Vector4(flareColorA.r,flareColorA.g,flareColorA.b,flareColorA.a) * flareColorA.a * lensflareIntensity);
Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _hollywoodFlareBlurMaterial);
_hollywoodFlareStretchMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
_hollywoodFlareStretchMaterial.SetFloat("stretchWidth", hollyStretchWidth);
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _hollywoodFlareStretchMaterial);

for (var ix : int = 0; ix < hollywoodFlareBlurIterations; ix++ ) {

_separableBlurMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _separableBlurMaterial);

_separableBlurMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _separableBlurMaterial);
}

// vignette for lens flares
_vignetteMaterial.SetFloat ("vignetteIntensity", 1.0);
Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _vignetteMaterial);

// creating the flares
// _lensFlareMaterial has One One Blend
_lensFlareMaterial.SetVector ("color0", Vector4(0.0,0.0,0.0,0.0) * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorA", Vector4(flareColorA.r,flareColorA.g,flareColorA.b,flareColorA.a) * flareColorA.a * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorB", Vector4(flareColorB.r,flareColorB.g,flareColorB.b,flareColorB.a) * flareColorB.a * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorC", Vector4(flareColorC.r,flareColorC.g,flareColorC.b,flareColorC.a) * flareColorC.a * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorD", Vector4(flareColorD.r,flareColorD.g,flareColorD.b,flareColorD.a) * flareColorD.a * lensflareIntensity);
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _lensFlareMaterial);

_addBrightStuffBlendOneOneMaterial.SetFloat ("intensity", 1.0);
Graphics.Blit (thirdQuarterRezColor, quarterRezColor, _addBrightStuffBlendOneOneMaterial);
}
}

_addBrightStuffBlendOneOneMaterial.SetFloat("intensity", bloomIntensity);
Graphics.Blit (quarterRezColor, destination, _addBrightStuffBlendOneOneMaterial);

RenderTexture.ReleaseTemporary (halfRezColor);
RenderTexture.ReleaseTemporary (quarterRezColor);
RenderTexture.ReleaseTemporary (secondQuarterRezColor);
RenderTexture.ReleaseTemporary (thirdQuarterRezColor);
}

}

Re: Unity 3D aide memoire scripts

Publié : jeu. mars 03, 2011 4:05 pm
par yann.minh
ColorCorrectionscript

Code : Tout sélectionner

public var redChannel : AnimationCurve;
public var greenChannel : AnimationCurve;
public var blueChannel : AnimationCurve;

public var useDepthCorrection : boolean = false;

public var zCurve : AnimationCurve;
public var depthRedChannel : AnimationCurve;
public var depthGreenChannel : AnimationCurve;
public var depthBlueChannel : AnimationCurve;

private var _ccMaterial : Material;
private var _ccDepthMaterial : Material;
private var _selectiveCcMaterial : Material;

private var _rgbChannelTex : Texture2D;
private var _rgbDepthChannelTex : Texture2D;

private var _zCurve : Texture2D;

public var selectiveCc : boolean = false;

public var selectiveFromColor : Color = Color.white;
public var selectiveToColor : Color = Color.white;


public var updateTextures : boolean = true;
public var recreateTextures : boolean = false;

public var curveResolution : int = 256;

// GENERAL stuff

@script ExecuteInEditMode
@script AddComponentMenu ("Image Effects/Color Correction (Curves)")

enum ColorCorrectionMode {
   Simple = 0,
   Advanced = 1   
}

public var mode : ColorCorrectionMode;

// SHADERS

public var colorCorrectionCurvesShader : Shader = null;
public var simpleColorCorrectionCurvesShader : Shader = null;
public var colorCorrectionSelectiveShader : Shader = null;

class ColorCorrectionCurves extends PostEffectsBase 
{
   function Start () {
      updateTextures = true;
      CreateMaterials ();   
   }
   
   function CreateMaterials () {
        if (recreateTextures)
        {
            _rgbChannelTex = null;
            _rgbDepthChannelTex = null;
            _zCurve = null;
            recreateTextures = false;
        }

      if (!_ccMaterial) {
         if(!CheckShader(simpleColorCorrectionCurvesShader)) {
            enabled = false;
            return;
         }
         _ccMaterial = new Material (simpleColorCorrectionCurvesShader);   
         _ccMaterial.hideFlags = HideFlags.HideAndDontSave;
      }

      if (!_ccDepthMaterial) {
         if(!CheckShader(colorCorrectionCurvesShader)) {
            enabled = false;
            return;
         }
         _ccDepthMaterial = new Material (colorCorrectionCurvesShader);   
         _ccDepthMaterial.hideFlags = HideFlags.HideAndDontSave;
      }   
      
      if (!_selectiveCcMaterial) {
         if(!CheckShader(colorCorrectionSelectiveShader)) {
            enabled = false;
            return;
         }
         _selectiveCcMaterial = new Material (colorCorrectionSelectiveShader);
         _selectiveCcMaterial.hideFlags = HideFlags.HideAndDontSave;   
      }
      
      if(!SystemInfo.SupportsRenderTextureFormat (RenderTextureFormat.Depth)) {
         enabled = false;
         return;   
      }
      
      // sample all curves, create textures
      if (!_rgbChannelTex) {
         _rgbChannelTex = new Texture2D(curveResolution, 4, TextureFormat.ARGB32, false);
         _rgbChannelTex.hideFlags = HideFlags.HideAndDontSave;
         updateTextures = true;
      }
      if (!_rgbDepthChannelTex) {
         _rgbDepthChannelTex = new Texture2D(curveResolution, 4, TextureFormat.ARGB32, false);
         _rgbDepthChannelTex.hideFlags = HideFlags.HideAndDontSave;
         updateTextures = true;
      }
      
      if (!_zCurve) {
         _zCurve = new Texture2D (curveResolution, 1, TextureFormat.ARGB32, false);
         _zCurve.hideFlags = HideFlags.HideAndDontSave;
         updateTextures = true;
      }   
      
      _rgbChannelTex.wrapMode = TextureWrapMode.Clamp;
      _rgbDepthChannelTex.wrapMode = TextureWrapMode.Clamp;
      _zCurve.wrapMode = TextureWrapMode.Clamp;      
   }
   
   function OnEnable() {
      if( !CheckSupport() ) {
         enabled = false;
         return;   
      }
   if(useDepthCorrection)
      camera.depthTextureMode |= DepthTextureMode.Depth;   
   }
   
   function OnDisable () {
   }
   
   public function UpdateParameters() 
   {
      if (updateTextures && redChannel && greenChannel && blueChannel) 
      {
            var rgbC : Vector3 = Vector3(0,0,0);
            var rgbDC : Vector3 = Vector3(0,0,0);
            var zC : float = 0;
            
            var curveResolutionAsFloat : float = curveResolution;
            var curveStep : float = 1.0 / curveResolutionAsFloat;
            
            var step : float = 1.0 / 256.0;
            var subStep : float = 0.0;
            
            var texelIndex : int = 0;
         for (var i : float = 0.0; i <= 1.0; i += step) 
         {
                rgbC.x += Mathf.Clamp01(redChannel.Evaluate(i));
                rgbC.y += Mathf.Clamp01(greenChannel.Evaluate(i));
                rgbC.z += Mathf.Clamp01(blueChannel.Evaluate(i));
                
                zC += Mathf.Clamp01(zCurve.Evaluate(i));
                    
                rgbDC.x += Mathf.Clamp01(depthRedChannel.Evaluate(i));
                rgbDC.y += Mathf.Clamp01(depthGreenChannel.Evaluate(i));
                rgbDC.z += Mathf.Clamp01(depthBlueChannel.Evaluate(i));
                
                subStep += step;
                if (subStep >= curveStep)
                {
                    rgbC *= step / curveStep;
                    zC *= step / curveStep;
                    rgbDC *= step / curveStep;
                   
                    _rgbChannelTex.SetPixel( texelIndex, 0, Color(rgbC.x,rgbC.x,rgbC.x) );
                    _rgbChannelTex.SetPixel( texelIndex, 1, Color(rgbC.y,rgbC.y,rgbC.y) );
                    _rgbChannelTex.SetPixel( texelIndex, 2, Color(rgbC.z,rgbC.z,rgbC.z) );
                    
                    _zCurve.SetPixel( texelIndex, 0, Color(zC,zC,zC) );
                
                    _rgbDepthChannelTex.SetPixel( texelIndex, 0, Color(rgbDC.x,rgbDC.x,rgbDC.x) );
                    _rgbDepthChannelTex.SetPixel( texelIndex, 1, Color(rgbDC.y,rgbDC.y,rgbDC.y) );
                    _rgbDepthChannelTex.SetPixel( texelIndex, 2, Color(rgbDC.z,rgbDC.z,rgbDC.z) );
                    
                    rgbC = Vector3(0,0,0);
                    rgbDC = Vector3(0,0,0);
                    zC = 0;

                    texelIndex++;
                    subStep = 0.0;                    
                }
         }
         
         _rgbChannelTex.Apply();
         _rgbDepthChannelTex.Apply();

         _zCurve.Apply();
            
         updateTextures = false;
      }
   }
   
   function OnRenderImage2 (source : RenderTexture, destination : RenderTexture)
   {
      CreateMaterials ();
      UpdateParameters();   
      
      // force disable anisotropic filtering
      if(_rgbChannelTex)
         _rgbChannelTex.anisoLevel = 0;
      if(_rgbDepthChannelTex)
         _rgbDepthChannelTex.anisoLevel = 0;
                  
      var renderTarget2Use : RenderTexture = destination;
      
      if (selectiveCc) {
         // we need an extra render target
         renderTarget2Use = RenderTexture.GetTemporary (source.width, source.height);
      }
      
      if (useDepthCorrection) 
      {
         _ccDepthMaterial.SetTexture ("_RgbTex", _rgbChannelTex);
   
         _ccDepthMaterial.SetTexture ("_ZCurve", _zCurve);
         
         _ccDepthMaterial.SetTexture ("_RgbDepthTex", _rgbDepthChannelTex);
   
         Graphics.Blit (source, renderTarget2Use, _ccDepthMaterial);    
      } 
      else 
      {
         _ccMaterial.SetTexture ("_RgbTex", _rgbChannelTex);
   
         Graphics.Blit (source, renderTarget2Use, _ccMaterial);          
      }
      
      if (selectiveCc) {
         _selectiveCcMaterial.SetVector ("selColor", Vector4(selectiveFromColor.r,selectiveFromColor.g,selectiveFromColor.b,selectiveFromColor.a) );
         _selectiveCcMaterial.SetVector ("targetColor", Vector4(selectiveToColor.r,selectiveToColor.g,selectiveToColor.b,selectiveToColor.a) );
         Graphics.Blit (renderTarget2Use, destination, _selectiveCcMaterial);    
         
         RenderTexture.ReleaseTemporary (renderTarget2Use);
      }
            
   }

}

Re: Unity 3D aide memoire scripts

Publié : jeu. mars 03, 2011 4:06 pm
par yann.minh
SunShaft

Code : Tout sélectionner

enum SunShaftsResolution {
    Low = 0,
    Normal = 1,
   High = 2,
}

public var resolution : SunShaftsResolution;

public var sunTransform : Transform;
public var radialBlurIterations : int = 2;
public var sunColor : Color = Color.white;
public var sunShaftBlurRadius : float = 0.0164;
public var sunShaftIntensity : float = 1.25;
public var useSkyBoxAlpha : float = 0.75;

public var maxRadius : float = 1.25;

public var useDepthTexture : boolean = true;

@script ExecuteInEditMode
@script RequireComponent (Camera)
@script AddComponentMenu ("Image Effects/Sun Shafts")
      
class SunShafts extends PostEffectsBase 
{   
    // needed shaders & materials
   
   public var clearShader : Shader;
   private var _clearMaterial : Material;
   
   public var depthDecodeShader : Shader;
   private var _encodeDepthRGBA8Material : Material;
   
   public var depthBlurShader : Shader;
   private var _radialDepthBlurMaterial : Material;
   
   public var sunShaftsShader : Shader;
   private var _sunShaftsMaterial : Material;   
   
   public var simpleClearShader : Shader;
   private var _simpleClearMaterial : Material;
   
   public var compShader : Shader;
   private var _compMaterial : Material;

   function Start () {
      order = 1; // hacked in higher order for sun shafts
      CreateMaterials ();   
   }
   
   function CreateMaterials () {         

      if (!_clearMaterial) {
         if(!CheckShader(clearShader)) {
            enabled = false;
            return;
         }
         _clearMaterial = new Material (clearShader);
         _clearMaterial.hideFlags = HideFlags.HideAndDontSave; 
      }
      
      if (!_sunShaftsMaterial) {
         if(!CheckShader(sunShaftsShader)) {
            enabled = false;
            return;
         }
         _sunShaftsMaterial = new Material (sunShaftsShader);
         _sunShaftsMaterial.hideFlags = HideFlags.HideAndDontSave; 
      }

      if (!_encodeDepthRGBA8Material) {
         if(!CheckShader(depthDecodeShader)) {
            enabled = false;
            return;
         }
         _encodeDepthRGBA8Material = new Material (depthDecodeShader);
         _encodeDepthRGBA8Material.hideFlags = HideFlags.HideAndDontSave; 
      }
      
      if (!_radialDepthBlurMaterial) {
         if(!CheckShader(depthBlurShader)) {
            enabled = false;
            return;
         }
         _radialDepthBlurMaterial = new Material (depthBlurShader);   
         _radialDepthBlurMaterial.hideFlags = HideFlags.HideAndDontSave; 
      }

      if (!_simpleClearMaterial) {
         if(!CheckShader(simpleClearShader)) {
            enabled = false;
            return;
         }
         _simpleClearMaterial = new Material (simpleClearShader);
         _simpleClearMaterial.hideFlags = HideFlags.HideAndDontSave; 
      } 
      
      //_compMaterial
       if (!_compMaterial) {
         if(!CheckShader(compShader)) {
            enabled = false;
            return;
         }
         _compMaterial = new Material (compShader);
         _compMaterial.hideFlags = HideFlags.HideAndDontSave; 
      }        
   }
   
   function OnEnable () {   
      if( !CheckSupport() ) {
         enabled = false;
         return;   
      }      
         
      if(useDepthTexture) { 
         camera.depthTextureMode |= DepthTextureMode.Depth;   
      }
   }
   
   function OnRenderImage2 (source : RenderTexture, destination : RenderTexture)
    {
      // save the color buffer
      Graphics.Blit (source, destination); 
        OnRenderImage3 (destination, source);
   }
    
    function PreferRenderImage3() : boolean { return true; }
    
    function OnRenderImage3 (sourceAndDestination : RenderTexture, temp : RenderTexture)
   {
      // needed for most of the new and improved image FX
      CreateMaterials ();   
      
        var divider : float = 4.0;
        if(resolution == SunShaftsResolution.Normal)
            divider = 2.0;
        if(resolution == SunShaftsResolution.High)
            divider = 1.0;
         
      // get render targets      
      var secondQuarterRezColor : RenderTexture = RenderTexture.GetTemporary(sourceAndDestination.width / divider, sourceAndDestination.height / divider, 0);   
        var lrDepthBuffer : RenderTexture = RenderTexture.GetTemporary(sourceAndDestination.width / divider, sourceAndDestination.height / divider, 0);
   
   
        var destination : RenderTexture = sourceAndDestination;
        
              // mask skybox (some pixels are clip()'ped, others are kept ...)
      if(!useDepthTexture) {         
         var tmpBuffer : RenderTexture = RenderTexture.GetTemporary(sourceAndDestination.width, sourceAndDestination.height, 0);   
         
         RenderTexture.active = tmpBuffer;
         GL.ClearWithSkybox(false, camera);
         
         RenderTexture.active = temp;
         _compMaterial.SetTexture("_Skybox", tmpBuffer);
         Graphics.Blit (sourceAndDestination, temp, _compMaterial);
         
         RenderTexture.ReleaseTemporary(tmpBuffer);
      
         // =>
         /*Graphics.Blit(source, destination);
         RenderTexture.ReleaseTemporary (lrDepthBuffer);   
         RenderTexture.ReleaseTemporary (secondQuarterRezColor);   
               
         return;
         */
      }
      else
             Graphics.Blit (sourceAndDestination, temp, _clearMaterial);
      // get depth values
      
        _encodeDepthRGBA8Material.SetFloat("noSkyBoxMask", 1.0-useSkyBoxAlpha);
      _encodeDepthRGBA8Material.SetFloat("dontUseSkyboxBrightness", 0.0);      
      Graphics.Blit (temp, lrDepthBuffer, _encodeDepthRGBA8Material);
        // black small pixel border to get rid of clamping annoyances
        
        // we don't need to care about this for bootcamp
      //DrawBorder(lrDepthBuffer,_simpleClearMaterial);
      
      var v : Vector3 = Vector3.one * 0.5;
      if (sunTransform)
         v = camera.WorldToViewportPoint (sunTransform.position);
      else {
         v = Vector3(0.5, 0.5, 0.0);
      }
        
      // radial depth blur now
      _radialDepthBlurMaterial.SetVector ("blurRadius4", Vector4 (1.0, 1.0, 0.0, 0.0) * sunShaftBlurRadius );
      _radialDepthBlurMaterial.SetVector ("sunPosition", Vector4 (v.x, v.y, v.z, maxRadius));
            
      if (radialBlurIterations<1)
         radialBlurIterations = 1;
            
      for (var it2 : int = 0; it2 < radialBlurIterations; it2++ ) {
         Graphics.Blit (lrDepthBuffer, secondQuarterRezColor, _radialDepthBlurMaterial);
         Graphics.Blit (secondQuarterRezColor, lrDepthBuffer, _radialDepthBlurMaterial);      
      }

      // composite now         
      _sunShaftsMaterial.SetFloat ("sunShaftIntensity", sunShaftIntensity);
      if (v.z >= 0.0)
         _sunShaftsMaterial.SetVector ("sunColor", Vector4 (sunColor.r,sunColor.g,sunColor.b,sunColor.a));
      else
         _sunShaftsMaterial.SetVector ("sunColor", Vector4 (0.0,0.0,0.0,0.0)); // no backprojection !
            

      Graphics.Blit(lrDepthBuffer, destination, _sunShaftsMaterial);    

      
      RenderTexture.ReleaseTemporary (lrDepthBuffer);   
      RenderTexture.ReleaseTemporary (secondQuarterRezColor);   
      
      /*
         tmpBuffer  = RenderTexture.GetTemporary(source.width, source.height, 0);   
         RenderTexture.active = tmpBuffer;
         GL.ClearWithSkybox(false, camera);
         
         RenderTexture.active = source;
         _compMaterial.SetTexture("_Skybox", tmpBuffer);
         Graphics.Blit (source, destination, _compMaterial);
         
         RenderTexture.ReleaseTemporary(tmpBuffer);   
      */
   
   }

}

Re: Unity 3D aide memoire scripts

Publié : jeu. mars 03, 2011 4:31 pm
par yann.minh

Code : Tout sélectionner

enum DofResolutionSetting {
    Low = 0,
    Normal = 1,
    High = 2,
}

enum DofQualitySetting {
   Low = 0,
   Medium = 1,
   High = 2,
}

public var resolution : DofResolutionSetting = DofResolutionSetting.Normal;
public var quality : DofQualitySetting = DofQualitySetting.High;

public var focalZDistance : float = 0.0;
public var focalZStart : float = 0.0;
public var focalZEnd : float = 10000.0;

private var _focalDistance01 : float;
private var _focalStart01 : float = 0.0;
private var _focalEnd01 : float = 1.0;

public var focalFalloff : float = 1.0;

public var focusOnThis : Transform = null;
public var focusOnScreenCenterDepth : boolean = false;
public var focalSize : float = 0.075;
public var focalChangeSpeed : float = 2.275;

public var blurIterations : int = 2;
public var foregroundBlurIterations : int = 2;

public var blurSpread : float = 1.25;
public var foregroundBlurSpread : float = 1.75;
public var foregroundBlurStrength : float = 1.15;
public var foregroundBlurThreshhold : float = 0.002;

@script ExecuteInEditMode
@script RequireComponent (Camera)
@script AddComponentMenu ("Image Effects/Depth of Field") 

class DepthOfField extends PostEffectsBase {
   
   public var available : boolean = true;
   
   public var weightedBlurShader : Shader;
   private var _weightedBlurMaterial : Material = null;   
   
   public var preDofShader : Shader;
   private var _preDofMaterial : Material = null;
   
   public var preDofZReadShader : Shader;
   private var _preDofZReadMaterial : Material = null;
   
   public var dofShader : Shader;
   private var _dofMaterial : Material = null;   
    
    public var blurShader : Shader;
    private var _blurMaterial : Material = null;
    
    public var foregroundShader : Shader;
    private var _foregroundBlurMaterial : Material = null;
    
    public var depthConvertShader : Shader;
    private var _depthConvertMaterial : Material = null;
    
    public var depthBlurShader : Shader;
    private var _depthBlurMaterial : Material = null;   
    
    public var recordCenterDepthShader : Shader;
    private var _recordCenterDepthMaterial : Material = null;
    
    private var _onePixel : RenderTexture = null;
   
   function CreateMaterials () 
   {      
       if(!_onePixel) {
          _onePixel = new RenderTexture(1,1, 0); 
          _onePixel.hideFlags = HideFlags.HideAndDontSave;
       }
       
      if(!_recordCenterDepthMaterial) {
         if(!CheckShader(recordCenterDepthShader)) {
            enabled = false;
            return;            
         }
         _recordCenterDepthMaterial = new Material(recordCenterDepthShader);   
         _recordCenterDepthMaterial.hideFlags = HideFlags.HideAndDontSave;            
      }
      
      if (!_weightedBlurMaterial) {
         if(!CheckShader(blurShader)) {
            enabled = false;
            return;
            }
         _weightedBlurMaterial = new Material(weightedBlurShader);   
         _weightedBlurMaterial.hideFlags = HideFlags.HideAndDontSave;
      }
        
      if (!_blurMaterial) {
         if(!CheckShader(blurShader)) {
            enabled = false;
            return;
            }
         _blurMaterial = new Material(blurShader);   
         _blurMaterial.hideFlags = HideFlags.HideAndDontSave;
      }        
      
      if (!_dofMaterial) { 
         if(!CheckShader(dofShader)) {
            enabled = false;
            return;
            }
         _dofMaterial = new Material(dofShader);   
         _dofMaterial.hideFlags = HideFlags.HideAndDontSave;
      }
      
      if (!_preDofMaterial) {
         if(!CheckShader(preDofShader)) {
            enabled = false;
            return;
            }
         _preDofMaterial = new Material(preDofShader);   
         _preDofMaterial.hideFlags = HideFlags.HideAndDontSave;
      }

      if (!_preDofZReadMaterial) {
         if(!CheckShader(preDofZReadShader)) {
            enabled = false;
            return;
            }
         _preDofZReadMaterial = new Material(preDofZReadShader);   
         _preDofZReadMaterial.hideFlags = HideFlags.HideAndDontSave;
      }
        
        if (!_foregroundBlurMaterial) {
           if(!CheckShader(foregroundShader)) {
            enabled = false;
            return;
            }
         _foregroundBlurMaterial = new Material(foregroundShader);   
         _foregroundBlurMaterial.hideFlags = HideFlags.HideAndDontSave;        
        }
        
        if (!_depthConvertMaterial) {
           if(!CheckShader(depthConvertShader)) {
            enabled = false;
            return;
            }
         _depthConvertMaterial = new Material(depthConvertShader);   
         _depthConvertMaterial.hideFlags = HideFlags.HideAndDontSave;        
        }
     
        if (!_depthBlurMaterial) {
           if(!CheckShader(depthBlurShader)) {
            enabled = false;
            return;
            }
         _depthBlurMaterial = new Material(depthBlurShader);   
         _depthBlurMaterial.hideFlags = HideFlags.HideAndDontSave;        
        }         
        
      if(!SystemInfo.SupportsRenderTextureFormat (RenderTextureFormat.Depth)) {
         enabled = false;
         return;   
      }                  
   }
   
   function Start () {
      CreateMaterials ();
      camera.depthTextureMode |= DepthTextureMode.Depth;      
   }


   function OnEnable(){
      if( !CheckSupport() ) {
         enabled = false;
         return;   
      }
      if(!available) {
         enabled = false;
         return;   
      }
   }
   
   function OnRenderImage2 (source : RenderTexture, destination : RenderTexture)
   {   
      CreateMaterials ();
         
      if(foregroundBlurIterations<1)
         foregroundBlurIterations = 1;

      if(blurIterations<1)
         blurIterations = 1;         
      
      // quality and resolution settings
      
        var divider : float = 4.0;
        if(resolution == DofResolutionSetting.Normal)
            divider = 2.0;
        else if(resolution == DofResolutionSetting.High) 
            divider = 1.0;
                       
        // support for a game object / transform defining the focal distance      
        
        var preDofMaterial = _preDofMaterial;  
                
      if(focusOnThis) 
      {
         var vpPoint = camera.WorldToViewportPoint(focusOnThis.position);
         vpPoint.z = (vpPoint.z) / (camera.farClipPlane);
         _focalDistance01 = vpPoint.z;
      } 
      else if(focusOnScreenCenterDepth) 
      { 
         preDofMaterial = _preDofZReadMaterial;
           // OK, here the zBuffer based "raycast" mode, let's record the blurred
           // depth buffer center area and add some smoothing
           _recordCenterDepthMaterial.SetFloat("deltaTime", Time.deltaTime * focalChangeSpeed);
           Graphics.Blit(_onePixel, _onePixel, _recordCenterDepthMaterial);         
      }
      else 
      {
         _focalDistance01 = camera.WorldToViewportPoint(focalZDistance * camera.transform.forward + camera.transform.position).z / (camera.farClipPlane);   
      }
      
      if(focalZEnd > camera.farClipPlane)
         focalZEnd = camera.farClipPlane;
      _focalStart01 = camera.WorldToViewportPoint(focalZStart * camera.transform.forward + camera.transform.position).z / (camera.farClipPlane);
      _focalEnd01 = camera.WorldToViewportPoint(focalZEnd * camera.transform.forward + camera.transform.position).z / (camera.farClipPlane);

      
      if(_focalEnd01<_focalStart01)
         _focalEnd01 = _focalStart01+Mathf.Epsilon;      
      
        // we use the alpha channel for storing the COC
        // which also means, that unfortunately, alpha based
        // image effects such as sun shafts, bloom or glow
        // won't work if placed *after* the DOF image effect
        
      // simple COC calculation based on distance to focal point     
        
      preDofMaterial.SetFloat("focalDistance01", _focalDistance01);
      preDofMaterial.SetFloat("focalFalloff", focalFalloff);
        preDofMaterial.SetFloat("focalStart01",_focalStart01);
        preDofMaterial.SetFloat("focalEnd01",_focalEnd01);
        preDofMaterial.SetFloat("focalSize", focalSize * 0.5);        
        preDofMaterial.SetTexture("_onePixelTex", _onePixel);
      Graphics.Blit(source, source, preDofMaterial); // ColorMask == ALPHA
      
        var lrTex0 : RenderTexture = RenderTexture.GetTemporary (source.width / divider, source.height / divider, 0); 
      var lrTex1 : RenderTexture = RenderTexture.GetTemporary (source.width / divider, source.height / divider, 0); 
      var lrTex2 : RenderTexture = RenderTexture.GetTemporary (source.width / divider, source.height / divider, 0); 
      
      // high quality DOF should blur the forground       
        
        if(quality >= DofQualitySetting.High) 
        {           
            lrTex0.filterMode = FilterMode.Point;
            lrTex1.filterMode = FilterMode.Point;   
            lrTex2.filterMode = FilterMode.Point;     
            source.filterMode = FilterMode.Point;      
           
            // downsample depth (and encoding in RGBA)
            
            Graphics.Blit(source, lrTex1, _depthConvertMaterial);

            source.filterMode = FilterMode.Bilinear;
               
         //
           // depth blur    (result in lrTex1)                    
            
            for(var it : int = 0; it < foregroundBlurIterations; it++) {
                _depthBlurMaterial.SetVector ("offsets", Vector4 (0.0, (foregroundBlurSpread) / lrTex1.height, 0.0, _focalDistance01));
                Graphics.Blit (lrTex1, lrTex0, _depthBlurMaterial);
                _depthBlurMaterial.SetVector ("offsets", Vector4 ((foregroundBlurSpread) / lrTex1.width,  0.0, 0.0, _focalDistance01));      
                Graphics.Blit (lrTex0, lrTex1, _depthBlurMaterial);      
            }      
            
         //
           // simple blur    (result in lrTex0)
        
         lrTex0.filterMode = FilterMode.Bilinear;
         lrTex1.filterMode = FilterMode.Bilinear;
         lrTex2.filterMode = FilterMode.Bilinear;   
         
         var tempBlurIterations = blurIterations;      
        
           if(resolution != DofResolutionSetting.High) 
           {
            Graphics.Blit(source, lrTex0);     
           } 
           else // high resolution, divider is 1
           {
               _blurMaterial.SetVector ("offsets", Vector4 (0.0, (blurSpread) / lrTex1.height, 0.0, 0.0));
                 Graphics.Blit (source, lrTex2, _blurMaterial);
               _blurMaterial.SetVector ("offsets", Vector4 ((blurSpread) / lrTex1.width,  0.0, 0.0, 0.0));      
               Graphics.Blit (lrTex2, lrTex0, _blurMaterial);                    
               
               tempBlurIterations -= 1;                
           }  
         
           for(it = 0; it < tempBlurIterations; it++) {
               _blurMaterial.SetVector ("offsets", Vector4 (0.0, (blurSpread) / lrTex1.height, 0.0, 0.0));
                 Graphics.Blit (lrTex0, lrTex2, _blurMaterial);
               _blurMaterial.SetVector ("offsets", Vector4 ((blurSpread) / lrTex1.width,  0.0, 0.0, 0.0));      
               Graphics.Blit (lrTex2, lrTex0, _blurMaterial);              
           }             

           // calculate the foreground blur factor and add to our COC
           
           lrTex1.filterMode = FilterMode.Point; 
            
            _foregroundBlurMaterial.SetFloat("focalFalloff", focalFalloff);
            _foregroundBlurMaterial.SetFloat("focalDistance01", _focalDistance01);
            _foregroundBlurMaterial.SetFloat("focalStart01",_focalStart01);
            _foregroundBlurMaterial.SetFloat("focalEnd01",_focalEnd01);    
            _foregroundBlurMaterial.SetFloat("foregroundBlurStrength", foregroundBlurStrength);  
            _foregroundBlurMaterial.SetFloat("foregroundBlurThreshhold", foregroundBlurThreshhold);
            _foregroundBlurMaterial.SetTexture("_SourceTex", source);
            _foregroundBlurMaterial.SetTexture("_BlurredCoc", lrTex0);
              Graphics.Blit (lrTex1, source, _foregroundBlurMaterial);    
            
            lrTex0.filterMode = FilterMode.Bilinear;
            lrTex1.filterMode = FilterMode.Bilinear;
            lrTex2.filterMode = FilterMode.Bilinear;
        } // high quality
        
      // weighted by COC blur
      
      var tempStdBlurIterations : int = blurIterations;
        
        if(resolution != DofResolutionSetting.High) {
         Graphics.Blit(source, lrTex1);            
        }
        else // high resolution and divider == 1
        {
            if(quality >= DofQualitySetting.Medium) 
            {           
            _weightedBlurMaterial.SetVector ("offsets", Vector4 (0.0, (blurSpread) / lrTex1.height, 0.0, _focalDistance01));
            Graphics.Blit (source, lrTex2, _weightedBlurMaterial);
            _weightedBlurMaterial.SetVector ("offsets", Vector4 ((blurSpread) / lrTex1.width,  0.0, 0.0, _focalDistance01));      
            Graphics.Blit (lrTex2, lrTex1, _weightedBlurMaterial);    
            }
            else
            {
            _blurMaterial.SetVector ("offsets", Vector4 (0.0, (blurSpread) / lrTex1.height, 0.0, 0.0));
            Graphics.Blit (source, lrTex2, _blurMaterial);
            _blurMaterial.SetVector ("offsets", Vector4 ((blurSpread) / lrTex1.width,  0.0, 0.0, 0.0));      
            Graphics.Blit (lrTex2, lrTex1, _blurMaterial);                   
            }          
           
           tempStdBlurIterations -= 1;
        }
            
        for(it = 0; it < tempStdBlurIterations; it++) 
        {
            if(quality >= DofQualitySetting.Medium) 
            {
                _weightedBlurMaterial.SetVector ("offsets", Vector4 (0.0, (blurSpread) / lrTex1.height, 0.0, _focalDistance01));
                Graphics.Blit (lrTex1, lrTex2, _weightedBlurMaterial);
                _weightedBlurMaterial.SetVector ("offsets", Vector4 ((blurSpread) / lrTex1.width,  0.0, 0.0, _focalDistance01));      
                Graphics.Blit (lrTex2, lrTex1, _weightedBlurMaterial);   
            } 
            else 
            {
                 _blurMaterial.SetVector ("offsets", Vector4 (0.0, (blurSpread) / lrTex1.height, 0.0, 0.0));
                Graphics.Blit (lrTex1, lrTex2, _blurMaterial);
                _blurMaterial.SetVector ("offsets", Vector4 ((blurSpread) / lrTex1.width,  0.0, 0.0, 0.0));      
                Graphics.Blit (lrTex2, lrTex1, _blurMaterial);              
            }
        }       
      
      //
      // composite the final image, depending on COC, source and low resolution color buffers
        
        _dofMaterial.SetFloat ("focalDistance01", _focalDistance01);
      _dofMaterial.SetTexture ("_LowRez", lrTex1);
      Graphics.Blit(source, destination, _dofMaterial);   // also writes ALPHA = 1
        
        RenderTexture.ReleaseTemporary(lrTex0);
      RenderTexture.ReleaseTemporary(lrTex1);
      RenderTexture.ReleaseTemporary(lrTex2);
   }   
}