mat3 operator +(const mat3 &_lhs, const mat3 &_rhs) { mat3 m; for(int i = 0; i < 9; ++i) m.set( i, _lhs.get(i) + _rhs.get(i) ); return m; }
void Leaf::fitBox(const mat3 &R, vec3 ¢er, vec3 &halfSize) { vec3 x = R.row(0); vec3 y = R.row(1); vec3 z = R.row(2); vec3 max(-1.0e10, -1.0e10, -1.0e10); vec3 min( 1.0e10, 1.0e10, 1.0e10); std::list<Triangle>::iterator it; for (it=mTriangles.begin(); it!=mTriangles.end(); it++) { boxSize( (*it).v1, min, max, x, y, z, TOLERANCE); boxSize( (*it).v2, min, max, x, y, z, TOLERANCE); boxSize( (*it).v3, min, max, x, y, z, TOLERANCE); } DBGP("Max: " << max); DBGP("Min: " << min); for (int i=0; i<3; i++) { halfSize[i] = 0.5 * (max[i] - min[i]); } DBGP("computed halfsize: " << halfSize); //halfSize = 0.5 * (max - min); center = min + halfSize; center = R.inverse() * center; //sanity check for (int i=0; i<3; i++) { if (halfSize[i] < TOLERANCE) { if (halfSize[i] < 0.5 * TOLERANCE) { DBGA("Warning: degenerate box computed"); } halfSize[i] = TOLERANCE; } } DBGP("returned halfsize: " << halfSize); }
bool operator ==(const mat3 &_lhs, const mat3 &_rhs) { for(int i = 0; i < 9; ++i) if(_lhs.get(i) != _rhs.get(i)) return false; return true; }
vec3 et::removeMatrixScale(mat3& mat) { vec3 c0 = mat.column(0); vec3 c1 = mat.column(1); vec3 c2 = mat.column(2); float lengths[3] = { c0.length(), c1.length(), c2.length() }; ET_ASSERT(lengths[0] > 0.0f); ET_ASSERT(lengths[1] > 0.0f); ET_ASSERT(lengths[2] > 0.0f); if (mat.determinant() < 0.0f) { float minValues[3] = { etMin(c0.x, etMin(c0.y, c0.z)), etMin(c1.x, etMin(c1.y, c1.z)), etMin(c2.x, etMin(c2.y, c2.z)) }; auto offset = std::min_element(minValues, minValues + 3) - minValues; lengths[offset] = -lengths[offset]; } for (size_t i = 0; i < 3; ++i) { mat[0][i] /= lengths[i]; mat[1][i] /= lengths[i]; mat[2][i] /= lengths[i]; } return vec3(lengths[0], lengths[1], lengths[2]); }
/*! Converts this quaternion to a 3x3 rotation matrix. */ void Quaternion::ToRotationMatrix(mat3 &R) const { double tx = 2.0*x; double ty = 2.0*y; double tz = 2.0*z; double twx = tx*w; double twy = ty*w; double twz = tz*w; double txx = tx*x; double txy = ty*x; double txz = tz*x; double tyy = ty*y; double tyz = tz*y; double tzz = tz*z; R.element(0,0) = 1.0-(tyy+tzz); R.element(1,0) = txy-twz; R.element(2,0) = txz+twy; R.element(0,1) = txy+twz; R.element(1,1) = 1.0-(txx+tzz); R.element(2,1) = tyz-twx; R.element(0,2) = txz-twy; R.element(1,2) = tyz+twx; R.element(2,2) = 1.0-(txx+tyy); }
void PropertyManager::updateMat3(wxPropertyGridManager *pg, std::string label, mat3 a) { std::string s = label + ".Row0.x"; pg->SetPropertyValue(wxString(s.c_str()), a.at(0,0)); s.clear(); s = label + ".Row0.y"; pg->SetPropertyValue(wxString(s.c_str()), a.at(0, 1)); s.clear(); s = label + ".Row0.z"; pg->SetPropertyValue(wxString(s.c_str()), a.at(0, 2)); s.clear(); s = label + ".Row1.x"; pg->SetPropertyValue(wxString(s.c_str()), a.at(1, 0)); s.clear(); s = label + ".Row1.y"; pg->SetPropertyValue(wxString(s.c_str()), a.at(1, 1)); s.clear(); s = label + ".Row1.z"; pg->SetPropertyValue(wxString(s.c_str()), a.at(1, 2)); s.clear(); s = label + ".Row2.x"; pg->SetPropertyValue(wxString(s.c_str()), a.at(2, 0)); s.clear(); s = label + ".Row2.y"; pg->SetPropertyValue(wxString(s.c_str()), a.at(2, 1)); s.clear(); s = label + ".Row2.z"; pg->SetPropertyValue(wxString(s.c_str()), a.at(2, 2)); }
/* order. */ vec3 operator* (const vec3& v, const mat3& m) { /* Multiply column one by the vector to get the new x component */ float x = m.getColumn(0) * v; /* Multiply column two by the vector to get the new y component */ float y = m.getColumn(1) * v; /* Multiply column three by the vector to get the new z component */ float z = m.getColumn(2) * v; /* Return a new vector with the new components */ return vec3(x, y, z); }
void Graphics::setMatrix(ConstantLocation location, const mat3& value) { FRHICommandListImmediate& commandList = GRHICommandList.GetImmediateCommandList(); TShaderMapRef<FVertexShaderExample> VertexShader(GetGlobalShaderMap(ERHIFeatureLevel::SM5)); mat3 value2 = value.Transpose(); float floats[12]; for (int y = 0; y < 3; ++y) { for (int x = 0; x < 3; ++x) { floats[y * 4 + x] = value.get(y, x); } } commandList.SetShaderParameter(VertexShader->GetVertexShader(), location.parameter.GetBufferIndex(), location.parameter.GetBaseIndex(), 4 * 12, floats); }
void ComponentPhysicsGeom::setOrientation(const mat3 &m) { dMatrix3 r; const vec3 x = m.getAxisX().getNormal(); const vec3 y = m.getAxisY().getNormal(); const vec3 z = m.getAxisZ().getNormal(); r[0] = x.x; r[1] = x.y; r[2] = x.z; r[3] = 0.0f; r[4] = y.x; r[5] = y.y; r[6] = y.z; r[7] = 0.0f; r[8] = z.x; r[9] = z.y; r[10]= z.z; r[11]= 0.0f; dGeomSetRotation(geom, r); getParentBlackBoard().relayMessage(MessageOrientationHasBeenSet(getOrientation())); }
inline mat3 inverse(mat3 const& m) { scalar_t const d = 1 / m.determinant(); if (d != 0) { scalar_t const id = 1 / d; return mat3( vec3( id * (m.y.y * m.z.z - m.y.z * m.z.y), -id * (m.x.y * m.z.z - m.x.z * m.z.y), id * (m.x.y * m.y.z - m.x.z * m.y.y)), vec3( -id * (m.y.x * m.z.z - m.y.z * m.z.x), id * (m.x.x * m.z.z - m.x.z * m.z.x), -id * (m.x.x * m.y.z - m.x.z * m.y.x)), vec3( id * (m.y.x * m.z.y - m.y.y * m.z.x), -id * (m.x.x * m.z.y - m.x.y * m.z.x), id * (m.x.x * m.y.y - m.x.y * m.y.x))); } else { return mat3::identity(); } }
float determinant(const mat3 &_m) { float a = _m.get(0,0); float b = _m.get(1,0); float c = _m.get(2,0); float d = _m.get(0,1); float e = _m.get(1,1); float f = _m.get(2,1); float g = _m.get(0,2); float h = _m.get(1,2); float i = _m.get(2,2); return a * (e*i - f*h) - b * (d*i - f*g) + c * (d*h - e*g); }
mat3 operator /(const mat3 &_lhs, const float &_rhs) { mat3 m; for(int i = 0; i < 9; ++i) m.set( i, _lhs.get(i) / _rhs ); return m; }
mat3 transpose(const mat3 &_m) { mat3 r; for(int i = 0; i < 3; ++i) for(int j = 0; j < 3; ++j) r.set(j, i, _m.get(i, j)); return r; }
void ComponentPhysicsGeom::drawAxes() const { CHECK_GL_ERROR(); glPushAttrib(GL_ALL_ATTRIB_BITS); { glLineWidth(2.0f); const mat3 orientation = getOrientation(); mat4 transformation(getPosition(), orientation.getAxisX(), orientation.getAxisY(), orientation.getAxisZ()); glPushMatrix(); glMultMatrixf(transformation); glBegin(GL_LINES); glColor4fv(red); glVertex3fv(vec3(0,0,0)); glVertex3fv(orientation.getAxisX()); glColor4fv(green); glVertex3fv(vec3(0,0,0)); glVertex3fv(orientation.getAxisY()); glColor4fv(blue); glVertex3fv(vec3(0,0,0)); glVertex3fv(orientation.getAxisZ()); glEnd(); glPopMatrix(); } glPopAttrib(); CHECK_GL_ERROR(); }
// Apply Householder reflection represented by u to column vectors of M void reflect_cols(mat3 &M, vec3 &u) { for (int i=0; i < 3; ++i) { nv_scalar s = dot(u , M.col(i)); for (int j=0; j < 3; ++j) M(j,i) -= u[j]*s; } }
bool mat3::operator ==(const mat3& rhs) { for(int i = 0; i < VEC_DIM; i++) { if(v[i] != rhs.getCol(i)) return false; } return true; }
void Graphics::setMatrix(ConstantLocation location, const mat3& value) { if (location.shaderType == -1) return; float floats[12]; for (int y = 0; y < 3; ++y) { for (int x = 0; x < 3; ++x) { floats[y * 4 + x] = value.get(y, x); } } if (location.shaderType == 0) device->SetVertexShaderConstantF(location.reg.regindex, floats, 3); else device->SetPixelShaderConstantF(location.reg.regindex, floats, 3); }
mat3 operator *(const mat3 &_lhs, const mat3 &_rhs) { mat3 m; for(int i = 0; i < 3; ++i) for(int j = 0; j < 3; ++j) { vec3 l ( _lhs.get( 0, j ), _lhs.get( 1, j ), _lhs.get( 2, j ) ); vec3 r ( _rhs.get( i, 0 ), _rhs.get( i, 1 ), _rhs.get( i, 2 ) ); m.set(i, j, dot(l, r)); } return m; }
mat3 mat3::operator *(const mat3& rhs) { float a[VEC_DIM*VEC_DIM] = {0.0f}; for(int i = 0; i < VEC_DIM; i++) { for(int j = 0; j < VEC_DIM; j++) { for(int z = 0; z < VEC_DIM; z++) { a[i * VEC_DIM + j] += v[i].v[z] * rhs.get(z , j); } } } return mat3(a); }
// I had to move it here because it depends on AtomicPair class which is defined after LaueSymmetry vector<AtomicPair> LaueSymmetry::multiply_pairs_by_matrix(vector<AtomicPair> pairs,mat3<double> transformation_matrix) { vector<AtomicPair>::iterator pair; for(pair=pairs.begin(); pair!=pairs.end(); pair++) { for(int average=0; average<2; average++) { pair->r(average)=transformation_matrix*pair->r(average); pair->U(average)=trusted_mat_to_sym_mat(transformation_matrix*pair->U(average)*transformation_matrix.transpose()); } } return pairs; }
bool DiagonalizeMatrix(const mat3& m, mat3& res) { vec3 v; if (!EigenValues(m, v)) return false; res.Identity(); res[0] = v[0]; res[4] = v[1]; res[8] = v[2]; return true; }
void Font::putBillboardChar(vec3 start, vec3 *offset, char character, const color *color, FontSize size, mat3 cameraOrientation) const { const float _size = fontSize.find(size)->second; float w = _size / 100.0f; float h = _size / 100.0f; const vec3 right = cameraOrientation.getAxisX(); const vec3 up = cameraOrientation.getAxisY(); vec3 nextOffset; if(character == '\n') { nextOffset = (*offset) + -up*(h*lineHeight); } else { /* center the quad place it shift left by an offset */ const vec3 a = -right*(w*0.5f) + (*offset) - right*w*getCharacter(character).left; const vec3 b = right*(w*0.5f) + (*offset) - right*w*getCharacter(character).left; const vec3 c = right*(w*0.5f) + up*h + (*offset) - right*w*getCharacter(character).left; const vec3 d = -right*(w*0.5f) + up*h + (*offset) - right*w*getCharacter(character).left; drawChar(a, b, c, d, character, *color); float offsetRight = w * (getCharacter(character).width + spacing); nextOffset = (*offset) + right*offsetRight; } (*offset) = nextOffset; }
void Program::setUniform(int nLoc, uint32_t type, const mat3& value, bool forced) { if (nLoc == -1) return; (void)type; assert(type == GL_FLOAT_MAT3); assert(loaded()); if (forced || ((_mat3Cache.count(nLoc) == 0) || (_mat3Cache[nLoc] != value))) { _mat3Cache[nLoc] = value; glUniformMatrix3fv(nLoc, 1, 0, value.data()); } checkOpenGLError("setUniform - mat3"); }
void Program::setUniform(int nLoc, uint32_t type, const mat3& value, bool forced) { #if !defined(ET_CONSOLE_APPLICATION) if (nLoc == -1) return; (void)type; ET_ASSERT(type == GL_FLOAT_MAT3); ET_ASSERT(apiHandleValid()); if (forced || ((_mat3Cache.count(nLoc) == 0) || (_mat3Cache[nLoc] != value))) { _mat3Cache[nLoc] = value; glUniformMatrix3fv(nLoc, 1, 0, value.data()); checkOpenGLError("glUniformMatrix3fv"); } #endif }
mat3 inverse(const mat3 &_m) { mat3 r; float det = determinant( _m ); for(int i = 0; i < 3; ++i) for(int j = 0; j < 3; ++j) r.set(i, j, determinant( _m.getMinor( i, j ) ) ); for(int i = 0; i < 9; ++i) if(i % 2 == 0) r.set(i, r.get(i) * -1.0f ); r.transpose(); return det * r; }
void XmlSceneLoader::parseTransformation(TiXmlElement* elem, vec3& tr, vec3& sc, mat3& rot, Collider* collider) { tr={0,0,0}; sc={1,1,1}; rot=mat3::IDENTITY(); elem = elem->FirstChildElement(); while(elem) { if(elem->ValueStr() == std::string("translate")) tr = toVec<3>(StringUtils::str(elem->GetText())); else if(elem->ValueStr() == std::string("scale")) sc = toVec<3>(StringUtils::str(elem->GetText())); else if(elem->ValueStr() == std::string("rotate")) { Vector<float, 9> r = toVec<9>(StringUtils::str(elem->GetText())); for(int i=0 ; i<9 ; ++i) rot.get(i) = r[i]; } else if(elem->ValueStr() == std::string("collider") && collider) { int col = Collider::NONE; elem->QueryIntAttribute("type", &col); elem->QueryFloatAttribute("mass", &collider->mass); elem->QueryFloatAttribute("restitution", &collider->restitution); elem->QueryFloatAttribute("friction", &collider->friction); elem->QueryFloatAttribute("rollingFriction", &collider->rollingFriction); if(col < Collider::USER_DEFINED) collider->type = col; else collider->type = Collider::NONE; } elem = elem->NextSiblingElement(); } }
vec3 eulerFromMatrix ( const mat3& m ) { const float * data = m.data (); vec3 angle; float c; angle.x = -asinf ( data [2] ); c = cosf ( angle.x ); if ( fabsf ( c ) > EPS ) { angle.y = atan2f ( data [5] / c, data [8] / c ); // m12, m22 angle.z = atan2f ( data [1] / c, data [0] / c ); } else { angle.y = 0.0f; angle.z = atan2f ( data [3], data [4] ); } return angle; }
// Find orthogonal factor Q of rank 1 (or less) M void do_rank1(mat3 & M, mat3& Q) { vec3 v1, v2; nv_scalar s; int col; Q = mat3_id; /* If rank(M) is 1, we should find a non-zero column in M */ col = find_max_col(M); if ( col < 0 ) return; /* Rank is 0 */ v1 = M.col(col); make_reflector(v1, v1); reflect_cols(M, v1); v2[0] = M[2][0]; v2[1] = M[2][1]; v2[2] = M[2][2]; make_reflector(v2, v2); reflect_rows(M, v2); s = M[2][2]; if (s < nv_zero) Q(2,2) = -nv_one; reflect_cols(Q, v1); reflect_rows(Q, v2); }
// matrix multiplication (m1 * m2) mat3 operator* (const mat3& m1, const mat3& m2) { mat3 mult; mult[0][0] = m1[0] * m2.getColumn(0); mult[0][1] = m1[0] * m2.getColumn(1); mult[0][2] = m1[0] * m2.getColumn(2); mult[1][0] = m1[1] * m2.getColumn(0); mult[1][1] = m1[1] * m2.getColumn(1); mult[1][2] = m1[1] * m2.getColumn(2); mult[2][0] = m1[2] * m2.getColumn(0); mult[2][1] = m1[2] * m2.getColumn(1); mult[2][2] = m1[2] * m2.getColumn(2); return mult; }
void RenderingEngine::Render(float theta) const { const float distance = 10; const vec3 target(0, -0.15, 0); const vec3 up(0, 1, 0); vec3 eye(0, -0.15, distance * 2); mat4 view = mat4::LookAt(eye, target, up); glUseProgram(m_simple.Program); glUniformMatrix4fv(m_simple.Uniforms.Modelview, 1, 0, view.Pointer()); glDepthFunc(GL_ALWAYS); glBindTexture(GL_TEXTURE_2D, m_textures.Metal); RenderDrawable(m_quad, m_simple); eye = vec3(0, 0, distance); view = mat4::LookAt(eye, target, up); const mat4 model = mat4::RotateY(theta * 180.0f / 3.14f); const mat3 model3x3 = model.ToMat3(); const mat4 modelview = model * view; vec4 eyeWorldSpace(0, 0, -10, 1); vec4 eyeObjectSpace = model * eyeWorldSpace; glUseProgram(m_cubemap.Program); glUniform3fv(m_cubemap.Uniforms.EyePosition, 1, eyeObjectSpace.Pointer()); glUniformMatrix4fv(m_cubemap.Uniforms.Modelview, 1, 0, modelview.Pointer()); glUniformMatrix3fv(m_cubemap.Uniforms.Model, 1, 0, model3x3.Pointer()); glBindTexture(GL_TEXTURE_CUBE_MAP, m_textures.Cubemap); glEnableVertexAttribArray(m_cubemap.Attributes.Normal); glDepthFunc(GL_LESS); RenderDrawable(m_kleinBottle, m_cubemap); }