Unityで、rotationの傾きを維持したままObjectの向きを変えたい

Question

実現したいもの

今こんなものが出来ているのですが、（画像1）

コードはこう

public class Move1 : MonoBehaviour {

    public float speed = 0.1f;
    float moveX = 0f;
    float moveZ = 0f;

    CharacterController controller;

    void Start(){
        controller = GetComponent<CharacterController>();
    }

    void Update() {
        moveX = Input.GetAxisRaw ("Horizontal") * speed;
        moveZ = Input.GetAxisRaw ("Vertical") * speed;
        Vector3 direction = new Vector3(moveX , 0, moveZ);

        controller.Move(direction);
    }
}

これをこの状態のまま(rotationが45のまま)、向きも変わるようにしたいんです。

試したこと1

一応、無料アセットStandardAssetsに付いてくるThirdPersonControllerで
・付属のThirdPersonUserController componentを無効化
・MainCameraのタグをUnTaggedに
・以下の移動用Scriptを作成

namespace UnityStandardAssets.Characters.ThirdPerson
{
    [RequireComponent(typeof (ThirdPersonCharacter))]
    public class Move2 : MonoBehaviour
    {
        private ThirdPersonCharacter m_Character; // A reference to the ThirdPersonCharacter on the object
        private Transform m_Cam;                  // A reference to the main camera in the scenes transform
        private Vector3 m_CamForward;             // The current forward direction of the camera
        private Vector3 m_Move;
        private bool m_Jump;                      // the world-relative desired move direction, calculated from the camForward and user input.


        private void Start()
        {
            // get the third person character ( this should never be null due to require component )
            m_Character = GetComponent<ThirdPersonCharacter>();
        }


        private void Update() {

        }


        // Fixed update is called in sync with physics
        private void FixedUpdate()
        {
            // read inputs
            float h = Input.GetAxisRaw("Horizontal");
            float v = Input.GetAxisRaw("Vertical");
            bool crouch = Input.GetKey(KeyCode.C);

            // キャラ操作の前後左右をカメラの方向に合わせる
            // 入力値をそのままキャラクターの移動方向として処理する
            m_Move = v*Vector3.forward + h*Vector3.right;

            // pass all parameters to the character control script
            m_Character.Move(m_Move, crouch, m_Jump);
            m_Jump = false;
        }
    }
}

すると、こんな感じで理想に近いものにはなるんですが（画像2）

これだと
・移動したい方向に向き切らないと進まない
・画像1と違って若干移動速度が一定ではないように見える（一定速度でもっとスーッと動かしたい）
・上下に動く時は遅くなってしまう
で、理想とはちょっと違うんです。

この動きの原因は恐らくファンクションとして使っている付属のThirdPersonCharacter.csの中にあると思うのですが
（文字数制限なので入れられませんでした）
http://coding-reptile.hateblo.jp/entry/2016/11/07/023330
ここの解説を見ても、どこを弄れば理想の動きになるのか分からず苦戦してます。
出来ればThirdPersonCharacter.csの中から必要な要素だけを取り出してスッキリさせたいのですが…

試したこと2

CharaconをやめてRigidbodyで。transform.upで回転軸を指定。

public class move2 : MonoBehaviour
{
    public float speed = 1f;

    private Vector3 Player_pos;
    private float x;
    private float z;
    private Rigidbody rigd;

    void Start()
    {
        Player_pos = GetComponent<Transform>().position; //プレイヤーのポジションを取得
        rigd = GetComponent<Rigidbody>();
    }

    void Update()
    {

        x = Input.GetAxisRaw("Horizontal");
        z = Input.GetAxisRaw("Vertical");

        rigd.velocity = new Vector3(x * speed, 0, z * speed);

        Vector3 diff = transform.position - Player_pos; //初期位置と現在地の座標差分を取得

        if (diff.magnitude > 0.01f)
        {
            transform.rotation = Quaternion.LookRotation(diff ,transform.up);//プレイヤーを回転
        }

        Player_pos = transform.position;

    }
}

結果は画像3

左右は希望通りの動きをしますが、前後入力すると強制的に傾き完全矯正
更に、1回斜め入力を入れるごとに、半分ずつ？ぐらいに傾きが小さくなっていきます(画像4)

試したこと3

ThirdPersonCharacter.csの解読を一旦諦め、
https://gomafrontier.com/unity/2883
こちらの考えをほぼそのまま流用し、傾き45のまま対象に向かせるものを試作してみました。
高低差が無くなっただけで、対象との位置関係とかは同じように考えられるはずなんですが、画像5のように、傾きが自動矯正されてしまいます。(Z軸X軸はちゃんと無視してくれてます)

