SLMesh Class Reference

An SLMesh object is a triangulated mesh, drawn with one draw call. More...

#include <SLMesh.h>

Inheritance diagram for SLMesh:

Public Member Functions
	SLMesh (SLAssetManager *assetMgr, const SLstring &name="Mesh")
	Construct a new SLMesh::SLMesh object. More...
	~SLMesh () override
	The destructor deletes everything by calling deleteData. More...
virtual void	init (SLNode *node)
	SLMesh::shapeInit sets the transparency flag of the AABB. More...
virtual void	draw (SLSceneView *sv, SLNode *node, SLuint intances=0)
void	drawIntoDepthBuffer (SLSceneView *sv, SLNode *node, SLMaterial *depthMat)
	Simplified drawing method for shadow map creation. More...
void	addStats (SLNodeStats &stats)
virtual void	buildAABB (SLAABBox &aabb, const SLMat4f &wmNode)
void	updateAccelStruct ()
SLbool	hit (SLRay *ray, SLNode *node)
virtual void	preShade (SLRay *ray)
virtual void	deleteData ()
	SLMesh::deleteData deletes all mesh data and vbo's. More...
virtual void	deleteDataGpu ()
void	deleteSelected (SLNode *node)
	Deletes the rectangle selected vertices and the dependent triangles. More...
void	deleteUnused ()
	Deletes unused vertices (= vertices that are not indexed in I16 or I32) More...
virtual void	calcMinMax ()
virtual void	calcNormals ()
	SLMesh::calcNormals recalculates vertex normals for triangle meshes. More...
void	calcCenterRad (SLVec3f &center, SLfloat &radius)
SLbool	hitTriangleOS (SLRay *ray, SLNode *node, SLuint iT)
virtual void	generateVAO (SLGLVertexArray &vao)
	Generate the Vertex Array Object for a specific shader program. More...
void	computeHardEdgesIndices (float angleRAD, float epsilon)
	computes the hard edges and stores the vertex indexes separately More...
void	transformSkin (bool forceCPUSkinning, const std::function< void(SLMesh *)> &cbInformNodes)
	Transforms the vertex positions and normals with by joint weights. More...
void	deselectPartialSelection ()
SLMaterial *	mat () const
SLMaterial *	matOut () const
SLGLPrimitiveType	primitive () const
const SLAnimSkeleton *	skeleton () const
SLuint	numI () const
SLGLVertexArray &	vao ()
SLbool	isSelected () const
SLfloat	edgeAngleDEG () const
SLfloat	edgeWidth () const
SLCol4f	edgeColor () const
SLVec3f	finalP (SLuint i)
SLVec3f	finalN (SLuint i)
SLbool	accelStructIsOutOfDate ()
void	mat (SLMaterial *m)
void	matOut (SLMaterial *m)
void	primitive (SLGLPrimitiveType pt)
void	skeleton (SLAnimSkeleton *skel)
void	isSelected (bool isSelected)
void	edgeWidth (SLfloat ew)
void	edgeAngleDEG (SLfloat ea)
void	edgeColor (const SLCol4f &ec)
void	vertexPosEpsilon (SLfloat eps)
Public Member Functions inherited from SLObject
	SLObject (const SLstring &Name="", const SLstring &url="")
virtual	~SLObject ()
void	name (const SLstring &Name)
void	url (const SLstring &url)
const SLstring &	name () const
const SLstring &	url () const

Static Public Member Functions
static void	calcTex3DMatrix (SLNode *node)

Public Attributes
SLVVec3f	P
	Vector for vertex positions layout (location = 0) More...
SLVVec3f	N
	Vector for vertex normals (opt.) layout (location = 1) More...
SLVVec2f	UV [2]
	Array of 2 Vectors for tex. coords. (opt.) layout (location = 2) More...
SLVCol4f	C
	Vector of vertex colors (opt.) layout (location = 4) More...
SLVVec4f	T
	Vector of vertex tangents (opt.) layout (location = 5) More...
SLVVuchar	Ji
	2D Vector of per vertex joint ids (opt.) layout (location = 6) More...
SLVVfloat	Jw
	2D Vector of per vertex joint weights (opt.) layout (location = 7) More...
SLVVec3f	skinnedP
	temp. vector for CPU skinned vertex positions More...
SLVVec3f	skinnedN
	temp. vector for CPU skinned vertex normals More...
SLVushort	I16
	Vector of vertex indices 16 bit. More...
SLVuint	I32
	Vector of vertex indices 32 bit. More...
SLVuint	IS32
	Vector of rectangle selected vertex indices 32 bit. More...
SLVushort	IE16
	Vector of hard edges vertex indices 16 bit (see computeHardEdgesIndices) More...
SLVuint	IE32
	Vector of hard edges vertex indices 32 bit (see computeHardEdgesIndices) More...
SLVec3f	minP
	min. vertex in OS More...
SLVec3f	maxP
	max. vertex in OS More...

Protected Attributes
SLGLPrimitiveType	_primitive
	Primitive type (default triangles) More...
SLMaterial *	_mat
	Pointer to the inside material. More...
SLMaterial *	_matOut
	Pointer to the outside material. More...
SLGLVertexArray	_vao
	Main OpenGL Vertex Array Object for drawing. More...
SLGLVertexArrayExt	_vaoN
	OpenGL VAO for optional normal drawing. More...
SLGLVertexArrayExt	_vaoT
	OpenGL VAO for optional tangent drawing. More...
SLGLVertexArrayExt	_vaoS
	OpenGL VAO for optional selection drawing. More...
SLbool	_isSelected
	Flag if mesh is partially of fully selected. More...
SLfloat	_edgeAngleDEG
	Edge crease angle in degrees between face normals (30 deg. default) More...
SLfloat	_edgeWidth
	Line width for hard edge drawing. More...
SLCol4f	_edgeColor
	Color for hard edge drawing. More...
SLfloat	_vertexPosEpsilon
	Vertex position epsilon used in computeHardEdgesIndices. More...
SLbool	_isVolume
	Flag for RT if mesh is a closed volume. More...
SLAccelStruct *	_accelStruct
	KD-tree or uniform grid. More...
SLbool	_accelStructIsOutOfDate
	Flag if accel. struct needs update. More...
SLAnimSkeleton *	_skeleton
	The skeleton this mesh is bound to. More...
SLVMat4f	_jointMatrices
	Joint matrix vector for this mesh. More...
SLbool	_isCPUSkinned
	Flag if mesh has been skinned on CPU during update. More...
SLVVec3f *	_finalP
	Pointer to final vertex position vector. More...
SLVVec3f *	_finalN
	pointer to final vertex normal vector More...
Protected Attributes inherited from SLObject
SLstring	_name
	name of an object More...
SLstring	_url
	uniform resource locator More...

Private Member Functions
void	calcTangents ()
	SLMesh::calcTangents computes the tangents per vertex for triangle meshes. More...
void	drawSelectedVertices ()
void	handleRectangleSelection (SLSceneView *sv, SLGLState *stateGL, SLNode *node)
	Handles the rectangle section of mesh vertices (partial selection) More...

Detailed Description

An SLMesh object is a triangulated mesh, drawn with one draw call.

The SLMesh class represents a single mesh object. The mesh object is drawn with one draw call using the vertex indices in I16 or I32. A mesh can be drawn with triangles, lines or points. The vertex attributes are stored in vectors with equal number of elements:
P (vertex position, mandatory)
N (vertex normals)
C (vertex color)
UV0 optional
UV1 optional
T (vertex tangents) optional
Ji (vertex joint index) optional 2D vector
Jw (vertex joint weights) optional 2D vector
I16 holds the unsigned short vertex indices.
I32 holds the unsigned int vertex indices.
The normals of a vertex are automatically calculated in the method calcNormals() by averaging the face normals of the adjacent triangles. A vertex has always only one normal and is used for the lighting calculation in the shader programs. With such averaged normals you can created a interpolated shading on smooth surfaces such as a sphere.
For objects with sharp edges such as a box you need 4 vertices per box face. All normals of a face point to the same direction. This means, that you have three times the same vertex position but with different normals for one corner of the box.
The following image shows a box with sharp edges and a sphere with mostly smooth but also 4 sharp edges. The smooth red normal as the top vertex got averaged because its position is only once in the vector P. On the other hand are the vertices of the hard edges in the front of the sphere doubled.

The following the example creates the box with 24 vertices:
The vertex positions and normals in P and N:
P.size = 24
P[0] = [1,1,1] N[0] = [1,0,0]
P[1] = [1,0,1] N[1] = [1,0,0]
P[2] = [1,0,0] N[2] = [1,0,0]
P[3] = [1,1,0] N[3] = [1,0,0]

P[4] = [1,1,0] N[4] = [0,0,-1]
P[5] = [1,0,0] N[5] = [0,0,-1]
P[6] = [0,0,0] N[6] = [0,0,-1]
P[7] = [0,1,0] N[7] = [0,0,-1]

P[8] = [0,0,1] N[8] = [-1,0,0]
P[9] = [0,1,1] N[9] = [-1,0,0]
P[10]= [0,1,0] N[10]= [-1,0,0]
P[11]= [0,0,0] N[11]= [-1,0,0]

P[12]= [1,1,1] N[12]= [0,0,1]
P[13]= [0,1,1] N[13]= [0,0,1]
P[14]= [0,0,1] N[14]= [0,0,1]
P[15]= [1,0,1] N[15]= [0,0,1]

P[16]= [1,1,1] N[16]= [0,1,0]
P[17]= [1,1,0] N[17]= [0,1,0]
P[18]= [0,1,0] N[18]= [0,1,0]
P[19]= [0,1,1] N[19]= [0,1,0]

P[20]= [0,0,0] N[20]= [0,-1,0]
P[21]= [1,0,0] N[21]= [0,-1,0]
P[22]= [1,0,1] N[22]= [0,-1,0]
P[23]= [0,0,1] N[23]= [0,-1,0]

The vertex indices in I16:
I16[] = {0,1,2, 0,2,3,
4,5,6, 4,6,7,
8,9,10, 8,10,11,
12,13,14, 12,14,15,
16,17,18, 16,18,19,
20,21,22, 20,22,23}

