This site uses strictly necessary cookies. More Information

X- Home /

# Getting Y position at a specific point

hello! I'm currently working on a water and buoyancy system - I have a working water solution but I need the Y (height of my waves) coordinate at my "floaters" (objects I use to calculate my buoyancy) position, however, I wasn't able to do it myself (script below is my water surface creator - original script from catlike coding, but I modified it a bit).

[RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))] public class SurfaceCreator : MonoBehaviour {

```
[Header("---Noise---")]
[Range(0f, 1f)]
public float strength = 1f;
public bool damping;
public float frequency = 1f;
[Range(1, 8)]
public int octaves = 1;
[Range(1f, 4f)]
public float lacunarity = 2f;
[Range(0f, 1f)]
public float persistence = 0.5f;
[Range(1, 3)]
public int dimensions = 3;
public NoiseMethodType type;
[Header("---Scroll Speed---")]
[Range(0, .1f)]
public float speedX;
[Range(0, .1f)]
public float speedY;
[Range(0, .1f)]
public float speedZ;
[Header("---Mesh---")]
public Gradient coloring;
[Range(1, 200)]
public int resolution = 10;
private Mesh mesh;
private Vector3[] vertices;
private Vector3[] normals;
private Color[] colors;
private int currentResolution;
bool coloringForStrength;
bool analyticalDerivatives;
bool showNormals;
public Vector3 offset;
public Vector3 rotation;
[Header("---Buoyancy---")]
public GameObject floater;
private void FixedUpdate()
{
Refresh();
offset.x += speedX * Time.deltaTime;
offset.y += speedY * Time.deltaTime;
offset.z += speedZ * Time.deltaTime;
}
private void OnEnable () {
if (mesh == null) {
mesh = new Mesh();
mesh.name = "Surface Mesh";
GetComponent<MeshFilter>().mesh = mesh;
}
Refresh();
}
public void Refresh () {
if (resolution != currentResolution) {
CreateGrid();
}
Quaternion q = Quaternion.Euler(rotation);
Quaternion qInv = Quaternion.Inverse(q);
Vector3 point00 = q * new Vector3(-0.5f, -0.5f) + offset;
Vector3 point10 = q * new Vector3( 0.5f, -0.5f) + offset;
Vector3 point01 = q * new Vector3(-0.5f, 0.5f) + offset;
Vector3 point11 = q * new Vector3( 0.5f, 0.5f) + offset;
NoiseMethod method = Noise.methods[(int)type][dimensions - 1];
float stepSize = 1f / resolution;
float amplitude = damping ? strength / frequency : strength;
for (int v = 0, y = 0; y <= resolution; y++) {
Vector3 point0 = Vector3.Lerp(point00, point01, y * stepSize);
Vector3 point1 = Vector3.Lerp(point10, point11, y * stepSize);
for (int x = 0; x <= resolution; x++, v++) {
Vector3 point = Vector3.Lerp(point0, point1, x * stepSize);
NoiseSample sample = Noise.Sum(method, point, frequency, octaves, lacunarity, persistence);
sample = sample * 0.5f;
if (coloringForStrength) {
colors[v] = coloring.Evaluate(sample.value + 0.5f);
sample *= amplitude;
}
else {
sample *= amplitude;
colors[v] = coloring.Evaluate(sample.value + 0.5f);
}
vertices[v].y = sample.value;
sample.derivative = qInv * sample.derivative;
if (analyticalDerivatives) {
normals[v] = new Vector3(-sample.derivative.x, 1f, -sample.derivative.y).normalized;
}
}
}
mesh.vertices = vertices;
mesh.colors = colors;
if (!analyticalDerivatives) {
CalculateNormals();
}
mesh.normals = normals;
}
private void CreateGrid () {
currentResolution = resolution;
mesh.Clear();
vertices = new Vector3[(resolution + 1) * (resolution + 1)];
colors = new Color[vertices.Length];
normals = new Vector3[vertices.Length];
Vector2[] uv = new Vector2[vertices.Length];
float stepSize = 1f / resolution;
for (int v = 0, z = 0; z <= resolution; z++) {
for (int x = 0; x <= resolution; x++, v++) {
vertices[v] = new Vector3(x * stepSize - 0.5f, 0f, z * stepSize - 0.5f);
colors[v] = Color.black;
normals[v] = Vector3.up;
uv[v] = new Vector2(x * stepSize, z * stepSize);
}
}
mesh.vertices = vertices;
mesh.colors = colors;
mesh.normals = normals;
mesh.uv = uv;
int[] triangles = new int[resolution * resolution * 6];
for (int t = 0, v = 0, y = 0; y < resolution; y++, v++) {
for (int x = 0; x < resolution; x++, v++, t += 6) {
triangles[t] = v;
triangles[t + 1] = v + resolution + 1;
triangles[t + 2] = v + 1;
triangles[t + 3] = v + 1;
triangles[t + 4] = v + resolution + 1;
triangles[t + 5] = v + resolution + 2;
}
}
mesh.triangles = triangles;
}
private float GetXDerivative (int x, int z) {
int rowOffset = z * (resolution + 1);
float left, right, scale;
if (x > 0) {
left = vertices[rowOffset + x - 1].y;
if (x < resolution) {
right = vertices[rowOffset + x + 1].y;
scale = 0.5f * resolution;
}
else {
right = vertices[rowOffset + x].y;
scale = resolution;
}
}
else {
left = vertices[rowOffset + x].y;
right = vertices[rowOffset + x + 1].y;
scale = resolution;
}
return (right - left) * scale;
}
private float GetZDerivative (int x, int z) {
int rowLength = resolution + 1;
float back, forward, scale;
if (z > 0) {
back = vertices[(z - 1) * rowLength + x].y;
if (z < resolution) {
forward = vertices[(z + 1) * rowLength + x].y;
scale = 0.5f * resolution;
}
else {
forward = vertices[z * rowLength + x].y;
scale = resolution;
}
}
else {
back = vertices[z * rowLength + x].y;
forward = vertices[(z + 1) * rowLength + x].y;
scale = resolution;
}
return (forward - back) * scale;
}
private void CalculateNormals () {
for (int v = 0, z = 0; z <= resolution; z++) {
for (int x = 0; x <= resolution; x++, v++) {
normals[v] = new Vector3(-GetXDerivative(x, z), 1f, -GetZDerivative(x, z)).normalized;
}
}
}
private void OnDrawGizmosSelected () {
float scale = 1f / resolution;
if (showNormals && vertices != null) {
Gizmos.color = Color.yellow;
for (int v = 0; v < vertices.Length; v++) {
Gizmos.DrawRay(vertices[v], normals[v] * scale);
}
}
}
```

}

any advice would be greatly appreciated!

### Your answer

### Welcome to Unity Answers

The best place to ask and answer questions about development with Unity.

To help users navigate the site we have posted a site navigation guide.

If you are a new user to Unity Answers, check out our FAQ for more information.

Make sure to check out our Knowledge Base for commonly asked Unity questions.

If you are a moderator, see our Moderator Guidelines page.

We are making improvements to UA, see the list of changes.

### Follow this Question

### Related Questions

Buoyancy using shaders 2 Answers

Having trouble with player boat movement with buoyancy pack 0 Answers

how to create morphing Water Effects 1 Answer

Pro Water - Matching Rotation 0 Answers

Finding the height of a mesh 1 Answer