色んな方法を探していますが、どうも原理が良く分かりません
どうかアドバイスを下さい。

Answer 1

Tilter改造案1
視界をひずめるのをビュー行列の代わりにプロジェクション行列で行うようにしてみました。旧Tilterよりも少々行列計算の回数が増えてしまいました...

using UnityEngine;

[RequireComponent(typeof(Camera))]
public class Tilter : MonoBehaviour
{
    [SerializeField][Range(-45.0f, 45.0f)] private float angle = 45.0f;
    private new Camera camera;

    private void Awake()
    {
        this.camera = this.GetComponent<Camera>();
    }
    
    private void OnPreCull()
    {
        var theta = this.angle * Mathf.Deg2Rad;
        var tiltMatrix = Matrix4x4.identity;
        tiltMatrix[5] = Mathf.Cos(theta);
        tiltMatrix[6] = Mathf.Sin(theta);
        this.camera.ResetProjectionMatrix();
        this.camera.projectionMatrix *= this.camera.worldToCameraMatrix * tiltMatrix * this.camera.cameraToWorldMatrix;
    }
}

Tilter改造案2
案1でやっていることをAwakeで1回だけ行うパターンです。
実行中の負荷はより小さいと思いますが、プレイモード中にプロジェクション関連のパラメーターを操作する...Projectionモードを変えたり、SizeやClipping Planesを変えたりすると、ひずみがリセットされてしまいます。また、プレイモード中にTilterのAngleを変えてもひずみ量は変わりません。さらにAwake時点でのビュー行列をプロジェクション行列ひずめに使っている都合上、プレイモード中にカメラを回転させるとひずみ方が奇妙になってしまう欠点もあります。平行移動するだけなら多分大丈夫だと思うのですが...

using UnityEngine;

[RequireComponent(typeof(Camera))]
public class Tilter : MonoBehaviour
{
    [SerializeField][Range(-45.0f, 45.0f)] private float angle = 45.0f;

    private void Awake()
    {
        var camera = this.GetComponent<Camera>();
        var theta = this.angle * Mathf.Deg2Rad;
        var tiltMatrix = Matrix4x4.identity;
        tiltMatrix[5] = Mathf.Cos(theta);
        tiltMatrix[6] = Mathf.Sin(theta);
        camera.projectionMatrix *= camera.worldToCameraMatrix * tiltMatrix * camera.cameraToWorldMatrix;
    }
}

Comments

[kaghita]

両方試しました。どちらも問題なく、どこまで行ってもちゃんと影が現れました。何度もお世話をかけてしまいました。ありがとうございます！

Answer 2

「試したこと1」の問題点をなんとか修正できないかと思って調べてみました。

「移動したい方向に向き切らないと進まない」について
転回速度を調整するともっさり感が改善するんじゃないかと思います。
ThirdPersonCharacterのインスペクター上で「Moving Turn Speed」と「Stationary Turn Speed」をもっと上げて、720とか1440にしてみてはいかがでしょう。

「画像1と違って若干移動速度が一定ではないように見える」について
ブレンドツリーによるモーション間の遷移にdampTimeが設定されており、一瞬で目的のモーションに遷移するわけではないことによるのかもしれません。
転回速度の調整だけでもだいぶ応答性がよくなるかと思いますが、まだ足りなければThirdPersonCharacterを下記のように少し改造して、ダンプ処理を無効化してみてはどうでしょうか。

using UnityEngine;

namespace UnityStandardAssets.Characters.ThirdPerson
{
	[RequireComponent(typeof(Rigidbody))]
	[RequireComponent(typeof(CapsuleCollider))]
	[RequireComponent(typeof(Animator))]
	public class ThirdPersonCharacter : MonoBehaviour
	{
		// ここまで変更なしのため省略

		void UpdateAnimator(Vector3 move)
		{
			// update the animator parameters
			
			// ここの2行を...
			/*
			m_Animator.SetFloat("Forward", m_ForwardAmount, 0.1f, Time.deltaTime);
			m_Animator.SetFloat("Turn", m_TurnAmount, 0.1f, Time.deltaTime);
			*/
			
			// このようにして、アニメーションのForwardとTurnが即座に目標値に到達するようにしてみる
			m_Animator.SetFloat("Forward", m_ForwardAmount);
			m_Animator.SetFloat("Turn", m_TurnAmount);
			
			// 残りは変更なしのため省略
		}