All vertex attributes are added to the vertex array object _vao (SLVertexArray).
All arrays remain in the main memory for ray tracing. A mesh uses only one material referenced by the SLMesh::mat pointer.

If a mesh is associated with a skeleton all its vertices and normals are transformed every frame by the joint weights. Every vertex of a mesh has weights for 1-n joints by which it can be influenced. This transform is called skinning and is done in CPU in the method transformSkin. The final transformed vertices and normals are stored in _finalP and _finalN.

Remarks

It is important that during instantiation NO OpenGL functions (gl*) get called because this constructor will be most probably called in a parallel thread from within an SLScene::registerAssetsToLoad or SLScene::assemble function. All objects that get rendered have to do their OpenGL initialization when they are used the first time during rendering in the main thread. For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP, _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.

Definition at line 129 of file SLMesh.h.

Constructor & Destructor Documentation

SLMesh()

SLMesh::SLMesh ( SLAssetManager *  assetMgr, const SLstring &  name = "Mesh"  )

explicit

Construct a new SLMesh::SLMesh object.

Meshes can be used in multiple nodes (SLNode). Meshes can belong therefore to the global assets such as meshes (SLMesh), materials (SLMaterial), textures (SLGLTexture) and shader programs (SLGLProgram).
It is important that during instantiation NO OpenGL functions (gl*) get called because this constructor will be most probably called in a parallel thread from within an SLScene::registerAssetsToLoad or SLScene::assemble function. All objects that get rendered have to do their OpenGL initialization when they are used the first time during rendering in the main thread.

Parameters

assetMgr	Pointer to a global asset manager. If passed the asset manager is the owner of the instance and will do the deallocation. If a nullptr is passed the creator is responsible for the deallocation.
name	Name of the mesh

Definition at line 51 of file SLMesh.cpp.

                                                             : SLObject(name)
{
    _primitive = PT_triangles;
    _mat       = nullptr;
    _matOut    = nullptr;
    _finalP    = &P;
    _finalN    = &N;
    minP.set(FLT_MAX, FLT_MAX, FLT_MAX);
    maxP.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
 
    _skeleton               = nullptr;
    _isVolume               = true;    // is used for RT to decide inside/outside
    _accelStruct            = nullptr; // no initial acceleration structure
    _accelStructIsOutOfDate = true;
    _isSelected             = false;
    _edgeAngleDEG           = 30.0f;
    _edgeWidth              = 2.0f;
    _edgeColor              = SLCol4f::WHITE;
    _vertexPosEpsilon       = 0.001f;
 
    // Add this mesh to the global resource vector for deallocation
    if (assetMgr)
        assetMgr->meshes().push_back(this);
}

~SLMesh()

SLMesh::~SLMesh ( )

override

The destructor deletes everything by calling deleteData.

The destructor should be called by the owner of the mesh. If an asset manager was passed in the constructor it will do it after scene destruction. The material (SLMaterial) that the mesh uses will not be deallocated.

Definition at line 82 of file SLMesh.cpp.

{
    deleteData();
}

Member Function Documentation

accelStructIsOutOfDate()

SLbool SLMesh::accelStructIsOutOfDate ( )

inline

Definition at line 189 of file SLMesh.h.

{ return _accelStructIsOutOfDate; }

addStats()

void SLMesh::addStats

(

SLNodeStats &

stats

)

SLMesh::updateStats updates the parent node statistics.

Definition at line 950 of file SLMesh.cpp.

{
    stats.numBytes += sizeof(SLMesh);
    if (!P.empty()) stats.numBytes += SL_sizeOfVector(P);
    if (!N.empty()) stats.numBytes += SL_sizeOfVector(N);
    if (!UV[0].empty()) stats.numBytes += SL_sizeOfVector(UV[0]);
    if (!UV[1].empty()) stats.numBytes += SL_sizeOfVector(UV[1]);
    if (!C.empty()) stats.numBytes += SL_sizeOfVector(C);
    if (!T.empty()) stats.numBytes += SL_sizeOfVector(T);
    if (!Ji.empty()) stats.numBytes += SL_sizeOfVector(Ji);
    if (!Jw.empty()) stats.numBytes += SL_sizeOfVector(Jw);
 
    if (!I16.empty())
        stats.numBytes += (SLuint)(I16.size() * sizeof(SLushort));
    else
        stats.numBytes += (SLuint)(I32.size() * sizeof(SLuint));
 
    stats.numMeshes++;
    if (_primitive == PT_triangles) stats.numTriangles += numI() / 3;
    if (_primitive == PT_lines) stats.numLines += numI() / 2;
 
    if (_accelStruct)
        _accelStruct->updateStats(stats);
}

buildAABB()

void SLMesh::buildAABB ( SLAABBox &  aabb, const SLMat4f &  wmNode  )

virtual

SLMesh::buildAABB builds the passed axis-aligned bounding box in OS and updates the min & max points in WS with the passed WM of the node.

Reimplemented in SLParticleSystem.

Definition at line 1111 of file SLMesh.cpp.

{
    // Update acceleration struct and calculate min max
    if (_skeleton)
    {
        minP = _skeleton->minOS();
        maxP = _skeleton->maxOS();
    }
    else
    {
        // For now, we just update the acceleration struct for non-skinned meshes
        // Building the entire voxelization of a mesh every frame is not feasible
        if (_accelStructIsOutOfDate)
            updateAccelStruct();
    }
    // Apply world matrix
    aabb.fromOStoWS(minP, maxP, wmNode);
}

calcCenterRad()

void SLMesh::calcCenterRad	(	SLVec3f &	center,
		SLfloat &	radius
	)

SLMesh::calcCenterRad calculates the center and the radius of an almost minimal bounding sphere. Code by Jack Ritter from Graphic Gems.

Definition at line 1000 of file SLMesh.cpp.

{
    SLulong i;
    SLfloat dx, dy, dz;
    SLfloat radius2, xspan, yspan, zspan, maxspan;
    SLfloat old_to_p, old_to_p_sq, old_to_new;
    SLVec3f xmin, xmax, ymin, ymax, zmin, zmax, dia1, dia2;
 
    // FIRST PASS: find 6 minima/maxima points
    xmin.x = ymin.y = zmin.z = FLT_MAX;
    xmax.x = ymax.y = zmax.z = -FLT_MAX;
 
    for (i = 0; i < P.size(); ++i)
    {
        if (P[i].x < xmin.x)
            xmin = P[i];
        else if (P[i].x > xmax.x)
            xmax = P[i];
        if (P[i].y < ymin.y)
            ymin = P[i];
        else if (P[i].y > ymax.y)
            ymax = P[i];
        if (P[i].z < zmin.z)
            zmin = P[i];
        else if (P[i].z > zmax.z)
            zmax = P[i];
    }
 
    // Set xspan = distance between the 2 points xmin & xmax (squared)
    dx    = xmax.x - xmin.x;
    dy    = xmax.y - xmin.y;
    dz    = xmax.z - xmin.z;
    xspan = dx * dx + dy * dy + dz * dz;
 
    // Same for y & z spans
    dx    = ymax.x - ymin.x;
    dy    = ymax.y - ymin.y;
    dz    = ymax.z - ymin.z;
    yspan = dx * dx + dy * dy + dz * dz;
 
    dx    = zmax.x - zmin.x;
    dy    = zmax.y - zmin.y;
    dz    = zmax.z - zmin.z;
    zspan = dx * dx + dy * dy + dz * dz;
 
    // Set points dia1 & dia2 to the maximally separated pair
    dia1    = xmin;
    dia2    = xmax; // assume xspan biggest
    maxspan = xspan;
    if (yspan > maxspan)
    {
        maxspan = yspan;
        dia1    = ymin;
        dia2    = ymax;
    }
    if (zspan > maxspan)
    {
        dia1 = zmin;
        dia2 = zmax;
    }
 
    // dia1,dia2 is a diameter of initial sphere
    // calc initial center
    center.x = (dia1.x + dia2.x) * 0.5f;
    center.y = (dia1.y + dia2.y) * 0.5f;
    center.z = (dia1.z + dia2.z) * 0.5f;
 
    // calculate initial radius*radius and radius
    dx      = dia2.x - center.x; // x component of radius vector
    dy      = dia2.y - center.y; // y component of radius vector
    dz      = dia2.z - center.z; // z component of radius vector
    radius2 = dx * dx + dy * dy + dz * dz;
    radius  = sqrt(radius2);
 
    // SECOND PASS: increment current sphere
    for (i = 0; i < P.size(); ++i)
    {
        dx          = P[i].x - center.x;
        dy          = P[i].y - center.y;
        dz          = P[i].z - center.z;
        old_to_p_sq = dx * dx + dy * dy + dz * dz;
 
        if (old_to_p_sq > radius2) // do r**2 test first
        {
            // this point is outside of current sphere
            old_to_p = sqrt(old_to_p_sq);
 
            // calc radius of new sphere
            radius     = (radius + old_to_p) * 0.5f;
            radius2    = radius * radius; // for next r**2 compare
            old_to_new = old_to_p - radius;
 
            // calc center of new sphere
            center.x = (radius * center.x + old_to_new * P[i].x) / old_to_p;
            center.y = (radius * center.y + old_to_new * P[i].y) / old_to_p;
            center.z = (radius * center.z + old_to_new * P[i].z) / old_to_p;
 
            // Suppress if desired
            SL_LOG("\n New sphere: center,radius = %f %f %f   %f",
                   center.x,
                   center.y,
                   center.z,
                   radius);
        }
    }
}

calcMinMax()

void SLMesh::calcMinMax ( )

virtual

SLMesh::calcMinMax calculates the axis alligned minimum and maximum point

Definition at line 978 of file SLMesh.cpp.

