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]); }