		// 残りは変更なしのため省略
	}
}

「上下に動く時は遅くなってしまう」について
ThirdPersonCharacterのMoveメソッドをご覧いただきますと、入力された移動ベクトルをキャラクターローカルの向きに変換して使用していることがお分かりいただけるかと思います。キャラクターが45°傾けられているので、キャラクターにとっては45°の坂道を上り下りしているような気分かもしれません。
Move2スクリプトでStart時点のキャラクターの回転を覚えておき、Move実行の際に渡すm_Moveを初期回転分だけ回してやってはいかがでしょう。

using UnityEngine;

namespace UnityStandardAssets.Characters.ThirdPerson
{
	[RequireComponent(typeof (ThirdPersonCharacter))]
	public class Move2 : MonoBehaviour
	{
		private ThirdPersonCharacter m_Character; // A reference to the ThirdPersonCharacter on the object
		private Transform m_Cam;				  // A reference to the main camera in the scenes transform
		private Vector3 m_CamForward;			  // The current forward direction of the camera
		private Vector3 m_Move;
		private bool m_Jump;					  // the world-relative desired move direction, calculated from the camForward and user input.
		private Quaternion m_InitialRotation;	  // The rotation of the transform at the Start

		private void Start()
		{
			// get the third person character ( this should never be null due to require component )
			m_Character = GetComponent<ThirdPersonCharacter>();
			m_InitialRotation = transform.rotation;
		}


		private void Update() {

		}


		// Fixed update is called in sync with physics
		private void FixedUpdate()
		{
			// read inputs
			float h = Input.GetAxisRaw("Horizontal");
			float v = Input.GetAxisRaw("Vertical");
			bool crouch = Input.GetKey(KeyCode.C);

			// キャラ操作の前後左右をカメラの方向に合わせる
			// 入力値をそのままキャラクターの移動方向として処理する
			m_Move = v*Vector3.forward + h*Vector3.right;

			// pass all parameters to the character control script
			m_Character.Move(m_InitialRotation * m_Move, crouch, m_Jump);
			m_Jump = false;
		}
	}
}

上記の3点を調整してみたところ、下図のような動きになりました。だいぶキビキビしたように思いますが、いかがでしょうか?

「上下に動く時は遅くなってしまう」について追記
すいません、前後方向の速さ調整が不十分で、水平方向よりも遅くなっていました。付け焼き刃ですがThirdPersonCharacterを下記のようにして、

using UnityEngine;

namespace UnityStandardAssets.Characters.ThirdPerson
{
	[RequireComponent(typeof(Rigidbody))]
	[RequireComponent(typeof(CapsuleCollider))]
	[RequireComponent(typeof(Animator))]
	public class ThirdPersonCharacter : MonoBehaviour
	{
		public Vector2 MoveSpeedMultiplier2D { get; set; } = Vector2.one; // プロパティを追加

		// 省略

		public void OnAnimatorMove()
		{
			// we implement this function to override the default root motion.
			// this allows us to modify the positional speed before it's applied.
			if (m_IsGrounded && Time.deltaTime > 0)
			{
				// X、Zに追加の速度調整を行う
				Vector3 v = Vector3.Scale(m_Animator.deltaPosition, new Vector3(MoveSpeedMultiplier2D.x, 0.0f, MoveSpeedMultiplier2D.y)) * m_MoveSpeedMultiplier / Time.deltaTime;

				// we preserve the existing y part of the current velocity.
				v.y = m_Rigidbody.velocity.y;
				m_Rigidbody.velocity = v;
			}
		}

		// 省略
	}
}

Move2を下記のようにしました。

using UnityEngine;

namespace UnityStandardAssets.Characters.ThirdPerson
{
	[RequireComponent(typeof (ThirdPersonCharacter))]
	public class Move2 : MonoBehaviour
	{
		private ThirdPersonCharacter m_Character; // A reference to the ThirdPersonCharacter on the object
		private Transform m_Cam;				  // A reference to the main camera in the scenes transform
		private Vector3 m_CamForward;			  // The current forward direction of the camera
		private Vector3 m_Move;
		private bool m_Jump;					  // the world-relative desired move direction, calculated from the camForward and user input.
		private Vector2 m_Gradient;				  // The gradient of the X-Z plane of the transform at the Start

		private void Start()
		{
			// get the third person character ( this should never be null due to require component )
			m_Character = GetComponent<ThirdPersonCharacter>();
			m_Gradient = new Vector2(-transform.up.x / transform.up.y, -transform.up.z / transform.up.y);
		}