{
    // init min & max points
    minP.set(FLT_MAX, FLT_MAX, FLT_MAX);
    maxP.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
 
    // calc min and max point of all vertices
    for (SLulong i = 0; i < P.size(); ++i)
    {
        if (finalP((SLuint)i).x < minP.x) minP.x = finalP((SLuint)i).x;
        if (finalP((SLuint)i).x > maxP.x) maxP.x = finalP((SLuint)i).x;
        if (finalP((SLuint)i).y < minP.y) minP.y = finalP((SLuint)i).y;
        if (finalP((SLuint)i).y > maxP.y) maxP.y = finalP((SLuint)i).y;
        if (finalP((SLuint)i).z < minP.z) minP.z = finalP((SLuint)i).z;
        if (finalP((SLuint)i).z > maxP.z) maxP.z = finalP((SLuint)i).z;
    }
}

calcNormals()

void SLMesh::calcNormals ( )

virtual

SLMesh::calcNormals recalculates vertex normals for triangle meshes.

SLMesh::calcNormals recalculates the normals only from the vertices. This algorithms doesn't know anything about smoothgroups. It just loops over the triangle of the material faces and sums up the normal for each of its vertices. Note that the face normals are not normalized. The cross product of 2 vectors is proportional to the area of the triangle. Like this the normal of big triangles are more weighted than small triangles and we get a better normal quality. At the end all vertex normals are normalized.

Reimplemented in SLParticleSystem.

Definition at line 1165 of file SLMesh.cpp.

{
    // Set vector for the normals & Zero out the normals vector
    N.clear();
 
    if (_primitive != PT_triangles)
        return;
 
    // Create vector and fill with zero vectors
    N.resize(P.size());
    std::fill(N.begin(), N.end(), SLVec3f::ZERO);
 
    if (!I16.empty())
    {
        // Loop over all triangles
        for (SLulong i = 0; i < I16.size(); i += 3)
        {
            // Calculate the face's normal
            SLVec3f e1, e2, n;
 
            // Calculate edges of triangle
            e1.sub(P[I16[i + 1]], P[I16[i + 2]]); // e1 = B - C
            e2.sub(P[I16[i + 1]], P[I16[i]]);     // e2 = B - A
 
            // Build normal with cross product but do NOT normalize it.
            n.cross(e1, e2); // n = e1 x e2
 
            // Add this normal to its vertices normals
            N[I16[i]] += n;
            N[I16[i + 1]] += n;
            N[I16[i + 2]] += n;
        }
    }
    else
    {
        for (SLulong i = 0; i < I32.size(); i += 3)
        {
            // Calculate the face's normal
            SLVec3f e1, e2, n;
 
            // Calculate edges of triangle
            e1.sub(P[I32[i + 1]], P[I32[i + 2]]); // e1 = B - C
            e2.sub(P[I32[i + 1]], P[I32[i]]);     // e2 = B - A
 
            // Build normal with cross product but do NOT normalize it.
            n.cross(e1, e2); // n = e1 x e2
 
            // Add this normal to its vertices normals
            N[I32[i]] += n;
            N[I32[i + 1]] += n;
            N[I32[i + 2]] += n;
        }
    }
 
    // normalize vertex normals
    for (SLulong i = 0; i < P.size(); ++i)
        N[i].normalize();
}

calcTangents()

void SLMesh::calcTangents ( )

private

SLMesh::calcTangents computes the tangents per vertex for triangle meshes.

SLMesh::calcTangents computes the tangent and bi-tangent per vertex used for GLSL normal map bump mapping. The code and mathematical derivation is in detail explained in: http://www.terathon.com/code/tangent.html

Definition at line 1229 of file SLMesh.cpp.

{
    if (!P.empty() &&
        !N.empty() && !UV[0].empty() &&
        (!I16.empty() || !I32.empty()))
    {
        // Delete old tangents
        T.clear();
 
        if (_primitive != PT_triangles)
            return;
 
        // allocate tangents
        T.resize(P.size());
 
        // allocate temp arrays for tangents
        SLVVec3f T1;
        T1.resize(P.size());
        fill(T1.begin(), T1.end(), SLVec3f::ZERO);
        SLVVec3f T2;
        T2.resize(P.size());
        fill(T2.begin(), T2.end(), SLVec3f::ZERO);
 
        SLuint iVA, iVB, iVC;
        SLuint numT = numI() / 3; // NO. of triangles
 
        for (SLuint t = 0; t < numT; ++t)
        {
            SLuint i = t * 3; // vertex index
 
            // Get the 3 vertex indices
            if (!I16.empty())
            {
                iVA = I16[i];
                iVB = I16[i + 1];
                iVC = I16[i + 2];
            }
            else
            {
                iVA = I32[i];
                iVB = I32[i + 1];
                iVC = I32[i + 2];
            }
 
            float x1 = P[iVB].x - P[iVA].x;
            float x2 = P[iVC].x - P[iVA].x;
            float y1 = P[iVB].y - P[iVA].y;
            float y2 = P[iVC].y - P[iVA].y;
            float z1 = P[iVB].z - P[iVA].z;
            float z2 = P[iVC].z - P[iVA].z;
 
            float s1 = UV[0][iVB].x - UV[0][iVA].x;
            float s2 = UV[0][iVC].x - UV[0][iVA].x;
            float t1 = UV[0][iVB].y - UV[0][iVA].y;
            float t2 = UV[0][iVC].y - UV[0][iVA].y;
 
            float   r = 1.0F / (s1 * t2 - s2 * t1);
            SLVec3f sdir((t2 * x1 - t1 * x2) * r,
                         (t2 * y1 - t1 * y2) * r,
                         (t2 * z1 - t1 * z2) * r);
            SLVec3f tdir((s1 * x2 - s2 * x1) * r,
                         (s1 * y2 - s2 * y1) * r,
                         (s1 * z2 - s2 * z1) * r);
 
            T1[iVA] += sdir;
            T1[iVB] += sdir;
            T1[iVC] += sdir;
 
            T2[iVA] += tdir;
            T2[iVB] += tdir;
            T2[iVC] += tdir;
        }
 
        for (SLulong i = 0; i < P.size(); ++i)
        {
            // Gram-Schmidt orthogonalization
            T[i] = T1[i] - N[i] * N[i].dot(T1[i]);
            T[i].normalize();
 
            // Calculate temp. bi-tangent and store its handedness in T.w
            SLVec3f bitangent;
            bitangent.cross(N[i], T1[i]);
            T[i].w = (bitangent.dot(T2[i]) < 0.0f) ? -1.0f : 1.0f;
        }
    }
}

calcTex3DMatrix()

void SLMesh::calcTex3DMatrix ( SLNode *  node )

static

Definition at line 1319 of file SLMesh.cpp.

{
    SLVec3f max = node->aabb()->maxOS();
    SLVec3f ctr = node->aabb()->centerOS();
    SLVec3f ext = max - ctr;
 
    // determine the scale factor s from the max. AABB extension
    SLint   dim;
    SLfloat maxExt = ext.maxXYZ(dim);
    SLfloat s      = 1.0f / (2.0f * maxExt);
 
    // scale and translate the texture matrix
    SLGLState* stateGL = SLGLState::instance();
    stateGL->textureMatrix.identity();
    stateGL->textureMatrix.scale(s);
    stateGL->textureMatrix.translate(-ctr);
    stateGL->textureMatrix.translate(-ext.comp[dim],
                                     -ext.comp[dim],
                                     -ext.comp[dim]);
}

computeHardEdgesIndices()

void SLMesh::computeHardEdgesIndices	(	float	angleDEG,
		float	epsilon
	)

computes the hard edges and stores the vertex indexes separately

Hard edges are edges between faces where there normals have an angle greater than angleDEG (by default 30°). If a mesh has only smooth edges such as a sphere there will be no hard edges. The indices of those hard edges are stored in the vector IE16 or IE32. For rendering these indices are appended behind the indices for the triangle drawing. This is because the index the same vertices of the same VAO. See SLMesh::generateVAO for the details.

Definition at line 819 of file SLMesh.cpp.

{
    // dihedral angle considered to sharp
    float angleRAD = angleDEG * Utils::DEG2RAD;
 
    if (_primitive != PT_triangles)
        return;
 
    Eigen::MatrixXf V;     // Input vertices for igl
    Eigen::MatrixXi F;     // Input faces (=triangle) indices for igl
    Eigen::MatrixXf newV;  // new vertices after duplicate removal
    Eigen::MatrixXi newF;  // new face indices after duplicate removal
    Eigen::MatrixXi edges; // all edges
    Eigen::MatrixXi edgeMap;
    Eigen::MatrixXi uniqueEdges;
    Eigen::MatrixXf faceN; // face normals
    Eigen::VectorXi SVI;   // new to old index mapping
    Eigen::VectorXi SVJ;   // old to new index mapping
 
    vector<vector<int>> uE2E;
 
    // fill input matrices
    V.resize((Eigen::Index)_finalP->size(), 3);
    for (int i = 0; i < _finalP->size(); i++)
        V.row(i) << finalP(i).x, finalP(i).y, finalP(i).z;
 
    if (!I16.empty())
    {
        F.resize((Eigen::Index)I16.size() / 3, 3);
        for (int j = 0, i = 0; i < I16.size(); j++, i += 3)
            F.row(j) << I16[i], I16[i + 1], I16[i + 2];
    }
    if (!I32.empty())
    {
        F.resize((Eigen::Index)I32.size() / 3, 3);
        for (int j = 0, i = 0; i < I32.size(); j++, i += 3)
            F.row(j) << (int)I32[i], (int)I32[i + 1], (int)I32[i + 2];
    }
 
    // extract sharp edges
    igl::remove_duplicate_vertices(V, F, epsilon, newV, SVI, SVJ, newF);
    igl::per_face_normals(newV, newF, faceN);
    igl::unique_edge_map(newF, edges, uniqueEdges, edgeMap, uE2E);
 
    for (int u = 0; u < uE2E.size(); u++)
    {
        bool sharp = false;
        if (uE2E[u].size() == 1) // edges at the border (with only one triangle)
            sharp = true;
 
        // if more than one edge is passing here, compute dihedral angles
        for (int i = 0; i < uE2E[u].size(); i++)
        {
            for (int j = i + 1; j < uE2E[u].size(); j++)
            {
                // E[faceId + |F| * c] opposite of vertex F[faceId][c]
                // ei = fi + |F| * c -> ei % |F| = fi % |F| = fi; fi is the face adjacent to ei
                // ej = fj + |F| * c -> ej % |F| = fj % |F| = fj; fj is the face adjacent to ej
                const int                  ei  = uE2E[u][i]; // edge i
                const int                  fi  = ei % (int)newF.rows();
                const int                  ej  = uE2E[u][j]; // edge j
                const int                  fj  = ej % (int)newF.rows();
                Eigen::Matrix<float, 1, 3> ni  = faceN.row(fi);
                Eigen::Matrix<float, 1, 3> nj  = faceN.row(fj);
                Eigen::Matrix<float, 1, 3> ev  = (newV.row(edges(ei, 1)) - newV.row(edges(ei, 0))).normalized();
                float                      dij = Utils::PI - atan2((ni.cross(nj)).dot(ev), ni.dot(nj));
                sharp                          = std::abs(dij - Utils::PI) > angleRAD;
            }
        }
 
        if (sharp)
        {
            if (!I16.empty())
            {
                IE16.push_back(SVI[uniqueEdges(u, 0)]);
                IE16.push_back(SVI[uniqueEdges(u, 1)]);
            }
            else if (!I32.empty())
            {
                IE32.push_back(SVI[uniqueEdges(u, 0)]);
                IE32.push_back(SVI[uniqueEdges(u, 1)]);
            }
        }
    }
}

