// Inits parameters for the camera void Camera::init() { // View Data // Camera position and orientation this->c[0]=0.0; this->c[1]=0.0; this->c[2]=1.0; // Camera position this->x[0]=1.0; this->x[1]=0.0; this->x[2]=0.0; normalize(this->x); // x axis this->y[0]=0.0; this->y[1]=1.0; this->y[2]=0.0; normalize(this->y); // y axis this->z[0]=0.0; this->z[1]=0.0; this->z[2]=1.0; normalize(this->z); // z axis setToIdentity(this->view); this->updateView(); // Projection data // Projection type : perspective:true / orthographic:false this->perspectiveProjection=false; // Projection frustum data GLfloat l=1.0; this->left=-l; this->right=l; this->bottom=-l; this->top=l; this->near=0.4;/*0.1 à l'origine*/ this->far=100;/*100 à l'origine*/ setToIdentity(this->projection); updateProjection(); }
bool WireCreator::checkPath(QVector<int> path) { auto modifiedPath=pathToPoints(path); auto basicPath=modifiedPath; m_wire.read_Input(modifiedPath); for(float rot=0.0f;rot<360.0f; rot+=5.0f ){ while(!m_wire.nextPoint3()){ //qDebug()<<"no collision for: "<<m_wire.outerPoints; if(m_wire.success){ cPath=modifiedPath; return true; } } auto rotMat=QMatrix4x4(); rotMat.setToIdentity(); rotMat.rotate(rot,1.0f, 0.0f, 0.0f); //qDebug()<<"old path"<<modifiedPath; modifiedPath=applyMatrix(basicPath, rotMat); //qDebug()<<"new path"<<modifiedPath; m_wire.read_Input(modifiedPath); } //qDebug()<<"no rotation found"; return false; }
// Updates view void Camera::updateView() { // Rotation to be aligned with correct camera axis float RcInv[]= {this->x[0], this->y[0], this->z[0], 0.0, this->x[1], this->y[1], this->z[1], 0.0, this->x[2], this->y[2], this->z[2], 0.0, 0.0, 0.0, 0.0, 1.0 }; // Translation to be at the right distance from the scene float TcInv[]= {1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, -this->c[0], -this->c[1], -this->c[2], 1.0 }; // Initializes setToIdentity(this->view); // Rotates multMatrixBtoMatrixA(this->view, RcInv); // Translates multMatrixBtoMatrixA(this->view, TcInv); // Updates in shaders this->shaders.setView(this->view, this->c); }
/* * Main display of the ColorSpaceKeyerOverlay class * @param args current arg (time/renderScale/pixelScale.... * @return if there is something drawed by the function (y or n) */ bool ColorSpaceKeyerOverlay::draw( const OFX::DrawArgs& args ) { bool displaySomethings = false; if( _plugin->_paramBoolPointCloudDisplay->getValue() ) //Is CloudPointData displayed ? (GUI) { glPushMatrix(); //new transformation prepareOpenGLScene(args); //prepare frustum and projection settings if(_plugin->_updateVBO ) //VBO need to be updated { //update VBO getData().updateVBO(); //update VBO from VBO data (already computed) _plugin->_updateVBO = false; //VBO has been recomputed } if(_plugin->_resetViewParameters) //View parameters need to be reseted { _rotateX = _rotateY = 0; //reset parameters _rotateXForm = _rotateYForm = 0; //reset geodesic form center rotation parameters _plugin->_resetViewParameters = false; //view parameters has been changed setToIdentity(_modelViewMatrix); //reset model-view matrix to identity } //OpenGL parameters glEnable(GL_DEPTH_TEST); //active depth (better for understand results) //drawing Axes drawAxes(); //draw the X, Y and Z axes //drawing VBO if(getData()._isVBOBuilt) //if VBO has already been built getData()._imgVBO.draw(); //draw VBO //drawing color selection VBO if(getData()._isSelectionVBOBuilt && _plugin->_paramBoolSeeSelection->getValue()) //color selection VBO data is built { glColor3f(1.0f,1.0f,1.0f); //color is white getData()._selectionColorVBO.draw(); //draw selection VBO } //drawing spill selection VBO if(getData()._isSpillSelectionVBOBuilt && _plugin->_paramBoolSeeSpillSelection->getValue()) //spill selection VBO data is built { glColor3f(.3f,.3f,.3f); //color is white getData()._selectionSpillVBO.draw(); //draw selection VBO } //drawing average getData()._averageColor.draw(); //draw average (cross) //drawing geodesic form if(_plugin->_paramBoolDisplayGeodesicForm->getValue()) //does user want to display color geodesic form getData()._geodesicFormColor.draw(false); //draw geodesic form on screen without alpha if(_plugin->_paramBoolDisplaySpillGF->getValue()) //does user want to display spill geodesic form getData()._geodesicFormSpill.draw(true); //draw spill geodesic form on screen with alpha //OpenGL end of parameters glDisable(GL_DEPTH_TEST); //disable deep glPopMatrix(); //pop matrix displaySomethings = true; //something has been drown on screen } return displaySomethings; //return if overlay has displayed something (y or n) }
Matrix2d& Matrix2d::setToMirroring(const Point2d& pnt, const Vector2d& dir) { float d2 = dir.lengthSquare(); if (mgIsZero(d2)) setToIdentity(); else { float s2 = 2.f * dir.x * dir.y / d2; float c2 = (dir.x * dir.x - dir.y * dir.y) / d2; set(c2, s2, s2, -c2, (1 - c2) * pnt.x - s2 * pnt.y, (1 + c2) * pnt.y - s2 * pnt.x); } return *this; }
// Moves void Camera::move(const bool spherical, const float * const moves, const float * const angles, const float radius) { float cameraNewPos[3]; for (unsigned int iCoord=0 ; iCoord<3 ; ++iCoord) { cameraNewPos[iCoord]=this->c[iCoord] +this->x[iCoord]*moves[0] +this->y[iCoord]*moves[1] +this->z[iCoord]*moves[2]; } float xAxis[]= {1.0, 0.0, 0.0}; float yAxis[]= {0.0, 1.0, 0.0}; float rotateAroundX[16]; setToRotate(rotateAroundX, -angles[1], xAxis); float rotateAroundY[16]; setToRotate(rotateAroundY, angles[0], yAxis); float t[]= {-cameraNewPos[0], -cameraNewPos[1], -cameraNewPos[2]}; float translate[16]; setToTranslate(translate, t); setToIdentity(this->view); if (spherical) { float tRadius[]= {0.0, 0.0, -radius}; float translateRadius[16]; setToTranslate(translateRadius, tRadius); multMatrixBtoMatrixA(this->view, translateRadius); } multMatrixBtoMatrixA(this->view, rotateAroundX); multMatrixBtoMatrixA(this->view, rotateAroundY); multMatrixBtoMatrixA(this->view, translate); for (unsigned int iCoord=0 ; iCoord<3 ; ++iCoord) { // Updates the axis with values in view this->x[iCoord]=this->view[iCoord*4+0]; this->y[iCoord]=this->view[iCoord*4+1]; this->z[iCoord]=this->view[iCoord*4+2]; // Updates the position of the camera c this->c[iCoord]=cameraNewPos[iCoord]; } // Updates in shaders this->shaders.setView(this->view, this->c); }
bool Matrix2d::invert() { float d = m11 * m22 - m12 * m21; if (mgIsZero(d)) { setToIdentity(); return false; } d = 1.f / d; set(m22 * d, -m12 * d, -m21 * d, m11 * d, (m21 * dy - m22 * dx) * d, (m12 * dx - m11 * dy) * d); return true; }
/* * Constructor * @param handle * @param effect */ ColorSpaceKeyerOverlay::ColorSpaceKeyerOverlay(OfxInteractHandle handle,OFX::ImageEffect* effect) : OFX::OverlayInteract(handle) , _infos(effect) { _plugin = static_cast<ColorSpaceKeyerPlugin*>(_effect); //get plugin _plugin->addRefCloudPointData(); //create pointer to overlay data _isPenDown = false; //mouse is not under control by default _isCtrlKeyDown = false; //Ctrl key is not pressed by default _rotateX = _rotateY = 0.0; //initialize rotation to 0 _rotateXForm = _rotateYForm = 0.0; //initialize rotation centered to geodesic form to 0 _origin.x = _origin.y = _end.x = _end.y = 0; //initialize mouse positions to 0 setToIdentity(_modelViewMatrix); //set model view matrix to identity ///HACK : to initialize correctly overlay display data OFX::InstanceChangedArgs args; //create instance changed arguments _plugin->changedParam(args,kPointCloudDisplay); //call changed parameters function to initialize overlay data }
// Initializes all the pointers to NULL // and sets the numbers of objects to 0 void Scene::init() { // Fixed max sizes for arrays this->maxStoredObjects=50; this->maxDrawnObjects=200; // Initialisation of the numbers of objets filled this->nbStoredObjects=0; this->nbDrawnObjects=0; // Array creation (with fixed size) this->storedObjects=new Object *[this->maxStoredObjects]; this->drawnObjects=new GLuint[this->maxDrawnObjects]; this->drawnObjectsColors=new GLfloat[this->maxDrawnObjects*4]; this->drawnObjectsModels=new GLfloat[this->maxDrawnObjects*16]; this->drawnObjectsShaderIDs=new GLuint[this->maxDrawnObjects]; // Default color GLfloat grey[16]={0.2, 0.2, 0.2, 1.0}; setDefaultColor(grey); // Default model GLfloat I[16]; setToIdentity(I); setDefaultModel(I); // Default shader ID setDefaultShaderID(1); // Initalisation of storedObjects for (GLuint iStoredObjects=0 ; iStoredObjects<this->maxStoredObjects ; iStoredObjects++) this->storedObjects[iStoredObjects]=NULL; // Light creation GLfloat lightPosition[]={0.0, 5.0, 0.0, 1.0}; GLfloat lightPower=1.0; this->setLight(lightPosition, lightPower); // Creation and initialisation of a camera this->camera=new Camera(); // in Scene::init() this->drawnObjectsTexture0IDs=new GLuint[this->maxDrawnObjects]; this->drawnObjectsTexture1IDs=new GLuint[this->maxDrawnObjects]; // Default texture ID setDefaultTextureID(1); }
/* * Create rotation matrix with rotation center (translate + rotates + inverse translate) */ Matrix4 constructRotationMatrix(const Ofx3DPointD& rotationCenter, const double& angleX, const double& angleY, const double& angleZ) { // define axes Axis axisX = {{1, 0, 0}}; // define axe X Axis axisY = {{0, 1, 0}}; // define axe Y Axis axisZ = {{0, 0, 1}}; // define axe Z // Define and create rotation + translation matrix Matrix4 rotationTranslationMatrix; // initialize setToIdentity(rotationTranslationMatrix); // set matrix center to identity // Define and construct rotation matrices Matrix4 rotationMatrixX; // initialize rotation matrix X setToRotate(rotationMatrixX, angleX / 10.0, axisX); // construct rotation matrix X Matrix4 rotationMatrixY; // initialize rotation matrix Y setToRotate(rotationMatrixY, angleY / 10.0, axisY); // construct rotation matrix Y Matrix4 rotationMatrixZ; // initialize rotation matrix Z setToRotate(rotationMatrixZ, angleZ / 10.0, axisZ); // construct rotation matrix Z // Define and construct translation matrix Matrix4 translationMatrix; // initialize translation matrix // Construct translation vector Vect4 translationVector = {{rotationCenter.x, rotationCenter.y, rotationCenter.z, 1.0}}; setToTranslate(translationMatrix, translationVector); // construct translation matrix // Define and construct inverse translation matrix Matrix4 translationInverseMatrix; // initialize inverse translation matrix // Construct inverse translation vector Vect4 inverseTranslationVector = {{-rotationCenter.x, -rotationCenter.y, -rotationCenter.z, 1.0}}; setToTranslate(translationInverseMatrix, inverseTranslationVector); // construct inverse translation matrix // Construct final reference center matrix (inverse order of application) multMatrixBtoMatrixA(rotationTranslationMatrix, translationMatrix); // translation matrix multMatrixBtoMatrixA(rotationTranslationMatrix, rotationMatrixZ); // rotation Z axis multMatrixBtoMatrixA(rotationTranslationMatrix, rotationMatrixY); // rotation Y axis multMatrixBtoMatrixA(rotationTranslationMatrix, rotationMatrixX); // rotation X axis multMatrixBtoMatrixA(rotationTranslationMatrix, translationInverseMatrix); // inverse translation matrix // return result return rotationTranslationMatrix; }
// Inits parameters for the camera void Camera::init() { // View Data // Camera position and orientation float c[]= {0.0, 1.0, 3.0}; // Camera position float aim[]= {0.0, 0.0, 0.0}; // Where we look float up[]= {0.0, 1.0, 0.0}; // Vector pointing over the camera lookAt(c, aim, up); // Projection data // Projection type : perspective:true / orthographic:false this->perspectiveProjection=true; // Projection frustum data float l=1.0; this->left=-l; this->right=l; this->bottom=-l; this->top=l; this->near=0.1; this->far=100.0; setToIdentity(this->projection); updateProjection(); }
TransformMatrix::TransformMatrix() { setToIdentity(); }
Mat4::Mat4() { setToIdentity(); }
Matrix44::Matrix44() { setToIdentity(); }
GLMatrix() { setToIdentity(); }