SLLens Class Reference

SLLens creates a lens mesh based on SLRevolver. More...

#include <SLLens.h>

Inheritance diagram for SLLens:

Public Member Functions
	SLLens (SLAssetManager *assetMgr, double sphere, double cylinder, SLfloat diameter, SLfloat thickness, SLuint stacks=32, SLuint slices=32, SLstring name="lens mesh", SLMaterial *mat=nullptr)
	Create a lens with given sphere, cylinder, diameter and thickness. More...
	SLLens (SLAssetManager *assetMgr, SLfloat radiusBot, SLfloat radiusTop, SLfloat diameter, SLfloat thickness, SLuint stacks=32, SLuint slices=32, SLstring name="lens mesh", SLMaterial *mat=nullptr)
	Create a lens with given radius, diameter and thickness. More...
Public Member Functions inherited from 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 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

Private Member Functions
void	initLens (SLfloat diopterBot, SLfloat diopterTop, SLfloat diameter, SLfloat thickness, SLuint stacks, SLuint slices, SLMaterial *mat)
	Initialize the lens. More...
void	generateLens (SLfloat radiusBot, SLfloat radiusTop, SLMaterial *mat)
	Generate the lens with given front and back radius. More...
SLfloat	generateLensBot (SLfloat radius)
	Generate the bottom (front) part of the lens. More...
SLfloat	generateLensTop (SLfloat radius)
	Generate the top (back) part of the lens. More...
SLfloat	calcSagitta (SLfloat radius)
	Calculate the sagitta (s) for a given radius (r) and diameter (l+l) where l is half of the lens diameter See also: http://en.wikipedia.org/wiki/Sagitta_%28geometry%29. More...

Private Attributes
SLfloat	_diameter
	The diameter of the lens. More...
SLfloat	_thickness
	The space between the primary planes of lens sides. More...
SLfloat	_radiusBot
	The radius of the bot (front) side of the lens. More...
SLfloat	_radiusTop
	The radius of the top (back) side of the lens. More...
SLbool	_pointOutput
	debug helper 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...
Protected Attributes inherited from SLRevolver
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...

Detailed Description

SLLens creates a lens mesh based on SLRevolver.

SLLens creates a lens mesh based on SLRevolver. Different constructors allow to either create the lens from the values written in the eyeglass prescription card or from the radius of the lens.

Lens types:

Myopia ( http://en.wikipedia.org/wiki/Myopia )
The eye is too long for its optical power.
To correct myopic (short-sightedness) a diverging lens is needed.

Hypermetropia ( http://en.wikipedia.org/wiki/Hyperopia )
The eye is too short for its optical power.
To correct presbyopic (far-sightedness) a converging lens is needed.

Definition at line 31 of file SLLens.h.

Constructor & Destructor Documentation

SLLens() [1/2]

SLLens::SLLens	(	SLAssetManager *	assetMgr,
		double	sphere,
		double	cylinder,
		SLfloat	diameter,
		SLfloat	thickness,
		SLuint	stacks = 32,
		SLuint	slices = 32,
		SLstring	name = "lens mesh",
		SLMaterial *	mat = nullptr
	)

Create a lens with given sphere, cylinder, diameter and thickness.

SLLens::SLLens ctor for lens revolution object around the y-axis.
Create the lens with the eye prescription card.

The first values in the prescription card is called Sphere. It is also the diopter of the front side of the lens.
The second value from the prescription card is called Cylinder. The sum from the sphere and the cylinder is the diopter of the back side of the lens.
The diopter is the inverse of the focal distance (f) of the lens.
To correct myopic, negative diopters are used.
To correct presbyopic, positive diopters are used.

Parameters

assetMgr	Pointer to the asset manager
sphere	SLfloat taken from the eyeglass passport.
cylinder	SLfloat taken from the eyeglass passport.
diameter	SLfloat The diameter (h) of the lens
thickness	SLfloat The space between the primary planes of lens sides (d)
stacks	SLint
slices	SLint
name	SLstring of the SLRevolver Mesh
mat	SLMaterial* The Material of the lens

The diopter of the front side is equal to the sphere.
The diopter of the backside is the sum of the spehere and the cylinder.
From the diopter, the radius (R1, R2) can be calculated:
radiusFront = (LensMaterial - OutsideMaterial) / FrontDiopter) * diameter;
radiusBack = (OutsideMaterial - LensMaterial) / BackDiopter) * diameter;