deleteData()

void SLMesh::deleteData ( )

virtual

SLMesh::deleteData deletes all mesh data and vbo's.

Definition at line 88 of file SLMesh.cpp.

{
    P.clear();
    N.clear();
    C.clear();
    T.clear();
    UV[0].clear();
    UV[1].clear();
    for (auto i : Ji) i.clear();
    Ji.clear();
    for (auto i : Jw) i.clear();
    Jw.clear();
    I16.clear();
    I32.clear();
    IS32.clear();
    IE16.clear();
    IE32.clear();
 
    _jointMatrices.clear();
    skinnedP.clear();
    skinnedN.clear();
 
    if (_accelStruct)
    {
        delete _accelStruct;
        _accelStruct = nullptr;
    }
 
    _vao.deleteGL();
    _vaoN.deleteGL();
    _vaoT.deleteGL();
 
#ifdef SL_HAS_OPTIX
    _vertexBuffer.free();
    _normalBuffer.free();
    _indexShortBuffer.free();
    _indexIntBuffer.free();
#endif
}

deleteDataGpu()

void SLMesh::deleteDataGpu ( )

virtual

Definition at line 128 of file SLMesh.cpp.

{
    _vao.deleteGL();
    _vaoN.deleteGL();
    _vaoT.deleteGL();
 
#ifdef SL_HAS_OPTIX
    _vertexBuffer.free();
    _normalBuffer.free();
    _indexShortBuffer.free();
    _indexIntBuffer.free();
#endif
}

deleteSelected()

void SLMesh::deleteSelected

(

SLNode *

node

)

Deletes the rectangle selected vertices and the dependent triangles.

The selection rectangle is defined in SLScene::selectRect and gets set and drawn in SLCamera::onMouseDown and SLCamera::onMouseMove. All vertices that are within the selectRect are listed in SLMesh::IS32. The selection evaluation is done during drawing in SLMesh::handleRectangleSelection and is only valid for the current frame. See also SLMesh::handleRectangleSelection.

Definition at line 148 of file SLMesh.cpp.

{
    // Loop over all rectangle selected indexes in IS32
    for (SLulong i = 0; i < IS32.size(); ++i)
    {
        SLulong ixDel = IS32[i] - i;
 
        if (ixDel < P.size()) P.erase(P.begin() + ixDel);
        if (ixDel < N.size()) N.erase(N.begin() + ixDel);
        if (ixDel < C.size()) C.erase(C.begin() + ixDel);
        if (ixDel < T.size()) T.erase(T.begin() + ixDel);
        if (ixDel < UV[0].size()) UV[0].erase(UV[0].begin() + ixDel);
        if (ixDel < UV[1].size()) UV[1].erase(UV[1].begin() + ixDel);
        if (ixDel < Ji.size()) Ji.erase(Ji.begin() + ixDel);
        if (ixDel < Jw.size()) Jw.erase(Jw.begin() + ixDel);
 
        // Loop over all 16 bit triangles indexes
        if (!I16.empty())
        {
            SLVushort i16;
            // copy the triangle that do not contain the index to delete
            for (SLulong t = 0; t < I16.size(); t += 3)
            {
                if (I16[t] != ixDel &&
                    I16[t + 1] != ixDel &&
                    I16[t + 2] != ixDel)
                {
                    if (I16[t] < ixDel)
                        i16.push_back(I16[t]);
                    else
                        i16.push_back(I16[t] - 1);
                    if (I16[t + 1] < ixDel)
                        i16.push_back(I16[t + 1]);
                    else
                        i16.push_back(I16[t + 1] - 1);
                    if (I16[t + 2] < ixDel)
                        i16.push_back(I16[t + 2]);
                    else
                        i16.push_back(I16[t + 2] - 1);
                }
            }
            I16 = i16;
        }
 
        // Loop over all 32 bit triangles indexes
        if (!I32.empty())
        {
            SLVuint i32;
            // copy the triangle that do not contain the index to delete
            for (SLulong t = 0; t < I32.size(); t += 3)
            {
                if (I32[t] != ixDel &&
                    I32[t + 1] != ixDel &&
                    I32[t + 2] != ixDel)
                {
                    if (I32[t] < ixDel)
                        i32.push_back(I32[t]);
                    else
                        i32.push_back(I32[t] - 1);
                    if (I32[t + 1] < ixDel)
                        i32.push_back(I32[t + 1]);
                    else
                        i32.push_back(I32[t + 1] - 1);
                    if (I32[t + 2] < ixDel)
                        i32.push_back(I32[t + 2]);
                    else
                        i32.push_back(I32[t + 2] - 1);
                }
            }
            I32 = i32;
        }
    }
 
    deleteUnused();
 
    calcNormals();
 
    // build tangents for bump mapping
    if (mat()->needsTangents() && !UV[0].empty() && T.empty())
        calcTangents();
 
    // delete vertex array object so it gets regenerated
    _vao.clearAttribs();
    _vaoS.deleteGL();
    _vaoN.deleteGL();
    _vaoT.deleteGL();
 
    // delete the selection indexes
    IS32.clear();
 
    // flag aabb and aceleration structure to be updated
    node->needAABBUpdate();
    _accelStructIsOutOfDate = true;
}

deleteUnused()

void SLMesh::deleteUnused

(

)

Deletes unused vertices (= vertices that are not indexed in I16 or I32)

Definition at line 244 of file SLMesh.cpp.

{
    // SLPoints have no indexes, so nothing to remove
    if (I16.empty() && I32.empty())
        return;
 
    // A boolean for each vertex to flag it as used or not
    SLVbool used(P.size());
    for (auto&& u : used)
        u = false;
 
    // Loop over all indexes and mark them as used
    for (unsigned short i : I16)
        used[i] = true;
 
    for (unsigned int i : I32)
        used[i] = true;
 
    SLuint unused = 0;
    for (SLulong u = 0; u < used.size(); ++u)
    {
        if (!used[u])
        {
            unused++;
            SLulong ixDel = u - (unused - 1);
 
            if (ixDel < P.size()) P.erase(P.begin() + ixDel);
            if (ixDel < N.size()) N.erase(N.begin() + ixDel);
            if (ixDel < C.size()) C.erase(C.begin() + ixDel);
            if (ixDel < T.size()) T.erase(T.begin() + ixDel);
            if (ixDel < UV[0].size()) UV[0].erase(UV[0].begin() + ixDel);
            if (ixDel < UV[1].size()) UV[1].erase(UV[1].begin() + ixDel);
            if (ixDel < Ji.size()) Ji.erase(Ji.begin() + ixDel);
            if (ixDel < Jw.size()) Jw.erase(Jw.begin() + ixDel);
 
            // decrease the indexes smaller than the deleted on
            for (unsigned short& i : I16)
            {
                if (i > ixDel)
                    i--;
            }
 
            for (unsigned int& i : I32)
            {
                if (i > ixDel)
                    i--;
            }
        }
    }
}

deselectPartialSelection()

void SLMesh::deselectPartialSelection

(

)

Clears the partial selection but not the flag SLMesh::_isSelected See also SLMesh::handleRectangleSelection.

Definition at line 698 of file SLMesh.cpp.

{
    _vaoS.clearAttribs();
    IS32.clear();
}

draw()

void SLMesh::draw ( SLSceneView *  sv, SLNode *  node, SLuint  instances = 0  )

virtual

SLMesh::draw does the OpenGL rendering of the mesh. The GL_TRIANGLES primitives are rendered normally with the vertex position vector P, the normal vector N, the vector UV1 and the index vector I16 or I32. GL_LINES & GL_POINTS don't have normals and tex.coords. GL_POINTS don't have indexes (I16,I32) and are rendered with glDrawArrays instead glDrawElements. Optionally you can draw the normals and/or the uniform grid voxels.

The method performs the following steps:

1) Apply the drawing bits
2) Generate Vertex Array Object once
3) Apply the uniform variables to the shader
3a) Activate a shader program if it is not yet in use and apply all its material parameters.
3b) Pass the standard matrices to the shader program.
4) Finally do the draw call by calling SLGLVertexArray::drawElementsAs
5) Draw optional normals & tangents
6) Draw optional acceleration structure
7) Draw selected mesh with points

Please view also the full process of rendering one frame

Reimplemented in SLParticleSystem.

Definition at line 389 of file SLMesh.cpp.