		private void Update()
		{
		}

		// Fixed update is called in sync with physics
		private void FixedUpdate()
		{
			// read inputs
			float h = Input.GetAxisRaw("Horizontal");
			float v = Input.GetAxisRaw("Vertical");
			bool crouch = Input.GetKey(KeyCode.C);

			// キャラ操作の前後左右をカメラの方向に合わせる
			// 入力値をそのままキャラクターの移動方向として処理する
			m_Move = v*Vector3.forward + h*Vector3.right;

			// pass all parameters to the character control script
			Vector3 move = m_Move + Vector3.up * Vector2.Dot(new Vector2(h, v), this.m_Gradient);
			float absMoveX = Mathf.Abs(m_Move.x);
			float absMoveZ = Mathf.Abs(m_Move.z);
			float multiplierX = absMoveX > 0.01f ? new Vector2(move.x, move.y).magnitude / absMoveX : 1.0f;
			float multiplierZ = absMoveZ > 0.01f ? new Vector2(move.z, move.y).magnitude / absMoveZ : 1.0f;
			this.m_Character.MoveSpeedMultiplier2D = new Vector2(multiplierX, multiplierZ);
			m_Character.Move(move, crouch, m_Jump);
			m_Jump = false;
		}
	}
}

何だかThirdPersonCharacterは普通の正立したキャラクターを前提にした部分が随所にあるようで、けっこうやっかいですね...

おまけ
ご質問者さんの進めていらっしゃる45°回転方式で問題なさそうですが、オブジェクトを正立させたまま見た目だけ傾けることはできないかと思い、個人的な興味から実験してみました。

カメラに下記スクリプトを付けて視界を傾け...

using UnityEngine;

[RequireComponent(typeof(Camera))]
public class Tilter : MonoBehaviour
{
	[SerializeField][Range(-45.0f, 45.0f)] private float angle = 45.0f;
	private new Camera camera;

	private void Awake()
	{
		this.camera = this.GetComponent<Camera>();
	}

	private void OnPreCull()
	{
		var theta = this.angle * Mathf.Deg2Rad;
		var tiltMatrix = Matrix4x4.identity;
		tiltMatrix[5] = Mathf.Cos(theta);
		tiltMatrix[6] = Mathf.Sin(theta);
		this.camera.ResetWorldToCameraMatrix();
		this.camera.worldToCameraMatrix *= tiltMatrix;
	}
}

影を正常化するため、ビルトインのInternal-ScreenSpaceShadowsを一部変更したバージョンをResourcesフォルダーに入れ...

// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)

// Collects cascaded shadows into screen space buffer
// シェーダー名をビルトインのものとかぶらないよう変更
Shader "Hidden/Internal-ScreenSpaceShadowsForFunkyProjection" {
	
	// ここまで変更なしのため省略
	
	// 本来のコードはここでcomputeCameraSpacePosFromDepthを宣言するだけだが
	// 実装を定義し常にcomputeCameraSpacePosFromDepthAndInvProjMatを使うようにする
	inline float3 computeCameraSpacePosFromDepth(v2f i)
	{
		return computeCameraSpacePosFromDepthAndInvProjMat(i);
	}

	// ここまで変更なしのため省略
	
	// 以下、各サブシェーダー内のcomputeCameraSpacePosFromDepth実装定義をすべて削除する

	// ----------------------------------------------------------------------------------------
	// Subshader for hard shadows:
	// Just collect shadows into the buffer. Used on pre-SM3 GPUs and when hard shadows are picked.

	SubShader {
		Tags{ "ShadowmapFilter" = "HardShadow" }
		Pass {
			ZWrite Off ZTest Always Cull Off

			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag_hard
			#pragma multi_compile_shadowcollector
			ENDCG
		}
	}

	// ----------------------------------------------------------------------------------------
	// Subshader for hard shadows:
	// Just collect shadows into the buffer. Used on pre-SM3 GPUs and when hard shadows are picked.
	// This version does inv projection at the PS level, slower and less precise however more general.

	SubShader {
		Tags{ "ShadowmapFilter" = "HardShadow_FORCE_INV_PROJECTION_IN_PS" }
		Pass{
			ZWrite Off ZTest Always Cull Off

			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag_hard
			#pragma multi_compile_shadowcollector
			ENDCG
		}
	}

	// ----------------------------------------------------------------------------------------
	// Subshader that does soft PCF filtering while collecting shadows.
	// Requires SM3 GPU.

	Subshader {
		Tags {"ShadowmapFilter" = "PCF_SOFT"}
		Pass {
			ZWrite Off ZTest Always Cull Off

			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag_pcfSoft
			#pragma multi_compile_shadowcollector
			#pragma target 3.0
			ENDCG
		}
	}

	// ----------------------------------------------------------------------------------------
	// Subshader that does soft PCF filtering while collecting shadows.
	// Requires SM3 GPU.
	// This version does inv projection at the PS level, slower and less precise however more general.

	Subshader{
		Tags{ "ShadowmapFilter" = "PCF_SOFT_FORCE_INV_PROJECTION_IN_PS" }
		Pass{
			ZWrite Off ZTest Always Cull Off

			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag_pcfSoft
			#pragma multi_compile_shadowcollector
			#pragma target 3.0
			ENDCG
		}
	}

	Fallback Off
}

