Ejemplo n.º 1
0
SimpleSphereGeometry::SimpleSphereGeometry(const ghoul::Dictionary& dictionary)
    : PlanetGeometry()
    , _realRadius("radius", "Radius", glm::vec4(1.f, 1.f, 1.f, 0.f), glm::vec4(-10.f, -10.f, -10.f, -20.f),
                glm::vec4(10.f, 10.f, 10.f, 20.f))
    , _segments("segments", "Segments", 20, 1, 5000)
    , _sphere(nullptr)
{
    using constants::simplespheregeometry::keyRadius;
    using constants::simplespheregeometry::keySegments;

    // The name is passed down from the SceneGraphNode
    bool success = dictionary.getValue(SceneGraphNode::KeyName, _name);
    assert(success);
    
    glm::vec4 radius;
    success = dictionary.getValue(keyRadius, _modRadius);
    if (!success) {
        LERROR("SimpleSphereGeometry of '" << _name << "' did not provide a key '"
                                           << keyRadius << "'");
    }
    else {
        radius[0] = _modRadius[0];
        radius[1] = _modRadius[0];
        radius[2] = _modRadius[0];
        radius[3] = _modRadius[1];
        _realRadius = radius; // In case the kernels does not supply a real
    }

    double segments;
    success = dictionary.getValue(keySegments, segments);
    if (!success) {
        LERROR("SimpleSphereGeometry of '" << _name << "' did not provide a key '"
                                           << keySegments << "'");
    }
    else
        _segments = static_cast<int>(segments);
    // The shader need the radii values but they are not changeable runtime
    // TODO: Possibly add a scaling property @AA
    addProperty(_realRadius);
    // Changing the radius/scaling should affect the shader but not the geometry? @AA
    //_radius.onChange(std::bind(&SimpleSphereGeometry::createSphere, this));
    addProperty(_segments);
    _segments.onChange(std::bind(&SimpleSphereGeometry::createSphere, this));
}
Ejemplo n.º 2
0
StaticRotation::StaticRotation(const ghoul::Dictionary& dictionary)
    : _rotationMatrix(1.0)
{
    const bool hasEulerAngles = dictionary.hasKeyAndValue<glm::dvec3>(KeyEulerAngles);
    if (hasEulerAngles) {
        glm::dvec3 tmp;
        dictionary.getValue(KeyEulerAngles, tmp);
        _rotationMatrix = glm::mat3_cast(glm::dquat(tmp));
    }
}
Ejemplo n.º 3
0
DynamicEphemeris::DynamicEphemeris(const ghoul::Dictionary& dictionary)
    : _position(0.f, 0.f, 0.f, 0.f)
{
    const bool hasPosition = dictionary.hasKeyAndValue<glm::vec4>(KeyPosition);
    if (hasPosition) {
        glm::vec4 tmp;
        dictionary.getValue(KeyPosition, tmp);
        _position = tmp;
    }
}
Ejemplo n.º 4
0
    SizeReferenceTileProvider::SizeReferenceTileProvider(const ghoul::Dictionary& dictionary) {
        _fontSize = 50;
        ghoul::fontrendering::FontManager& fm = OsEng.fontManager();
        _font = fm.font("Mono", _fontSize);

        glm::dvec3 radii(1,1,1);
        if (!dictionary.getValue(KeyRadii, radii)) {
            throw std::runtime_error("Must define key '" + KeyRadii + "'");
        }
        _ellipsoid = Ellipsoid(radii);

        _backgroundTile.status = Tile::Status::Unavailable;
        std::string backgroundImagePath;
        if (dictionary.getValue(KeyBackgroundImagePath, backgroundImagePath)) {
            using namespace ghoul::io;
            std::string imgAbsPath = absPath(backgroundImagePath);
            _backgroundTile.texture = TextureReader::ref().loadTexture(imgAbsPath);
            _backgroundTile.texture->uploadTexture();
            _backgroundTile.texture->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
            _backgroundTile.status = Tile::Status::OK;
        }

    }