{
    SLGLState* stateGL = SLGLState::instance();
 
    // Check data
    SLstring msg;
    if (P.empty())
        msg = "No vertex positions (P)\n";
    if (_primitive != PT_points && I16.empty() && I32.empty())
        msg += "No vertex indices (I16 or I32)\n";
    if (msg.length() > 0)
    {
        SL_WARN_MSG((msg + "in SLMesh::draw: " + _name).c_str());
        return;
    }
 
    ////////////////////////
    // 1) Apply Drawing Bits
    ////////////////////////
 
    // Return if hidden
    if (sv->drawBit(SL_DB_HIDDEN) || node->drawBit(SL_DB_HIDDEN))
        return;
 
    SLGLPrimitiveType primitiveType = _primitive;
 
    // Set polygon mode
    if ((sv->drawBit(SL_DB_MESHWIRED) || node->drawBit(SL_DB_MESHWIRED)) &&
        typeid(*node) != typeid(SLSkybox))
    {
#ifdef SL_GLES
        primitiveType = PT_lineLoop; // There is no polygon line or point mode on ES2!
#else
        stateGL->polygonLine(true);
#endif
    }
    else
        stateGL->polygonLine(false);
 
    // Set face culling
    bool noFaceCulling = sv->drawBit(SL_DB_CULLOFF) || node->drawBit(SL_DB_CULLOFF);
    stateGL->cullFace(!noFaceCulling);
 
    // enable polygon offset if voxels are drawn to avoid stitching
    if (sv->drawBit(SL_DB_VOXELS) || node->drawBit(SL_DB_VOXELS))
        stateGL->polygonOffsetLine(true, -1.0f, -1.0f);
 
    ///////////////////////////////////////
    // 2) Generate Vertex Array Object once
    ///////////////////////////////////////
 
    if (!_vao.vaoID())
        generateVAO(_vao);
 
    /////////////////////////////
    // 3) Apply Uniform Variables
    /////////////////////////////
 
    // 3.a) Apply mesh material if exists & differs from current
    // If a material is not created so far, it will be created here
    _mat->activate(sv->camera(),
                   &sv->s()->lights(),
                   (!Ji.empty() && !Jw.empty()));
 
    // 3.b) Pass the standard matrices to the shader program
    SLGLProgram* sp = _mat->program();
    sp->uniformMatrix4fv("u_mMatrix", 1, (SLfloat*)&stateGL->modelMatrix);
    sp->uniformMatrix4fv("u_vMatrix", 1, (SLfloat*)&stateGL->viewMatrix);
    sp->uniformMatrix4fv("u_pMatrix", 1, (SLfloat*)&stateGL->projectionMatrix);
 
    // Pass skeleton joint matrices to the shader program
    if (!Ji.empty() && !Jw.empty())
    {
        // Only perform skinning in the shader if we haven't performed CPU skinning and if there are joint IDs
        SLbool skinningEnabled = !_isCPUSkinned;
        sp->uniform1i("u_skinningEnabled", skinningEnabled);
 
        if (skinningEnabled && !_jointMatrices.empty())
            sp->uniformMatrix4fv("u_jointMatrices",
                                 (SLsizei)_jointMatrices.size(),
                                 (SLfloat*)&_jointMatrices[0]);
    }
 
    SLint locTM = sp->getUniformLocation("u_tMatrix");
    if (locTM >= 0)
    {
        if (_mat->has3DTexture() && _mat->textures3d()[0]->autoCalcTM3D())
            calcTex3DMatrix(node);
        else
            stateGL->textureMatrix = _mat->textures(TT_diffuse)[0]->tm();
        sp->uniformMatrix4fv(locTM, 1, (SLfloat*)&stateGL->textureMatrix);
    }
 
    ///////////////////////////////
    // 4): Finally do the draw call
    ///////////////////////////////
 
    if ((sv->drawBit(SL_DB_ONLYEDGES) || node->drawBit(SL_DB_ONLYEDGES)) &&
        (!IE32.empty() || !IE16.empty()))
        _vao.drawEdges(_edgeColor, _edgeWidth);
    else
    {
        if (_primitive == PT_points)
            _vao.drawArrayAs(PT_points);
        else
        {
            if (instances > 1)
                _vao.drawElementsInstanced(primitiveType, instances);
            else
                _vao.drawElementsAs(primitiveType);
 
            if ((sv->drawBit(SL_DB_WITHEDGES) || node->drawBit(SL_DB_WITHEDGES)) &&
                (!IE32.empty() || !IE16.empty()))
            {
                stateGL->polygonOffsetLine(true, 1.0f, 1.0f);
                _vao.drawEdges(_edgeColor, _edgeWidth);
                stateGL->polygonOffsetLine(false);
            }
        }
    }
 
    //////////////////////////////////////
    // 5) Draw optional normals & tangents
    //////////////////////////////////////
 
    // All helper lines must be drawn without blending
    SLbool blended = stateGL->blend();
    if (blended) stateGL->blend(false);
 
    if (!N.empty() && (sv->drawBit(SL_DB_NORMALS) || node->drawBit(SL_DB_NORMALS)))
    {
        // Scale factor r 2% from scaled radius for normals & tangents
        // Build array between vertex and normal target point
        float    r = node->aabb()->radiusOS() * 0.02f;
        SLVVec3f V2;
        V2.resize(P.size() * 2);
        for (SLulong i = 0; i < P.size(); ++i)
        {
            V2[i << 1] = finalP((SLuint)i);
            V2[(i << 1) + 1].set(finalP((SLuint)i) + finalN((SLuint)i) * r);
        }
 
        // Create or update VAO for normals
        _vaoN.generateVertexPos(&V2);
 
        if (!T.empty())
        {
            for (SLulong i = 0; i < P.size(); ++i)
            {
                V2[(i << 1) + 1].set(finalP((SLuint)i).x + T[i].x * r,
                                     finalP((SLuint)i).y + T[i].y * r,
                                     finalP((SLuint)i).z + T[i].z * r);
            }
 
            // Create or update VAO for tangents
            _vaoT.generateVertexPos(&V2);
        }
 
        // Draw normals
        _vaoN.drawArrayAsColored(PT_lines, SLCol4f::BLUE);
 
        // Draw tangents if available
        if (!T.empty())
            _vaoT.drawArrayAsColored(PT_lines, SLCol4f::RED);
        if (blended)
            stateGL->blend(false);
    }
    else
    { // release buffer objects for normal & tangent rendering
        if (_vaoN.vaoID())
            _vaoN.deleteGL();
        if (_vaoT.vaoID())
            _vaoT.deleteGL();
    }
 
    //////////////////////////////////////////
    // 6) Draw optional acceleration structure
    //////////////////////////////////////////
 
    if (_accelStruct)
    {
        if (sv->drawBit(SL_DB_VOXELS) || node->drawBit(SL_DB_VOXELS))
        {
            _accelStruct->draw(sv);
            stateGL->polygonOffsetLine(false);
        }
        else
        { // Delete the visualization VBO if not rendered anymore
            _accelStruct->disposeBuffers();
        }
    }
 
    ////////////////////////////////////
    // 7: Draw selected mesh with points
    ////////////////////////////////////
 
    if (!node->drawBit(SL_DB_NOTSELECTABLE))
        handleRectangleSelection(sv, stateGL, node);
 
    if (blended)
        stateGL->blend(true);
}

drawIntoDepthBuffer()

void SLMesh::drawIntoDepthBuffer	(	SLSceneView *	sv,
		SLNode *	node,
		SLMaterial *	depthMat
	)

Simplified drawing method for shadow map creation.

This is used from within SLShadowMap::drawNodesIntoDepthBufferRec

Definition at line 330 of file SLMesh.cpp.

{
    SLGLState* stateGL = SLGLState::instance();
 
    // Check data
    SLstring msg;
    if (P.empty())
        msg = "No vertex positions (P)\n";
 
    if (_primitive == PT_points && I16.empty() && I32.empty())
        msg += "No vertex indices (I16 or I32)\n";
 
    if (msg.length() > 0)
    {
        SL_WARN_MSG((msg + "in SLMesh::draw: " + _name).c_str());
        return;
    }
 
    // Return if hidden
    if (node->levelForSM() == 0 &&
        (node->drawBit(SL_DB_HIDDEN) || _primitive == PT_points))
        return;
 
    if (!_vao.vaoID())
        generateVAO(_vao);
 
    // Now use the depth material
    SLGLProgram* sp = depthMat->program();
    sp->useProgram();
    sp->uniformMatrix4fv("u_mMatrix", 1, (SLfloat*)&stateGL->modelMatrix);
    sp->uniformMatrix4fv("u_vMatrix", 1, (SLfloat*)&stateGL->viewMatrix);
    sp->uniformMatrix4fv("u_pMatrix", 1, (SLfloat*)&stateGL->projectionMatrix);
 
    _vao.drawElementsAs(PT_triangles);
}

drawSelectedVertices()

void SLMesh::drawSelectedVertices ( )

private

If the entire mesh is selected all points will be drawn with an the vertex array only without indices. If a subset is selected we use the extra index array IS32. See also SLMesh::handleRectangleSelection.

Definition at line 708 of file SLMesh.cpp.

{
    SLGLState* stateGL = SLGLState::instance();
    stateGL->polygonOffsetPoint(true);
    stateGL->depthMask(false);
    stateGL->depthTest(false);
 
    if (IS32.empty())
    {
        // Draw all
        _vaoS.generateVertexPos(_finalP);
        _vaoS.drawArrayAsColored(PT_points, SLCol4f::YELLOW, 2);
    }
    else
    {
        // Draw only selected
        _vaoS.clearAttribs();
        _vaoS.setIndices(&IS32);
        _vaoS.generateVertexPos(_finalP);
        _vaoS.drawElementAsColored(PT_points, SLCol4f::YELLOW, 2);
    }
 
    stateGL->polygonLine(false);
    stateGL->polygonOffsetPoint(false);
    stateGL->depthMask(true);
    stateGL->depthTest(true);
}

edgeAngleDEG() [1/2]

SLfloat SLMesh::edgeAngleDEG ( ) const

inline

Definition at line 184 of file SLMesh.h.

{ return _edgeAngleDEG; }

edgeAngleDEG() [2/2]

void SLMesh::edgeAngleDEG ( SLfloat  ea )

inline

Definition at line 198 of file SLMesh.h.

{ _edgeAngleDEG = ea; }

edgeColor() [1/2]

SLCol4f SLMesh::edgeColor ( ) const

inline

Definition at line 186 of file SLMesh.h.

{ return _edgeColor; }

edgeColor() [2/2]