プロジェクト設定で上記シェーダーをスクリーンスペースシャドウ生成時に使用するよう設定したところ...

下図のような動きになりました。オブジェクトを剪断変形するかのようにひずめるため、45°回転方式とは違ってオブジェクトの上面が見えやすいという特徴があり、なんとなく縦に引き延ばされたように感じます。Z方向にわずかに縮めてやるとバランスがよくなるかもしれません。

Comments

[kaghita]

すみません。
”Move2スクリプトでStart時点のキャラクターの回転を覚えておき、Move実行の際に渡すm_Moveを初期回転分だけ回してやってはいかがでしょう。”
の部分をもっと詳しくお願いします。
回転を覚えておくというのは、transform.rotationを変数に代入しておくという意味でいいんですよね？
m_Moveを初期回転分だけ回すには、その変数をどこかに入れればいいということなんでしょうか？
だとしたらどこに入れればいいんでしょうか？
Move関数には回転を入れられる引数が無いから多分ここでは無いですよね？

[Bongo]

はい、「回転を覚えておく」と申し上げたのはm_InitialRotationにtransform.rotationを代入しておくことのつもりでした。そしてm_Moveを回すのは「m_Character.Move(m_InitialRotation * m_Move, crouch, m_Jump);」という具合にMove実行時に行っております。m_Moveをそのまま引数に渡す代わりに、m_Moveをm_InitialRotationで回転した結果を渡すようにしてみました。

ただし、その後の追記で申し上げたように、このやり方だと上下移動の速さがまだ足りなかったですね。45°に傾けていることによる錯覚のせいか案外いい感じに見えてしまい、気付くのが遅れてしまいました...

[kaghita]

おまけのForFunkyProjectionの方法を試してみたんですが、こちらの方がThirdPersonCharacterを使う必要がなく、理想的に動かせると判断しました。こっちだと球体のオブジェクトなどの表現に工夫が要りそうですが、この方法をベースに進めていこうと思います。丁寧なご教授ありがとうございました。

[kaghita]

すみません！
Resourceフォルダを作ってそこにForFunkyProjectionのファイルを入れてproject設定でこれを使うようにしたんですが、
undeclared identifier 'computeCameraSpacePosFromDepthAndInvProjMat'
Compiling Vertex program　とエラーが出てGameviewに影が出ないんです。
computeCameraSpacePosFromDepthAndInvProjMatが定義されてないということなんでしょうか？

[Bongo]

関数が見つからないようですね...
改造元にしたのは2019.2.6f1版ビルトインシェーダー（https://netstorage.unity3d.com/unity/fe82a0e88406/builtin_shaders-2019.2.6f1.zip ）に入っているDefaultResourcesExtra/Internal-ScreenSpaceShadows.shaderだったのですが、ファイルは合っていたでしょうか?あるいはバージョン違いとかもあるんでしょうかね?

念のため改造版のInternal-ScreenSpaceShadowsForFunkyProjection.shaderを省略なしで追記いたします。文字数が多いため別回答になってしまいますがご容赦ください。元のファイルにはけっこう詳細にコメントが入れられていましたが、それらを大幅に削除したところ1回答分におさめることができました。こちらでもうまくいかないでしょうか?

[kaghita]

エラーは無事解消しました。ありがとうございます。
ただ、今度は移動した場所によって、影が消えたり濃度が変わったりしてしまいます。
どうやらGameviewで正投影法(orthographic)を使っていることが関係しているようなのですが、CameraやLightの位置を色々変えたりしても今一つ法則性が見えてきません。出来ればorthographicを使いたいんです。
因みにThirdPersonCharacterは使わず、試したこと2のMove2Scriptで動かしています。