Definition at line 45 of file SLLens.cpp.

                                    : SLRevolver(assetMgr, name)
{
    assert(slices >= 3 && "Error: Not enough slices.");
    assert(slices > 0 && "Error: Not enough stacks.");
 
    SLfloat diopterBot = (SLfloat)sphere;              // D1 = sphere
    SLfloat diopterTop = (SLfloat)(sphere + cylinder); // D2 = sphere + cylinder
 
    initLens(diopterBot, diopterTop, diameter, thickness, stacks, slices, mat);
}

SLLens() [2/2]

SLLens::SLLens	(	SLAssetManager *	assetMgr,
		SLfloat	radiusBot,
		SLfloat	radiusTop,
		SLfloat	diameter,
		SLfloat	thickness,
		SLuint	stacks = 32,
		SLuint	slices = 32,
		SLstring	name = "lens mesh",
		SLMaterial *	mat = nullptr
	)

Create a lens with given radius, diameter and thickness.

SLLens::SLLens ctor for lens revolution object around the y-axis.
Create the lens with radius.
To correct presbyopic (far-sightedness) a converging lens is needed. To correct myopic (short-sightedness) a diverging lens is needed.

Parameters

assetMgr	Pointer to the asset manager
radiusBot	The radius of the front side of the lens
radiusTop	The radius of the back side of the lens
diameter	The diameter (h) of the lens
thickness	The space between the primary planes of lens sides (d)
stacks	No. of stacks of the lens
slices	No. of slices in the lens
name	Name of the SLRevolver Mesh
mat	Pointer to the Material of the lens

Positive radius creates a convex lens side.
Negative radius creates a concave lens side.
Setting the radius to 0 creates a plane.
Combine the two radius to get the required lens.

Definition at line 86 of file SLLens.cpp.

                                    : SLRevolver(assetMgr, std::move(name))
{
    SLfloat nOut       = 1.00;      // kn material outside lens
    SLfloat nLens      = mat->kn(); // kn material of the lens
    SLfloat diopterBot = (SLfloat)((nLens - nOut) * diameter / radiusBot);
    SLfloat diopterTop = (SLfloat)((nOut - nLens) * diameter / radiusTop);
 
    initLens(diopterBot, diopterTop, diameter, thickness, stacks, slices, mat);
}

Member Function Documentation

calcSagitta()

SLfloat SLLens::calcSagitta ( SLfloat  radius )

private

Calculate the sagitta (s) for a given radius (r) and diameter (l+l) where l is half of the lens diameter See also: http://en.wikipedia.org/wiki/Sagitta_%28geometry%29.

Parameters

radius

r of the lens

Returns

sagitta s of the lens

Definition at line 374 of file SLLens.cpp.

{
    // take the amount of the radius
    SLfloat radiusAmount = (radius < 0) ? -radius : radius;
    SLfloat l            = _diameter * 0.5f;
 
    // sagitta = radius - sqrt( radius*radius - l*l )
    // calc this part to sort out negative numbers in square root
    SLfloat part = radiusAmount * radiusAmount - l * l;
 
    // set sagitta negative if no bulge is given -> plane
    SLfloat sagitta = (part >= 0) ? (radiusAmount - sqrt(part)) : -1;
    return sagitta;
}

generateLens()

void SLLens::generateLens ( SLfloat  radiusBot, SLfloat  radiusTop, SLMaterial *  mat  )

private

Generate the lens with given front and back radius.

Parameters

radiusBot	radius of the lens front side
radiusTop	radius of the lens back side
mat	the material pointer that is passed to SLRevolver

Definition at line 155 of file SLLens.cpp.

{
    _smoothFirst = true;
    _smoothLast  = true;
    _revAxis.set(0, 1, 0);
 
    if (_diameter > 0)
    {
        SLfloat x = generateLensTop(radiusTop);
        if (x < 0.0001f)
            buildMesh(mat);
        else
            cout << "error in lens calculation: (x = " << x << ")" << endl;
    }
    else
        cout << "invalid lens diameter: " << _diameter << endl;
}

generateLensBot()

SLfloat SLLens::generateLensBot ( SLfloat  radius )

private

