SLRevolver is an SLMesh object built out of revolving points. More...

#include <SLRevolver.h>

Inheritance diagram for SLRevolver:

Public Member Functions
	SLRevolver (SLAssetManager assetMgr, SLVVec3f revolvePoints, SLVec3f revolveAxis, SLuint slices=36, SLbool smoothFirst=false, SLbool smoothLast=false, SLstring name="revolver mesh", SLMaterial mat=nullptr)
	ctor for generic revolver mesh More...

	SLRevolver (SLAssetManager *assetMgr, SLstring name)
	ctor for derived revolver shapes More...

void	buildMesh (SLMaterial *mat=nullptr)

SLuint	stacks ()

SLuint	slices ()

Public Member Functions inherited from SLMesh
	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

Protected Attributes
SLVVec3f	_revPoints
	Array revolving points. More...

SLVec3f	_revAxis
	axis of revolution More...

SLuint	_stacks
	No. of stacks (mostly used) More...

SLuint	_slices
	NO. of slices. More...

SLbool	_smoothFirst
	flag if the normal of the first point is eqaual to -revAxis More...

SLbool	_smoothLast
	flag if the normal of the last point is eqaual to revAxis More...

Protected Attributes inherited from SLMesh
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...

Additional Inherited Members
Static Public Member Functions inherited from SLMesh
static void	calcTex3DMatrix (SLNode *node)

Public Attributes inherited from SLMesh
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...

Detailed Description

SLRevolver is an SLMesh object built out of revolving points.

SLRevolver is an SLMesh object that is built out of points that are revolved in slices around and axis. The surface will be outwards if the points in the array _revPoints increase towards the axis direction. If all points in the array _revPoints are different the normals will be smoothed. If two consecutive points are identical the normals will define a hard edge. Texture coords. are cylindrically mapped. See the online example Revolving Meshes with various revolver objects.

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 37 of file SLRevolver.h.

Constructor & Destructor Documentation

◆ SLRevolver() [1/2]

SLRevolver::SLRevolver	(	SLAssetManager *	assetMgr,
		SLVVec3f	revolvePoints,
		SLVec3f	revolveAxis,
		SLuint	slices = `36`,
		SLbool	smoothFirst = `false`,
		SLbool	smoothLast = `false`,
		SLstring	name = `"revolver mesh"`,
		SLMaterial *	mat = `nullptr`
	)

ctor for generic revolver mesh

SLRevolver::SLRevolver ctor for generic revolution object.

Definition at line 16 of file SLRevolver.cpp.

                                             : SLMesh(assetMgr, name)
 {
     assert(revolvePoints.size() >= 2 && "Error: Not enough revolve points.");
     assert(revolveAxis != SLVec3f::ZERO && "Error axis is a zero vector.");
     assert(slices >= 3 && "Error: Not enough slices.");
  
     _revPoints   = revolvePoints;
     _revAxis     = revolveAxis;
     _slices      = slices;
     _smoothFirst = smoothFirst;
     _smoothLast  = smoothLast;
  
     _revAxis.normalize();
  
     buildMesh(mat);
 }

◆ SLRevolver() [2/2]

SLRevolver::SLRevolver	(	SLAssetManager *	assetMgr,
		SLstring	name
	)

inline

ctor for derived revolver shapes

Definition at line 51 of file SLRevolver.h.

51 : SLMesh(assetMgr, std::move(name)) { ; }

Member Function Documentation

◆ buildMesh()

void SLRevolver::buildMesh ( SLMaterial * material = nullptr )

SLRevolver::buildMesh builds the underlying mesh data structure

