Generating normals for the created mesh

Unity Engine
,
1

I create my own mesh and immediately set the normals, since the mesh is not a smooth canvas but has curves, I set the normals manually and also used RecalculateNormals(), but as a result the normals look incorrect, they always look forward, I show in the video what happens.

The code for generating the grid is something like this, of course I won’t post the whole code, just the formation itself.

int _countVert = _cols * _rows;
Vector3[] _vertices = new Vector3[_countVert];
Vector3[] _normals = new Vector3[_countVert];
Vector2[] _uv = new Vector2[_countVert];
int[] _triangles = new int[_countVert * 6];
int _triangleIndex = 0;
int _colLast = _cols - 1;
int _rowLast = _rows - 1;

for(int _col = 0; _col < _cols; _col++){

    // _pos _normal - vertex positions and normals are taken from pre-prepared arrays, their results are visible in the video
    int _colRows = _col * _rows;

    for(int _row = 0; _row < _rows; _row++){
        int _index = _colRows + _row;
        _pos.y = (float)(_row * _density);
        _vertices[_index] = _pos;
        _normals[_index] = _normal;
        _uv[_index] = new Vector2((float)_col / _colLast, (float)_row / _rowLast);
                       
        if(_col != _colLast && _row != _rowLast){
            int _topLeft = _col * _rows + _row;
            int _bottomLeft = (_col + 1) * _rows + _row;

            if(_leftSide){
                _triangles[_triangleIndex] = _topLeft;
                _triangles[_triangleIndex + 1] = _topLeft + 1;
                _triangles[_triangleIndex + 2] = _bottomLeft;
                _triangles[_triangleIndex + 3] = _topLeft + 1;
                _triangles[_triangleIndex + 4] = _bottomLeft + 1;
                _triangles[_triangleIndex + 5] = _bottomLeft;
                }
            else{
                _triangles[_triangleIndex] = _topLeft;
                _triangles[_triangleIndex + 1] = _bottomLeft;
                _triangles[_triangleIndex + 2] = _topLeft + 1;
                _triangles[_triangleIndex + 3] = _topLeft + 1;
                _triangles[_triangleIndex + 4] = _bottomLeft;
                _triangles[_triangleIndex + 5] = _bottomLeft + 1;
                }

            _triangleIndex += 6;
            }
        }
    }


Mesh _mesh = new Mesh();
_mesh.vertices = _vertices;
_mesh.normals = _normals;
_mesh.triangles = _triangles;
_mesh.uv = _uv;
// _mesh.RecalculateNormals();
_obj.GetComponent<MeshFilter>().mesh = _mesh;
_obj.GetComponent<MeshRenderer>().material = Mat;

what to do in this case with normals?

2

What exactly do you want the normals to point at? The issue isn‘t clear neither in the video nor code. Normals are either perpendicular to a given triangle to provide „hard edges“ or an average of all triangles a vertex shares to provide a „smooth edge“. You seem to have done the latter case, and I believe that‘s also what RecalculateNormals does.

I have a hunch that you expect something to happen that’s actually normal (bump) mapping of the texture, where you would provide a normal map texture to make the surface appear as if it had plenty of minor depth variation, altering the lighting based on the view angle. The mesh normals only factor into this kind of mapping but most of the effect comes from the normal map texture.

3

I will show screenshots from different sides, it is visually clear that the normal is incorrect.

this is one mesh with the material lit, the uv is correctly specified, I also set the normals (in the video you can see where they visually point), but the result as you see is incorrect, the entire wall should look like the wall in front, but this is not the case…

9916404--1433658--1.jpg
9916404--1433661--2.jpg
9916404--1433664--3.jpg
9916404--1433667--4.jpg
9916404--1433670--5.jpg

4

Are you sure this is because of the normals?

I suppose 1.jpg is the correct looks, the others clearly look weird (overbright and too dark). This could be related to the material in case the material isn’t the same as the one from the 1.jpg mesh.

Other than that, there’s only one way meshes can differ where normals affect the lighting and look: whether vertices are shared or separate. Take a quad for instance, this has two triangles. You can create the quad either with 4 (shared) vertices or with 6 (separate) vertices. Shared vertices provide a smooth lighting look, as if there wasn’t an edge at the vertex whereas separate vertices provide a flat-shaded polygon look with a hard edge because now you can have each triangle’s vertex normals point perpendicular away from each individual triangle.

Also try checking what it looks like with no normals at all.

5

Here’s another video I made, showing it from all sides, as well as the structure of the mesh itself and what it looks like without normals, here you can immediately see that the problem is with the lateral normals, you can see it right away…

https://www.youtube.com/watch?v=9h_vbq-Cao0

6

it was necessary to calculate the tangents… that’s what was missing…

_mesh.RecalculateTangents();
1 Like