Texture2Dをななめに切り出す方法

Question

Texture2Dをななめに切り出す方法を探しています。
4点を基準に画像を切り取る関数などはないでしょうか？
GetPixelsの引数も一つの座標と幅、高さしかないためどう斜めに切り取ればいいかわかりません。

Answer 1

Unityの備え付けの機能で目的に適いそうなものは見つけられませんでした...
ですが、テクスチャを4点で切り取るというのは面白そうでしたので、どうにかならないかと思い、下記のような方法を試してみましたが、ご参考になりますでしょうか?

ホモグラフィ変換で検索すると役に立ちそうなサイトがいろいろ出てきましたので、それらを参考にしました。

下のような画像をp、q、r、sの4点で切り抜きたいとすると、

下の式のような、元の四隅(0, 0)、(0, 1)、(1, 1)、(1, 0)を与えると切り抜きたい四隅p、q、r、sを得られるようなa、b、c、d、e、f、g、hが分かればいいのかと思います。

上の式のx、yに(0, 0)、(0, 1)、(1, 1)、(1, 0)を代入すると、まずc、fを

と確定でき、



の関係が得られます。これらを変形すると、

の形になってg、hを確定でき、芋づる式にa、b、c、dが決定します。

Unityのデフォルトのシェーダーを一部改造して、生のUV座標の代わりに上記行列で変換した座標を使うようにしました。スプライト用シェーダーをベースにしましたが、他のものでも構わないかと思います。

