Connexion




Poster un nouveau sujet Répondre au sujet  [ 5 messages ] 
Auteur Message
 Sujet du message: Unity 3D aide memoire scripts
UNREAD_POSTPosté: Mer Jan 19, 2011 1:27 am 
NooFondateur
Avatar de l’utilisateur
Inscription: Mar Jan 09, 2007 3:21 am
Messages: 1166
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.


 Hors ligne
 
 Sujet du message: Re: Unity 3D aide memoire scripts
UNREAD_POSTPosté: Jeu Mar 03, 2011 4:00 pm 
NooFondateur
Avatar de l’utilisateur
Inscription: Mar Jan 09, 2007 3:21 am
Messages: 1166
Scripts BootCamp


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

soldiercamera

Code:
#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:
// 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);
}

}


 Hors ligne
 
 Sujet du message: Re: Unity 3D aide memoire scripts
UNREAD_POSTPosté: Jeu Mar 03, 2011 4:05 pm 
NooFondateur
Avatar de l’utilisateur
Inscription: Mar Jan 09, 2007 3:21 am
Messages: 1166
ColorCorrectionscript



Code:

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);
      }
            
   }

}


 Hors ligne
 
 Sujet du message: Re: Unity 3D aide memoire scripts
UNREAD_POSTPosté: Jeu Mar 03, 2011 4:06 pm 
NooFondateur
Avatar de l’utilisateur
Inscription: Mar Jan 09, 2007 3:21 am
Messages: 1166
SunShaft

Code:
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);   
      */
   
   }

}


 Hors ligne
 
 Sujet du message: Re: Unity 3D aide memoire scripts
UNREAD_POSTPosté: Jeu Mar 03, 2011 4:31 pm 
NooFondateur
Avatar de l’utilisateur
Inscription: Mar Jan 09, 2007 3:21 am
Messages: 1166
Code:
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);
   }   
}


 Hors ligne
 

Afficher les messages postés depuis:  Trier par  

Poster un nouveau sujet Répondre au sujet  [ 5 messages ] 


Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 12 invités

Panel

Haut Vous ne pouvez pas poster de nouveaux sujets
Vous ne pouvez pas répondre aux sujets
Vous ne pouvez pas éditer vos messages
Vous ne pouvez pas supprimer vos messages
Rechercher:
Aller à:  
 cron
Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group
Traduction par: phpBB-fr.com
Dizayn Ercan Koc