[solved]Problema con cambio di coordinate fra cartesiane e sferiche

lux

Ho problemi a far cambio di coordinate fra cartesiane e sferiche in uno shader su Unity, vi scrivo qui il codice strippato da tutto tranne il necessario:

Shader "Custom/BlindShader" {
    Properties {
		_MainTex ("Albedo (RGB)", 2D) = "white" { }

	}
	SubShader {
        Tags { "RenderType"="Opaque" }
		LOD 200
		
		CGPROGRAM
		#pragma surface surf Lambert vertex:vert// tessellate:tessEdge
		#pragma enable_d3d11_debug_symbols
		#pragma target 3.0
		
        struct Input {
            float2 uv_MainTex;
        };
		sampler2D _MainTex;
		
		static const float EPSILON = 1e-10;
		static const float PI = 3.14159274;

		float3 CartesianToSpherical(float3 cartesianCoordinates) {
			if (cartesianCoordinates.x == 0)
				cartesianCoordinates.x = EPSILON;
			float radius = length(cartesianCoordinates);
			float polar = atan(cartesianCoordinates.z / cartesianCoordinates.x);
			if (cartesianCoordinates.x < 0)
				polar += PI;
			float elevation = asin(cartesianCoordinates.y / radius);
			return (radius, polar, elevation);
		}

		float3 CartesianToSpherical(float3 center, float3 world) {
			return CartesianToSpherical(world - center);
		}

		float3 SphericalToCartesian(float3 sphericalCoordinates) {
			float a = sphericalCoordinates.x * cos(sphericalCoordinates.z);
			return (
				a * cos(sphericalCoordinates.y), 
				sphericalCoordinates.x * sin(sphericalCoordinates.z),
				a * sin(sphericalCoordinates.y));
		}

		void vert (inout appdata_full v) {
			float3 spherical;
			float3 newSpherical;
			float3 world;
			float3 newWorld;
			
			world = mul(unity_ObjectToWorld, v.vertex.xyz);
			spherical = CartesianToSpherical(world);
			newWorld = SphericalToCartesian(spherical);
			v.vertex.xyz = mul(unity_WorldToObject, newWorld);
		}
		
		void surf (Input IN, inout SurfaceOutput o) {
			o.Albedo = tex2D (_MainTex, IN.uv_MainTex).rgb;
		}
		ENDCG
	}
	FallBack "Diffuse"
}

La cosa strana è che lo stesso identico codice trasformato in C# funziona su unity:

    public Vector3 CartesianToSpherical(Vector3 cartesianCoordinates)
    {
        if (cartesianCoordinates.x == 0f)
            cartesianCoordinates.x = Mathf.Epsilon;
        float radius = cartesianCoordinates.magnitude;
        float polar = Mathf.Atan(cartesianCoordinates.z / cartesianCoordinates.x);
        if (cartesianCoordinates.x < 0f)
            polar += Mathf.PI;
        float elevation = Mathf.Asin(cartesianCoordinates.y / radius);
        return new Vector3(radius, polar, elevation);
    }

    public Vector3 SphericalToCartesian(Vector3 sphericalCoordinates)
    {
        float a = sphericalCoordinates.x * Mathf.Cos(sphericalCoordinates.z);
        return new Vector3(
            a * Mathf.Cos(sphericalCoordinates.y), 
            sphericalCoordinates.x * Mathf.Sin(sphericalCoordinates.z),
            a * Mathf.Sin(sphericalCoordinates.y));
    }

Edit: non ho scritto il problema... comunque non funziona nulla con lo shader, tutti i vertici vanno a rotoli.

theGiallo

Cosa c'è in sphericalCoordinates? Che sono le xyz? Ti da problemi solo la SpericalToCartesian? Hai provato a debuggare se funziona chiamandola con l'inversa?

vec3 v = vec3(1.0,2.0,3.0);
vec3 vv = SpericalToCartesian(CartesianToSpherical(v));
if ( vv == v )
{
    color.rgb = vec3(1.0,1.0,1.0);
} else
{
    color.rgb = vec3(1.0,0.0,0.0);
}

