void publishCamera() { const auto cameraSettings = _config.getFrameData().getCameraSettings(); const Matrix4f& modelView = cameraSettings->getModelViewMatrix(); const FloatVector matrix( modelView.begin(), modelView.end( )); _vwsPublisher->publish( ::zeq::hbp::serializeCamera( matrix )); }
void Camera::headMovement(int usernum, double x, double y, double z) { //mm to meters and cast to float calculateTranslationVector(); getModelViewMatrix(); vec4 originCentric = modelViewMatrix * vec4(x/250.0,y/250.0,z/250.0,1.0); if (originCentric.z != 0) { float ysin = originCentric.x/originCentric.z; float xcos = originCentric.y/originCentric.z; if (ysin > 1) ysin = 1; else if (ysin < -1) ysin = -1; if (xcos > 1) xcos = 1; else if (xcos < -1) xcos = -1; yHeadAngle = -atan(ysin); xHeadAngle = -atan(xcos); } moveCamera(xHead-(float)(x/250.0), yHead -(float)(y/250.0), zHead +(float)(z/250.0)); xHead = (float)(x/250.0); yHead = (float)(y/250.0); zHead = -(float)(z/250.0); // printf("%d - (%6.2f, %6.2f, %6.2f) ==> (%6.2f,%6.2f,%6.2f), yaw=%f, pitch=%f\n", usernum,x,y,z,xHead, yHead, zHead, xHeadAngle, yHeadAngle); }
Vec2f Camera::worldToScreen( const Vec3f &worldCoord, float screenWidth, float screenHeight ) const { Vec3f eyeCoord = getModelViewMatrix().transformPointAffine( worldCoord ); Vec3f ndc = getProjectionMatrix().transformPoint( eyeCoord ); return Vec2f( ( ndc.x + 1.0f ) / 2.0f * screenWidth, ( 1.0f - ( ndc.y + 1.0f ) / 2.0f ) * screenHeight ); }
const bool CCCameraBase::GluProject(CCRenderable *object, CCVector3 &result) { return gluProject( object->positionPtr->x, object->positionPtr->y, object->positionPtr->z, getModelViewMatrix().data(), projectionMatrix.data(), viewport, &result.x, &result.y, &result.z ); }
Vector3 GameObject::getWorldPosition() { if (parent == nullptr) { return position; } Vector4 pos = getModelViewMatrix(false) * Vector4(0, 0, 0, 1); return Vector3(pos.x, pos.y, pos.z); }
void SpawnParticles(Mat4f CameraTransforms) { Mat4f ModelTransforms = CameraTransforms.inverse() * getModelViewMatrix(); Vec4<float> WorldPoint = ModelTransforms * Vec4f(0, 0, 0, 1); AddParticleStartingAt(WorldPoint); return; }
Mat3 GraphicsDevice::getCameraOrientation() { const Mat4 modl = getModelViewMatrix(); Mat3 orientation; memcpy(orientation._m[0], modl._m[0], sizeof(real_t)*3); memcpy(orientation._m[1], modl._m[1], sizeof(real_t)*3); memcpy(orientation._m[2], modl._m[2], sizeof(real_t)*3); return orientation; }
//---------------------------------------- void ofCamera::begin(ofRectangle viewport) { if(!isActive) ofPushView(); isActive = true; ofViewport(viewport.x,viewport.y,viewport.width,viewport.height); ofSetOrientation(ofGetOrientation(),vFlip); ofSetMatrixMode(OF_MATRIX_PROJECTION); ofLoadMatrix( getProjectionMatrix(viewport) ); ofSetMatrixMode(OF_MATRIX_MODELVIEW); ofLoadViewMatrix( getModelViewMatrix() ); }
// We are going to override (is that the right word?) the draw() // method of ModelerView to draw out RobotArm void RobotArm::draw() { /* pick up the slider values */ float theta = VAL( BASE_ROTATION ); float phi = VAL( LOWER_TILT ); float psi = VAL( UPPER_TILT ); float cr = VAL( CLAW_ROTATION ); float h1 = VAL( BASE_LENGTH ); float h2 = VAL( LOWER_LENGTH ); float h3 = VAL( UPPER_LENGTH ); float pc = VAL( PARTICLE_COUNT ); // This call takes care of a lot of the nasty projection // matrix stuff ModelerView::draw(); static GLfloat lmodel_ambient[] = { 0.4, 0.4, 0.4, 1.0 }; Mat4f temp = getModelViewMatrix(); // define the model ground(-0.2); if (true) { Ariou(); } else { base(0.8); glTranslatef( 0.0, 0.8, 0.0 ); // move to the top of the base glRotatef( theta, 0.0, 1.0, 0.0 ); // turn the whole assembly around the y-axis. rotation_base(h1); // draw the rotation base glTranslatef( 0.0, h1, 0.0 ); // move to the top of the base glRotatef( phi, 0.0, 0.0, 1.0 ); // rotate around the z-axis for the lower arm glTranslatef( -0.1, 0.0, 0.4 ); lower_arm(h2); // draw the lower arm glTranslatef( 0.0, h2, 0.0 ); // move to the top of the lower arm glRotatef( psi, 0.0, 0.0, 1.0 ); // rotate around z-axis for the upper arm upper_arm(h3); // draw the upper arm glTranslatef( 0.0, h3, 0.0 ); glRotatef(cr, 0.0, 0.0, 1.0); claw(1.0); SpawnParticles(temp); } //*** DON'T FORGET TO PUT THIS IN YOUR OWN CODE **/ endDraw(); }
uint32_t rSimpleMesh::getMatrix( rMat4f **_mat, rObjectBase::MATRIX_TYPES _type ) { switch ( _type ) { case SCALE: *_mat = getScaleMatrix(); return 0; case ROTATION: *_mat = getRotationMatrix(); return 0; case TRANSLATION: *_mat = getTranslationMatrix(); return 0; case CAMERA_MATRIX: *_mat = getViewProjectionMatrix(); return 0; case MODEL_MATRIX: *_mat = getModelMatrix(); return 0; case VIEW_MATRIX: *_mat = getViewMatrix(); return 0; case PROJECTION_MATRIX: *_mat = getProjectionMatrix(); return 0; case MODEL_VIEW_MATRIX: *_mat = getModelViewMatrix(); return 0; case MODEL_VIEW_PROJECTION: *_mat = getModelViewProjectionMatrix(); return 0; case NORMAL_MATRIX: break; } return INDEX_OUT_OF_RANGE; }
void GameObject::draw() { if (scene == nullptr) { abortWithMessage("In GameObject::draw(): Scene for GameObject was never set"); } mat4 mv = getModelViewMatrix(); scene->middleman->updateModelViewMatrix(mv); glBindVertexArray(vao); glDrawArrays(GL_TRIANGLES, 0, getNumberOfVertices()); std::vector<GameObject*>::iterator it = children.begin(); while (it != children.end()) { (*it)->draw(); it++; } }
void GLMatrices::submitMatrices(ShaderProgram &program) { if(!matricesReady) { modelViewMatrix = getModelViewMatrix(); Core::Mat44 n = modelViewMatrix.inverse().transpose(); normalMatrix[0] = {n[0].x, n[0].y, n[0].z}; normalMatrix[1] = {n[1].x, n[1].y, n[1].z}; normalMatrix[2] = {n[2].x, n[2].y, n[2].z}; // normalMatrix = normalMatrix; matricesReady = true; //base program.setUniform("modelMatrix", getModelMatrix()); program.setUniform("viewMatrix", getViewMatrix()); program.setUniform("projectionMatrix", getProjectionMatrix()); // program.setUniform("normalMatrix", normalMatrix); } }
void RenderPreview::drawPreview() { if (_renderingInProgress) return; // avoid double-entering this method util::ScopedBoolLock lock(_renderingInProgress); glViewport(0, 0, _previewWidth, _previewHeight); // Set up the render and clear the drawing area in any case glDepthMask(GL_TRUE); glClearColor(0.3f, 0.3f, 0.3f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Set up the camera Matrix4 projection = getProjectionMatrix(0.1f, 10000, PREVIEW_FOV, _previewWidth, _previewHeight); // Keep the modelview matrix in the volumetest class up to date _volumeTest.setModelView(getModelViewMatrix()); _volumeTest.setProjection(projection); // Pre-Render event if (!onPreRender()) { // a return value of false means to cancel rendering drawTime(); return; } // Front-end render phase, collect OpenGLRenderable objects from the scene getScene()->foreachVisibleNodeInVolume(_volumeTest, _sceneWalker); RenderStateFlags flags = getRenderFlagsFill(); // Launch the back end rendering _renderSystem->render(flags, _volumeTest.GetModelview(), projection); // Give subclasses an opportunity to render their own on-screen stuff onPostRender(); // Draw the render time drawTime(); }
// The SpawnParticles function is responsible for generating new // particles in your world. You will call this function as you // you traverse your model's hierarchy. When you reach a point // in the hierarchy from where particles should be emitted, // call this function! // // SpawnParticles takes the camera transformation matrix as a // parameter. More on this later. void SampleModel::spawnParticles(Mat4<float> cameraTransform) { /**************************************************************** ** ** THIS FUNCTION WILL ADD A NEW PARTICLE TO OUR WORLD ** ** Suppose we want particles to spawn from a the model's arm. ** We need to find the location of the model's arm in world ** coordinates so that we can set the initial position of new ** particles. As discussed on the Animator project page, ** all particle positions should be in world coordinates. ** ** At this point in execution, the MODELVIEW matrix contains the ** camera transforms multiplied by some model transforms. In other words, ** ** MODELVIEW = CameraTransforms * ModelTransforms ** ** We are interested only in ModelTransforms, which is the ** transformation that will convert a point from the current, local ** coordinate system to the world coordinate system. ** ** To do this, we're going to "undo" the camera transforms from the ** current MODELVIEW matrix. The camera transform is passed in as ** a parameter to this function (remember when we saved it ** near the top of the model's draw method?). We can "undo" the ** camera transforms by pre-multiplying the current MODELVIEW matrix ** with the inverse of the camera matrix. In other words, ** ** ModelTransforms = InverseCameraTransforms * MODELVIEW ** ********************************************************************/ ParticleSystem *ps = ModelerApplication::Instance()->GetParticleSystem(); //Get the current MODELVIEW matrix. // ... "Undo" the camera transforms from the MODELVIEW matrix // ... by multiplying Inverse(CameraTransforms) * CurrentModelViewMatrix. // ... Store the result of this in a local variable called WorldMatrix. // ... Mat4f ModelMatrix = getModelViewMatrix(); Mat4f WorldMatrix = cameraTransform.inverse() * ModelMatrix; /***************************************************************** ** ** At this point, we have the transformation that will convert a point ** in the local coordinate system to a point in the world coordinate ** system. ** ** We need to find the actual point in world coordinates ** where particle should be spawned. This is simply ** "the origin of the local coordinate system" transformed by ** the WorldMatrix. ** ******************************************************************/ Vec4f Loc = WorldMatrix * Vec4f(0.0, 0.0, 0.0, 1.0); Vec4f VelL = WorldMatrix * Vec4f(0.0, 0.0, -0.5, 1.0); Vec4f Vel = VelL - Loc; Vec3f velocity(Vel[0], Vel[1], Vel[2]); velocity.normalize(); /***************************************************************** ** ** Now that we have the particle's initial position, we ** can finally add it to our system! ** ***************************************************************/ ps->setParticleStart(Vec3f(Loc[0], Loc[1], Loc[2]), velocity); }
void Ariou() { Mat4f temp = getModelViewMatrix(); ModelerApplication::Instance()->Swing(LEFT_UPPER_ARM_ROTATE_X, 3.1); //ModelerApplication::Instance()->Swing(LEFT_UPPER_ARM_ROTATE_Y, 2.5); ModelerApplication::Instance()->Swing(HEAD_ROTATE, 1); ModelerApplication::Instance()->Swing(RIGHT_UPPER_ARM_ROTATE_X, 1.1); ModelerApplication::Instance()->Swing(RIGHT_UPPER_ARM_ROTATE_Y, 4.5); ModelerApplication::Instance()->Swing(LEFT_LEG_ROTATE_X, 6.1); ModelerApplication::Instance()->Swing(RIGHT_LEG_ROTATE_X, 6.1); glPushMatrix(); glTranslated(VAL(XPOS), VAL(YPOS), VAL(ZPOS)); glScaled(VAL(XSCALE), VAL(YSCALE), VAL(ZSCALE)); glRotated(VAL(ROTATE), 0, 1, 0); setDiffuseColor(COLOR_YELLOW); // Torus if (VAL(DETAIL_LEVEL) > 1) { glPushMatrix(); glTranslated(.0f, 6, .0f); drawTorus(VAL(TORUS_R), VAL(TORUS_r)); glPopMatrix(); } //head glPushMatrix(); glTranslated(0, VAL(LEG_LENGTH) + 0.05 + VAL(HEIGHT) + 0.05 + VAL(HEAD_SIZE), 0); glRotated(VAL(HEAD_ROTATE), 0.0, 1.0, 0.0); drawSphere(VAL(HEAD_SIZE)); if (VAL(DETAIL_LEVEL) > 2) { // Nose drawRoundCylinder(VAL(HEAD_SIZE) * 1.1, 0.2, 0.2); // Ear glPushMatrix(); glTranslated(0.9 / sqrt(0.9*0.9 + 1.1*1.1) * VAL(HEAD_SIZE), 1.1 / sqrt(0.9*0.9 + 1.1*1.1) * VAL(HEAD_SIZE), 0); glRotated(-20, 0, 0, 1); SpawnParticles(temp); drawPyramid(VAL(EAR_SIZE)); glPopMatrix(); glPushMatrix(); glTranslated(-0.9 / sqrt(0.9*0.9 + 1.1*1.1) * VAL(HEAD_SIZE), 1.1 / sqrt(0.9*0.9 + 1.1*1.1) * VAL(HEAD_SIZE), 0); glRotated(20, 0, 0, 1); SpawnParticles(temp); drawPyramid(VAL(EAR_SIZE)); glPopMatrix(); // Eyes glPushMatrix(); setDiffuseColor(COLOR_RED); glTranslated(-0.5 / sqrt(0.5*0.5 * 2) * VAL(HEAD_SIZE) * 0.5, 0.5 / sqrt(0.5*0.5 * 2) * VAL(HEAD_SIZE) * 0.5, VAL(HEAD_SIZE) - 0.9); drawRoundCylinder( 0.9, 0.2, 0.2); glPopMatrix(); glPushMatrix(); setDiffuseColor(COLOR_RED); glTranslated( 0.5 / sqrt(0.5*0.5 * 2) * VAL(HEAD_SIZE) * 0.5, 0.5 / sqrt(0.5*0.5 * 2) * VAL(HEAD_SIZE) * 0.5, VAL(HEAD_SIZE) - 0.9); drawRoundCylinder( 0.9, 0.2, 0.2); glPopMatrix(); } glPopMatrix(); if (VAL(DETAIL_LEVEL) > 1) { //body // a.k.a. torso/trunk glPushMatrix(); setDiffuseColor(COLOR_YELLOW); glTranslated(0, 0.05 + VAL(LEG_LENGTH), 0); glRotated(-90, 1.0, 0.0, 0.0); drawRoundCylinder(VAL(HEIGHT), 0.7, 0.6); glPushMatrix(); glTranslated(-0.8, 0, VAL(HEIGHT) - 0.4); glRotated(90, 0, 1, 0); // the shoulder if (VAL(DETAIL_LEVEL) > 2) { drawRoundCylinder(1.6, 0.2, 0.2); } glPopMatrix(); // the waist if (VAL(DETAIL_LEVEL) > 3) { glPushMatrix(); glTranslated(0, 0, 0.5); glRotated(90, 1, 0, 0); drawTorus(0.7, 0.08); glPopMatrix(); } glPopMatrix(); if (VAL(DETAIL_LEVEL) > 2) { //right arm glPushMatrix(); glTranslated(-0.7 - 0.20, VAL(LEG_LENGTH) + 0.05 + VAL(HEIGHT) * 0.9f, 0); glTranslated(0.15, 0, 0); glRotated(VAL(RIGHT_UPPER_ARM_ROTATE_X), 1.0, 0.0, 0.0); glRotated(VAL(RIGHT_UPPER_ARM_ROTATE_Y), 0.0, 1.0, 0.0); glTranslated(-0.15, 0, 0); drawRoundCylinder(VAL(UPPER_ARM_LENGTH), 0.22, 0.15); // lower arm glTranslated(0, 0, VAL(UPPER_ARM_LENGTH) - 0.1); glRotated(VAL(RIGHT_LOWER_ARM_ROTATE) - 180, 1, 0, 0); drawRoundCylinder(VAL(LOWER_ARM_LENGTH), 0.15, 0.20); // hand glPushMatrix(); glTranslated(-0.03, -0.15, VAL(LOWER_ARM_LENGTH) - 0.1); glRotated(VAL(RIGHT_HAND_ANGLE), 0, 1, 0); drawCylinder(0.8, 0.15, 0.0001); glPopMatrix(); glPushMatrix(); glTranslated(0.03, -0.15, VAL(LOWER_ARM_LENGTH) - 0.1); glRotated(-VAL(RIGHT_HAND_ANGLE), 0, 1, 0); drawCylinder(0.8, 0.15, 0.0001); glPopMatrix(); glPopMatrix(); //left arm glPushMatrix(); glTranslated(0.7 + 0.20, VAL(LEG_LENGTH) + 0.05 + VAL(HEIGHT) * 0.9f, 0); glTranslated(-0.15, 0, 0); glRotated(VAL(LEFT_UPPER_ARM_ROTATE_X), 1.0, 0.0, 0.0); glRotated(VAL(LEFT_UPPER_ARM_ROTATE_Y), 0.0, 1.0, 0.0); glTranslated(0.15, 0, 0); drawRoundCylinder(VAL(UPPER_ARM_LENGTH), 0.22, 0.15); glTranslated(0, 0, VAL(UPPER_ARM_LENGTH) - 0.1); glRotated(VAL(LEFT_LOWER_ARM_ROTATE) - 180, 1, 0, 0); drawRoundCylinder(VAL(LOWER_ARM_LENGTH), 0.15, 0.20); // hand glPushMatrix(); glTranslated(-0.03, 0, VAL(LOWER_ARM_LENGTH) - 0.1); glRotated(VAL(LEFT_HAND_ANGLE), 0, 1, 0); drawBox(0.03, 0.25, 0.5); glPopMatrix(); glPushMatrix(); glTranslated(0.03, 0, VAL(LOWER_ARM_LENGTH) - 0.1); glRotated(-VAL(LEFT_HAND_ANGLE), 0, 1, 0); drawBox(0.03, 0.25, 0.5); if (VAL(DETAIL_LEVEL) > 3) { glRotated(90, 0, 0, 1); drawCylinder(5, 0.02, 0.02); if (VAL(DETAIL_LEVEL) > 4) { glTranslated(0, 0, 4); glPushMatrix(); setDiffuseColor(COLOR_GREEN); glTranslated(0, -0.5, 1); //SpawnParticles(temp); glPushMatrix(); glRotated(90, 1.0, 0.0, 0.0); glPopMatrix(); glPopMatrix(); } } glPopMatrix(); glPopMatrix(); } //right leg glPushMatrix(); setDiffuseColor(COLOR_YELLOW); glTranslated(-0.5, VAL(LEG_LENGTH), 0); glRotated(VAL(RIGHT_LEG_ROTATE_X), 1.0, 0.0, 0.0); glRotated(VAL(RIGHT_LEG_ROTATE_Y), 0.0, 1.0, 0.0); drawRoundCylinder(VAL(LEG_LENGTH) - 0.15, 0.3, 0.4); glTranslated(0, 0, VAL(LEG_LENGTH) * 0.85f); glRotated(70, 1, 0, 0); drawTorus(VAL(FEET_SIZE), VAL(FEET_SIZE) / 4); glPopMatrix(); //left leg glPushMatrix(); glTranslated(0.5, VAL(LEG_LENGTH), 0); glRotated(VAL(LEFT_LEG_ROTATE_X), 1.0, 0.0, 0.0); glRotated(VAL(LEFT_LEG_ROTATE_Y), 0.0, 1.0, 0.0); drawRoundCylinder(VAL(LEG_LENGTH) - 0.15, 0.3, 0.4); glTranslated(0, 0, VAL(LEG_LENGTH) * 0.85f); glRotated(70, 1, 0, 0); drawTorus(VAL(FEET_SIZE), VAL(FEET_SIZE) / 4); glPopMatrix(); } glPopMatrix(); }
//---------------------------------------- ofMatrix4x4 ofCamera::getModelViewProjectionMatrix(ofRectangle viewport) const { return getModelViewMatrix() * getProjectionMatrix(viewport); }
Vector Camera::unproject(const Vector& point) const { Vector result = MathHelper::Unproject(point, getModelViewMatrix(), getProjectionMatrix(), Viewport(0, 0, getWidth(), getHeight())); return result; }
void CCCameraBase::ExtractFrustum() { float *proj = projectionMatrix.data(); float *modv = getModelViewMatrix().data(); float clip[16]; float t; /* Get the current MODELVIEW matrix from OpenGL */ //glGetFloatv( GL_MODELVIEW_MATRIX, modv ); /* Combine the two matrices (multiply projection by modelview) */ clip[ 0] = modv[ 0] * proj[ 0] + modv[ 1] * proj[ 4] + modv[ 2] * proj[ 8] + modv[ 3] * proj[12]; clip[ 1] = modv[ 0] * proj[ 1] + modv[ 1] * proj[ 5] + modv[ 2] * proj[ 9] + modv[ 3] * proj[13]; clip[ 2] = modv[ 0] * proj[ 2] + modv[ 1] * proj[ 6] + modv[ 2] * proj[10] + modv[ 3] * proj[14]; clip[ 3] = modv[ 0] * proj[ 3] + modv[ 1] * proj[ 7] + modv[ 2] * proj[11] + modv[ 3] * proj[15]; clip[ 4] = modv[ 4] * proj[ 0] + modv[ 5] * proj[ 4] + modv[ 6] * proj[ 8] + modv[ 7] * proj[12]; clip[ 5] = modv[ 4] * proj[ 1] + modv[ 5] * proj[ 5] + modv[ 6] * proj[ 9] + modv[ 7] * proj[13]; clip[ 6] = modv[ 4] * proj[ 2] + modv[ 5] * proj[ 6] + modv[ 6] * proj[10] + modv[ 7] * proj[14]; clip[ 7] = modv[ 4] * proj[ 3] + modv[ 5] * proj[ 7] + modv[ 6] * proj[11] + modv[ 7] * proj[15]; clip[ 8] = modv[ 8] * proj[ 0] + modv[ 9] * proj[ 4] + modv[10] * proj[ 8] + modv[11] * proj[12]; clip[ 9] = modv[ 8] * proj[ 1] + modv[ 9] * proj[ 5] + modv[10] * proj[ 9] + modv[11] * proj[13]; clip[10] = modv[ 8] * proj[ 2] + modv[ 9] * proj[ 6] + modv[10] * proj[10] + modv[11] * proj[14]; clip[11] = modv[ 8] * proj[ 3] + modv[ 9] * proj[ 7] + modv[10] * proj[11] + modv[11] * proj[15]; clip[12] = modv[12] * proj[ 0] + modv[13] * proj[ 4] + modv[14] * proj[ 8] + modv[15] * proj[12]; clip[13] = modv[12] * proj[ 1] + modv[13] * proj[ 5] + modv[14] * proj[ 9] + modv[15] * proj[13]; clip[14] = modv[12] * proj[ 2] + modv[13] * proj[ 6] + modv[14] * proj[10] + modv[15] * proj[14]; clip[15] = modv[12] * proj[ 3] + modv[13] * proj[ 7] + modv[14] * proj[11] + modv[15] * proj[15]; /* Extract the numbers for the RIGHT plane */ frustum[frustum_right][0] = clip[ 3] - clip[ 0]; frustum[frustum_right][1] = clip[ 7] - clip[ 4]; frustum[frustum_right][2] = clip[11] - clip[ 8]; frustum[frustum_right][3] = clip[15] - clip[12]; /* Normalize the result */ t = sqrtf( frustum[frustum_right][0] * frustum[frustum_right][0] + frustum[frustum_right][1] * frustum[frustum_right][1] + frustum[frustum_right][2] * frustum[frustum_right][2] ); frustum[frustum_right][0] /= t; frustum[frustum_right][1] /= t; frustum[frustum_right][2] /= t; frustum[frustum_right][3] /= t; /* Extract the numbers for the LEFT plane */ frustum[frustum_left][0] = clip[ 3] + clip[ 0]; frustum[frustum_left][1] = clip[ 7] + clip[ 4]; frustum[frustum_left][2] = clip[11] + clip[ 8]; frustum[frustum_left][3] = clip[15] + clip[12]; /* Normalize the result */ t = sqrtf( frustum[frustum_left][0] * frustum[frustum_left][0] + frustum[frustum_left][1] * frustum[frustum_left][1] + frustum[frustum_left][2] * frustum[frustum_left][2] ); frustum[frustum_left][0] /= t; frustum[frustum_left][1] /= t; frustum[frustum_left][2] /= t; frustum[frustum_left][3] /= t; /* Extract the BOTTOM plane */ frustum[frustum_bottom][0] = clip[ 3] + clip[ 1]; frustum[frustum_bottom][1] = clip[ 7] + clip[ 5]; frustum[frustum_bottom][2] = clip[11] + clip[ 9]; frustum[frustum_bottom][3] = clip[15] + clip[13]; /* Normalize the result */ t = sqrtf( frustum[frustum_bottom][0] * frustum[frustum_bottom][0] + frustum[frustum_bottom][1] * frustum[frustum_bottom][1] + frustum[frustum_bottom][2] * frustum[frustum_bottom][2] ); frustum[frustum_bottom][0] /= t; frustum[frustum_bottom][1] /= t; frustum[frustum_bottom][2] /= t; frustum[frustum_bottom][3] /= t; /* Extract the TOP plane */ frustum[frustum_top][0] = clip[ 3] - clip[ 1]; frustum[frustum_top][1] = clip[ 7] - clip[ 5]; frustum[frustum_top][2] = clip[11] - clip[ 9]; frustum[frustum_top][3] = clip[15] - clip[13]; /* Normalize the result */ t = sqrtf( frustum[frustum_top][0] * frustum[frustum_top][0] + frustum[frustum_top][1] * frustum[frustum_top][1] + frustum[frustum_top][2] * frustum[frustum_top][2] ); frustum[frustum_top][0] /= t; frustum[frustum_top][1] /= t; frustum[frustum_top][2] /= t; frustum[frustum_top][3] /= t; /* Extract the FAR plane */ frustum[frustum_far][0] = clip[ 3] - clip[ 2]; frustum[frustum_far][1] = clip[ 7] - clip[ 6]; frustum[frustum_far][2] = clip[11] - clip[10]; frustum[frustum_far][3] = clip[15] - clip[14]; /* Normalize the result */ t = sqrtf( frustum[frustum_far][0] * frustum[frustum_far][0] + frustum[frustum_far][1] * frustum[frustum_far][1] + frustum[frustum_far][2] * frustum[frustum_far][2] ); frustum[frustum_far][0] /= t; frustum[frustum_far][1] /= t; frustum[frustum_far][2] /= t; frustum[frustum_far][3] /= t; /* Extract the NEAR plane */ frustum[frustum_near][0] = clip[ 3] + clip[ 2]; frustum[frustum_near][1] = clip[ 7] + clip[ 6]; frustum[frustum_near][2] = clip[11] + clip[10]; frustum[frustum_near][3] = clip[15] + clip[14]; /* Normalize the result */ t = sqrtf( frustum[frustum_near][0] * frustum[frustum_near][0] + frustum[frustum_near][1] * frustum[frustum_near][1] + frustum[frustum_near][2] * frustum[frustum_near][2] ); frustum[frustum_near][0] /= t; frustum[frustum_near][1] /= t; frustum[frustum_near][2] /= t; frustum[frustum_near][3] /= t; }
bool CCCameraBase::GluUnProject(const float x, const float y, const float z, CCVector3 &result) { return gluUnProject( x, y, z, getModelViewMatrix().data(), projectionMatrix.data(), viewport, &result.x, &result.y, &result.z ); }
void Camera::getBillboardVectors( Vec3f *right, Vec3f *up ) const { right->set( getModelViewMatrix().m[0], getModelViewMatrix().m[4], getModelViewMatrix().m[8] ); up->set( getModelViewMatrix().m[1], getModelViewMatrix().m[5], getModelViewMatrix().m[9] ); }
// We are going to override (is that the right word?) the draw() // method of ModelerView to draw out SampleModel void SampleModel::draw() { // This call takes care of a lot of the nasty projection // matrix stuff. Unless you want to fudge directly with the // projection matrix, don't bother with this ... ModelerView::draw(); /************************************************* ** ** NOW SAVE THE CURRENT MODELVIEW MATRIX ** ** At this point in execution, the MODELVIEW matrix contains ** ONLY the camera transformation. We need to save this camera ** transformation so that we can use it later (for reasons ** explained below). ** *****************************************************/ cameraMatrix = getModelViewMatrix(); // draw the sample model setAmbientColor(.1f, .1f, .1f); //glPushMatrix(); //glPopMatrix(); glPushMatrix(); // push identity glTranslated(VAL(XPOS), VAL(YPOS), VAL(ZPOS)); // values set by the sliders if (VAL(NINJATURTLE)) setDiffuseColor(COLOR_GREEN); else setDiffuseColor(.940f, .816f, .811f); if (animate) glRotated(animHeadAngle, 0.0, 1.0, 0.0); if (VAL(EYEBANDANA)) drawEyeBandana(); if (!VAL(NINJATURTLE)) setDiffuseColor(.940f, .816f, .811f); drawHead(); if (!VAL(NINJATURTLE)) { setDiffuseColor(0, 0, 0); drawFace(); setDiffuseColor(.940f, .816f, .811f); drawNeck(); } drawUpperTorso(); drawLowerTorso(); if (!VAL(NINJATURTLE)) setDiffuseColor(.940f, .816f, .811f); drawRightHandJoint(); glPushMatrix(); if (animate) glRotated(animUpperArmAngle, 1.0, 0, 0); drawUpperRightHand(); drawLowerRightHand(); drawRightHand(); glPopMatrix(); drawLeftHandJoint(); glPushMatrix(); if (animate) glRotated(-animUpperArmAngle, 1.0, 0, 0); drawUpperLeftHand(); drawLowerLeftHand(); drawLeftHand(); glPopMatrix(); drawRightLegJoint(); drawLeftLegJoint(); drawUpperRightLeg(); drawLowerRightLeg(); drawRightFoot(); drawUpperLeftLeg(); drawLowerLeftLeg(); drawLeftFoot(); if (VAL(NINJATURTLE)) drawShell(); else drawTail(); // handle the positioning and hierachical modeling of the tail if (VAL(METABALLSKIN)) { MetaBalls mb; mb.setUpGrid(); mb.setUpMetaballs(); mb.evalScalarField(); mb.draw(); } glPopMatrix(); /*********************************************** ** ** NOW WE WILL ACTUALLY BEGIN DRAWING THE MODEL ** ** Draw your model up to the node where you would like ** particles to spawn from. ** ** FYI: As you call glRotate, glScale, or glTranslate, ** OpenGL is multiplying new transformations into the ** MODELVIEW matrix. ** ********************************************/ // If particle system exists, draw it ParticleSystem *ps = ModelerApplication::Instance()->GetParticleSystem(); if (ps != NULL) { ps->computeForcesAndUpdateParticles(t); ps->drawParticles(t, m_camera); } /************************************************* ** ** NOW DO ANY CLOSING CODE ** ** Don't forget that animator requires you to call ** endDraw(). ** **************************************************/ endDraw(); }