void SLMesh::edgeColor ( const SLCol4f &  ec )

inline

Definition at line 199 of file SLMesh.h.

{ _edgeColor = ec; }

edgeWidth() [1/2]

SLfloat SLMesh::edgeWidth ( ) const

inline

Definition at line 185 of file SLMesh.h.

{ return _edgeWidth; }

edgeWidth() [2/2]

void SLMesh::edgeWidth ( SLfloat  ew )

inline

Definition at line 197 of file SLMesh.h.

{ _edgeWidth = ew; }

finalN()

SLVec3f SLMesh::finalN ( SLuint  i )

inline

Definition at line 188 of file SLMesh.h.

{ return _finalN->operator[](i); }

finalP()

SLVec3f SLMesh::finalP ( SLuint  i )

inline

Definition at line 187 of file SLMesh.h.

{ return _finalP->operator[](i); }

generateVAO()

void SLMesh::generateVAO ( SLGLVertexArray &  vao )

virtual

Generate the Vertex Array Object for a specific shader program.

Definition at line 738 of file SLMesh.cpp.

{
    PROFILE_FUNCTION();
 
    vao.setAttrib(AT_position, AT_position, _finalP);
    if (!N.empty()) vao.setAttrib(AT_normal, AT_normal, _finalN);
    if (!UV[0].empty()) vao.setAttrib(AT_uv1, AT_uv1, &UV[0]);
    if (!UV[1].empty()) vao.setAttrib(AT_uv2, AT_uv2, &UV[1]);
    if (!C.empty()) vao.setAttrib(AT_color, AT_color, &C);
    if (!T.empty()) vao.setAttrib(AT_tangent, AT_tangent, &T);
 
    if (!I16.empty() || !I32.empty())
    {
        // for triangle meshes compute hard edges and store indices behind the ones of the triangles
        if (_primitive == PT_triangles)
        {
            IE16.clear();
            IE32.clear();
            computeHardEdgesIndices(_edgeAngleDEG, _vertexPosEpsilon);
            if (!I16.empty()) vao.setIndices(&I16, &IE16);
            if (!I32.empty()) vao.setIndices(&I32, &IE32);
        }
        else
        {
            // for points there are no indices at all
            if (!I16.empty()) vao.setIndices(&I16);
            if (!I32.empty()) vao.setIndices(&I32);
        }
    }
 
    SLVVec4i jointIndicesData; // indices are passed to the shader as ivec4s
    SLVVec4f jointWeightsData; // weights are passed to the shader as vec4s
 
    if (!Ji.empty() && !Jw.empty())
    {
        assert(Ji.size() == P.size());
        assert(Jw.size() == P.size());
 
        jointIndicesData = SLVVec4i(P.size(), SLVec4i(0, 0, 0, 0));
        jointWeightsData = SLVVec4f(P.size(), SLVec4f(0.0f, 0.0f, 0.0f, 0.0f));
 
        // create the vec4 of indices for all points
        for (unsigned i = 0; i < P.size(); i++)
        {
            const SLVuchar& curIndices = Ji[i];
            assert(!curIndices.empty());
 
            jointIndicesData[i] = SLVec4i(curIndices.size() >= 1 ? curIndices[0] : 0,
                                          curIndices.size() >= 2 ? curIndices[1] : 0,
                                          curIndices.size() >= 3 ? curIndices[2] : 0,
                                          curIndices.size() >= 4 ? curIndices[3] : 0);
        }
 
        // create the vec4 of weights for all points
        for (unsigned i = 0; i < P.size(); i++)
        {
            const SLVfloat& curWeights = Jw[i];
            assert(curWeights.size() == Ji[i].size());
 
            jointWeightsData[i] = SLVec4f(curWeights.size() >= 1 ? curWeights[0] : 0.0f,
                                          curWeights.size() >= 2 ? curWeights[1] : 0.0f,
                                          curWeights.size() >= 3 ? curWeights[2] : 0.0f,
                                          curWeights.size() >= 4 ? curWeights[3] : 0.0f);
        }
        vao.setAttrib(AT_jointIndex, AT_jointIndex, &jointIndicesData);
        vao.setAttrib(AT_jointWeight, AT_jointWeight, &jointWeightsData);
    }
 
    vao.generate((SLuint)P.size(),
                 !Ji.empty() ? BU_stream : BU_static,
                 Ji.empty());
}

handleRectangleSelection()

void SLMesh::handleRectangleSelection ( SLSceneView *  sv, SLGLState *  stateGL, SLNode *  node  )

private

Handles the rectangle section of mesh vertices (partial selection)

Definition at line 606 of file SLMesh.cpp.

{
    SLScene*  s   = sv->s();
    SLCamera* cam = sv->camera();
 
    // Single node and mesh is selected
    if (cam->selectRect().isEmpty() && cam->deselectRect().isEmpty())
    {
        if (node->isSelected() && _isSelected)
            drawSelectedVertices();
    }
    else // rect selection or deselection is going on
    {
        // Build full viewport-modelview-projection transform matrix
        SLMat4f mvp(stateGL->projectionMatrix * stateGL->viewMatrix * node->updateAndGetWM());
        SLMat4f v;
        SLRecti vp = sv->viewportRect();
        v.viewport((SLfloat)vp.x,
                   (SLfloat)vp.y,
                   (SLfloat)vp.width,
                   (SLfloat)vp.height);
        SLMat4f     v_mvp = v * mvp;
        set<SLuint> tempIselected; // Temp. vector for selected vertex indices
 
        if (!cam->selectRect().isEmpty()) // Do rectangle Selection
        {
            // Select by transform all vertices and add the ones in the rect to tempInRect
            set<SLuint> tempInRect;
            for (SLulong i = 0; i < P.size(); ++i)
            {
                SLVec3f p = v_mvp * P[i];
                if (cam->selectRect().contains(SLVec2f(p.x, p.y)))
                    tempInRect.insert((SLuint)i);
            }
 
            // Merge the rectangle selected by doing a set union operation
            set<SLuint> IS32set(IS32.begin(), IS32.end());
            std::set_union(IS32set.begin(),
                           IS32set.end(),
                           tempInRect.begin(),
                           tempInRect.end(),
                           inserter(tempIselected, tempIselected.begin()));
        }
        else if (!cam->deselectRect().isEmpty()) // Do rectangle Deselection
        {
            // Deselect by transform all vertices and add the ones in the rect to tempIdeselected
            set<SLuint> tempIdeselected; // Temp. vector for deselected vertex indices
            for (SLulong i = 0; i < P.size(); ++i)
            {
                SLVec3f p = v_mvp * P[i];
                if (cam->deselectRect().contains(SLVec2f(p.x, p.y)))
                    tempIdeselected.insert((SLuint)i);
            }
 
            // Remove the deselected ones by doing a set difference operation
            tempIselected.clear();
            set<SLuint> IS32set(IS32.begin(), IS32.end());
            std::set_difference(IS32set.begin(),
                                IS32set.end(),
                                tempIdeselected.begin(),
                                tempIdeselected.end(),
                                inserter(tempIselected, tempIselected.begin()));
        }
 
        // Flag node and mesh for the first time a mesh gets rectangle selected.
        if (!tempIselected.empty() && !node->isSelected() && !_isSelected)
        {
            node->isSelected(true);
            s->selectedNodes().push_back(node);
            _isSelected = true;
            s->selectedMeshes().push_back(this);
            drawSelectedVertices();
        }
 
        // Do not rect-select if the mesh is not selected because it got
        // selected within another node.
        if (node->isSelected() && _isSelected)
        {
            if (!tempIselected.empty())
                IS32.assign(tempIselected.begin(), tempIselected.end());
 
            if (!IS32.empty())
                drawSelectedVertices();
        }
    }
}

hit()

SLbool SLMesh::hit	(	SLRay *	ray,
		SLNode *	node
	)

SLMesh::hit does the ray-mesh intersection test. If no acceleration structure is defined all triangles are tested in a brute force manner.

Definition at line 910 of file SLMesh.cpp.

{
    // return true for point & line objects
    if (_primitive != PT_triangles)
    {
        ray->hitNode = node;
        ray->hitMesh = this;
        SLVec3f OC   = node->aabb()->centerWS() - ray->origin;
        ray->length  = OC.length();
        return true;
    }
 
    // Force the mesh to be skinned in software even if it would be normally
    // skinned on the GPU. We need the results from the skinning on the CPU to
    // perform the ray-triangle intersection.
    if (_skeleton && _mat && (!Ji.empty() && !Jw.empty()) && !_isCPUSkinned)
        transformSkin(true, [](SLMesh*) {});
 
    if (_accelStruct)
    {
        if (_accelStructIsOutOfDate)
            updateAccelStruct();
 
        return _accelStruct->intersect(ray, node);
    }
    else
    { // intersect against all faces
        SLbool wasHit = false;
 
        for (SLuint t = 0; t < numI(); t += 3)
            if (hitTriangleOS(ray, node, t) && !wasHit)
                wasHit = true;
 
        return wasHit;
    }
}

hitTriangleOS()

SLbool SLMesh::hitTriangleOS	(	SLRay *	ray,
		SLNode *	node,
		SLuint	iT
	)

SLMesh::hitTriangleOS is the fast and minimum storage ray-triangle intersection test by Tomas Moeller and Ben Trumbore (Journal of graphics tools 2, 1997).

Definition at line 1345 of file SLMesh.cpp.