lux

Ho scritto l'intero shader incriminato sopra.

Lo shader di esempio, in teoria, non dovrebbe far nulla:
1) scambio i vertici della mesh in coordinate globali (unity_ObjectToWorld) == world
2) passo da coordinate cartesiani a coordinate sferiche == spherical [qui potrebbe rompersi]
3) passo da coordinate sferiche a coordinate cartesiani == newWorld [anche qui potrebbe rompersi]
4) ritorno a coordinate locali della mesh (unity_WorldToObject) e aggiorno il vertice attuale

Senza 2 e 3 funziona (ovviamente), quindi c'è qualcosa che non va nelle due funzioni di cambio, come dicevo, però le stesse funzioni utilizzate direttamente in Unity con C# funzionano:

	    var cart = transform.position;
        var spherical = CartesianToSpherical(cart);
        var backCart = SphericalToCartesian(spherical);
        Debug.Log((backCart - cart).magnitude);

Questo è il codice di esempio in cui uso le due funzione scritte sopra in C#, la magnitude fra le differenze della posizione iniziale e quella in cui faccio il test dal cambio è sempre approssimata a 0.

theGiallo

Prova a mettere dati estremi e semplici, come raggio 1 e angoli 0, prova non con mesh ma con dati scritti a mano e fallo nel fragment usando il colore come una printf.

lux

Niente sono diversi:

        void surf (Input IN, inout SurfaceOutput o) {
			float3 rgb;
			float3 v = (1.0,2.0,3.0);
			float3 vv = SphericalToCartesian(CartesianToSpherical(v));
			if (distance(vv, v) <= EPSILON)
			{
				rgb = (1.0,1.0,1.0);
			} else
			{
				rgb = (0.0,0.0,0.0);
			}
            o.Albedo = rgb;
            o.Alpha = 1;
        }

Ho provato anche con valori maggiori di EPSILON, la differenza fra i due vettori è notevole...

Nemo

Ho letto moolto rapidamente, ma io intanto sostituirei atan(a/b) con atan2(a, b) (e il test per lo zero lo farei sulla lenght eventualmente tornando 0,0,0 per correttezza, ma questo non c'entra col tuo problema) e secondariamente darei un occhio alle matrici w2o e o2w (row major o column major? ste xose qui) che oltre ad essere la differenza più marcata col codice c# sono sede di errori la metà delle volte.
Poi andrei si shadertoy e - un po come diceva thegiallo- proverei a disegnare i punti, quantomeno il polar-to-cartesian con coordinate polari note, senza passare per matrici varie. Per "disegnare" su shadertoy, per ogni punto generato dovresti ricavarti il distance field... mentre lo dico realizzo che non è la cosa più comoda o furba del mondo, ma io farei così perché ci sono abituato...

lux

Nemo
Il possibile problema del w2o e o2w non c'è, ho provato senza come consigliava theGiallo "printando" il colore del pixel se il cambio funzionava, ma nulla (ovvero printa tutto nero, quindi non entra mai nel primo if).
Atan2 già era così prima ma non cambia nulla, rimesso comunque!

Shadertoy davvero interessante, proverò a testare anche lì, ma comunque non dovrebbe cambiare molto da testare direttamente su unity?

theGiallo

lux nel test nel fragment prova invece che a usare un if a usare v come colore, magari è un problema di precisione.

ATTENZIONE atan è tra -PI e PI, mentre atan2 restituisce 0-TAU, ovvero già l'angolo delle coordinate polari.
https://msdn.microsoft.com/it-it/library/system.math.atan(v=vs.110).aspx
http://www.shaderific.com/glsl-functions/

lux

Non sono riuscito a risolvere alla fine... se qualcuno ha idee mi faccia sapere!

lux

Wintermute Desktop, quello che dici è quello che già faccio nel test, proprio uguale 😛

theGiallo già avevo provato anche a veder se la delta della diff era <= 0.001 e altri valori meno "precisi"

Alla fine ho risolto usando float4 invece che float3 (tutto il resto identico), presumo che il problema sia che dx10+ richiedono allineamento a 16bytes... sarà che non sono abituato a lavorare in questo ambito ma mi è sembrato davvero assurdo che fosse questo il problema! non pensate? (almeno un warning o qualcosa sarebbe stato ottimo).
GLSL non ha questa richiesta se ho capito quindi per questo funzionava su shadertoy.

Wintermute

@lux Su quale piattaforma runni? Mobile o desktop?
Comunque, prova a debuggare prima solo una funzione, metti un certo vettore di input, runna lo shader facendo solo una conversione, tipo da cartesiane a sferiche, fallo sputare il valore con una printf dentro lo shader (non so se puoi) oppure settalo nell'albedo e poi leggilo dalla texture da c#. Ripeti la stessa cosa con il codice c# puro e guarda quanto, ad esempio, i 2 valori solo di coordinate sferiche siano diversi (e magari postali).

theGiallo

lux Non capisco. Che c'entra? fai i conti te a mano, elemento per elemento... la parte di moltiplicazione matriciale non c'entra. 😐

Wintermute

lux Wintermute Desktop, quello che dici è quello che già faccio nel test, proprio uguale 😛
Beh non proprio, mi sembra tu abbia postato la prova facendo ENTRAMBE le conversioni, se devi debuggare un errore fai un passo alla volte, quindi ad esempio una conversione...

float3/float4 mi sembra strano, pero' se cosi' dici... Una cosa che notavo e' anche che usi dei
return (a, b, c)
invece che
return float3(a, b, c)
Non so se CG triggeri qualcosa di strano nel tuo modo.

lux

theGiallo
No nulla ho confuso con il codice che avevo nel vertex, sto shader mi sta facendo uscire pazzo.

Comunque pare andare ora, anche se non è troppo preciso, c'è un errore sullo 0.001... e si vede molto se tocco la geometria, immagino che sia normale viste tutte le funzioni trigonometriche su cui deve passare? (anche se mi sembra eccessivo l'errore)