Shader "Sprites/Homography"
{
	Properties
	{
		[PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
		_Color ("Tint", Color) = (1,1,1,1)
		[MaterialToggle] PixelSnap ("Pixel snap", Float) = 0
		[HideInInspector] _RendererColor ("RendererColor", Color) = (1,1,1,1)
		[HideInInspector] _Flip ("Flip", Vector) = (1,1,1,1)
		[PerRendererData] _AlphaTex ("External Alpha", 2D) = "white" {}
		[PerRendererData] _EnableExternalAlpha ("Enable External Alpha", Float) = 0
		[HideInInspector] _BottomLeftTopLeft ("BottomLeftTopLeft", Vector) = (0,0,0,1) // 追加...左下と左上の隅
		[HideInInspector] _TopRightBottomRight ("TopRightBottomRight", Vector) = (1,1,1,0) // 追加...右上と右下の隅
		[HideInInspector] _HomographyMatrixR0 ("HomographyMatrixR0", Vector) = (1,0,0,0) // 追加...UV変換行列0行目
		[HideInInspector] _HomographyMatrixR1 ("HomographyMatrixR1", Vector) = (0,1,0,0) // 追加...UV変換行列1行目
		[HideInInspector] _HomographyMatrixR2 ("HomographyMatrixR2", Vector) = (0,0,1,0) // 追加...UV変換行列2行目（実際にはこの行はいつも一定なので、削除してもいいかと思います）
		[HideInInspector] _HomographyMatrixR3 ("HomographyMatrixR3", Vector) = (0,0,0,1) // 追加...UV変換行列3行目
	}

	SubShader
	{
		Tags
		{ 
			"Queue"="Transparent" 
			"IgnoreProjector"="True" 
			"RenderType"="Transparent" 
			"PreviewType"="Plane"
			"CanUseSpriteAtlas"="True"
		}

		Cull Off
		Lighting Off
		ZWrite Off
		Blend One OneMinusSrcAlpha

		Pass
		{
		CGPROGRAM
			#pragma vertex SpriteVert
			#pragma fragment SpriteFrag
			#pragma target 2.0
			#pragma multi_compile_instancing
			#pragma multi_compile _ PIXELSNAP_ON
			#pragma multi_compile _ ETC1_EXTERNAL_ALPHA
			// 以下、#include "UnitySprites.cginc"の代わりにUnitySprites.cgincの内容をペーストし、一部修正を加える
			#include "UnityCG.cginc"

			#ifdef UNITY_INSTANCING_ENABLED

			    UNITY_INSTANCING_CBUFFER_START(PerDrawSprite)
			        // SpriteRenderer.Color while Non-Batched/Instanced.
			        fixed4 unity_SpriteRendererColorArray[UNITY_INSTANCED_ARRAY_SIZE];
			        // this could be smaller but that's how bit each entry is regardless of type
			        float4 unity_SpriteFlipArray[UNITY_INSTANCED_ARRAY_SIZE];
			    UNITY_INSTANCING_CBUFFER_END

			    #define _RendererColor unity_SpriteRendererColorArray[unity_InstanceID]
			    #define _Flip unity_SpriteFlipArray[unity_InstanceID]

			#endif // instancing

			CBUFFER_START(UnityPerDrawSprite)
			#ifndef UNITY_INSTANCING_ENABLED
			    fixed4 _RendererColor;
			    float4 _Flip;
			#endif
			    float _EnableExternalAlpha;
			CBUFFER_END

			// Material Color.
			fixed4 _Color;

			float4 _HomographyMatrixR0; // 追加...UV座標変換用の行列0行目
			float4 _HomographyMatrixR1; // 追加...UV座標変換用の行列1行目
			float4 _HomographyMatrixR2; // 追加...UV座標変換用の行列2行目（実際にはこの行はいつも一定なので、削除してもいいかと思います）
			float4 _HomographyMatrixR3; // 追加...UV座標変換用の行列3行目

			struct appdata_t
			{
			    float4 vertex   : POSITION;
			    float4 color    : COLOR;
			    float2 texcoord : TEXCOORD0;
			    UNITY_VERTEX_INPUT_INSTANCE_ID
			};

			struct v2f
			{
			    float4 vertex   : SV_POSITION;
			    fixed4 color    : COLOR;
			    float3 texcoord : TEXCOORD0; // 変更...float2をfloat3に
			    UNITY_VERTEX_OUTPUT_STEREO
			};

			v2f SpriteVert(appdata_t IN)
			{
			    v2f OUT;

			    UNITY_SETUP_INSTANCE_ID (IN);
			    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);

			#ifdef UNITY_INSTANCING_ENABLED
			    IN.vertex.xy *= _Flip.xy;
			#endif

			    OUT.vertex = UnityObjectToClipPos(IN.vertex);
			    OUT.texcoord = mul(float4x4(_HomographyMatrixR0, _HomographyMatrixR1, _HomographyMatrixR2, _HomographyMatrixR3), float4(IN.texcoord, 0.0, 1.0)).xyw; // 変更...IN.texcoordを変換してからx、y、wを渡す
			    OUT.color = IN.color * _Color * _RendererColor;

			    #ifdef PIXELSNAP_ON
			    OUT.vertex = UnityPixelSnap (OUT.vertex);
			    #endif

			    return OUT;
			}

			sampler2D _MainTex;
			sampler2D _AlphaTex;

			fixed4 SampleSpriteTexture (float2 uv)
			{
			    fixed4 color = tex2D (_MainTex, uv);

			#if ETC1_EXTERNAL_ALPHA
			    fixed4 alpha = tex2D (_AlphaTex, uv);
			    color.a = lerp (color.a, alpha.r, _EnableExternalAlpha);
			#endif

			    return color;
			}

			fixed4 SpriteFrag(v2f IN) : SV_Target
			{
			    fixed4 c = SampleSpriteTexture (IN.texcoord.xy / IN.texcoord.z) * IN.color; // 変更...受け取ったIN.texcoordのx、yをzで割ってサンプリング座標とする
			    c.rgb *= c.a;
			    return c;
			}
		ENDCG
		}
	}
	CustomEditor "HomographyShaderGUI" // 追加...パラメータ設定用のカスタムUI
}

また、シェーダーのパラメータ設定用スクリプトを作り、その中で先の式により変換行列を作ってシェーダーに渡しました。

using UnityEditor;
using UnityEngine;