Ejemplo n.º 5
0
ScriptScheduler::ScheduledScript::ScheduledScript(const ghoul::Dictionary& dictionary)
    : time(-std::numeric_limits<double>::max())
{
    std::string timeStr = dictionary.value<std::string>(KeyTime);
    time = Time::ref().convertTime(timeStr);
    
    // If a universal script is specified, retrieve it and add a ; as a separator so that
    // it can be added to the other scripts
    std::string universal;
    dictionary.getValue(KeyUniversalScript, universal);
    if (!universal.empty()) {
        universal += ";";
    }
    
    if (dictionary.hasKeyAndValue<std::string>(KeyForwardScript)) {
        forwardScript =
            universal + dictionary.value<std::string>(KeyForwardScript);
    }
    
    if (dictionary.hasKeyAndValue<std::string>(KeyBackwardScript)) {
        backwardScript =
            universal + dictionary.value<std::string>(KeyBackwardScript);
    }
}
Ejemplo n.º 6
0
    RenderableGalaxy::RenderableGalaxy(const ghoul::Dictionary& dictionary)
    : Renderable(dictionary)
    , _stepSize("stepSize", "Step Size", 0.012, 0.0005, 0.05)
    , _pointStepSize("pointStepSize", "Point Step Size", 0.01, 0.01, 0.1)
    , _translation("translation", "Translation", glm::vec3(0.0, 0.0, 0.0), glm::vec3(0.0), glm::vec3(10.0))
    , _rotation("rotation", "Euler rotation", glm::vec3(0.0, 0.0, 0.0), glm::vec3(0), glm::vec3(6.28))
    , _enabledPointsRatio("nEnabledPointsRatio", "Enabled points", 0.2, 0, 1) {

    float stepSize;
    glm::vec3 scaling, translation, rotation;
    glm::vec4 color;
    ghoul::Dictionary volumeDictionary, pointsDictionary;

    if (dictionary.getValue("Translation", translation)) {
        _translation = translation;
    }
    if (dictionary.getValue("Rotation", rotation)) {
        _rotation = rotation;
    }
    if (dictionary.getValue("StepSize", stepSize)) {
        _stepSize = stepSize;
    }
    if (dictionary.getValue("Volume", volumeDictionary)) {
        std::string volumeFilename;
        if (volumeDictionary.getValue("Filename", volumeFilename)) {
            _volumeFilename = absPath(volumeFilename);
        } else {
            LERROR("No volume filename specified.");
        }
        glm::vec3 volumeDimensions;
        if (volumeDictionary.getValue("Dimensions", volumeDimensions)) {
            _volumeDimensions = static_cast<glm::ivec3>(volumeDimensions);
        } else {
            LERROR("No volume dimensions specified.");
        }
        glm::vec3 volumeSize;
        if (volumeDictionary.getValue("Size", volumeSize)) {
            _volumeSize = static_cast<glm::vec3>(volumeSize);
        }
        else {
            LERROR("No volume dimensions specified.");
        }

    } else {
        LERROR("No volume dictionary specified.");
    }
    if (dictionary.getValue("Points", pointsDictionary)) {
        std::string pointsFilename;
        if (pointsDictionary.getValue("Filename", pointsFilename)) {
            _pointsFilename = absPath(pointsFilename);
        } else {
            LERROR("No points filename specified.");
        }
        glm::vec3 pointsScaling;
        if (pointsDictionary.getValue("Scaling", pointsScaling)) {
            _pointScaling = static_cast<glm::vec3>(pointsScaling);
        }
        else {
            LERROR("No volume dimensions specified.");
        }
    } else {
        LERROR("No points dictionary specified.");
    }

}
Ejemplo n.º 7
0
RenderableDebugPlane::RenderableDebugPlane(const ghoul::Dictionary& dictionary)
    : Renderable(dictionary)
    , _texture("texture", "Texture", -1, -1, 255)
    , _billboard("billboard", "Billboard", false)
    , _size("size", "Size", glm::vec2(1,1), glm::vec2(0.f), glm::vec2(1.f, 25.f))
    , _origin(Origin::Center)
    , _shader(nullptr)
    , _quad(0)
    , _vertexPositionBuffer(0)
{
    glm::vec2 size;
    dictionary.getValue("Size", size);
    _size = size;

    if (dictionary.hasKey("Name")){
        dictionary.getValue("Name", _nodeName);
    }

    if (dictionary.hasKey("Texture")) {
        int t;
        dictionary.getValue("Texture", t);
        _texture = t;
    }

    std::string origin;
    if (dictionary.getValue("Origin", origin)) {
        if (origin == "LowerLeft") {
            _origin = Origin::LowerLeft;
        }
        else if (origin == "LowerRight") {
            _origin = Origin::LowerRight;
        }
        else if (origin == "UpperLeft") {
            _origin = Origin::UpperLeft;
        }
        else if (origin == "UpperRight") {
            _origin = Origin::UpperRight;
        }
        else if (origin == "Center") {
            _origin = Origin::Center;
        }
    }

    // Attempt to get the billboard value
    bool billboard = false;
    if (dictionary.getValue("Billboard", billboard)) {
        _billboard = billboard;
    }

    int texture;
    if (dictionary.getValue("Texture", texture))
        _texture = texture;
    addProperty(_texture);

    addProperty(_billboard);

    addProperty(_size);
    _size.onChange([this](){ _planeIsDirty = true; });

    setBoundingSphere(_size.value());
}
Ejemplo n.º 8
0
RenderableTrailNew::RenderableTrailNew(const ghoul::Dictionary& dictionary)
    : Renderable(dictionary)
    // Properties
    , _lineColor("lineColor", "Line Color", DEFAULT_COLOR, glm::vec3(0), glm::vec3(1))
    , _pointColor("pointColor", "Point Color", DEFAULT_COLOR, glm::vec3(0), glm::vec3(1))
    , _lineFade("lineFade", "Line Fade", DEFAULT_LINE_FADE, 0, 1)
    , _lineWidth("lineWidth", "Line Width", DEFAULT_LINE_WIDTH, 1, 10)
    , _renderPart("renderPart", "Render Part", DEFAULT_RENDER_PART, 0, DEFAULT_RENDER_PART)
    , _showTimeStamps("showTimeStamps", "Show TimeStamps", DEFAULT_SHOW_TIME_STAMPS)
    , _renderFullTrail("renderFullTrail", "Render Full Trail", DEFAULT_RENDER_FULL_TRAIL)
    // OpenGL
    , _vaoGlobalID(0)
    , _vBufferGlobalID(0)
    , _vaoLocalID(0)
    , _vBufferLocalID(0)
    // Other
    , _programObject(nullptr)
    , _successfullDictionaryFetch(true)
    , _currentTimeClamped(0)
    , _subSamples(0)
{
    ghoul::Dictionary timeRangeDict;

    // Values that needs to be set
    _successfullDictionaryFetch &= dictionary.getValue(keyBody, _body);
    _successfullDictionaryFetch &= dictionary.getValue(keyObserver, _observer);
    _successfullDictionaryFetch &= dictionary.getValue(keyFrame, _frame);
    _successfullDictionaryFetch &= dictionary.getValue(keySampleDeltaTime, _sampleDeltaTime);
    _successfullDictionaryFetch &= dictionary.getValue(keyTimeRange, timeRangeDict);
    _successfullDictionaryFetch &= TimeRange::initializeFromDictionary(
        timeRangeDict, _timeRange);

    // Validate
    _successfullDictionaryFetch &= _sampleDeltaTime > 0;

    // Initialize optional values
    glm::vec3 lineColor = glm::vec3(DEFAULT_COLOR);
    glm::vec3 pointColor = glm::vec3(DEFAULT_COLOR);
    float lineFade = DEFAULT_LINE_FADE;
    float lineWidth = DEFAULT_LINE_WIDTH;
    float pointSteps = DEFAULT_POINT_STEPS;
    double renderPart = DEFAULT_RENDER_PART;
    bool showTimeStamps = DEFAULT_SHOW_TIME_STAMPS;
    bool renderFullTrail = DEFAULT_RENDER_FULL_TRAIL;

    // Fetch from dictionary
    dictionary.getValue(keyLineColor, lineColor);
    dictionary.getValue(keyPointColor, pointColor);
    dictionary.getValue(keyLineFade, lineFade);
    dictionary.getValue(keyLineWidth, lineWidth);
    dictionary.getValue(keyRenderPart, renderPart);
    dictionary.getValue(keyShowTimeStamps, showTimeStamps);
    dictionary.getValue(keyRenderFullTrail, renderFullTrail);
    float fSubSamples; // ghoul can not read ints from dictionaries...
    if (dictionary.getValue(keySubSamples, fSubSamples))
        _subSamples = fSubSamples;

    // Set property values
    _lineColor = lineColor;
    _pointColor = pointColor;
    _lineFade = lineFade;
    _lineWidth = lineWidth;
    _renderPart = renderPart;
    _showTimeStamps = showTimeStamps;
    _renderFullTrail = renderFullTrail;

    // Add all properties and set view options
    addProperty(_lineColor);
    addProperty(_pointColor);
    addProperty(_lineFade);
    addProperty(_lineWidth);
    addProperty(_renderPart);
    addProperty(_showTimeStamps);
    addProperty(_renderFullTrail);

    _lineColor.setViewOption(properties::Property::ViewOptions::Color);
    _pointColor.setViewOption(properties::Property::ViewOptions::Color);
}
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;
        }
    }
}