theGiallo

lux Beh sì, l'errore mi pare normale. Era colpa di atan/atan2?

lux

theGiallo Sì e altre piccole sviste

lux

Wintermute Sì assolutamente, era una delle altre "piccole" sviste.

Wintermute

I see. Se sei arrivato ad una versione che funziona ok, postala a futura memoria!

lux

Wintermute eccolo lo script di test fixato

 
Shader "Custom/SphericalTest" {
    Properties {
	}
	SubShader {
        Tags { "RenderType"="Opaque" }
		LOD 200
		
	CGPROGRAM
	#pragma surface surf Lambert
	#pragma target 3.0
	
    struct Input {
        float2 uv_MainTex;
    };

	static const float EPSILON = 1e-10;
	static const float PI = 3.14159274;

	float3 CartesianToSpherical(float3 cartesianCoordinates) {
		if (cartesianCoordinates.x == 0) {
			cartesianCoordinates.x = EPSILON;
		}
		float radius = length(cartesianCoordinates);
		float polar = atan2(cartesianCoordinates.z, cartesianCoordinates.x);

		float elevation = asin(cartesianCoordinates.y / radius);
		return float3(radius, polar, elevation);
	}

	float3 SphericalToCartesian(float3 sphericalCoordinates) {
		float a = sphericalCoordinates.x * cos(sphericalCoordinates.z);
		return float3(
			a * cos(sphericalCoordinates.y),
			sphericalCoordinates.x * sin(sphericalCoordinates.z), 
			a * sin(sphericalCoordinates.y));
	}

    void surf (Input IN, inout SurfaceOutput o) {
		float3 start = float3(10, -20, 125);
		float3 spherical = CartesianToSpherical(start);
		float3 end = SphericalToCartesian(spherical);
		if (distance(start.xyz, end.xyz) < 0.01) {
			o.Albedo = half3(0.0, 1.0, 1.0);
		} else {
			o.Albedo = half3(1.0, 0.0, 0.0);
		}
		//o.Albedo = half3(1.0, 1.0, 1.0) * distance(start, end);
        o.Alpha = 1;
    }

	ENDCG
}
FallBack "Diffuse"
}