public class HomographyShaderGUI : ShaderGUI
{
    public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] properties)
    {
        var material = materialEditor.target as Material;
        var bottomLeftTopLeft = FindProperty("_BottomLeftTopLeft", properties).vectorValue;
        var topRightBottomRight = FindProperty("_TopRightBottomRight", properties).vectorValue;
        EditorGUI.BeginChangeCheck();
        var bottomLeft = EditorGUILayout.Vector2Field(
            "Bottom Left",
            new Vector2(bottomLeftTopLeft.x, bottomLeftTopLeft.y));
        var topLeft = EditorGUILayout.Vector2Field(
            "Top Left",
            new Vector2(bottomLeftTopLeft.z, bottomLeftTopLeft.w));
        var topRight = EditorGUILayout.Vector2Field(
            "Top Right",
            new Vector2(topRightBottomRight.x, topRightBottomRight.y));
        var bottomRight = EditorGUILayout.Vector2Field(
            "Bottom Right",
            new Vector2(topRightBottomRight.z, topRightBottomRight.w));
        if (EditorGUI.EndChangeCheck())
        {
            material.SetVector(
                "_BottomLeftTopLeft",
                new Vector4(bottomLeft.x, bottomLeft.y, topLeft.x, topLeft.y));
            material.SetVector(
                "_TopRightBottomRight",
                new Vector4(topRight.x, topRight.y, bottomRight.x, bottomRight.y));
            var matrix = HomographyMatrix(bottomLeft, topLeft, topRight, bottomRight);
            material.SetVector("_HomographyMatrixR0", matrix.GetRow(0));
            material.SetVector("_HomographyMatrixR1", matrix.GetRow(1));
            material.SetVector("_HomographyMatrixR2", matrix.GetRow(2));
            material.SetVector("_HomographyMatrixR3", matrix.GetRow(3));
        }
        base.OnGUI(materialEditor, properties);
    }

    /// <summary>
    ///     Vector2の外積を求める
    /// </summary>
    /// <param name="a">左項</param>
    /// <param name="b">右項</param>
    /// <returns>外積</returns>
    private static float Cross(Vector2 a, Vector2 b)
    {
        return (a.x * b.y) - (b.x * a.y);
    }

    /// <summary>
    ///     4隅の座標を変換する行列を求める
    /// </summary>
    /// <param name="bl">(0, 0)の変換先</param>
    /// <param name="tl">(0, 1)の変換先</param>
    /// <param name="tr">(1, 1)の変換先</param>
    /// <param name="br">(1, 0)の変換先</param>
    /// <returns>変換行列</returns>
    private static Matrix4x4 HomographyMatrix(Vector2 bl, Vector2 tl, Vector2 tr, Vector2 br)
    {
        var cf = bl; // cとfはblの座標で確定
        Vector2 ghMatR0;
        Vector2 ghMatR1;
        Inverse(br - tr, tl - tr, out ghMatR0, out ghMatR1);
        var v = (bl + tr) - (tl + br);
        var gh = new Vector2(Vector2.Dot(ghMatR0, v), Vector2.Dot(ghMatR1, v)); // まずgとhを求める
        var ad = ((gh.x + 1.0f) * br) - bl; // gを使ってaとdを求める
        var be = ((gh.y + 1.0f) * tl) - bl; // hを使ってbとeを求める
        var result = Matrix4x4.identity; // Unityで扱うには4次元ベースの方が便利そうなので、Matrix4x4に整形しました
        result.SetColumn(0, new Vector4(ad.x, ad.y, 0.0f, gh.x));
        result.SetColumn(1, new Vector4(be.x, be.y, 0.0f, gh.y));
        result.SetColumn(2, new Vector4(0.0f, 0.0f, 1.0f, 0.0f));
        result.SetColumn(3, new Vector4(cf.x, cf.y, 0.0f, 1.0f));
        return result;
    }

    /// <summary>
    ///     2x2行列の逆行列を求める
    /// </summary>
    /// <param name="column0">元の行列の0列目</param>
    /// <param name="column1">元の行列の1列目</param>
    /// <param name="inverseRow0">逆行列の0行目</param>
    /// <param name="inverseRow1">逆行列の1行目</param>
    private static void Inverse(Vector2 column0, Vector2 column1, out Vector2 inverseRow0, out Vector2 inverseRow1)
    {
        var determinant = Cross(column0, column1);
        inverseRow0 = new Vector2(column1.y, -column1.x) / determinant;
        inverseRow1 = new Vector2(-column0.y, column0.x) / determinant;
    }
}

