void Sphere::generate() {
S32 segments2 = segments / 2;
S32 slices2 = slices / 2;
Vertex *points = new Vertex[segments * slices * 2];
U32 point = 0;
for (S32 y = -slices2; y < slices2; y ++) {
float cosy = cos(y * step);
float cosy1 = cos((y + 1) * step);
float siny = sin(y * step);
float siny1 = sin((y + 1) * step);
for (S32 i = -segments2; i < segments2; i ++) {
float cosi = cos(i * step);
float sini = sin(i * step);
//Math not invented by me
Point3F point0 = Point3F(radius * cosi * cosy, radius * siny, radius * sini * cosy);
Point3F point1 = Point3F(radius * cosi * cosy1, radius * siny1, radius * sini * cosy1);
Point4F color0 = Point4F(fabs(point0.x), fabs(point0.y), fabs(point0.z), radius).normalize();
Point4F color1 = Point4F(fabs(point1.x), fabs(point1.y), fabs(point1.z), radius).normalize();
color0 /= color0.z;
color1 /= color1.z;
Point2F uv0 = Point2F((F32)i / (F32)segments2, (F32)y / (F32)slices2);
Point2F uv1 = Point2F((F32)i / (F32)segments2, (F32)(y + 1) / (F32)slices2);
Point3F tangent0 = point0.cross(Point3F(0, 0, 1)).normalize();
Point3F tangent1 = point1.cross(Point3F(0, 0, 1)).normalize();
Point3F bitangent0 = point0.cross(tangent0).normalize();
Point3F bitangent1 = point0.cross(tangent0).normalize();
points[point].point = point0;
points[point].uv = uv0;
points[point].normal = point0;
points[point].tangent = tangent0;
points[point].bitangent = bitangent0;
point ++;
points[point].point = point1;
points[point].uv = uv1;
points[point].normal = point1;
points[point].tangent = tangent1;
points[point].bitangent = bitangent1;
point ++;
}
}
//Generate a buffer
glGenBuffers(1, &renderBuffer);
glBindBuffer(GL_ARRAY_BUFFER, renderBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex) * point, points, GL_STATIC_DRAW);
delete [] points;
}
void convertRotation(const F32 inRotMat[3][3], MatrixF& outRotation)
{
// Set rotation. We need to convert from sixense coordinates to
// Torque coordinates. The conversion is:
//
// Sixense Torque
// a b c a b c a -c b
// d e f --> -g -h -i --> -g i -h
// g h i d e f d -f e
outRotation.setColumn(0, Point4F( inRotMat[0][0], -inRotMat[0][2], inRotMat[0][1], 0.0f));
outRotation.setColumn(1, Point4F(-inRotMat[2][0], inRotMat[2][2], -inRotMat[2][1], 0.0f));
outRotation.setColumn(2, Point4F( inRotMat[1][0], -inRotMat[1][2], inRotMat[1][1], 0.0f));
outRotation.setPosition(Point3F::Zero);
}
Point4F Matrix43::TransformPoint( const Point4F& point ) const
{
return Point4F(M11 * point.X + M21 * point.Y + M31 * point.Z+M41*point.W,
M12 * point.X + M22 * point.Y + M32 * point.Z+M42*point.W,
M13 * point.X + M23 * point.Y + M33 * point.Z+M43*point.W,
point.W
);
}
void convertPointableRotation(const Leap::Pointable& pointable, MatrixF& outRotation)
{
// We need to convert from Motion coordinates to
// Torque coordinates. The conversion is:
//
// Motion Torque
// a b c a b c a -c b
// d e f --> -g -h -i --> -g i -h
// g h i d e f d -f e
Leap::Vector pointableFront = -pointable.direction();
Leap::Vector pointableRight = Leap::Vector::up().cross(pointableFront);
Leap::Vector pointableUp = pointableFront.cross(pointableRight);
outRotation.setColumn(0, Point4F( pointableRight.x, -pointableRight.z, pointableRight.y, 0.0f));
outRotation.setColumn(1, Point4F( -pointableFront.x, pointableFront.z, -pointableFront.y, 0.0f));
outRotation.setColumn(2, Point4F( pointableUp.x, -pointableUp.z, pointableUp.y, 0.0f));
outRotation.setPosition(Point3F::Zero);
}
void convertHandRotation(const Leap::Hand& hand, MatrixF& outRotation)
{
// We need to convert from Motion coordinates to
// Torque coordinates. The conversion is:
//
// Motion Torque
// a b c a b c a -c b
// d e f --> -g -h -i --> -g i -h
// g h i d e f d -f e
const Leap::Vector& handToFingers = hand.direction();
Leap::Vector handFront = -handToFingers;
const Leap::Vector& handDown = hand.palmNormal();
Leap::Vector handUp = -handDown;
Leap::Vector handRight = handUp.cross(handFront);
outRotation.setColumn(0, Point4F( handRight.x, -handRight.z, handRight.y, 0.0f));
outRotation.setColumn(1, Point4F( -handFront.x, handFront.z, -handFront.y, 0.0f));
outRotation.setColumn(2, Point4F( handUp.x, -handUp.z, handUp.y, 0.0f));
outRotation.setPosition(Point3F::Zero);
}
void PathCamera::calculateLookDirMat(Point3F dir)
{
mLookDirMat.identity();
if(dir == Point3F(0.f, 0.f, 0.f))
{
mUseLookDirMatrix = false;
return;
}
Point3F left = mCross(dir, Point3F(0.f, 0.f, 1.f));
left.normalize();
Point3F up = mCross(left, dir);
up.normalize();
mLookDirMat.setColumn(0, Point4F(left.x, left.y, left.z, 0.f));
mLookDirMat.setColumn(1, Point4F(dir.x, dir.y, dir.z, 0.f));
mLookDirMat.setColumn(2, Point4F(up.x, up.y, up.z, 0.f));
mUseLookDirMatrix = true;
}
void AdvancedLightBinManager::LightMaterialInfo::setViewParameters( const F32 _zNear,
const F32 _zFar,
const Point3F &_eyePos,
const PlaneF &_farPlane,
const PlaneF &_vsFarPlane)
{
MaterialParameters *matParams = matInstance->getMaterialParameters();
matParams->setSafe( farPlane, *((const Point4F *)&_farPlane) );
matParams->setSafe( vsFarPlane, *((const Point4F *)&_vsFarPlane) );
if ( negFarPlaneDotEye->isValid() )
{
// -dot( farPlane, eyePos )
const F32 negFarPlaneDotEyeVal = -( mDot( *((const Point3F *)&_farPlane), _eyePos ) + _farPlane.d );
matParams->set( negFarPlaneDotEye, negFarPlaneDotEyeVal );
}
matParams->setSafe( zNearFarInvNearFar, Point4F( _zNear, _zFar, 1.0f / _zNear, 1.0f / _zFar ) );
}
void LightManager::_update4LightConsts( const SceneData &sgData,
GFXShaderConstHandle *lightPositionSC,
GFXShaderConstHandle *lightDiffuseSC,
GFXShaderConstHandle *lightAmbientSC,
GFXShaderConstHandle *lightInvRadiusSqSC,
GFXShaderConstHandle *lightSpotDirSC,
GFXShaderConstHandle *lightSpotAngleSC,
GFXShaderConstHandle *lightSpotFalloffSC,
GFXShaderConstBuffer *shaderConsts )
{
PROFILE_SCOPE( LightManager_Update4LightConsts );
// Skip over gathering lights if we don't have to!
if ( lightPositionSC->isValid() ||
lightDiffuseSC->isValid() ||
lightInvRadiusSqSC->isValid() ||
lightSpotDirSC->isValid() ||
lightSpotAngleSC->isValid() ||
lightSpotFalloffSC->isValid() )
{
PROFILE_SCOPE( LightManager_Update4LightConsts_setLights );
static AlignedArray<Point4F> lightPositions( 3, sizeof( Point4F ) );
static AlignedArray<Point4F> lightSpotDirs( 3, sizeof( Point4F ) );
static AlignedArray<Point4F> lightColors( 4, sizeof( Point4F ) );
static Point4F lightInvRadiusSq;
static Point4F lightSpotAngle;
static Point4F lightSpotFalloff;
F32 range;
// Need to clear the buffers so that we don't leak
// lights from previous passes or have NaNs.
dMemset( lightPositions.getBuffer(), 0, lightPositions.getBufferSize() );
dMemset( lightSpotDirs.getBuffer(), 0, lightSpotDirs.getBufferSize() );
dMemset( lightColors.getBuffer(), 0, lightColors.getBufferSize() );
lightInvRadiusSq = Point4F::Zero;
lightSpotAngle.set( -1.0f, -1.0f, -1.0f, -1.0f );
lightSpotFalloff.set( F32_MAX, F32_MAX, F32_MAX, F32_MAX );
// Gather the data for the first 4 lights.
const LightInfo *light;
for ( U32 i=0; i < 4; i++ )
{
light = sgData.lights[i];
if ( !light )
break;
// The light positions and spot directions are
// in SoA order to make optimal use of the GPU.
const Point3F &lightPos = light->getPosition();
lightPositions[0][i] = lightPos.x;
lightPositions[1][i] = lightPos.y;
lightPositions[2][i] = lightPos.z;
const VectorF &lightDir = light->getDirection();
lightSpotDirs[0][i] = lightDir.x;
lightSpotDirs[1][i] = lightDir.y;
lightSpotDirs[2][i] = lightDir.z;
if ( light->getType() == LightInfo::Spot )
{
lightSpotAngle[i] = mCos( mDegToRad( light->getOuterConeAngle() / 2.0f ) );
lightSpotFalloff[i] = 1.0f / getMax( F32_MIN, mCos( mDegToRad( light->getInnerConeAngle() / 2.0f ) ) - lightSpotAngle[i] );
}
// Prescale the light color by the brightness to
// avoid doing this in the shader.
lightColors[i] = Point4F(light->getColor()) * light->getBrightness();
// We need 1 over range^2 here.
range = light->getRange().x;
lightInvRadiusSq[i] = 1.0f / ( range * range );
}
shaderConsts->setSafe( lightPositionSC, lightPositions );
shaderConsts->setSafe( lightDiffuseSC, lightColors );
shaderConsts->setSafe( lightInvRadiusSqSC, lightInvRadiusSq );
shaderConsts->setSafe( lightSpotDirSC, lightSpotDirs );
shaderConsts->setSafe( lightSpotAngleSC, lightSpotAngle );
shaderConsts->setSafe( lightSpotFalloffSC, lightSpotFalloff );
}
// Setup the ambient lighting from the first
// light which is the directional light if
// one exists at all in the scene.
if ( lightAmbientSC->isValid() )
shaderConsts->set( lightAmbientSC, sgData.ambientLightColor );
}
void DecalManager::_generateWindingOrder( const Point3F &cornerPoint, Vector<Point3F> *sortPoints )
{
// This block of code is used to find
// the winding order for the points in our quad.
// First, choose an arbitrary corner point.
// We'll use the "lowerRight" point.
Point3F relPoint( 0, 0, 0 );
// See comment below about radius.
//F32 radius = 0;
F32 theta = 0;
Vector<Point4F> tmpPoints;
for ( U32 i = 0; i < (*sortPoints).size(); i++ )
{
const Point3F &pnt = (*sortPoints)[i];
relPoint = cornerPoint - pnt;
// Get the radius (r^2 = x^2 + y^2).
// This is commented because for a quad
// you typically can't have the same values
// for theta, which is the caveat which would
// require sorting by the radius.
//radius = mSqrt( (relPoint.x * relPoint.x) + (relPoint.y * relPoint.y) );
// Get the theta value for the
// interval -PI, PI.
// This algorithm for determining the
// theta value is defined by
// | arctan( y / x ) if x > 0
// | arctan( y / x ) if x < 0 and y >= 0
// theta = | arctan( y / x ) if x < 0 and y < 0
// | PI / 2 if x = 0 and y > 0
// | -( PI / 2 ) if x = 0 and y < 0
if ( relPoint.x > 0.0f )
theta = mAtan2( relPoint.y, relPoint.x );
else if ( relPoint.x < 0.0f )
{
if ( relPoint.y >= 0.0f )
theta = mAtan2( relPoint.y, relPoint.x ) + M_PI_F;
else if ( relPoint.y < 0.0f )
theta = mAtan2( relPoint.y, relPoint.x ) - M_PI_F;
}
else if ( relPoint.x == 0.0f )
{
if ( relPoint.y > 0.0f )
theta = M_PI_F / 2.0f;
else if ( relPoint.y < 0.0f )
theta = -(M_PI_F / 2.0f);
}
tmpPoints.push_back( Point4F( pnt.x, pnt.y, pnt.z, theta ) );
}
dQsort( tmpPoints.address(), tmpPoints.size(), sizeof( Point4F ), cmpQuadPointTheta );
for ( U32 i = 0; i < tmpPoints.size(); i++ )
{
const Point4F &tmpPoint = tmpPoints[i];
(*sortPoints)[i].set( tmpPoint.x, tmpPoint.y, tmpPoint.z );
}
}
Point4F Matrix43::Column( byte column )
{
return Point4F(M[column],M[RowSize+column],M[2*RowSize+column],M[3*RowSize+column]);
}