{
    assert(ray && "ray pointer is null");
    assert(node && "node pointer is null");
    assert(_mat && "material pointer is null");
 
    ++SLRay::tests;
 
    if (_primitive != PT_triangles)
        return false;
 
    // prevent self-intersection of triangle
    if (ray->srcMesh == this && ray->srcTriangle == (SLint)iT)
        return false;
 
    SLVec3f cornerA, cornerB, cornerC;
    SLVec3f e1, e2; // edge 1 and 2
    SLVec3f AO, K, Q;
 
    // get the corner vertices
    if (!I16.empty())
    {
        cornerA = finalP(I16[iT]);
        cornerB = finalP(I16[iT + 1]);
        cornerC = finalP(I16[iT + 2]);
    }
    else
    {
        cornerA = finalP(I32[iT]);
        cornerB = finalP(I32[iT + 1]);
        cornerC = finalP(I32[iT + 2]);
    }
 
    // find vectors for two edges sharing the triangle vertex A
    e1.sub(cornerB, cornerA);
    e2.sub(cornerC, cornerA);
 
    // begin calculating determinant - also used to calculate U parameter
    K.cross(ray->dirOS, e2);
 
    // if determinant is near zero, ray lies in plane of triangle
    const SLfloat det = e1.dot(K);
 
    SLfloat inv_det, t, u, v;
 
    // if ray is outside do test with face culling
    if (ray->isOutside && _isVolume)
    { // check only front side triangles
 
        // exit if ray is from behind or parallel
        if (det < FLT_EPSILON) return false;
 
        // calculate distance from corner A to ray origin
        AO.sub(ray->originOS, cornerA);
 
        // Calculate barycentric coordinates: u>0 && v>0 && u+v<=1
        u = AO.dot(K);
        if (u < 0.0f || u > det) return false;
 
        // prepare to test v parameter
        Q.cross(AO, e1);
 
        // calculate v parameter and test bounds
        v = Q.dot(ray->dirOS);
        if (v < 0.0f || u + v > det) return false;
 
        // calculate intersection distance t
        inv_det = 1.0f / det;
        t       = e2.dot(Q) * inv_det;
 
        // if intersection is closer replace ray intersection parameters
        if (t > ray->length || t < 0.0f) return false;
 
        ray->length = t;
 
        // scale down u & v so that u+v<=1
        ray->hitU = u * inv_det;
        ray->hitV = v * inv_det;
    }
    else
    { // check front & backside triangles
        // exit if ray is parallel
        if (det < FLT_EPSILON && det > -FLT_EPSILON) return false;
 
        inv_det = 1.0f / det;
 
        // calculate distance from corner A to ray origin
        AO.sub(ray->originOS, cornerA);
 
        // Calculate barycentric coordinates: u>0 && v>0 && u+v<=1
        u = AO.dot(K) * inv_det;
        if (u < 0.0f || u > 1.0f) return false;
 
        // prepare to test v parameter
        Q.cross(AO, e1);
 
        // calculate v parameter and test bounds
        v = Q.dot(ray->dirOS) * inv_det;
        if (v < 0.0f || u + v > 1.0f) return false;
 
        // calculate t, ray intersects triangle
        t = e2.dot(Q) * inv_det;
 
        // if intersection is closer replace ray intersection parameters
        if (t > ray->length || t < 0.0f) return false;
 
        ray->length = t;
        ray->hitU   = u;
        ray->hitV   = v;
    }
 
    ray->hitTriangle = (SLint)iT;
    ray->hitNode     = node;
    ray->hitMesh     = this;
 
    ++SLRay::intersections;
 
    return true;
}

init()

void SLMesh::init ( SLNode *  node )

virtual

SLMesh::shapeInit sets the transparency flag of the AABB.

Definition at line 296 of file SLMesh.cpp.

{
    // Check data
    SLstring msg;
    if (P.empty())
        msg = "No vertex positions (P)\n";
    if (_primitive != PT_points && I16.empty() && I32.empty())
        msg += "No vertex indices (I16 or I32)\n";
    if (msg.length() > 0)
        SL_EXIT_MSG((msg + "in SLMesh::init: " + _name).c_str());
 
    if (N.empty()) calcNormals();
 
    // Set default materials if no materials are assigned
    // If colors are available use diffuse color attribute shader
    // otherwise use the default gray material
    if (!mat())
    {
        if (!C.empty())
            mat(SLMaterialDefaultColorAttribute::instance());
        else
            mat(SLMaterialDefaultGray::instance());
    }
 
    // build tangents for bump mapping
    if (mat()->needsTangents() && !UV[0].empty() && T.empty())
        calcTangents();
 
    _isSelected = false;
}

isSelected() [1/2]

SLbool SLMesh::isSelected ( ) const

inline

Definition at line 183 of file SLMesh.h.

{ return _isSelected; }

isSelected() [2/2]

void SLMesh::isSelected ( bool  isSelected )

inline

Definition at line 196 of file SLMesh.h.

{ _isSelected = isSelected; }

mat() [1/2]

SLMaterial* SLMesh::mat ( ) const

inline

Definition at line 177 of file SLMesh.h.

{ return _mat; }

mat() [2/2]

void SLMesh::mat ( SLMaterial *  m )

inline

Definition at line 192 of file SLMesh.h.

{ _mat = m; }

matOut() [1/2]

SLMaterial* SLMesh::matOut ( ) const

inline

Definition at line 178 of file SLMesh.h.

{ return _matOut; }

matOut() [2/2]

void SLMesh::matOut ( SLMaterial *  m )

inline

Definition at line 193 of file SLMesh.h.

{ _matOut = m; }

numI()

SLuint SLMesh::numI ( ) const

inline

Definition at line 181 of file SLMesh.h.

{ return (SLuint)(!I16.empty() ? I16.size() : I32.size()); }

preShade()

void SLMesh::preShade ( SLRay *  ray )

virtual

SLMesh::preShade calculates the rest of the intersection information after the final hit point is determined. Should be called just before the shading when the final intersection point of the closest triangle was found.

Definition at line 1470 of file SLMesh.cpp.

{
    if (_primitive != PT_triangles)
        return;
 
    // Get the triangle indices
    SLuint iA, iB, iC;
    if (!I16.empty())
    {
        iA = I16[(SLushort)ray->hitTriangle];
        iB = I16[(SLushort)ray->hitTriangle + 1];
        iC = I16[(SLushort)ray->hitTriangle + 2];
    }
    else
    {
        iA = I32[(SLuint)ray->hitTriangle];
        iB = I32[(SLuint)ray->hitTriangle + 1];
        iC = I32[(SLuint)ray->hitTriangle + 2];
    }
 
    // calculate the hit point in world space
    ray->hitPoint.set(ray->origin + ray->length * ray->dir);
 
    // calculate the interpolated normal with vertex normals in object space
    ray->hitNormal.set(finalN(iA) * (1 - (ray->hitU + ray->hitV)) +
                       finalN(iB) * ray->hitU +
                       finalN(iC) * ray->hitV);
 
    // transform normal back to world space
    SLMat3f wmN(ray->hitNode->updateAndGetWM().mat3());
    ray->hitNormal.set(wmN * ray->hitNormal);
 
    // for shading the normal is expected to be unit length
    ray->hitNormal.normalize();
 
    // calculate interpolated texture coordinates
    SLVGLTexture& diffuseTex = ray->hitMesh->mat()->textures(TT_diffuse);
 
    if (!diffuseTex.empty() &&
        !diffuseTex[0]->images().empty() &&
        !UV[0].empty())
    {
        SLVec2f Tu(UV[0][iB] - UV[0][iA]);
        SLVec2f Tv(UV[0][iC] - UV[0][iA]);
        SLVec2f tc(UV[0][iA] + ray->hitU * Tu + ray->hitV * Tv);
        ray->hitTexColor.set(diffuseTex[0]->getTexelf(tc.x, tc.y));
 
        // bump mapping
        SLVGLTexture& bumpTex = ray->hitMesh->mat()->textures(TT_normal);
        if (!bumpTex.empty() && !bumpTex[0]->images().empty())
        {
            if (!T.empty())
            {
                // calculate the interpolated tangent with vertex tangent in object space
                SLVec4f hitT(T[iA] * (1 - (ray->hitU + ray->hitV)) +
                             T[iB] * ray->hitU +
                             T[iC] * ray->hitV);
 
                SLVec3f T3(hitT.x, hitT.y, hitT.z);         // tangent with 3 components
                T3.set(wmN * T3);                           // transform tangent back to world space
                SLVec2f d   = bumpTex[0]->dudv(tc.x, tc.y); // slope of bump-map at tc
                SLVec3f Nrm = ray->hitNormal;               // unperturbated normal
                SLVec3f B(Nrm ^ T3);                        // bi-normal tangent B
                B *= T[iA].w;                               // correct handedness
                SLVec3f D(d.x * T3 + d.y * B);              // perturbation vector D
                Nrm += D;
                Nrm.normalize();
                ray->hitNormal.set(Nrm);
            }
        }
 
        // Get ambient occlusion
        SLVGLTexture& aoTex = ray->hitMesh->mat()->textures(TT_occlusion);
        if (!UV[1].empty())
        {
            SLVec2f Tu2(UV[1][iB] - UV[1][iA]);
            SLVec2f Tv2(UV[1][iC] - UV[1][iA]);
            SLVec2f tc2(UV[1][iA] + ray->hitU * Tu2 + ray->hitV * Tv2);
 
            if (!aoTex.empty())
                ray->hitAO = aoTex[0]->getTexelf(tc2.x, tc2.y).r;
        }
    }
 
    // calculate interpolated color for meshes with color attributes
    if (!ray->hitMesh->C.empty())
    {
        SLCol4f CA = ray->hitMesh->C[iA];
        SLCol4f CB = ray->hitMesh->C[iB];
        SLCol4f CC = ray->hitMesh->C[iC];
        ray->hitTexColor.set(CA * (1 - (ray->hitU + ray->hitV)) +
                             CB * ray->hitU +
                             CC * ray->hitV);
    }
}

primitive() [1/2]

SLGLPrimitiveType SLMesh::primitive ( ) const

inline

Definition at line 179 of file SLMesh.h.

{ return _primitive; }

primitive() [2/2]

void SLMesh::primitive ( SLGLPrimitiveType  pt )

inline

Definition at line 194 of file SLMesh.h.

{ _primitive = pt; }

skeleton() [1/2]

const SLAnimSkeleton* SLMesh::skeleton ( ) const

inline

Definition at line 180 of file SLMesh.h.

{ return _skeleton; }

skeleton() [2/2]

void SLMesh::skeleton ( SLAnimSkeleton *  skel )

inline

Definition at line 195 of file SLMesh.h.

{ _skeleton = skel; }

transformSkin()

