Scripts BootCamp
-----------------------------------------
Scripts de la camera à la 3me personne qui suit le personnage.
soldiercamera
Code : Tout sélectionner
#pragma strict
#pragma implicit
#pragma downcast
class SoldierCamera extends MonoBehaviour
{
public var target : Transform;
public var soldier : Transform;
public var speed : Vector2 = new Vector2(135.0, 135.0);
public var aimSpeed : Vector2 = new Vector2(70.0, 70.0);
public var maxSpeed : Vector2 = new Vector2(100.0, 100.0);
public var yMinLimit = -90;
public var yMaxLimit = 90;
public var normalFOV = 60;
public var zoomFOV = 30;
public var lerpSpeed = 8.0;
private var distance = 10.0;
private var x = 0.0;
public var y = 0.0;
private var camTransform : Transform;
private var rotation : Quaternion;
private var position : Vector3;
private var deltaTime : float;
private var originalSoldierRotation : Quaternion;
private var soldierController : SoldierController;
public var orbit : boolean;
public var hitLayer : LayerMask;
private var cPos : Vector3;
public var normalDirection : Vector3;
public var aimDirection : Vector3;
public var crouchDirection : Vector3;
public var aimCrouchDirection : Vector3;
public var positionLerp : float;
public var normalHeight : float;
public var crouchHeight : float;
public var normalAimHeight : float;
public var crouchAimHeight : float;
public var minHeight : float;
public var maxHeight : float;
public var normalDistance : float;
public var crouchDistance : float;
public var normalAimDistance : float;
public var crouchAimDistance : float;
public var minDistance : float;
public var maxDistance : float;
private var targetDistance : float;
private var camDir : Vector3;
private var targetHeight : float;
public var minShakeSpeed : float;
public var maxShakeSpeed : float;
public var minShake : float;
public var maxShake : float = 2.0;
public var minShakeTimes : int;
public var maxShakeTimes : int;
public var maxShakeDistance : float;
private var shake : boolean;
private var shakeSpeed : float = 2.0;
private var cShakePos : float;
private var shakeTimes : int = 8;
private var cShake : float;
private var cShakeSpeed : float;
private var cShakeTimes : int;
public var radar : Transform;
public var radarCamera : Transform;
private var _depthOfFieldEffect : DepthOfField;
function Start ()
{
cShakeTimes = 0;
cShake = 0.0;
cShakeSpeed = shakeSpeed;
_depthOfFieldEffect = gameObject.GetComponent("DepthOfField") as DepthOfField;
if(target == null || soldier == null)
{
Destroy(this);
return;
}
target.parent = null;
camTransform = transform;
var angles = camTransform.eulerAngles;
x = angles.y;
y = angles.x;
originalSoldierRotation = soldier.rotation;
soldierController = soldier.GetComponent("SoldierController");
targetDistance = normalDistance;
cPos = soldier.position + new Vector3(0, normalHeight, 0);
}
function GoToOrbitMode(state : boolean)
{
orbit = state;
soldierController.idleTimer = 0.0;
}
function Update()
{
if(GameManager.pause || GameManager.scores) return;
//if(GameManager.scores) return;
if(orbit && (Input.GetKeyDown(KeyCode.O) || Input.GetAxis("Horizontal") != 0.0 || Input.GetAxis("Vertical") != 0.0 || soldierController.aim || soldierController.fire))
{
GoToOrbitMode(false);
}
if(!orbit && soldierController.idleTimer > 0.1)
{
GoToOrbitMode(true);
}
}
function LateUpdate ()
{
//if(GameManager.pause || GameManager.scores) return;
if(GameManager.scores) return;
deltaTime = Time.deltaTime;
GetInput();
RotateSoldier();
CameraMovement();
DepthOfFieldControl();
}
function CameraMovement()
{
if(soldierController.aim)
{
(camera.GetComponent(DepthOfField) as DepthOfField).enabled = true;
camera.fieldOfView = Mathf.Lerp(camera.fieldOfView, zoomFOV, deltaTime * lerpSpeed);
if(soldierController.crouch)
{
camDir = (aimCrouchDirection.x * target.forward) + (aimCrouchDirection.z * target.right);
targetHeight = crouchAimHeight;
targetDistance = crouchAimDistance;
}
else
{
camDir = (aimDirection.x * target.forward) + (aimDirection.z * target.right);
targetHeight = normalAimHeight;
targetDistance = normalAimDistance;
}
}
else
{
(camera.GetComponent(DepthOfField) as DepthOfField).enabled = false;
camera.fieldOfView = Mathf.Lerp(camera.fieldOfView, normalFOV, deltaTime * lerpSpeed);
if(soldierController.crouch)
{
camDir = (crouchDirection.x * target.forward) + (crouchDirection.z * target.right);
targetHeight = crouchHeight;
targetDistance = crouchDistance;
}
else
{
camDir = (normalDirection.x * target.forward) + (normalDirection.z * target.right);
targetHeight = normalHeight;
targetDistance = normalDistance;
}
}
camDir = camDir.normalized;
HandleCameraShake();
cPos = soldier.position + new Vector3(0, targetHeight, 0);
var hit : RaycastHit;
if(Physics.Raycast(cPos, camDir, hit, targetDistance + 0.2, hitLayer))
{
var t : float = hit.distance - 0.1;
t -= minDistance;
t /= (targetDistance - minDistance);
targetHeight = Mathf.Lerp(maxHeight, targetHeight, Mathf.Clamp(t, 0.0, 1.0));
cPos = soldier.position + new Vector3(0, targetHeight, 0);
}
if(Physics.Raycast(cPos, camDir, hit, targetDistance + 0.2, hitLayer))
{
targetDistance = hit.distance - 0.1;
}
if(radar != null)
{
radar.position = cPos;
radarCamera.rotation = Quaternion.Euler(90, x, 0);
}
var lookPoint : Vector3 = cPos;
lookPoint += (target.right * Vector3.Dot(camDir * targetDistance, target.right));
camTransform.position = cPos + (camDir * targetDistance);
camTransform.LookAt(lookPoint);
target.position = cPos;
target.rotation = Quaternion.Euler(y, x, 0);
}
function HandleCameraShake()
{
if(shake)
{
cShake += cShakeSpeed * deltaTime;
if(Mathf.Abs(cShake) > cShakePos)
{
cShakeSpeed *= -1.0;
cShakeTimes++;
if(cShakeTimes >= shakeTimes)
{
shake = false;
}
if(cShake > 0.0)
{
cShake = maxShake;
}
else
{
cShake = -maxShake;
}
}
targetHeight += cShake;
}
}
function StartShake(distance : float)
{
var proximity : float = distance / maxShakeDistance;
if(proximity > 1.0) return;
proximity = Mathf.Clamp(proximity, 0.0, 1.0);
proximity = 1.0 - proximity;
cShakeSpeed = Mathf.Lerp(minShakeSpeed, maxShakeSpeed, proximity);
shakeTimes = Mathf.Lerp(minShakeTimes, maxShakeTimes, proximity);
cShakeTimes = 0;
cShakePos = Mathf.Lerp(minShake, maxShake, proximity);
shake = true;
}
function GetInput()
{
var a : Vector2 = soldierController.aim ? aimSpeed : speed;
x += Mathf.Clamp(Input.GetAxis("Mouse X") * a.x, -maxSpeed.x, maxSpeed.x) * deltaTime;
y -= Mathf.Clamp(Input.GetAxis("Mouse Y") * a.y, -maxSpeed.y, maxSpeed.y) * deltaTime;
y = ClampAngle(y, yMinLimit, yMaxLimit);
}
function DepthOfFieldControl()
{
if(_depthOfFieldEffect == null) return;
if(soldierController == null) return;
if(soldierController.aim && GameQualitySettings.depthOfField)
{
if(!_depthOfFieldEffect.enabled)
{
_depthOfFieldEffect.enabled = true;
}
}
else
{
if(_depthOfFieldEffect.enabled)
{
_depthOfFieldEffect.enabled = false;
}
}
}
function RotateSoldier()
{
if(!orbit)
soldierController.targetYRotation = x;
}
static function ClampAngle(angle : float, min : float, max : float) : float
{
if (angle < -360)
{
angle += 360;
}
if (angle > 360)
{
angle -= 360;
}
return Mathf.Clamp (angle, min, max);
}
}
Effets :
Bloom&Flares
Code : Tout sélectionner
// general settings
public var bloomThisTag : String;
public var sepBlurSpread : float = 1.5;
public var useSrcAlphaAsMask : float = 0.5;
// bloom settings
public var bloomIntensity : float = 1.0;
public var bloomThreshhold : float = 0.4;
public var bloomBlurIterations : int = 3;
// lens flare settings
enum LensflareStyle {
Ghosting = 0,
Hollywood = 1,
Combined = 2,
}
enum TweakMode {
Simple = 0,
Advanced = 1,
}
public var tweakMode : TweakMode = 1;
public var lensflares : boolean = true;
public var hollywoodFlareBlurIterations : int = 4;
public var lensflareMode : LensflareStyle = 0;
public var hollyStretchWidth : float = 2.5;
public var lensflareIntensity : float = 0.75;
public var lensflareThreshhold : float = 0.5;
public var flareColorA : Color = Color(0.4,0.4,0.8,0.75);
public var flareColorB : Color = Color(0.4,0.8,0.8,0.75);
public var flareColorC : Color = Color(0.8,0.4,0.8,0.75);
public var flareColorD : Color = Color(0.8,0.4,0.0,0.75);
public var blurWidth : float = 1.0;
@script ExecuteInEditMode
@script RequireComponent (Camera)
@script AddComponentMenu ("Image Effects/Bloom and Flares")
class BloomAndFlares extends PostEffectsBase
{
// needed shaders & materials ...
public var addAlphaHackShader : Shader;
private var _alphaAddMaterial : Material;
public var lensFlareShader : Shader;
private var _lensFlareMaterial : Material;
public var vignetteShader : Shader;
private var _vignetteMaterial : Material;
public var separableBlurShader : Shader;
private var _separableBlurMaterial : Material;
public var addBrightStuffOneOneShader: Shader;
private var _addBrightStuffBlendOneOneMaterial : Material;
public var hollywoodFlareBlurShader: Shader;
private var _hollywoodFlareBlurMaterial : Material;
public var hollywoodFlareStretchShader: Shader;
private var _hollywoodFlareStretchMaterial : Material;
public var brightPassFilterShader : Shader;
private var _brightPassFilterMaterial : Material;
function Start () {
CreateMaterials ();
}
function CreateMaterials () {
if(!_lensFlareMaterial) {
if(!CheckShader(lensFlareShader)) {
enabled = false;
return;
}
_lensFlareMaterial = new Material (lensFlareShader);
_lensFlareMaterial.hideFlags = HideFlags.HideAndDontSave;
}
if (!_vignetteMaterial) {
if(!CheckShader(vignetteShader)) {
enabled = false;
return;
}
_vignetteMaterial = new Material (vignetteShader);
_vignetteMaterial.hideFlags = HideFlags.HideAndDontSave;
}
if (!_separableBlurMaterial) {
if(!CheckShader(separableBlurShader)) {
enabled = false;
return;
}
_separableBlurMaterial = new Material (separableBlurShader);
_separableBlurMaterial.hideFlags = HideFlags.HideAndDontSave;
}
if (!_addBrightStuffBlendOneOneMaterial) {
if(!CheckShader(addBrightStuffOneOneShader)) {
enabled = false;
return;
}
_addBrightStuffBlendOneOneMaterial = new Material (addBrightStuffOneOneShader);
_addBrightStuffBlendOneOneMaterial.hideFlags = HideFlags.HideAndDontSave;
}
if (!_hollywoodFlareBlurMaterial) {
if(!CheckShader(hollywoodFlareBlurShader)) {
enabled = false;
return;
}
_hollywoodFlareBlurMaterial = new Material (hollywoodFlareBlurShader);
_hollywoodFlareBlurMaterial.hideFlags = HideFlags.HideAndDontSave;
}
if (!_hollywoodFlareStretchMaterial) {
if(!CheckShader(hollywoodFlareStretchShader)) {
enabled = false;
return;
}
_hollywoodFlareStretchMaterial = new Material (hollywoodFlareStretchShader);
_hollywoodFlareStretchMaterial.hideFlags = HideFlags.HideAndDontSave;
}
if (!_brightPassFilterMaterial) {
if(!CheckShader(brightPassFilterShader)) {
enabled = false;
return;
}
_brightPassFilterMaterial = new Material (brightPassFilterShader);
_brightPassFilterMaterial.hideFlags = HideFlags.HideAndDontSave;
}
if(!_alphaAddMaterial) {
if(!CheckShader(addAlphaHackShader)) {
enabled = false;
return;
}
_alphaAddMaterial = new Material(addAlphaHackShader);
_alphaAddMaterial.hideFlags = HideFlags.HideAndDontSave;
}
}
function OnEnable() {
if( !CheckSupport() ) {
enabled = false;
return;
}
}
function OnPreCull ()
{
if(bloomThisTag && bloomThisTag != "Untagged") {
var gos : GameObject[] = GameObject.FindGameObjectsWithTag(bloomThisTag);
for (var go : GameObject in gos) {
if(go.GetComponent(MeshFilter)) {
var mesh : Mesh = (go.GetComponent(MeshFilter) as MeshFilter).sharedMesh;
Graphics.DrawMesh(mesh,go.transform.localToWorldMatrix,_alphaAddMaterial,0,camera);
}
}
}
}
function OnRenderImage2 (source : RenderTexture, destination : RenderTexture)
{
Graphics.Blit (source, destination);
OnRenderImage3 (destination, null);
}
function PreferRenderImage3() : boolean { return true; }
function OnRenderImage3 (sourceAndDestination : RenderTexture, temp : RenderTexture)
{
var source : RenderTexture = sourceAndDestination;
var destination : RenderTexture = sourceAndDestination;
CreateMaterials ();
// needed render targets
var halfRezColor : RenderTexture = RenderTexture.GetTemporary(source.width / 2.0, source.height / 2.0, 0);
var quarterRezColor : RenderTexture = RenderTexture.GetTemporary(source.width / 4.0, source.height / 4.0, 0);
var secondQuarterRezColor : RenderTexture = RenderTexture.GetTemporary(source.width / 4.0, source.height / 4.0, 0);
var thirdQuarterRezColor : RenderTexture = RenderTexture.GetTemporary(source.width / 4.0, source.height / 4.0, 0);
// at this point, we have massaged the alpha channel enough to start downsampling process for bloom
Graphics.Blit (source, halfRezColor);
Graphics.Blit (halfRezColor, quarterRezColor);
// cut colors (threshholding)
_brightPassFilterMaterial.SetVector ("threshhold", Vector4 (bloomThreshhold, 1.0/(1.0-bloomThreshhold), 0.0, 0.0));
_brightPassFilterMaterial.SetFloat ("useSrcAlphaAsMask", useSrcAlphaAsMask);
Graphics.Blit (quarterRezColor, secondQuarterRezColor, _brightPassFilterMaterial);
// blurring
if (bloomBlurIterations < 1)
bloomBlurIterations = 1;
// blur the result to get a nicer bloom radius
Graphics.Blit(secondQuarterRezColor, quarterRezColor);
for (var iter : int = 0; iter < bloomBlurIterations; iter++ ) {
_separableBlurMaterial.SetVector ("offsets", Vector4 (0.0, (sepBlurSpread * 1.0) / quarterRezColor.height, 0.0, 0.0));
Graphics.Blit (quarterRezColor, thirdQuarterRezColor, _separableBlurMaterial);
_separableBlurMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
Graphics.Blit (thirdQuarterRezColor, quarterRezColor, _separableBlurMaterial);
}
// operate on lens flares now
if (lensflares) {
if(lensflareMode == 0) // ghosting
{
// lens flare fun: cut some additional values and normalize
_brightPassFilterMaterial.SetVector ("threshhold", Vector4 (lensflareThreshhold, 1.0 / (1.0-lensflareThreshhold), 0.0, 0.0));
_brightPassFilterMaterial.SetFloat ("useSrcAlphaAsMask", 0.0);
Graphics.Blit (quarterRezColor, thirdQuarterRezColor, _brightPassFilterMaterial);
_separableBlurMaterial.SetVector ("offsets", Vector4 (0.0, (sepBlurSpread * 1.0) / quarterRezColor.height, 0.0, 0.0));
Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _separableBlurMaterial);
_separableBlurMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _separableBlurMaterial);
// vignette for lens flares
_vignetteMaterial.SetFloat ("vignetteIntensity", 1.0);
Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _vignetteMaterial);
// creating the flares
// _lensFlareMaterial has One One Blend
_lensFlareMaterial.SetVector ("color0", Vector4(0.0,0.0,0.0,0.0) * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorA", Vector4(flareColorA.r,flareColorA.g,flareColorA.b,flareColorA.a) * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorB", Vector4(flareColorB.r,flareColorB.g,flareColorB.b,flareColorB.a) * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorC", Vector4(flareColorC.r,flareColorC.g,flareColorC.b,flareColorC.a) * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorD", Vector4(flareColorD.r,flareColorD.g,flareColorD.b,flareColorD.a) * lensflareIntensity);
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _lensFlareMaterial);
_addBrightStuffBlendOneOneMaterial.SetFloat ("intensity", 1.0);
Graphics.Blit (thirdQuarterRezColor, quarterRezColor, _addBrightStuffBlendOneOneMaterial);
}
else if(lensflareMode == 1) // hollywood flares
{
// lens flare fun: cut some additional values
_brightPassFilterMaterial.SetVector ("threshhold", Vector4 (lensflareThreshhold, 1.0 / (1.0-lensflareThreshhold), 0.0, 0.0));
_brightPassFilterMaterial.SetFloat ("useSrcAlphaAsMask", 0.0);
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _brightPassFilterMaterial);
// ole: NEW and AWESOME new feature for hollyflares
// narrow down the size that creates on of these lines
_hollywoodFlareBlurMaterial.SetVector ("offsets", Vector4(0.0, (sepBlurSpread * 1.0) / quarterRezColor.height, 0.0, 0.0));
_hollywoodFlareBlurMaterial.SetTexture("_NonBlurredTex", quarterRezColor);
_hollywoodFlareBlurMaterial.SetVector ("tintColor", Vector4(flareColorA.r,flareColorA.g,flareColorA.b,flareColorA.a) * flareColorA.a * lensflareIntensity);
Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _hollywoodFlareBlurMaterial);
_hollywoodFlareStretchMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
_hollywoodFlareStretchMaterial.SetFloat("stretchWidth", hollyStretchWidth);
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _hollywoodFlareStretchMaterial);
for (var itera : int = 0; itera < hollywoodFlareBlurIterations; itera++ ) {
_separableBlurMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _separableBlurMaterial);
_separableBlurMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _separableBlurMaterial);
}
_addBrightStuffBlendOneOneMaterial.SetFloat ("intensity", 1.0);
Graphics.Blit (thirdQuarterRezColor, quarterRezColor, _addBrightStuffBlendOneOneMaterial);
}
else // 'both' flares
{
// lens flare fun: cut some additional values
_brightPassFilterMaterial.SetVector ("threshhold", Vector4 (lensflareThreshhold, 1.0 / (1.0-lensflareThreshhold), 0.0, 0.0));
_brightPassFilterMaterial.SetFloat ("useSrcAlphaAsMask", 0.0);
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _brightPassFilterMaterial);
// ole: NEW and AWESOME new feature for hollyflares
// narrow down the size that creates on of these lines
_hollywoodFlareBlurMaterial.SetVector ("offsets", Vector4(0.0, (sepBlurSpread * 1.0) / quarterRezColor.height, 0.0, 0.0));
_hollywoodFlareBlurMaterial.SetTexture("_NonBlurredTex", quarterRezColor);
_hollywoodFlareBlurMaterial.SetVector ("tintColor", Vector4(flareColorA.r,flareColorA.g,flareColorA.b,flareColorA.a) * flareColorA.a * lensflareIntensity);
Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _hollywoodFlareBlurMaterial);
_hollywoodFlareStretchMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
_hollywoodFlareStretchMaterial.SetFloat("stretchWidth", hollyStretchWidth);
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _hollywoodFlareStretchMaterial);
for (var ix : int = 0; ix < hollywoodFlareBlurIterations; ix++ ) {
_separableBlurMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _separableBlurMaterial);
_separableBlurMaterial.SetVector ("offsets", Vector4 ((sepBlurSpread * 1.0) / quarterRezColor.width, 0.0, 0.0, 0.0));
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _separableBlurMaterial);
}
// vignette for lens flares
_vignetteMaterial.SetFloat ("vignetteIntensity", 1.0);
Graphics.Blit (thirdQuarterRezColor, secondQuarterRezColor, _vignetteMaterial);
// creating the flares
// _lensFlareMaterial has One One Blend
_lensFlareMaterial.SetVector ("color0", Vector4(0.0,0.0,0.0,0.0) * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorA", Vector4(flareColorA.r,flareColorA.g,flareColorA.b,flareColorA.a) * flareColorA.a * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorB", Vector4(flareColorB.r,flareColorB.g,flareColorB.b,flareColorB.a) * flareColorB.a * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorC", Vector4(flareColorC.r,flareColorC.g,flareColorC.b,flareColorC.a) * flareColorC.a * lensflareIntensity);
_lensFlareMaterial.SetVector ("colorD", Vector4(flareColorD.r,flareColorD.g,flareColorD.b,flareColorD.a) * flareColorD.a * lensflareIntensity);
Graphics.Blit (secondQuarterRezColor, thirdQuarterRezColor, _lensFlareMaterial);
_addBrightStuffBlendOneOneMaterial.SetFloat ("intensity", 1.0);
Graphics.Blit (thirdQuarterRezColor, quarterRezColor, _addBrightStuffBlendOneOneMaterial);
}
}
_addBrightStuffBlendOneOneMaterial.SetFloat("intensity", bloomIntensity);
Graphics.Blit (quarterRezColor, destination, _addBrightStuffBlendOneOneMaterial);
RenderTexture.ReleaseTemporary (halfRezColor);
RenderTexture.ReleaseTemporary (quarterRezColor);
RenderTexture.ReleaseTemporary (secondQuarterRezColor);
RenderTexture.ReleaseTemporary (thirdQuarterRezColor);
}
}