Generate the bottom (front) part of the lens.

Parameters

radius

of the lens

Returns

x the x coordinate of the last point of the bulge

Definition at line 180 of file SLLens.cpp.

{
    // Point
    SLVec3f p;
    SLfloat y;
    SLfloat x = 0;
 
    SLfloat sagitta    = calcSagitta(radius);
    SLint   halfStacks = _stacks / 2;
 
    // check if lens has a deep
    if ((sagitta >= 0))
    {
        SLfloat alphaAsin       = _diameter / (2.0f * radius);
        alphaAsin               = Utils::clamp(alphaAsin, -1.0f, 1.0f);
        SLfloat alphaRAD        = 2.0f * (SLfloat)asin(alphaAsin);
        SLfloat dAlphaRAD       = (alphaRAD * 0.5f) / halfStacks;
        SLfloat yStart1         = -sagitta;
        SLfloat currentAlphaRAD = -Utils::HALFPI;
        SLfloat currentAlphaDEG = currentAlphaRAD * Utils::RAD2DEG;
        SLfloat radiusAmount1   = radius;
        SLfloat yTranslate1     = radius - sagitta;
 
        // settings for negative radius
        if (radius < 0)
        {
            yStart1         = 0;
            currentAlphaRAD = Utils::HALFPI;
            radiusAmount1   = -radius;
            yTranslate1     = radius;
        }
 
        y = yStart1;
        // set start point
        p.x = (SLfloat)x;
        p.y = (SLfloat)y;
        p.z = 0;
        _revPoints.push_back(p);
        if (_pointOutput) cout << currentAlphaDEG << "  x: " << x << "  y: " << y << endl;
 
        // draw bottom part of the lens
        for (int i = 0; i < halfStacks; i++)
        {
            // change angle
            currentAlphaRAD += dAlphaRAD;
            currentAlphaDEG = currentAlphaRAD * Utils::RAD2DEG;
 
            // calc x
            x = cos(currentAlphaRAD) * radiusAmount1;
 
            // calc y
            if ((i + 1 == halfStacks) && (radius >= 0))
                y = 0;
            else
                y = ((sin(currentAlphaRAD)) * radiusAmount1 + yTranslate1);
 
            if (_pointOutput) cout << currentAlphaDEG << "  x: " << x << "  y: " << y << endl;
 
            // set point
            p.x = x;
            p.y = y;
            p.z = 0;
            _revPoints.push_back(p);
        }
    }
    else
    {
        SLfloat cutX = (_diameter / 2) / halfStacks;
 
        // Draw plane
        for (int i = 0; i <= halfStacks - 1; i++)
        {
            x = cutX * i;
            y = 0;
 
            // set point
            p.x = x;
            p.y = y;
            p.z = 0;
            _revPoints.push_back(p);
            if (_pointOutput) cout << "0"
                                   << "  x: " << x << "  y: " << y << " _B" << endl;
        }
    }
    return x;
}

generateLensTop()

SLfloat SLLens::generateLensTop ( SLfloat  radius )

private

Generate the top (back) part of the lens.

Parameters

radius

of the lens

Returns

x the x coordinate of the last point of the bulge

Definition at line 272 of file SLLens.cpp.

