void matrix4x4::Identity( void ) { mat[0] = Vector4D( 1, 0, 0, 0 ); mat[1] = Vector4D( 0, 1, 0, 0 ); mat[2] = Vector4D( 0, 0, 1, 0 ); mat[3] = Vector4D( 0, 0, 0, 1 ); }
// functie care plaseaza efectivl umina in scena void Light::Render() { // atenuari standard glLightf(GL_LIGHT0 + id,GL_CONSTANT_ATTENUATION,1); glLightf(GL_LIGHT0 + id,GL_LINEAR_ATTENUATION,0.2f); // culoarea luminii glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, Vector4D(diffuse.x, diffuse.y, diffuse.z, diffuse.a).Array()); // culoarea ambientala glLightfv(GL_LIGHT0 + id, GL_AMBIENT, ambient.Array()); // culoarea speculara glLightfv(GL_LIGHT0 + id, GL_SPECULAR, specular.Array()); // pozitia luminii glLightfv(GL_LIGHT0 + id, GL_POSITION, Vector4D(translation.x,translation.y,translation.z,1).Array()); // daca este de tip spot , setam parametrii de spot ( se vor folosi valori default ) if(LightType == IlluminationType::Spot) { // directia spotului va fi in jos glLightfv(GL_LIGHT0 + id , GL_SPOT_DIRECTION, (Vector3D(-1.0,0.0,0.0)).Array()); // deschidere de 45 de grade glLightf(GL_LIGHT0 + id , GL_SPOT_CUTOFF, 45.0); glLightf(GL_LIGHT0 + id , GL_SPOT_EXPONENT, 2); } // activam lumina glEnable(GL_LIGHT0 + id); }
void Box::Init() { m_MeshData = (char*)malloc(sizeof(Avni_Vertex_pos_diffuse)*4); Avni_Vertex_pos_diffuse* mesh = (Avni_Vertex_pos_diffuse*)(m_MeshData); Avni_Vertex_pos_diffuse vert[4]; vert[0].vertex = Vector4D(-1.0f, 1.0f, 0.0f,1.0f); vert[1].vertex = Vector4D( 1.0f, 1.0f, 0.0f,1.0f); vert[2].vertex = Vector4D( 1.0f,-1.0f, 0.0f,1.0f); vert[3].vertex = Vector4D(-1.0f,-1.0f, 0.0f,1.0f); vert[0].diffuseColor = Vector3D(1.0f,0.0f,0.0f); vert[1].diffuseColor = Vector3D(0.0f,1.0f,0.0f); vert[2].diffuseColor = Vector3D(0.0f,0.0f,1.0f); vert[3].diffuseColor = Vector3D(1.0f,0.0f,1.0f); u32 indices[] = { 0, 1, 3, 3, 1, 2, }; m_Mesh = SINGLETONMANAGER->GetRenderer()->CreateMesh(VERTEXTYPE_POS_DIFFUSE, 4, vert,indices, 6); m_Material = SINGLETONMANAGER->GetMaterialManager()->GetMaterial(MATERIALNAME_BASIC); }
Matrix4x4 a4_get_unproject_matrix(int width, int height, double fov, double d, Point3D eye, Vector3D view, Vector3D up) { double fov_r = fov * M_PI / 180.0; double h = 2.0*d*tan(fov_r / 2.0); // height of projection plane based field of view and distance to the plane // First translate the pixel so that it is centered at the origin in the projection plane (origin is in the middle of the screen) Matrix4x4 viewport_translate = Matrix4x4().translate(-(double)width / 2.0, -(double)height / 2.0, d); // Then scale it to the projection plane such that aspect ratio is maintained and we have a right handed coordinate system Matrix4x4 viewport_scale = Matrix4x4().scale(-h / (double)height, -h / (double)height, 1.0); // Calculate the basis for the view coordinate system view.normalize(); up.normalize(); Vector3D u = up.cross(view); u.normalize(); Vector3D v = view.cross(u); v.normalize(); // Create the view rotation and translation matrix Matrix4x4 view_rotate = Matrix4x4(Vector4D(u, 0.0), Vector4D(v, 0.0), Vector4D(view, 0.0), Vector4D(0.0, 0.0, 0.0, 1.0)).transpose(); Matrix4x4 view_translate = Matrix4x4().translate(Vector3D(eye)); // Now multiply these together to form the pixel to 3D point transformation matrix Matrix4x4 unproject = view_translate * view_rotate * viewport_scale * viewport_translate; return unproject; }
void SceneNode::scale(const Vector3D& amount) { Matrix4x4 t = Matrix4x4( Vector4D(amount[0], 0.0, 0.0, 0.0), Vector4D(0.0, amount[1], 0.0, 0.0), Vector4D(0.0, 0.0, amount[2], 0.0), Vector4D(0.0, 0.0, 0.0, 1.0) ); set_transform(m_trans * t); }
int COpenGLGrassRenderer::Sorter::compareElements( SGPVertex_GRASS_Cluster first, SGPVertex_GRASS_Cluster second ) noexcept { float firstDistance = -(m_pRD->getOpenGLCamera()->m_CameraPos - Vector4D(first.vPosition[0], first.vPosition[1], first.vPosition[2])).GetLengthSquared(); float secondDistance = -(m_pRD->getOpenGLCamera()->m_CameraPos - Vector4D(second.vPosition[0], second.vPosition[1], second.vPosition[2])).GetLengthSquared(); if( firstDistance < secondDistance ) return -1; if( firstDistance > secondDistance ) return 1; return 0; }
void SceneNode::translate(const Vector3D& amount) { Matrix4x4 t = Matrix4x4( Vector4D(1.0, 0.0, 0.0, amount[0]), Vector4D(0.0, 1.0, 0.0, amount[1]), Vector4D(0.0, 0.0, 1.0, amount[2]), Vector4D(0.0, 0.0, 0.0, 1.0) ); set_transform(m_trans * t); }
Matrix4D::Matrix4D( float m00, float m10, float m20, float m30, float m01, float m11, float m21, float m31, float m02, float m12, float m22, float m32, float m03, float m13, float m23, float m33 ) { m[0] = Vector4D( m00, m10, m20, m30 ); m[1] = Vector4D( m01, m11, m21, m31 ); m[2] = Vector4D( m02, m12, m22, m32 ); m[3] = Vector4D( m03, m13, m23, m33 ); }
void CustomObject3D::setDefault() { // Default lighting diffuse = Vector4D(1,1,1,1); ambient = Vector4D(0,0,0,0); specular = Vector4D(1,1,1,1); color = Vector3D(1,1,1); scale = Vector3D(1.0,1.0,1.0); // Default, it's not wireframe Wireframe = false; }
void Satellite::setParameters(GLuint size){ explosion = NULL; ambient4f1= Vector4D(0.9, 0.4, 0.1, 1); diffuse4f1=Vector4D(0.9, 0.4, 0.1, 1); specular4f1=Vector4D(0.9, 0.9, 0.9, 1.0); Vector4D emmision4f1(0, 0, 0, 1); static GLint shininess1 = 64; GLfloat ast_color [][5] = { {0.5, 0.2, 0.2, 2}, {0.55, 0.55, 0.55, 2}, {0.01, 0.3, 0.1, 2}, {0.7, 0.4, 0.3, 2}, {0.7, 0.3, 0.5, 2}, {0, 0, 0.2, 2} }; int pick = rand() % 6; //setare pozitie + culoare asteroid for(int i = 0; i < 4; i++) color[i] = ast_color[pick][i]; box = size; posx = rand() % box; posy = rand() % box; posz = rand() % box; Size = (rand() % 5+3)/2.0; time = 0; dx = (double) (rand() % RAND_MAX) / RAND_MAX * 2; int sign=rand()%2-1; dx*=sign; { dz = (double) (rand() % RAND_MAX) / RAND_MAX; dy = (double) (rand() % RAND_MAX) / RAND_MAX; sign=rand()%2-1; // dy*=sign; } v0 = (double) (rand() % RAND_MAX) / RAND_MAX; //acc = (double) (rand() % RAND_MAX) / RAND_MAX; //v0 = 0; }
Vector4D GlslProgram :: getUniformVector ( const char * name ) { float values [4]; int loc = glGetUniformLocationARB ( program, name ); if ( loc < 0 ) return Vector4D ( 0, 0, 0, 0 ); glGetUniformfvARB ( program, loc, values ); return Vector4D ( values [0], values [1], values [2], values [3] ); }
Vector4D GlslProgram :: getAttribute ( const char * name ) { int index = glGetAttribLocationARB ( program, name ); if ( index < 0 ) return Vector4D ( 0, 0, 0, 0 ); float buf [4]; glGetVertexAttribfvARB ( index, GL_CURRENT_VERTEX_ATTRIB_ARB, buf ); return Vector4D ( buf [0], buf [1], buf [2], buf [3] ); }
void scale(Matrix4x4 &mat,double x,double y,double z) { Matrix4x4 temp; Vector4D r1,r2,r3,r4; r1=Vector4D(x,0,0,0); r2=Vector4D(0,y,0,0); r3=Vector4D(0,0,z,0); r4=Vector4D(0,0,0,1); temp=Matrix4x4(r1,r2,r3,r4); mat=temp*mat; }
void translate(Matrix4x4 &mat,double x,double y,double z) { Matrix4x4 temp; Vector4D r1,r2,r3,r4; r1=Vector4D(1,0,0,x); r2=Vector4D(0,1,0,y); r3=Vector4D(0,0,1,z); r4=Vector4D(0,0,0,1); temp=Matrix4x4(r1,r2,r3,r4); mat=mat*temp; }
void SonarMonitor::draw() { Point point = m_hud->project(m_point); int radius = (m_hud->project(m_point + Point(0, m_radius)) - point).y; float scale = static_cast<float>(radius)/m_scale; PointF center = PointF(point) - PointF(1.5f); RectF rect = RectF(center, SizeF(4, 4)); Matrix m(1); m = glm::scale(m, Vector3D(1, -1, 0)); m = glm::rotate(m, m_hud->scenario()->yaw(), Vector3D(0, 0, 1)); m = glm::translate(m, -m_hud->scenario()->position()); m_hud->fontGreen().draw("T", point + Point(-2, -radius)); m_hud->fontGreen().draw(QString("%1M").arg(m_scale), Rect(point + Point(-100, radius - 8), SizeF(200, -1)), true, false); m_center.draw(rect); for (fight::NavPoint *navPoint : m_hud->scenario()->navPoints()) if (navPoint->isEnabled()) { Vector2D dir = Vector2D(m * Vector4D(navPoint->position(), 1)); float distance = glm::length(dir); if (distance < m_scale) { rect.setPos(center - dir*scale); m_nav.draw(rect); } } for (const auto &entry : m_hud->scenario()->sonar()) { Vector2D dir = Vector2D(m * Vector4D(entry.object->position(), 1)); float distance = glm::length(dir); if (distance < m_scale) { rect.setPos(center - dir*scale); (entry.isFriend ? m_friend : m_enemy).draw(rect); } } fight::Target &target = m_hud->scenario()->target(); if (target.isLocked()) { Vector2D dir = Vector2D(m * Vector4D(target.position(), 1)); float distance = glm::length(dir); if (distance < m_scale) { rect.setPos(center - dir*scale); m_target.draw(rect); } } }
// constructor care primeste ca parametru latura cubului Cube::Cube() : Object3D() { // valori default diffuse = Vector4D(1,1,1,1); ambient = Vector4D(0,0,0,0); specular = Vector4D(1,1,1,1); color = Vector3D(1,1,1); scale = Vector3D(1.0,1.0,1.0); // default , nu este wireframe Wireframe = false; latura = 1.0; }
Quad::Quad(const Point3D& point1, const Point3D& point2, const Point3D& point3, const Point3D& point4, const Material& material) : tri1_(point1, point2, point4, material) , tri2_(point2, point3, point4, material) { // Verify that it is on the if (tri1_.normal(Vector4D()) != tri2_.normal(Vector4D())) { std::cout << "All points of quad must be in the same plane." << std::endl; std::exit(-1); } }
Vector4D CatmullRom(const Vector4D &a, const Vector4D &b, const Vector4D &c, const Vector4D &d, Float t) { return Vector4D(Math::CatmullRom(a.mX, b.mX, c.mX, d.mX, t), Math::CatmullRom(a.mY, b.mY, c.mY, d.mY, t), Math::CatmullRom(a.mZ, b.mZ, c.mZ, d.mZ, t), Math::CatmullRom(a.mW, b.mW, c.mW, d.mW, t)); }
Vector4D Matrix4D::operator * ( const Vector4D& v ) const { return Vector4D( m[0][0]*v.x + m[0][1]*v.y + m[0][2]*v.z + m[0][3]*v.w, m[1][0]*v.x + m[1][1]*v.y + m[1][2]*v.z + m[1][3]*v.w, m[2][0]*v.x + m[2][1]*v.y + m[2][2]*v.z + m[2][3]*v.w, m[3][0]*v.x + m[3][1]*v.y + m[3][2]*v.z + m[3][3]*v.w ); }
// functie override customDraw(), apelata din Draw()-ul din Object3D void Plane::customDraw() { glPushMatrix(); // setari de material glMaterialfv(GL_FRONT,GL_DIFFUSE,(Vector4D(color.x ,color.y,color.z,1)).Array()); glMaterialfv(GL_FRONT,GL_AMBIENT,(Vector4D(color.x*ambientColorIntensity, color.y*ambientColorIntensity, color.z*ambientColorIntensity,1)).Array()); glMaterialfv(GL_FRONT,GL_SPECULAR,(Vector4D(0,0,0,0)).Array()); float leftMargin,rightMargin; leftMargin = -size; rightMargin = size; float i,j; float factor = 0.1f; // mutare in coordonate glTranslatef(translation.x, translation.y, translation.z); // colorare corespunzatoare glColor3f(color.x, color.y, color.z); // desenare plan for( i = leftMargin ; i+(levelOfDetail*factor)<=rightMargin; i+=(levelOfDetail*factor)) for(j=leftMargin;j+(levelOfDetail*factor)<=rightMargin; j+=(levelOfDetail*factor)) { if( !Wireframe) glBegin(GL_QUADS); else glBegin(GL_LINE_LOOP); glNormal3f(0.0,1.0,0.0); glVertex3f(i , 0, j); glVertex3f(i, 0, j+(levelOfDetail*factor)); if(j+(levelOfDetail*factor) !=rightMargin) glVertex3f(i+(levelOfDetail*factor), 0, j+(levelOfDetail*factor)); else glVertex3f(i+(levelOfDetail*factor), 0, rightMargin); glVertex3f(i+(levelOfDetail*factor), 0, j); glEnd(); } glPopMatrix(); }
Vector4D Barycentric(const Vector4D &a, const Vector4D &b, const Vector4D &c, Float t1, Float t2) { return Vector4D(Math::Barycentric(a.mX, b.mX, c.mX, t1, t2), Math::Barycentric(a.mY, b.mY, c.mY, t1, t2), Math::Barycentric(a.mZ, b.mZ, c.mZ, t1, t2), Math::Barycentric(a.mW, b.mW, c.mW, t1, t2)); }
Vector4D GlslProgram :: getAttribute ( int index ) { float buf [4]; glGetVertexAttribfvARB ( index, GL_CURRENT_VERTEX_ATTRIB_ARB, buf ); return Vector4D ( buf [0], buf [1], buf [2], buf [3] ); }
Vector4D Decelerate(const Vector4D &a, const Vector4D &b, Float t) { return Vector4D(Math::Decelerate(a.mX, b.mX, t), Math::Decelerate(a.mY, b.mY, t), Math::Decelerate(a.mZ, b.mZ, t), Math::Decelerate(a.mW, b.mW, t)); }
Vector4D Clamp(const Vector4D &value, const Vector4D &min, const Vector4D &max) { return Vector4D(Math::WrapFloat(value.mX, min.mX, max.mX), Math::WrapFloat(value.mY, min.mY, max.mY), Math::WrapFloat(value.mZ, min.mZ, max.mZ), Math::WrapFloat(value.mW, min.mW, max.mW)); }
Vector4D SmoothStep(const Vector4D &a, const Vector4D &b, Float t) { return Vector4D(Math::SmoothStep(a.mX, b.mX, t), Math::SmoothStep(a.mY, b.mY, t), Math::SmoothStep(a.mZ, b.mZ, t), Math::SmoothStep(a.mW, b.mW, t)); }
Vector4D ShaderManager :: GetUniformVector ( int location ) { float values [SIZE4D]; glGetUniformfv ( Program, location, values ); return Vector4D ( values ); }
Vector4D ShaderManager :: GetAttributeVector ( int location ) { float values [SIZE4D]; glGetVertexAttribfv ( location, GL_CURRENT_VERTEX_ATTRIB, values ); return Vector4D ( values ); }
Vector4D Transformation::Transform(const Vector4D& V) { return Vector4D( curr[0][0]*V[0] + curr[0][1]*V[1] + curr[0][2]*V[2] + curr[0][3]*V[3], curr[1][0]*V[0] + curr[1][1]*V[1] + curr[1][2]*V[2] + curr[1][3]*V[3], curr[2][0]*V[0] + curr[2][1]*V[1] + curr[2][2]*V[2] + curr[2][3]*V[3], curr[3][0]*V[0] + curr[3][1]*V[1] + curr[3][2]*V[2] + curr[3][3]*V[3] ); }
Vector4D Transformation::InverseTransform(Vector4D& V) { return Vector4D( inv[0][0]*V[0] + inv[0][1]*V[1] + inv[0][2]*V[2] + inv[0][3]*V[3], inv[1][0]*V[0] + inv[1][1]*V[1] + inv[1][2]*V[2] + inv[1][3]*V[3], inv[2][0]*V[0] + inv[2][1]*V[1] + inv[2][2]*V[2] + inv[2][3]*V[3], inv[3][0]*V[0] + inv[3][1]*V[1] + inv[3][2]*V[2] + inv[3][3]*V[3] ); }
// constructor fara parametri, mosteneste constructorul de Sfera din Object3D // deoarece dorim ca lumina sa fie ilustrata printr-o sfera Light::Light() : Object3D(GlutSphere) { // valori default diffuse = Vector4D(4,4,4,1); ambient = Vector4D(0,0,0,0); specular = Vector4D(1,1,1,1); color = Vector3D(1,1,1); scale = Vector3D(0.2,0.2,0.2); // id-ul este unic, id-ul de baza incrementat id = baseId++; // sfera plasata in locul luminii nu este wireframe Wireframe = false; // default lumina este omnidirectionala LightType = IlluminationType::Ideal; }