動かしてみるとこんな感じです。

Comments

[Aran1976734]

スクリプトから動かしたかったので助かりました！
丁寧に行列の説明までしてくださりとても分かりやすかったです！
コードもありがとうございます！！
無事切り出すことができました！

Answer 2

xstarteraさんのコメントに対して追記しようとしましたが、またもやうまくいかなかったため別回答にて追記します（一応字数制限はクリアしたつもりでしたが...何がいけなかったんでしょうか?）。

4つのノブを動かしてUV座標を決めるパターンを作ってみました。ノブのドラッグ時に新しいUV座標を求め、マテリアルのホモグラフィ行列を更新する方式としています。

ヒエラルキー

• ResultLabel、OriginalLabel...板の上方に浮かんでいる文字
• ResultQuad...後述のResultControllerをアタッチした板、マテリアルは後述のUnlit/Homographyを使用
• OriginalQuad...元のテクスチャを表示する板、マテリアルは改変なしのUnlit/Textureを使用
• Line...ノブを繋ぐ線を描画するためのラインレンダラーをアタッチ
• TopLeftKnob〜BottomLeftKnob...4色の球体、それぞれ後述のKnobControllerがアタッチされており、あらかじめインスペクタ上でCornerToControlを対応する頂点の値にセットしておく（併せてLine、OriginalQuad、ResultQuadもそれぞれヒエラルキー上の各オブジェクトをセット）

TopLeftKnob〜BottomLeftKnob用スクリプト

using System.Linq;
using UnityEngine;

public class KnobController : MonoBehaviour
{
    public enum CornerToControl
    {
        TopLeft,
        TopRight,
        BottomRight,
        BottomLeft
    }

    private static readonly Vector2[] UvForCorner =
    {
        new Vector2(0.0f, 1.0f),
        new Vector2(1.0f, 1.0f),
        new Vector2(1.0f, 0.0f),
        new Vector2(0.0f, 0.0f)
    };

    public CornerToControl Corner;
    public LineRenderer Line;
    public GameObject OriginalQuad;
    public GameObject ResultQuad;
    private Vector3 originalQuadOrigin;
    private Vector3 originalQuadUVector;
    private Vector3 originalQuadVVector;
    private ResultController resultController;

    /// <summary>
    ///     直線と交差する平面上のUV座標を得る
    /// </summary>
    /// <param name="rayOrigin">直線の起点のワールド座標</param>
    /// <param name="rayDirection">直線のワールド方向</param>
    /// <param name="planeU">平面のワールドUベクトル</param>
    /// <param name="planeV">平面のワールドVベクトル</param>
    /// <param name="planeOrigin">平面原点のワールド座標</param>
    /// <returns>UV座標（交点のワールド座標はplaneU * u + planeV * v + planeOrigin）</returns>
    private static Vector2 GetUv(
        Vector3 rayOrigin,
        Vector3 rayDirection,
        Vector3 planeU,
        Vector3 planeV,
        Vector3 planeOrigin)
    {
        var matrix = Matrix4x4.identity;
        matrix.SetColumn(0, planeU);
        matrix.SetColumn(1, planeV);
        matrix.SetColumn(2, -rayDirection);
        return matrix.inverse * (rayOrigin - planeOrigin);
    }

    private void OnMouseDrag()
    {
        this.UpdateKnobPosition(Input.mousePosition);
    }