{
    // Point
    SLVec3f p;
    SLfloat x = _diameter / 2;
    SLfloat y; // = yStart2;
 
    SLfloat sagitta    = calcSagitta(radius);
    SLint   halfStacks = _stacks / 2;
 
    // check if the lens has a deep
    if ((sagitta >= 0))
    {
        SLfloat yStart2       = _thickness;
        SLfloat radiusAmount2 = radius;
        SLfloat yTranslate2   = -radius + sagitta;
 
        SLfloat betaAsin       = _diameter / (2.0f * radius);
        betaAsin               = (betaAsin > 1) ? 1 : betaAsin;   // correct rounding errors
        betaAsin               = (betaAsin < -1) ? -1 : betaAsin; // correct rounding errors
        SLfloat betaRAD        = 2.0f * (SLfloat)asin(betaAsin);
        SLfloat currentBetaRAD = Utils::HALFPI - (betaRAD * 0.5f);
 
        // settings for negative radius
        if (radius < 0)
        {
            currentBetaRAD = -Utils::HALFPI - (betaRAD * 0.5f);
            yStart2        = sagitta + _thickness;
            radiusAmount2  = -radius;
            yTranslate2    = -radius;
        }
 
        SLfloat currentBetaDEG = currentBetaRAD * Utils::RAD2DEG;
        SLfloat dBetaRAD       = (betaRAD * 0.5f) / halfStacks;
 
        // set start point
        y   = yStart2;
        p.x = (SLfloat)x;
        p.y = (SLfloat)y;
        p.z = 0;
        _revPoints.push_back(p);
        if (_pointOutput) cout << currentBetaDEG << "  x: " << x << "  y: " << y << endl;
 
        // draw top part of the lens
        for (int i = 0; i < halfStacks; i++)
        {
            // change angle
            currentBetaRAD += dBetaRAD;
            currentBetaDEG = currentBetaRAD * Utils::RAD2DEG;
 
            // calc y
            y = (((sin(currentBetaRAD)) * (radiusAmount2)) + yTranslate2 + _thickness);
 
            // calc x
            if ((i + 1 == halfStacks))
            {
                x = 0;
                if (radius < 0)
                    y = _thickness;
            }
            else
                x = cos(currentBetaRAD) * radiusAmount2;
 
            if (_pointOutput) cout << currentBetaDEG << "  x: " << x << "  y: " << y << endl;
 
            // set point
            p.x = x;
            p.y = y;
            p.z = 0;
            _revPoints.push_back(p);
        }
    }
    else
    {
        SLfloat cutX = x / halfStacks;
 
        // Draw plane
        for (int i = halfStacks - 1; i >= 0; i--)
        {
            x = cutX * i;
            y = _thickness;
 
            // set point
            p.x = x;
            p.y = y;
            p.z = 0;
            _revPoints.push_back(p);
            if (_pointOutput) cout << "0"
                                   << "  x: " << x << "  y: " << y << " _T" << endl;
        }
    }
    return x;
}

initLens()

void SLLens::initLens ( SLfloat  diopterBot, SLfloat  diopterTop, SLfloat  diameter, SLfloat  thickness, SLuint  stacks, SLuint  slices, SLMaterial *  mat  )

private

Initialize the lens.

Parameters

diopterBot	SLfloat The diopter of the bot (front) part of the lens
diopterTop	SLfloat The diopter of the top (back) part of the lens
diameter	SLfloat The diameter of the lens
thickness	SLfloat d The space between the primary planes of lens sides
stacks	SLint
slices	SLint
mat	SLMaterial* The Material of the lens

Definition at line 114 of file SLLens.cpp.

{
    assert(slices >= 3 && "Error: Not enough slices.");
    assert(slices > 0 && "Error: Not enough stacks.");
 
    _diameter    = diameter;
    _thickness   = thickness;
    _stacks      = stacks;
    _slices      = slices;
    _pointOutput = false; // cout the coordinates of each point of the lens
 
    // Gullstrand-Formel
    // D = D1 + D2 - delta * D1 * D2
 
    // calc radius
    SLfloat nOut  = 1.00;      // kn material outside lens
    SLfloat nLens = mat->kn(); // kn material of the lens
 
    // calc radius
    _radiusBot = (SLfloat)((nLens - nOut) / diopterBot) * _diameter;
    _radiusTop = (SLfloat)((nOut - nLens) / diopterTop) * _diameter;
 
    if (_pointOutput)
        cout << " radiusBot: " << _radiusBot << " radiusTop: " << _radiusTop << endl;
 
    // generate lens
    generateLens(_radiusBot, _radiusTop, mat);
}

Member Data Documentation

_diameter

SLfloat SLLens::_diameter

private

The diameter of the lens.

Definition at line 71 of file SLLens.h.

_pointOutput

SLbool SLLens::_pointOutput

private

debug helper

Definition at line 75 of file SLLens.h.

_radiusBot

SLfloat SLLens::_radiusBot

private

The radius of the bot (front) side of the lens.

Definition at line 73 of file SLLens.h.

_radiusTop

SLfloat SLLens::_radiusTop

private

The radius of the top (back) side of the lens.

Definition at line 74 of file SLLens.h.

_thickness

SLfloat SLLens::_thickness

private

The space between the primary planes of lens sides.

Definition at line 72 of file SLLens.h.

---

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

• SLLens.h
• SLLens.cpp