PowerScaledScalar & PowerScaledScalar::operator*=(const float &rhs) { double ds = this->_data[1]; if(ds >= 0) { *this = PowerScaledScalar( static_cast<float>(rhs*pow(k, -ds) * this->_data[0]), this->_data[1] + this->_data[1]); } else { *this = PowerScaledScalar( static_cast<float>(rhs * this->_data[0] * pow(k, ds)), 0.0f); } return *this; }
PowerScaledScalar & PowerScaledScalar::operator+=(const PowerScaledScalar &rhs) { double ds = this->_data[1] - rhs._data[1]; if(ds >= 0.0) { *this = PowerScaledScalar( static_cast<float>(rhs._data[0] * pow(k, -ds) + this->_data[0]), this->_data[1]); } else { *this = PowerScaledScalar( static_cast<float>(rhs._data[0] + this->_data[0] * pow(k, ds)), rhs._data[1]); } return *this; }
PowerScaledScalar PowerScaledScalar::CreatePSS(double d1) { char buff[30]; // find the number with maximum number of digits double ad1 = std::abs(d1); // find out how many digits #ifdef _MSC_VER sprintf_s(buff, 30, "%.0f", ad1); #else sprintf(buff, "%.0f", ad1); #endif size_t digits = strlen(buff)-1; // rescale and return double tp = 1.0 / pow(k, digits); return PowerScaledScalar(static_cast<float>(d1*tp), static_cast<float>(digits)); }
bool ModelGeometry::initialize(Renderable* parent) { _parent = parent; float maximumDistanceSquared = 0; for (auto v: _vertices) { maximumDistanceSquared = glm::max( glm::pow(v.location[0], 2.f) + glm::pow(v.location[1], 2.f) + glm::pow(v.location[2], 2.f), maximumDistanceSquared); } _parent->setBoundingSphere(PowerScaledScalar(glm::sqrt(maximumDistanceSquared), 0.0)); if (_vertices.empty()) return false; glGenVertexArrays(1, &_vaoID); glGenBuffers(1, &_vbo); glGenBuffers(1, &_ibo); glBindVertexArray(_vaoID); glBindBuffer(GL_ARRAY_BUFFER, _vbo); glBufferData(GL_ARRAY_BUFFER, _vertices.size() * sizeof(Vertex), _vertices.data(), GL_STATIC_DRAW); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const GLvoid*>(offsetof(Vertex, location))); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const GLvoid*>(offsetof(Vertex, tex))); glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const GLvoid*>(offsetof(Vertex, normal))); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ibo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, _indices.size() * sizeof(int), _indices.data(), GL_STATIC_DRAW); glBindVertexArray(0); return true; }
bool SceneGraphNode::deinitialize() { LDEBUG("Deinitialize: " << name()); if (_renderable) { _renderable->deinitialize(); delete _renderable; _renderable = nullptr; } if (_ephemeris) { delete _ephemeris; _ephemeris = nullptr; } if (_rotation) { delete _rotation; _rotation = nullptr; } if (_scale) { delete _scale; _scale = nullptr; } //delete _ephemeris; //_ephemeris = nullptr; // for (SceneGraphNode* child : _children) { // child->deinitialize(); // delete child; //} _children.clear(); // reset variables _parent = nullptr; _renderableVisible = false; _boundingSphereVisible = false; _boundingSphere = PowerScaledScalar(0.0, 0.0); return true; }
const PowerScaledScalar PowerScaledScalar::operator*(const float &rhs) const { return PowerScaledScalar(*this) *= rhs; }
const PowerScaledScalar PowerScaledScalar::operator-(const PowerScaledScalar &rhs) const { return PowerScaledScalar(*this) -= rhs; }
PowerScaledScalar PowerScaledCoordinate::length() const { return PowerScaledScalar(glm::length(glm::vec3(_vec[0], _vec[1], _vec[2])), _vec[3]); }
namespace openspace { // needs to be set from dictionary - REMEMBER const PowerScaledScalar radius = PowerScaledScalar(1.f, 20.f); RenderableSphericalGrid::RenderableSphericalGrid(const ghoul::Dictionary& dictionary) : Renderable(dictionary) , _gridProgram(nullptr) , _vaoID(0) , _vBufferID(0) , _iBufferID(0) , _mode(GL_LINES) { _gridMatrix = glm::mat4(1); dictionary.getValue(KeyGridType, _gridType); dictionary.getValue(KeyGridColor, _gridColor); staticGrid = dictionary.getValue(KeyGridMatrix, _gridMatrix); if (!staticGrid){ staticGrid = dictionary.getValue(KeyGridParentsRotation, _parentsRotation); } dictionary.getValue(KeyGridSegments, _segments); /*glm::vec2 radius; dictionary.getValue(constants::renderablesphericalgrid::gridRadius, radius); */ _isize = int(6 * _segments * _segments); _vsize = int((_segments + 1) * (_segments + 1)); _varray = new Vertex[_vsize]; _iarray = new int[_isize]; static_assert(sizeof(Vertex) == 64, "The size of the Vertex needs to be 64 for performance"); int nr = 0; const float fsegments = static_cast<float>(_segments); const float r = static_cast<float>(radius[0]); //int nr2 = 0; for (int i = 0; i <= _segments; i++) { // define an extra vertex around the y-axis due to texture mapping for (int j = 0; j <= _segments; j++) { const float fi = static_cast<float>(i); const float fj = static_cast<float>(j); // inclination angle (north to south) const float theta = fi * float(M_PI) / fsegments*2.f; // 0 -> PI // azimuth angle (east to west) const float phi = fj * float(M_PI) * 2.0f / fsegments; // 0 -> 2*PI const float x = r * sin(phi) * sin(theta); // const float y = r * cos(theta); // up const float z = r * cos(phi) * sin(theta); // glm::vec3 normal = glm::vec3(x, y, z); if (!(x == 0.f && y == 0.f && z == 0.f)) normal = glm::normalize(normal); //const float t1 = fj / fsegments; const float t2 = fi / fsegments; // tex coord. not used, use to manip color if (round(y) == 0.0f) _varray[nr].tex[0] = -2; _varray[nr].tex[1] = t2; glm::vec4 tmp(x, y, z, 1); glm::mat4 rot = glm::rotate(glm::mat4(1), static_cast<float>(M_PI_2), glm::vec3(1, 0, 0)); tmp = _gridMatrix*rot*tmp; for (int i = 0; i < 3; i++){ _varray[nr].location[i] = tmp[i]; _varray[nr].normal[i] = normal[i]; } _varray[nr].location[3] = static_cast<GLfloat>(radius[1]); ++nr; } } nr = 0; // define indices for all triangles for (int i = 1; i <= _segments; ++i) { for (int j = 0; j < _segments; ++j) { const int t = _segments + 1; _iarray[nr] = t * (i - 1) + j + 0; ++nr; _iarray[nr] = t * (i + 0) + j + 0; ++nr; _iarray[nr] = t * (i + 0) + j + 1; ++nr; _iarray[nr] = t * (i - 1) + j + 1; ++nr; _iarray[nr] = t * (i - 1) + j + 0; ++nr; } } } RenderableSphericalGrid::~RenderableSphericalGrid(){ deinitialize(); // Delete not done in deinitialize because new is done in constructor delete[] _varray; delete[] _iarray; } bool RenderableSphericalGrid::isReady() const { bool ready = true; ready &= (_gridProgram != nullptr); return ready; } bool RenderableSphericalGrid::deinitialize(){ glDeleteVertexArrays(1,&_vaoID); _vaoID = 0; glDeleteBuffers(1,&_vBufferID); _vBufferID = 0; glDeleteBuffers(1,&_iBufferID); _iBufferID = 0; return true; } bool RenderableSphericalGrid::initialize(){ bool completeSuccess = true; if (_gridProgram == nullptr) completeSuccess &= OsEng.ref().configurationManager().getValue("GridProgram", _gridProgram); // Initialize and upload to graphics card glGenVertexArrays(1, &_vaoID); glGenBuffers(1, &_vBufferID); glGenBuffers(1, &_iBufferID); // First VAO setup glBindVertexArray(_vaoID); glBindBuffer(GL_ARRAY_BUFFER, _vBufferID); glBufferData(GL_ARRAY_BUFFER, _vsize * sizeof(Vertex), _varray, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const GLvoid*>(offsetof(Vertex, location))); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const GLvoid*>(offsetof(Vertex, tex))); glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const GLvoid*>(offsetof(Vertex, normal))); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _iBufferID); glBufferData(GL_ELEMENT_ARRAY_BUFFER, _isize * sizeof(int), _iarray, GL_STATIC_DRAW); glBindVertexArray(0); return completeSuccess; } void RenderableSphericalGrid::render(const RenderData& data){ _gridProgram->activate(); glm::mat4 transform; for (int i = 0; i < 3; i++){ for (int j = 0; j < 3; j++){ transform[i][j] = static_cast<float>(_parentMatrix[i][j]); } } using IgnoreError = ghoul::opengl::ProgramObject::IgnoreError; // setup the data to the shader _gridProgram->setIgnoreUniformLocationError(IgnoreError::Yes); _gridProgram->setUniform("ViewProjection", data.camera.viewProjectionMatrix()); _gridProgram->setUniform("ModelTransform", transform); setPscUniforms(*_gridProgram, data.camera, data.position); _gridProgram->setUniform("gridColor", _gridColor); glLineWidth(0.5f); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glEnable(GL_LINE_SMOOTH); glBindVertexArray(_vaoID); // select first VAO glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _iBufferID); glDrawElements(_mode, _isize, GL_UNSIGNED_INT, 0); glBindVertexArray(0); _gridProgram->deactivate(); } void RenderableSphericalGrid::update(const UpdateData& data) { _parentMatrix = SpiceManager::ref().positionTransformMatrix("IAU_JUPITER", "GALACTIC", data.time); } }