    private void Start()
    {
        this.resultController = this.ResultQuad.GetComponent<ResultController>();

        // OriginalQuadのメッシュの4頂点から原点・Uベクトル・Vベクトルを調べ、ノブの初期位置を合わせる
        var originalMesh = this.OriginalQuad.GetComponent<MeshFilter>().sharedMesh;
        var vertices = originalMesh.vertices.Select(v => this.OriginalQuad.transform.TransformPoint(v)).ToArray();
        var uvs = originalMesh.uv;
        var vertexCount = vertices.Length;
        var bottomLeft = Vector3.zero;
        var topLeft = Vector3.up;
        var bottomRight = Vector3.right;
        for (var i = 0; i < vertexCount; i++)
        {
            var uv = uvs[i];
            if (uv == UvForCorner[(int)CornerToControl.BottomLeft])
            {
                bottomLeft = vertices[i];
            }
            else if (uv == UvForCorner[(int)CornerToControl.TopLeft])
            {
                topLeft = vertices[i];
            }
            else if (uv == UvForCorner[(int)CornerToControl.BottomRight])
            {
                bottomRight = vertices[i];
            }
        }

        this.originalQuadOrigin = bottomLeft;
        this.originalQuadUVector = bottomRight - bottomLeft;
        this.originalQuadVVector = topLeft - bottomLeft;
        var knobUv = UvForCorner[(int)this.Corner];
        for (var i = 0; i < vertexCount; i++)
        {
            if (uvs[i] == knobUv)
            {
                this.UpdateKnobPosition(Camera.main.WorldToScreenPoint(vertices[i]));
                break;
            }
        }

        this.UpdateLine();
    }

    private void UpdateKnobPosition(Vector3 screenPosition)
    {
        // ノブの位置を更新
        // UV座標はレイキャストで求めてもいいのですが、レイがOriginalQuadを外れても対応できるよう、自前で算出することにしました
        var ray = Camera.main.ScreenPointToRay(screenPosition);
        var newUv = GetUv(
            ray.origin,
            ray.direction,
            this.originalQuadUVector,
            this.originalQuadVVector,
            this.originalQuadOrigin);
        // ノブの位置はレイ交点とレイ原点の中間としました
        this.transform.position = Vector3.Lerp(
            ray.origin,
            (this.originalQuadUVector * newUv.x) + (this.originalQuadVVector * newUv.y) + this.originalQuadOrigin,
            0.5f);
        // ノブと対応するResultControllerの頂点に求めたUV座標をセット
        switch (this.Corner)
        {
            default:
            case CornerToControl.TopLeft:
                this.resultController.TopLeft = newUv;
                break;
            case CornerToControl.TopRight:
                this.resultController.TopRight = newUv;
                break;
            case CornerToControl.BottomRight:
                this.resultController.BottomRight = newUv;
                break;
            case CornerToControl.BottomLeft:
                this.resultController.BottomLeft = newUv;
                break;
        }
        this.UpdateLine(); // ラインレンダラーの頂点位置を更新
    }

    private void UpdateLine()
    {
        this.Line.SetPosition((int)this.Corner, this.transform.position);
    }
}

ResultQuad用スクリプト
ここに以前の回答で例示したホモグラフィ変換行列算出メソッドを引っ越しました。4頂点のUV座標はプロパティとし、set中でマテリアル更新メソッドを呼ぶことにしました。

using UnityEngine;

[RequireComponent(typeof(Renderer))]
public class ResultController : MonoBehaviour
{
    private Vector2 bottomLeft;
    private Vector2 bottomRight;
    private Material resultMaterial;
    private Vector2 topLeft;
    private Vector2 topRight;

    public Vector2 BottomLeft
    {
        get { return this.bottomLeft; }
        set
        {
            this.bottomLeft = value;
            this.UpdateTexture();
        }
    }

    public Vector2 BottomRight
    {
        get { return this.bottomRight; }
        set
        {
            this.bottomRight = value;
            this.UpdateTexture();
        }
    }

    public Vector2 TopLeft
    {
        get { return this.topLeft; }
        set
        {
            this.topLeft = value;
            this.UpdateTexture();
        }
    }