void SLMesh::transformSkin	(	bool	forceCPUSkinning,
		const std::function< void(SLMesh *)> &	cbInformNodes
	)

Transforms the vertex positions and normals with by joint weights.

If the mesh is used for skinned skeleton animation this method transforms each vertex and normal by max. four joints of the skeleton. Each joint has a weight and an index. After the transform the VBO have to be updated. This skinning process can also be done (a lot faster) on the GPU. This software skinning is also needed for ray or path tracing.

Definition at line 1573 of file SLMesh.cpp.

{
    if (_isSelected)
        forceCPUSkinning = true;
 
    // create the secondary buffers for P and N once
    if (skinnedP.empty())
    {
        skinnedP.resize(P.size());
        for (SLulong i = 0; i < P.size(); ++i)
            skinnedP[i] = P[i];
    }
    if (skinnedN.empty() && !N.empty())
    {
        skinnedN.resize(P.size());
        for (SLulong i = 0; i < P.size(); ++i)
            skinnedN[i] = N[i];
    }
 
    // Create array for joint matrices once
    if (_jointMatrices.empty())
    {
        _jointMatrices.clear();
        _jointMatrices.resize((SLuint)_skeleton->numJoints());
    }
 
    // update the joint matrix array
    _skeleton->getJointMatrices(_jointMatrices);
 
    // notify parent nodes to update AABB
    cbInformNodes(this);
 
    // flag acceleration structure to be rebuilt
    _accelStructIsOutOfDate = true;
 
    // remember if this node has been skinned on the CPU
    _isCPUSkinned = forceCPUSkinning;
 
    // Perform software skinning if the material doesn't support CPU skinning or
    // if the results of the skinning process are required somewhere else.
    if (forceCPUSkinning)
    {
        _finalP = &skinnedP;
        _finalN = &skinnedN;
 
        // iterate over all vertices and write to new buffers
        for (SLulong i = 0; i < P.size(); ++i)
        {
            skinnedP[i] = SLVec3f::ZERO;
            if (!N.empty()) skinnedN[i] = SLVec3f::ZERO;
 
            // accumulate final normal and positions
            for (SLulong j = 0; j < Ji[i].size(); ++j)
            {
                const SLMat4f& jm      = _jointMatrices[Ji[i][j]];
                SLVec4f        tempPos = SLVec4f(jm * P[i]);
                skinnedP[i].x += tempPos.x * Jw[i][j];
                skinnedP[i].y += tempPos.y * Jw[i][j];
                skinnedP[i].z += tempPos.z * Jw[i][j];
 
                if (!N.empty())
                {
                    // Build the 3x3 submatrix in GLSL 110 (= mat3 jt3 = mat3(jt))
                    // for the normal transform that is the normally the inverse transpose.
                    // The inverse transpose can be ignored as long as we only have
                    // rotation and uniform scaling in the 3x3 submatrix.
                    SLMat3f jnm = jm.mat3();
                    skinnedN[i] += jnm * N[i] * Jw[i][j];
                }
            }
        }
    }
    else
    {
        _finalP = &P;
        _finalN = &N;
    }
 
    // update or create buffers
    if (_vao.vaoID())
    {
        _vao.updateAttrib(AT_position, _finalP);
        if (!N.empty()) _vao.updateAttrib(AT_normal, _finalN);
    }
}

updateAccelStruct()

void SLMesh::updateAccelStruct

(

)

SLMesh::updateAccelStruct rebuilds the acceleration structure if the dirty flag is set. This can happen for mesh animations.

Definition at line 1133 of file SLMesh.cpp.

{
    calcMinMax();
 
    // Add half a percent in each direction to avoid zero size dimensions
    SLVec3f distMinMax = maxP - minP;
    SLfloat addon      = distMinMax.length() * 0.005f;
    minP -= addon;
    maxP += addon;
 
    if (_primitive != PT_triangles)
        return;
 
    if (_accelStruct == nullptr)
        _accelStruct = new SLCompactGrid(this);
 
    if (_accelStruct && numI() > 15)
    {
        _accelStruct->build(minP, maxP);
        _accelStructIsOutOfDate = false;
    }
}

vao()

SLGLVertexArray& SLMesh::vao ( )

inline

Definition at line 182 of file SLMesh.h.

{ return _vao; }

vertexPosEpsilon()

void SLMesh::vertexPosEpsilon ( SLfloat  eps )

inline

Definition at line 200 of file SLMesh.h.

{ _vertexPosEpsilon = eps; }

Member Data Documentation

_accelStruct

SLAccelStruct* SLMesh::_accelStruct

protected

KD-tree or uniform grid.

Definition at line 254 of file SLMesh.h.

_accelStructIsOutOfDate

SLbool SLMesh::_accelStructIsOutOfDate

protected

Flag if accel. struct needs update.

Definition at line 255 of file SLMesh.h.

_edgeAngleDEG

SLfloat SLMesh::_edgeAngleDEG

protected

Edge crease angle in degrees between face normals (30 deg. default)

Definition at line 239 of file SLMesh.h.

_edgeColor

SLCol4f SLMesh::_edgeColor

protected

Color for hard edge drawing.

Definition at line 241 of file SLMesh.h.

_edgeWidth

SLfloat SLMesh::_edgeWidth

protected

Line width for hard edge drawing.

Definition at line 240 of file SLMesh.h.

_finalN

SLVVec3f* SLMesh::_finalN

protected

pointer to final vertex normal vector

Definition at line 260 of file SLMesh.h.

_finalP

SLVVec3f* SLMesh::_finalP

protected

Pointer to final vertex position vector.

Definition at line 259 of file SLMesh.h.

_isCPUSkinned

SLbool SLMesh::_isCPUSkinned

protected

Flag if mesh has been skinned on CPU during update.

Definition at line 258 of file SLMesh.h.

_isSelected

SLbool SLMesh::_isSelected

protected

Flag if mesh is partially of fully selected.

Definition at line 238 of file SLMesh.h.

_isVolume

SLbool SLMesh::_isVolume

protected

Flag for RT if mesh is a closed volume.

Definition at line 253 of file SLMesh.h.

_jointMatrices

SLVMat4f SLMesh::_jointMatrices

protected

Joint matrix vector for this mesh.

Definition at line 257 of file SLMesh.h.

_mat

SLMaterial* SLMesh::_mat

protected

Pointer to the inside material.

Definition at line 232 of file SLMesh.h.

_matOut

SLMaterial* SLMesh::_matOut

protected

Pointer to the outside material.

Definition at line 233 of file SLMesh.h.

_primitive

SLGLPrimitiveType SLMesh::_primitive

protected

Primitive type (default triangles)

Definition at line 231 of file SLMesh.h.

_skeleton

SLAnimSkeleton* SLMesh::_skeleton

protected

The skeleton this mesh is bound to.

Definition at line 256 of file SLMesh.h.

_vao

SLGLVertexArray SLMesh::_vao

protected

Main OpenGL Vertex Array Object for drawing.

Definition at line 234 of file SLMesh.h.

_vaoN

SLGLVertexArrayExt SLMesh::_vaoN

protected

OpenGL VAO for optional normal drawing.

Definition at line 235 of file SLMesh.h.

_vaoS

SLGLVertexArrayExt SLMesh::_vaoS

protected

OpenGL VAO for optional selection drawing.

Definition at line 237 of file SLMesh.h.

_vaoT

SLGLVertexArrayExt SLMesh::_vaoT

protected

OpenGL VAO for optional tangent drawing.

Definition at line 236 of file SLMesh.h.

_vertexPosEpsilon

SLfloat SLMesh::_vertexPosEpsilon

protected

Vertex position epsilon used in computeHardEdgesIndices.

Definition at line 242 of file SLMesh.h.

C

SLVCol4f SLMesh::C

Vector of vertex colors (opt.) layout (location = 4)

Definition at line 206 of file SLMesh.h.

I16

SLVushort SLMesh::I16

Vector of vertex indices 16 bit.

Definition at line 214 of file SLMesh.h.

I32

SLVuint SLMesh::I32

Vector of vertex indices 32 bit.

Definition at line 215 of file SLMesh.h.

IE16

SLVushort SLMesh::IE16

Vector of hard edges vertex indices 16 bit (see computeHardEdgesIndices)

Definition at line 217 of file SLMesh.h.

IE32

SLVuint SLMesh::IE32

Vector of hard edges vertex indices 32 bit (see computeHardEdgesIndices)

Definition at line 218 of file SLMesh.h.

IS32

SLVuint SLMesh::IS32

Vector of rectangle selected vertex indices 32 bit.

Definition at line 216 of file SLMesh.h.

Ji

SLVVuchar SLMesh::Ji

2D Vector of per vertex joint ids (opt.) layout (location = 6)

Definition at line 208 of file SLMesh.h.

Jw

SLVVfloat SLMesh::Jw

2D Vector of per vertex joint weights (opt.) layout (location = 7)

Definition at line 209 of file SLMesh.h.

maxP

SLVec3f SLMesh::maxP

max. vertex in OS

Definition at line 221 of file SLMesh.h.

minP

SLVec3f SLMesh::minP

min. vertex in OS

Definition at line 220 of file SLMesh.h.

N

SLVVec3f SLMesh::N

Vector for vertex normals (opt.) layout (location = 1)

Definition at line 204 of file SLMesh.h.

P

SLVVec3f SLMesh::P

Vector for vertex positions layout (location = 0)

Definition at line 203 of file SLMesh.h.

skinnedN

SLVVec3f SLMesh::skinnedN

temp. vector for CPU skinned vertex normals

Definition at line 211 of file SLMesh.h.

skinnedP

SLVVec3f SLMesh::skinnedP

temp. vector for CPU skinned vertex positions

Definition at line 210 of file SLMesh.h.

T

SLVVec4f SLMesh::T

Vector of vertex tangents (opt.) layout (location = 5)

Definition at line 207 of file SLMesh.h.

UV

SLVVec2f SLMesh::UV[2]

Array of 2 Vectors for tex. coords. (opt.) layout (location = 2)

Definition at line 205 of file SLMesh.h.

---

The documentation for this class was generated from the following files:

• SLMesh.h
• SLMesh.cpp