Definition at line 43 of file SLRevolver.cpp.

 {
     deleteData();
  
     ///////////////////////////////
     // Vertices & Texture coords //
     ///////////////////////////////
  
     // calculate no. of vertices & allocate vectors for P, UV1 & N.
     // On one stack it has one vertex more at the end that is identical with the
     // first vertex of the stack. This is for cylindrical texture mapping where
     // we need 2 different texture s-coords (0 & 1) at the same point.
     P.clear();
     P.resize((_slices + 1) * _revPoints.size());
     N.clear();
     N.resize(P.size());
     UV[0].clear();
     UV[0].resize(P.size());
     UV[1].clear();
  
     // calculate length of segments for texture coords
     SLfloat  totalLenght = 0;
     SLVfloat segments;
     segments.push_back(0);
     for (SLuint r = 0; r < _revPoints.size() - 1; ++r)
     {
         SLVec3f s   = _revPoints[r + 1] - _revPoints[r];
         SLfloat len = s.length();
         totalLenght += len;
         segments.push_back(len);
     }
  
     // Normalize segment lengths for texture coords
     for (auto& segment : segments)
         segment /= totalLenght;
  
     // Texture coordinate
     SLVec2f uv1(0, 0);               // y is increased by segment[r]
     SLfloat deltaS = 1.0f / _slices; // increase value for s-tecCoord
  
     // define matrix & angles for rotation
     SLMat4f m;
     SLfloat dPhi = 360.0f / _slices;
  
     // calculate vertices & texture coords for all revolution points
     SLuint iV = 0;
     for (SLuint r = 0; r < _revPoints.size(); ++r)
     {
         m.identity();
         uv1.x = 0;
         uv1.y += segments[r];
         for (SLuint s = 0; s <= _slices; ++s)
         {
             if (s == 0 || s == _slices)
                 P[iV] = _revPoints[r];
             else
                 P[iV] = m.multVec(_revPoints[r]);
  
             UV[0][iV++] = uv1;
             m.rotate(dPhi, _revAxis);
             uv1.x += deltaS;
         }
     }
  
     /////////////////
     //    Faces    //
     /////////////////
  
     vector<SLVec3ui> faces;
  
     // set faces (triangles) for all revolution segments
     SLVec3ui f;
     SLuint   iV1, iV2;
     for (SLuint r = 0; r < _revPoints.size() - 1; ++r)
     {
         iV1 = r * (_slices + 1);
         iV2 = (r + 1) * (_slices + 1);
  
         // only define faces if neighboring points are different
         if (_revPoints[r] != _revPoints[r + 1])
         {
             for (SLuint s = 0; s < _slices; ++s)
             {
                 // Add two triangles if real quad is visible
                 // Add upper triangle only iB (or iC) are not on rev. axis
                 if (_revAxis.distSquared(P[iV2 + s]) > FLT_EPSILON)
                 {
                     f.x = iV1 + s;
                     f.y = iV2 + s + 1;
                     f.z = iV2 + s;
                     faces.push_back(f);
                 }
  
                 // Add lower triangle only iA (or iB) are not on rev. axis
                 if (_revAxis.distSquared(P[iV1 + s]) > FLT_EPSILON)
                 {
                     f.x = iV1 + s;
                     f.y = iV1 + s + 1;
                     f.z = iV2 + s + 1;
                     faces.push_back(f);
                 }
             }
         }
     }
  
     assert(!faces.empty() && "SLRevolver::buildMesh: No faces defined!");
  
     // calculate no. of faces (triangles) & allocate arrays
     SLuint i = 0;
     if (P.size() < 65536)
     {
         I16.clear();
         I16.resize(faces.size() * 3);
         for (auto face : faces)
         {
             I16[i++] = (SLushort)face.x;
             I16[i++] = (SLushort)face.y;
             I16[i++] = (SLushort)face.z;
         }
     }
     else
     {
         I32.clear();
         I32.resize(faces.size() * 3);
         for (auto face : faces)
         {
             I32[i++] = face.x;
             I32[i++] = face.y;
             I32[i++] = face.z;
         }
     }
  
     // Set one default material index
     mat(material);
  
     /////////////////
     //   Normals   //
     /////////////////
  
     // Calculate normals with the SLMesh method
     calcNormals();
  
     // correct normals at the first point
     if (_smoothFirst)
     {
         for (SLuint s = 0; s < _slices; ++s)
         {
             N[s]     = -_revAxis;
             N[s + 1] = -_revAxis;
         }
     }
  
     // correct normals at the first point
     if (_smoothLast)
     {
         for (SLuint s = 0; s < _slices; ++s)
         {
             N[P.size() - s - 1] = _revAxis;
             N[P.size() - s - 2] = _revAxis;
         }
     }
  
     // correct (smooth) the start normal and the end normal of a stack
     for (SLuint r = 0; r < _revPoints.size(); ++r)
     {
         iV1 = r * (_slices + 1);
         iV2 = iV1 + _slices;
         N[iV1] += N[iV2];
         N[iV1].normalize();
         N[iV2] = N[iV1];
     }
 }

◆ slices()

SLuint SLRevolver::slices ( )

inline

Definition at line 55 of file SLRevolver.h.

55 { return _slices; }

◆ stacks()

SLuint SLRevolver::stacks ( )

inline

Definition at line 54 of file SLRevolver.h.

54 { return _stacks; }

SLRevolver::_stacks

SLuint _stacks

No. of stacks (mostly used)

Definition: SLRevolver.h:60

Member Data Documentation

◆ _revAxis

SLVec3f SLRevolver::_revAxis

protected

axis of revolution

Definition at line 59 of file SLRevolver.h.

◆ _revPoints

SLVVec3f SLRevolver::_revPoints

protected

Array revolving points.

Definition at line 58 of file SLRevolver.h.

◆ _slices

SLuint SLRevolver::_slices

protected

NO. of slices.

Definition at line 61 of file SLRevolver.h.

◆ _smoothFirst

SLbool SLRevolver::_smoothFirst

protected

flag if the normal of the first point is eqaual to -revAxis

Definition at line 64 of file SLRevolver.h.

◆ _smoothLast

SLbool SLRevolver::_smoothLast

protected

flag if the normal of the last point is eqaual to revAxis

Definition at line 67 of file SLRevolver.h.

◆ _stacks

SLuint SLRevolver::_stacks

protected

No. of stacks (mostly used)

Definition at line 60 of file SLRevolver.h.

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

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SLRevolver() [1/2]

◆ SLRevolver() [2/2]

Member Function Documentation

◆ buildMesh()

◆ slices()

◆ stacks()

Member Data Documentation

◆ _revAxis

◆ _revPoints

◆ _slices

◆ _smoothFirst

◆ _smoothLast

◆ _stacks