[Bongo]

なるほど...Orthographicでは試しておらず気付きませんでしたが、傾きを大きくすると影が消えますね...
どうやらPerspectiveでもClipping PlanesのFarを小さくしたりすると影が消え始めるようです。何だかライトから見たときのデプスをレンダリングする際に可視領域を正しく求められず、影描画の必要なしと判定されているような動きに感じました。

ちょっと試した感じですと、ビュー行列ではなくプロジェクション行列の方をいじればライトのデプスレンダリングに悪影響を与えずに済みそうでした。字数を使い切ってしまったためまたもや別回答に分かれてしまいましたが、Tilterに変更を加えてみましたので追記します。これだとどうでしょうか?

Answer 3

Internal-ScreenSpaceShadowsForFunkyProjection
省略なし、コメント削減

// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)

Shader "Hidden/Internal-ScreenSpaceShadowsForFunkyProjection" {
	Properties {
		_ShadowMapTexture ("", any) = "" {}
		_ODSWorldTexture("", 2D) = "" {}
	}

	CGINCLUDE

	UNITY_DECLARE_SHADOWMAP(_ShadowMapTexture);
	float4 _ShadowMapTexture_TexelSize;
	#define SHADOWMAPSAMPLER_AND_TEXELSIZE_DEFINED
	sampler2D _ODSWorldTexture;

	#include "UnityCG.cginc"
	#include "UnityShadowLibrary.cginc"

	#define UNITY_USE_CASCADE_BLENDING 0
	#define UNITY_CASCADE_BLEND_DISTANCE 0.1

	struct appdata {
		float4 vertex : POSITION;
		float2 texcoord : TEXCOORD0;
		#ifdef UNITY_STEREO_INSTANCING_ENABLED
			float3 ray0 : TEXCOORD1;
			float3 ray1 : TEXCOORD2;
		#else
			float3 ray : TEXCOORD1;
		#endif
		UNITY_VERTEX_INPUT_INSTANCE_ID
	};

	struct v2f {

		float4 pos : SV_POSITION;
		float4 uv : TEXCOORD0;
		float3 ray : TEXCOORD1;
		float3 orthoPosNear : TEXCOORD2;
		float3 orthoPosFar	: TEXCOORD3;
		UNITY_VERTEX_INPUT_INSTANCE_ID
		UNITY_VERTEX_OUTPUT_STEREO
	};

	v2f vert (appdata v)
	{
		v2f o;
		UNITY_SETUP_INSTANCE_ID(v);
		UNITY_TRANSFER_INSTANCE_ID(v, o);
		UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
		float4 clipPos;
		#if defined(STEREO_CUBEMAP_RENDER_ON)
			clipPos = mul(UNITY_MATRIX_VP, mul(unity_ObjectToWorld, v.vertex));
		#else
			clipPos = UnityObjectToClipPos(v.vertex);
		#endif
		o.pos = clipPos;
		o.uv.xy = v.texcoord;

		o.uv.zw = ComputeNonStereoScreenPos(clipPos);

		#ifdef UNITY_STEREO_INSTANCING_ENABLED
			o.ray = unity_StereoEyeIndex == 0 ? v.ray0 : v.ray1;
		#else
			o.ray = v.ray;
		#endif

		clipPos.y *= _ProjectionParams.x;
		float3 orthoPosNear = mul(unity_CameraInvProjection, float4(clipPos.x,clipPos.y,-1,1)).xyz;
		float3 orthoPosFar	= mul(unity_CameraInvProjection, float4(clipPos.x,clipPos.y, 1,1)).xyz;
		orthoPosNear.z *= -1;
		orthoPosFar.z *= -1;
		o.orthoPosNear = orthoPosNear;
		o.orthoPosFar = orthoPosFar;

		return o;
	}

	UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);
	float4 unity_ShadowCascadeScales;

	#if defined (SHADOWS_SPLIT_SPHERES)
		#define GET_CASCADE_WEIGHTS(wpos, z)	getCascadeWeights_splitSpheres(wpos)
	#else
		#define GET_CASCADE_WEIGHTS(wpos, z)	getCascadeWeights( wpos, z )
	#endif

	#if defined (SHADOWS_SINGLE_CASCADE)
		#define GET_SHADOW_COORDINATES(wpos,cascadeWeights) getShadowCoord_SingleCascade(wpos)
	#else
		#define GET_SHADOW_COORDINATES(wpos,cascadeWeights) getShadowCoord(wpos,cascadeWeights)
	#endif

	inline fixed4 getCascadeWeights(float3 wpos, float z)
	{
		fixed4 zNear = float4( z >= _LightSplitsNear );
		fixed4 zFar = float4( z < _LightSplitsFar );
		fixed4 weights = zNear * zFar;
		return weights;
	}

	inline fixed4 getCascadeWeights_splitSpheres(float3 wpos)
	{
		float3 fromCenter0 = wpos.xyz - unity_ShadowSplitSpheres[0].xyz;
		float3 fromCenter1 = wpos.xyz - unity_ShadowSplitSpheres[1].xyz;
		float3 fromCenter2 = wpos.xyz - unity_ShadowSplitSpheres[2].xyz;
		float3 fromCenter3 = wpos.xyz - unity_ShadowSplitSpheres[3].xyz;
		float4 distances2 = float4(dot(fromCenter0,fromCenter0), dot(fromCenter1,fromCenter1), dot(fromCenter2,fromCenter2), dot(fromCenter3,fromCenter3));
		fixed4 weights = float4(distances2 < unity_ShadowSplitSqRadii);
		weights.yzw = saturate(weights.yzw - weights.xyz);
		return weights;
	}

	inline float4 getShadowCoord( float4 wpos, fixed4 cascadeWeights )
	{
		float3 sc0 = mul (unity_WorldToShadow[0], wpos).xyz;
		float3 sc1 = mul (unity_WorldToShadow[1], wpos).xyz;
		float3 sc2 = mul (unity_WorldToShadow[2], wpos).xyz;
		float3 sc3 = mul (unity_WorldToShadow[3], wpos).xyz;
		float4 shadowMapCoordinate = float4(sc0 * cascadeWeights[0] + sc1 * cascadeWeights[1] + sc2 * cascadeWeights[2] + sc3 * cascadeWeights[3], 1);
		#if defined(UNITY_REVERSED_Z)
			float  noCascadeWeights = 1 - dot(cascadeWeights, float4(1, 1, 1, 1));
			shadowMapCoordinate.z += noCascadeWeights;
		#endif
		return shadowMapCoordinate;
	}

	inline float4 getShadowCoord_SingleCascade( float4 wpos )
	{
		return float4( mul (unity_WorldToShadow[0], wpos).xyz, 0);
	}

	inline float3 computeCameraSpacePosFromDepthAndInvProjMat(v2f i)
	{
		float zdepth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv.xy);

		#if defined(UNITY_REVERSED_Z)
			zdepth = 1 - zdepth;
		#endif

		float4 clipPos = float4(i.uv.zw, zdepth, 1.0);
		clipPos.xyz = 2.0f * clipPos.xyz - 1.0f;
		float4 camPos = mul(unity_CameraInvProjection, clipPos);
		camPos.xyz /= camPos.w;
		camPos.z *= -1;
		return camPos.xyz;
	}

	inline float3 computeCameraSpacePosFromDepthAndVSInfo(v2f i)
	{
		float zdepth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv.xy);

		float depth = lerp(Linear01Depth(zdepth), zdepth, unity_OrthoParams.w);
		#if defined(UNITY_REVERSED_Z)
			zdepth = 1 - zdepth;
		#endif

		float3 vposPersp = i.ray * depth;
		float3 vposOrtho = lerp(i.orthoPosNear, i.orthoPosFar, zdepth);
		float3 camPos = lerp(vposPersp, vposOrtho, unity_OrthoParams.w);
		return camPos.xyz;
	}

	// computeCameraSpacePosFromDepthで常にcomputeCameraSpacePosFromDepthAndInvProjMatを使うよう変更
	inline float3 computeCameraSpacePosFromDepth(v2f i)
	{
		return computeCameraSpacePosFromDepthAndInvProjMat(i);
	}

	fixed4 frag_hard (v2f i) : SV_Target
	{
		UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
		float4 wpos;
		float3 vpos;

		#if defined(STEREO_CUBEMAP_RENDER_ON)
			wpos.xyz = tex2D(_ODSWorldTexture, i.uv.xy).xyz;
			wpos.w = 1.0f;
			vpos = mul(unity_WorldToCamera, wpos).xyz;
		#else
			vpos = computeCameraSpacePosFromDepth(i);
			wpos = mul (unity_CameraToWorld, float4(vpos,1));
		#endif

		fixed4 cascadeWeights = GET_CASCADE_WEIGHTS (wpos, vpos.z);
		float4 shadowCoord = GET_SHADOW_COORDINATES(wpos, cascadeWeights);

		fixed shadow = UNITY_SAMPLE_SHADOW(_ShadowMapTexture, shadowCoord);
		shadow = lerp(_LightShadowData.r, 1.0, shadow);

		fixed4 res = shadow;
		return res;
	}

	fixed4 frag_pcfSoft(v2f i) : SV_Target
	{
		UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
		float4 wpos;
		float3 vpos;

		#if defined(STEREO_CUBEMAP_RENDER_ON)
			wpos.xyz = tex2D(_ODSWorldTexture, i.uv.xy).xyz;
			wpos.w = 1.0f;
			vpos = mul(unity_WorldToCamera, wpos).xyz;
		#else
			vpos = computeCameraSpacePosFromDepth(i);
			wpos = mul(unity_CameraToWorld, float4(vpos,1));
		#endif

		fixed4 cascadeWeights = GET_CASCADE_WEIGHTS(wpos, vpos.z);
		float4 coord = GET_SHADOW_COORDINATES(wpos, cascadeWeights);

		float3 receiverPlaneDepthBias = 0.0;
		#ifdef UNITY_USE_RECEIVER_PLANE_BIAS
			float3 coordCascade0 = getShadowCoord_SingleCascade(wpos);
			float biasMultiply = dot(cascadeWeights,unity_ShadowCascadeScales);
			receiverPlaneDepthBias = UnityGetReceiverPlaneDepthBias(coordCascade0.xyz, biasMultiply);
		#endif

		#if defined(SHADER_API_MOBILE)
			half shadow = UnitySampleShadowmap_PCF5x5(coord, receiverPlaneDepthBias);
		#else
			half shadow = UnitySampleShadowmap_PCF7x7(coord, receiverPlaneDepthBias);
		#endif
		shadow = lerp(_LightShadowData.r, 1.0f, shadow);

		#if UNITY_USE_CASCADE_BLENDING && !defined(SHADOWS_SPLIT_SPHERES) && !defined(SHADOWS_SINGLE_CASCADE)
			half4 z4 = (float4(vpos.z,vpos.z,vpos.z,vpos.z) - _LightSplitsNear) / (_LightSplitsFar - _LightSplitsNear);
			half alpha = dot(z4 * cascadeWeights, half4(1,1,1,1));

			UNITY_BRANCH
			if (alpha > 1 - UNITY_CASCADE_BLEND_DISTANCE)
			{
				alpha = (alpha - (1 - UNITY_CASCADE_BLEND_DISTANCE)) / UNITY_CASCADE_BLEND_DISTANCE;
				cascadeWeights = fixed4(0, cascadeWeights.xyz);
				coord = GET_SHADOW_COORDINATES(wpos, cascadeWeights);

				#ifdef UNITY_USE_RECEIVER_PLANE_BIAS
					biasMultiply = dot(cascadeWeights,unity_ShadowCascadeScales);
					receiverPlaneDepthBias = UnityGetReceiverPlaneDepthBias(coordCascade0.xyz, biasMultiply);
				#endif

				half shadowNextCascade = UnitySampleShadowmap_PCF3x3(coord, receiverPlaneDepthBias);
				shadowNextCascade = lerp(_LightShadowData.r, 1.0f, shadowNextCascade);
				shadow = lerp(shadow, shadowNextCascade, alpha);
			}
		#endif

		return shadow;
	}
	ENDCG

	SubShader {
		Tags{ "ShadowmapFilter" = "HardShadow" }
		Pass {
			ZWrite Off ZTest Always Cull Off

			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag_hard
			#pragma multi_compile_shadowcollector
			ENDCG
		}
	}

	SubShader {
		Tags{ "ShadowmapFilter" = "HardShadow_FORCE_INV_PROJECTION_IN_PS" }
		Pass{
			ZWrite Off ZTest Always Cull Off

			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag_hard
			#pragma multi_compile_shadowcollector
			ENDCG
		}
	}

	Subshader {
		Tags {"ShadowmapFilter" = "PCF_SOFT"}
		Pass {
			ZWrite Off ZTest Always Cull Off

			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag_pcfSoft
			#pragma multi_compile_shadowcollector
			#pragma target 3.0
			ENDCG
		}
	}

	Subshader{
		Tags{ "ShadowmapFilter" = "PCF_SOFT_FORCE_INV_PROJECTION_IN_PS" }
		Pass{
			ZWrite Off ZTest Always Cull Off

			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag_pcfSoft
			#pragma multi_compile_shadowcollector
			#pragma target 3.0
			ENDCG
		}
	}

	Fallback Off
}