    public Vector2 TopRight
    {
        get { return this.topRight; }
        set
        {
            this.topRight = value;
            this.UpdateTexture();
        }
    }

    private static float Cross(Vector2 a, Vector2 b)
    {
        return (a.x * b.y) - (b.x * a.y);
    }

    private static Matrix4x4 HomographyMatrix(Vector2 bl, Vector2 tl, Vector2 tr, Vector2 br)
    {
        var cf = bl;
        Vector2 ghMatR0;
        Vector2 ghMatR1;
        Inverse(br - tr, tl - tr, out ghMatR0, out ghMatR1);
        var v = (bl + tr) - (tl + br);
        var gh = new Vector2(Vector2.Dot(ghMatR0, v), Vector2.Dot(ghMatR1, v));
        var ad = ((gh.x + 1.0f) * br) - bl;
        var be = ((gh.y + 1.0f) * tl) - bl;
        var result = Matrix4x4.identity;
        result.SetColumn(0, new Vector4(ad.x, ad.y, 0.0f, gh.x));
        result.SetColumn(1, new Vector4(be.x, be.y, 0.0f, gh.y));
        result.SetColumn(2, new Vector4(0.0f, 0.0f, 1.0f, 0.0f));
        result.SetColumn(3, new Vector4(cf.x, cf.y, 0.0f, 1.0f));
        return result;
    }

    private static void Inverse(Vector2 column0, Vector2 column1, out Vector2 inverseRow0, out Vector2 inverseRow1)
    {
        var determinant = Cross(column0, column1);
        inverseRow0 = new Vector2(column1.y, -column1.x) / determinant;
        inverseRow1 = new Vector2(-column0.y, column0.x) / determinant;
    }

    private void Start()
    {
        this.topLeft = new Vector2(0.0f, 1.0f);
        this.topRight = new Vector2(1.0f, 1.0f);
        this.bottomRight = new Vector2(1.0f, 0.0f);
        this.bottomLeft = new Vector2(0.0f, 0.0f);
    }

    private void UpdateTexture()
    {
        // 現在の4頂点から変換行列を求め、マテリアルにセット
        if (this.resultMaterial == null)
        {
            this.resultMaterial = this.GetComponent<Renderer>().material;
        }
        this.resultMaterial.SetMatrix(
            "_HomographyMatrix",
            HomographyMatrix(this.bottomLeft, this.topLeft, this.topRight, this.bottomRight));
    }
}

ResultQuadのマテリアル用シェーダー

Shader "Unlit/Homography"
{
	Properties
	{
		_MainTex ("Texture", 2D) = "white" {}
	}
	SubShader
	{
		Tags { "RenderType"="Opaque" }
		LOD 100

		Pass
		{
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			// make fog work
			#pragma multi_compile_fog
			
			#include "UnityCG.cginc"

			struct appdata
			{
				float4 vertex : POSITION;
				float2 uv : TEXCOORD0;
			};

			struct v2f
			{
				float3 uv : TEXCOORD0; // float2をfloat3に
				UNITY_FOG_COORDS(1)
				float4 vertex : SV_POSITION;
			};

			sampler2D _MainTex;
			float4 _MainTex_ST;
			float4x4 _HomographyMatrix; // 変換行列は行ごとに分割せず丸ごと送る
			
			v2f vert (appdata v)
			{
				v2f o;
				o.vertex = UnityObjectToClipPos(v.vertex);
				o.uv = mul(_HomographyMatrix, float4(TRANSFORM_TEX(v.uv, _MainTex), 0.0, 1.0)).xyw; // uvを変換してからx、y、wを渡す
				UNITY_TRANSFER_FOG(o,o.vertex);
				return o;
			}
			
			fixed4 frag (v2f i) : SV_Target
			{
				// sample the texture
				fixed4 col = tex2D(_MainTex, i.uv.xy / i.uv.z); // i.uvのx、yをzで割ってサンプリング座標とする
				// apply fog
				UNITY_APPLY_FOG(i.fogCoord, col);
				return col;
			}
			ENDCG
		}
	}
}

