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.
Unity 3D aide memoire scripts
Re: Unity 3D aide memoire scripts
Scripts BootCamp
-----------------------------------------
Scripts de la camera à la 3me personne qui suit le personnage.
soldiercamera
Effets :
Bloom&Flares
_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);
}
}
-----------------------------------------
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);
}
}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 ("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
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
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
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);
}
}