koobas.hobune.stream
Geometry Shader showing wrong geometry
Hi, I wonder if anyone can help me?
I have been trying to create a basic hair simulation using a geometry shader to create the hair strands.
I want the shader, for now, to produce one hair/ line from the middle of a “plane” mesh (a square of 4 vertices).
I do all the physics modelling based on Hooke's law (two masses, two springs and one anchor point - the middle of the plane) and I then send the new coordinates to the geometry shader.
When I enter play mode, I get oscillating coordinates from the inspector view and I get the bounce motion in the game view (but only when the rotation in X is 0.) Unity seems to import my Blender models with a rotation of -89.98 in X.
The problem is I get this bouncing “V” shape. I don't understand what I have done wrong.
Code is below:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;
public struct HairPoints3
{
public float x0; // The base vertex position of the hair
public float y0; // The base vertex position of the hair
public float z0; // The base vertex of position the hair
public float x1; // The Second vertex of the hair
public float y1; // The Second vertex of the hair
public float z1; // The Second vertex of the hair
public float x2; // The third vertex of the hair
public float y2; // The third vertex of the hair
public float z2; // The third vertex of the hair
}
public class HairPhysicsScript3 : MonoBehaviour
{
public Material HairMaterial;
HairPoints3 HairPointStruct;
public Mesh TheMesh;
public MeshFilter MF;
public Vector3[] MeshVertsCopy;
ComputeBuffer OutPutBuffer;
public List<Vector3> MeshVertsToSort;
public List<HairPoints3> HairsLocationsToComputeBuffer;
public HairPoints3[] HairPointsArrayOutPut;
public float GravityNumber; // Gravity constant
public float K; // This is Hooke's constant
public float Dampening; // Dampening Constant;
public float Mass; // This is the mass of each vertex
public bool A;
public float MidPointX;
public float MidPointY;
public float MidPointZ;
public Vector3 H;
public Vector3 H1;
public Vector3 H2;
public Vector3 HLocal;
public Vector3 HLocal1;
public Vector3 HLocal2;
float VelocityX;
float VelocityY;
float VelocityZ;
float VelocityX1;
float VelocityY1;
float VelocityZ1;
float VelocityX2;
float VelocityY2;
float VelocityZ2;
float ForceX;
float ForceX1;
float ForceX2;
float ForceY;
float ForceY1;
float ForceY2;
float ForceZ;
float ForceZ1;
float ForceZ2;
float AccelerationX1;
float AccelerationX2;
float AccelerationY1;
float AccelerationY2;
float AccelerationZ1;
float AccelerationZ2;
// Use this for initialization
void Start()
{
TheMesh = MF.mesh;
MeshVertsCopy = TheMesh.vertices;
// This converts the default "triangle topology" to "point topology" which creates a "point cloud" and also allowes for the geometry shader to work fully.
TheMesh.SetIndices(TheMesh.GetIndices(0), MeshTopology.Points, 0);
HairsLocationsToComputeBuffer = new List<HairPoints3>();
OutPutBuffer = new ComputeBuffer(1, (sizeof(float) * 9) );
HairPointStruct = new HairPoints3();
MeshVertsToSort.Clear();
foreach (Vector3 AB in MeshVertsCopy)
{
Vector3 ABC = transform.TransformPoint(AB);
MeshVertsToSort.Add(ABC);
}
MeshVertsToSort.Sort((a, b) => a.x.CompareTo(b.x));
MidPointX = (MeshVertsToSort[0].x + MeshVertsToSort[3].x) / 2;
// This sorts the verts from low to high in order of y.
MeshVertsToSort.Sort((a, b) => a.y.CompareTo(b.y));
MidPointY = (MeshVertsToSort[0].y + MeshVertsToSort[3].y) / 2;
MeshVertsToSort.Sort((a, b) => a.z.CompareTo(b.z));
MidPointZ = (MeshVertsToSort[0].z + MeshVertsToSort[3].z) / 2;
H = new Vector3(MidPointX, MidPointY, MidPointZ);
H1 = new Vector3(MidPointX, MidPointY -1 , MidPointZ);
H2 = new Vector3(MidPointX, MidPointY -2 , MidPointZ);
}
// Update is called once per frame
void Update()
{
if (A == true)
{
StartCoroutine("DoHair");
}
}
IEnumerator DoHair()
{
A = false;
yield return new WaitForSeconds(Time.deltaTime);
HairsLocationsToComputeBuffer.Clear(); // Clear the list.
////////////////////////////////////////////
// Hooke's calculations below! - They work!!!! ///
///////////////////////////////////////////
//Dealing with the X forces
ForceX1 = (-K * (H1.x - H.x)) - (Dampening * VelocityX1) - (-K * (H2.x - H1.x)) + (Dampening * VelocityX2);
ForceX2 = (-K * (H2.x - H1.x) ) - (Dampening * VelocityX2);
//Dealing with the Y forces
ForceY1 = (-K * (H1.y - H.y)) - (Dampening * VelocityY1) - (Mass * GravityNumber) - (-K * (H2.y - H1.y)) + (Dampening * VelocityY2) ;
ForceY2 = (-K * (H2.y - H1.y)) - (Dampening * VelocityY2) - (Mass * GravityNumber) ;
//Dealing with the Z forces
ForceZ1 = (-K * (H1.z - H.z)) - (Dampening * VelocityZ1) - (-K * (H2.z - H1.z)) + (Dampening * VelocityZ2);
ForceZ2 = (-K * (H2.z - H1.z)) - (Dampening * VelocityZ2) ;
/////////////////////////////////
// Calculating accelerations here....//
////////////////////////////////
AccelerationX1 = ForceX1 / Mass;
AccelerationY1 = ForceY1 / Mass;
AccelerationZ1 = ForceZ1 / Mass;
AccelerationX2 = ForceX2 / Mass;
AccelerationY2 = ForceY2 / Mass;
AccelerationZ2 = ForceZ2 / Mass;
//////////////////////////////
// Calculating velocities here....//
/////////////////////////////
VelocityX1 = VelocityX1 + (AccelerationX1 * Time.deltaTime);
VelocityY1 = VelocityY1 + (AccelerationY1 * Time.deltaTime);
VelocityZ1 = VelocityZ1 + (AccelerationZ1 * Time.deltaTime);
VelocityX2 = VelocityX2 + (AccelerationX2 * Time.deltaTime);
VelocityY2 = VelocityY2 + (AccelerationY2 * Time.deltaTime);
VelocityZ2 = VelocityZ2 + (AccelerationZ2 * Time.deltaTime);
////////////////////////////
// Calculating Positions here...//
/////////////////////////////
H1.x = H1.x + VelocityX1;
H1.y = H1.y + VelocityY1;
H1.z = H1.z + VelocityZ1;
H2.x = H2.x + VelocityX2;
H2.y =H2.y + VelocityY2;
H2.z = H2.z +VelocityZ2;
// Converting to Local/Model Space
HLocal = transform.InverseTransformPoint(H);
HLocal1 =transform.InverseTransformPoint(H1);
HLocal2 =transform.InverseTransformPoint(H2);
// Placing these in a struct.
HairPointStruct.x0 = HLocal.x;
HairPointStruct.y0 = HLocal.y;
HairPointStruct.z0 = HLocal.z;
HairPointStruct.x1 = HLocal1.x;
HairPointStruct.y1 = HLocal1.y;
HairPointStruct.z1 = HLocal1.z;
HairPointStruct.x2 = HLocal2.x;
HairPointStruct.y2 = HLocal2.y;
HairPointStruct.z2 = HLocal2.z;
HairsLocationsToComputeBuffer.Add(HairPointStruct);
OutPutBuffer.SetData(HairsLocationsToComputeBuffer.ToArray() ); // We now copy the array into the buffer.
HairMaterial.SetBuffer("HairPointsBuffer", OutPutBuffer); // This will update the buffer in the shader (the one with vertex shaders etc...)
HairMaterial.SetFloat("GravityNumber", GravityNumber);
HairMaterial.SetFloat("Dampening", Dampening);
HairMaterial.SetFloat("K", K);
HairMaterial.SetFloat("Mass", Mass);
A = true;
}
}
// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,)' with 'UnityObjectToClipPos()'
Shader "Custom/UnlitShaderHair1" {
Properties
{
}
SubShader
{
Tags { "RenderType"="Opaque" }
LOD 100
Pass
{
CGPROGRAM
// Upgrade NOTE: excluded shader from DX11, OpenGL ES 2.0 because it uses unsized arrays
//#pragma exclude_renderers d3d11 gles #pragma vertex vert
#pragma geometry MyGeometryShader #pragma fragment frag
// make fog work
#pragma multi_compile_fog
#include "UnityCG.cginc"
struct HairPoints3
{
int HairNumber;
float x0; // The base vertex position of the hair
float y0; // The base vertex position of the hair
float z0; // The base vertex of position the hair
float x1; // The Second vertex of the hair
float y1; // The Second vertex of the hair
float z1; // The Second vertex of the hair
float x2; // The third vertex of the hair
float y2; // The third vertex of the hair
float z2; // The third vertex of the hair
};
StructuredBuffer<HairPoints3> HairPointsBuffer;
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
};
struct v2f
{
float2 uv : TEXCOORD0;
UNITY_FOG_COORDS(1)
float4 vertex : POSITION;
};
struct GSOut
{
float4 Pos : SV_POSITION;
float2 uv : TEXCOORD0;
// UNITY_FOG_COORDS(1)
};
sampler2D _MainTex;
float4 _MainTex_ST;
fixed4 Color;
/////////////////
//Vertex Shader//
////////////////
v2f vert (appdata v,uint vid : SV_VertexID)
{
v2f o;
o.vertex = v.vertex;
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
UNITY_TRANSFER_FOG(o,o.vertex);
return o;
}
//////////////////////////////////
//GEOMETRY SHADER SITS HERE!//
//////////////////////////////////
[maxvertexcount (3)]
void MyGeometryShader(point v2f GeometryIn[1], inout LineStream<GSOut> TriStream , uint PrimID : SV_PrimitiveID)
{
GSOut Out;
// Hairs are created at this point......
if (PrimID ==0)
{
Out.Pos = UnityObjectToClipPos( float4(HairPointsBuffer[0].x0,HairPointsBuffer[0].y0,HairPointsBuffer[0].z0, 1) );
Out.uv = GeometryIn[0].uv;
TriStream.Append(Out);
Out.Pos = UnityObjectToClipPos(float4(HairPointsBuffer[0].x1,HairPointsBuffer[0].y1,HairPointsBuffer[0].z1,1 ) );
Out.uv = GeometryIn[0].uv;
TriStream.Append(Out);
Out.Pos = UnityObjectToClipPos( float4(HairPointsBuffer[0].x2,HairPointsBuffer[0].y2,HairPointsBuffer[0].z2,1 ) );
Out.uv = GeometryIn[0].uv;
TriStream.Append(Out);
}
}
//////////////////////////
// This is our pixel shader.//
/////////////////////////
fixed4 frag (GSOut i) : SV_Target
{
Color = fixed4(1,0,0,1); // We need to write fixed4 like this with the bracket. It seems anything else does not work.
return Color;
}
ENDCG
}
}
}
Thanks.