実行時の様子
図ではカメラがPerspectiveですが、Orthographicでも大丈夫なようにしたつもりです。

Comments

[teraps]

反応が遅くなってしまって申し訳ありません．
試してみたところ，理想としていた処理を実現することができました！
また，これで行いたかった処理も，まだ実装中なのですが上手く活用することができそうです．
なにからなにまで，本当にありがとうございます．
自力でも組んでいけるよう今後の参考にさせて頂きます！

Answer 3

先の回答へ追記を行おうとしましたが、うまくいかなかったため別回答にて追記します。

「ななめに切り出す」の意図を読み違えていたかもしれません。スプライトエディターでアウトラインを編集する方が適切でしょうか?こちらでしたらシェーダーを用意する必要がなく、より簡単に実現できるかと思います。こちらのサイトの記事もご参考になりそうです。

スクリプトからアウトラインを変更する場合はOverrideGeometryが使えそうです。

Comments

[teraps]

>Bongoさん
Unityで射影変換を行いたかったため，非常に参考になりました．ありがとうございます．
この処理ではスクリプトから変換したい座標をInspector上で数値入力していると思うのですが，
Gameビュー上で切り出したい4点をクリック，あるいはPhotoshopの拡大処理のように
ドラッグで台形を作成して指定するようなGUIを構築したいと考えております．
Rayなどを飛ばして，通常のUV座標を取得することはできるのですが，
これらの変換に用いる座標は通常のUV座標とは異なることと存じます，
なにか，良い方法があれば教えて頂けませんでしょうか．
この処理に用いている座標についての情報だけでも助かります．
質問に質問を重ねる形になってしまいすみませんが，回答頂けると幸いです．

[Bongo]

ご参考になりましたようで幸いです。
射影変換行列にさらに適当な変換行列を掛ければ異なる座標系にも対応可能と思いますが、xstarteraさんの想定されるUV座標はどのようなものでしょうか?
私が回答中で想定したのはテクスチャ画像の左下隅が原点、そこから上方向がU軸+で画像上端がU+1.0、原点から右方向がV軸+で画像右端がV+1.0なのですが、試しにQuadオブジェクトに対してレイキャストし、得られたRaycastHitのtextureCoordを見てみたところ、その場合はちゃんとこの座標系になっていたようです。xstarteraさんの場合はどのような条件でレイキャストされましたでしょうか。

[teraps]

すみません，勘違いしておりました．RaycastでのUV座標取得は問題なく行えました．
（ただ，0.1-0.9の小数点第一までですが…）
別の質問になってしまうのですが，EditorスクリプトだとRaycastが使えず(？)困っております．
他のMonoBehaviourスクリプトを作ってそこから持ってくるのも上手くいかず，，
また，exeにビルドする際などもEditorスクリプトは出力できないようです．
このShaderでのホモグラフィ処理を，Editor上ではなくMonoBehaviourスクリプトで
実行することは可能でしょうか？そちらで動かせた方が扱いやすいと思って改変を試しています．
何度もすみませんが，よければご助力頂けると幸いですm(_ _)m

[Bongo]

実際のところ、上記のシェーダーコードで「_BottomLeftTopLeft」「_TopRightBottomRight」で四隅の座標を覚えさせたり、「_HomographyMatrixR0」〜「_HomographyMatrixR3」でわざわざ行列を行に分けて渡したりしているのは、インスペクタ上で4隅の座標を設定できるように試行錯誤した結果でして、本来は不要なものです。このへんを削除し単純化して、実際の実行時の使用を主眼とした例を追記します。ご参考になりますでしょうか?

※コード中のコメントにもありますが、UV座標をレイキャストで求める方式ですとレイが板に命中しなかった場合にUV座標が得られないことに後になって気付き、自前で交点を求めることにしました。板の下辺をU軸、左辺をV軸とする平面との交点をUV座標として採用しております。また、字数を少々オーバーしてしまったため、以前の回答ではホモグラフィ行列算出メソッドに付いていたドキュメントコメントを削除しました。