Esempio n. 1
0
void KisColorSelector::mousePressEvent(QMouseEvent* event)
{
    m_clickPos       = mapCoord(event->posF(), m_renderArea);
    m_mouseMoved     = false;
    m_pressedButtons = event->buttons();
    m_clickedRing    = getSaturationIndex(m_clickPos);
    
    qint8 clickedLightPiece = getLightIndex(event->posF());
    
    if (clickedLightPiece >= 0) {
        setLight(getLight(event->posF()), m_relativeLight);
        m_selectedLightPiece = clickedLightPiece;
        setSelectedColor(m_selectedColor, !(m_pressedButtons & Qt::RightButton), true);
        m_mouseMoved   = true;
    }
    else if (m_clickedRing >= 0) {
        if (getNumPieces() > 1) {
            for(int i=0; i<getNumRings(); ++i)
                m_colorRings[i].setTemporaries(m_selectedColor);
        }
        else {
            Radian angle = std::atan2(m_clickPos.x(), m_clickPos.y()) - RAD_90;
            m_selectedColor.setH(angle.scaled(0.0f, 1.0f));
            m_selectedColor.setS(getSaturation(m_clickedRing));
            m_selectedColor.setX(getLight(m_light, m_selectedColor.getH(), m_relativeLight));
            setSelectedColor(m_selectedColor, !(m_pressedButtons & Qt::RightButton), true);
            m_selectedRing = m_clickedRing;
            m_mouseMoved   = true;
            update();
        }
    }
}
void TerrainWrapper::Enable()
{




	Controller * ctrl = static_cast<Controller*>(GetManager()->Get("Controller"));
	DataManager * dm = static_cast<DataManager*>(GetManager()->Get("DataManager"));



	Techniques * tech = static_cast<Techniques*>(dm->Get("Techniques"));
	ResourceLoader * res = static_cast<ResourceLoader*>(dm->Get("Resources"));
	Environment * env = static_cast<Environment*>(res->Get("Environment"));
	Camera * camera = static_cast<Camera*>(ctrl->Get("Camera"));
	View * view = camera->GetView();
	ViewInfo * info = camera->GetInfo();



	Shader::Enable();
	Shader::Set("myTextureSampler", 0);
	Shader::Set("myTextureSampler2", 1);
	Shader::Set("myTextureSampler3", 2);
	Shader::Set("shadow_map", 3);
	TerrainShader::SendTextureAttributes(terra->GetTextureAttributes(), 4);


	/**
	Raising to power for gamma correction
	*/
	getLight()->SetFog(glm::pow(env->fog_color, glm::vec3(2.2)), env->fog_density);
	getLight()->SetDirectionalLight(env->terrain_bright*
		glm::pow(env->sun_color, glm::vec3(2.2)),
		env->sun_dir,
		env->terrain_ambient,
		env->terrain_diffuse);





	Set("LightMatrix", Math::GetBiasMatrix()*
		tech->GetShadow()->GetDirectionalShadow(env, info, view));



	tech->GetShadow()->GetShadowMap()->BindTexture(0, GL_TEXTURE3);
	tech->GetShadow()->GetShadowMap()->ResetTextureState();




	ManagePlayerCollision(ctrl, false);



}
Esempio n. 3
0
void KisColorSelector::drawRing(QPainter& painter, KisColorSelector::ColorRing& ring, const QRect& rect)
{
    painter.setRenderHint(QPainter::Antialiasing, false);
    painter.resetTransform();
    painter.translate(rect.width()/2, rect.height()/2);
    
    if (ring.pieced.size() > 1) {
        painter.rotate(-ring.getShift().degrees());
        painter.scale(rect.width()/2, rect.height()/2);
        painter.setPen(Qt::NoPen);
        
        QBrush brush(Qt::SolidPattern);
        
        for(int i=0; i<ring.pieced.size(); ++i) {
            float hue = float(i) / float(ring.pieced.size()) + ring.getShift().scaled(0.0f, 1.0f);
            hue = (hue >= 1.0f) ? (hue - 1.0f) : hue;
            hue = (hue <  0.0f) ? (hue + 1.0f) : hue;
            
            KisColor color(hue, 1.0f, m_colorSpace);
            color.setS(ring.saturation);
            color.setX(getLight(m_light, hue, m_relativeLight));
            
            brush.setColor(color.getQColor());
            painter.fillPath(ring.pieced[i], brush);
        }
    }
    else {
        KisColor colors[7] = {
            KisColor(Qt::red    , m_colorSpace),
            KisColor(Qt::yellow , m_colorSpace),
            KisColor(Qt::green  , m_colorSpace),
            KisColor(Qt::cyan   , m_colorSpace),
            KisColor(Qt::blue   , m_colorSpace),
            KisColor(Qt::magenta, m_colorSpace),
            KisColor(Qt::red    , m_colorSpace)
        };
        
        QConicalGradient gradient(0, 0, 0);
        
        for(int i=0; i<=6; ++i) {
            qreal hue = float(i) / 6.0f;
            colors[i].setS(ring.saturation);
            colors[i].setX(getLight(m_light, hue, m_relativeLight));
            gradient.setColorAt(hue, colors[i].getQColor());
        }
        
        painter.scale(rect.width()/2, rect.height()/2);
        painter.fillPath(ring.pieced[0], QBrush(gradient));
    }
    
    painter.resetTransform();
}
Esempio n. 4
0
void KisColorSelector::mouseMoveEvent(QMouseEvent* event)
{
    QPointF dragPos           = mapCoord(event->posF(), m_renderArea);
    qint8   clickedLightPiece = getLightIndex(event->posF());
    
    if (clickedLightPiece >= 0) {
        setLight(getLight(event->posF()), m_relativeLight);
        m_selectedLightPiece = clickedLightPiece;
        setSelectedColor(m_selectedColor, m_selectedColorIsFgColor, true);
    }
    
    if (m_clickedRing < 0)
        return;
    
    if (getNumPieces() > 1) {
        float angle     = std::atan2(dragPos.x(), dragPos.y()) - std::atan2(m_clickPos.x(), m_clickPos.y());
        float dist      = std::sqrt(dragPos.x()*dragPos.x() + dragPos.y()*dragPos.y()) * 0.80f;
        float threshold = 5.0f * (1.0f-(dist*dist));
        
        if (qAbs(angle * TO_DEG) >= threshold || m_mouseMoved) {
            bool selectedRingMoved = true;
            
            if (m_pressedButtons & Qt::RightButton) {
                selectedRingMoved                 = m_clickedRing == m_selectedRing;
                m_colorRings[m_clickedRing].angle = m_colorRings[m_clickedRing].tmpAngle + angle;
            }
            else for(int i=0; i<getNumRings(); ++i)
                m_colorRings[i].angle = m_colorRings[i].tmpAngle + angle;
            
            if (selectedRingMoved) {
                KisColor color = m_colorRings[m_clickedRing].tmpColor;
                Radian   angle = m_colorRings[m_clickedRing].getMovedAngel() + (color.getH()*PI2);
                color.setH(angle.scaled(0.0f, 1.0f));
                color.setX(getLight(m_light, color.getH(), m_relativeLight));
                
                m_selectedPiece = getHueIndex(angle, m_colorRings[m_clickedRing].getShift());
                setSelectedColor(color, m_selectedColorIsFgColor, true);
            }
            
            m_mouseMoved = true;
        }
    }
    else {
        Radian angle = std::atan2(dragPos.x(), dragPos.y()) - RAD_90;
        m_selectedColor.setH(angle.scaled(0.0f, 1.0f));
        m_selectedColor.setX(getLight(m_light, m_selectedColor.getH(), m_relativeLight));
        setSelectedColor(m_selectedColor, m_selectedColorIsFgColor, true);
    }
    
    update();
}
Esempio n. 5
0
void ossimPlanetViewer::addEphemeris(ossim_uint32 memberBitMask)
{
   if(!theEphemerisLayer.valid())
   {
      if(getLight())
      {
         theSavedLight = (osg::Light*)getLight()->clone(osg::CopyOp::DEEP_COPY_ALL);
      }
      ossimPlanet* tempPlanet = new ossimPlanet;
      tempPlanet->setComputeIntersectionFlag(false);
      theEphemerisRoot = tempPlanet;
      theEphemerisLayer = new ossimPlanetEphemeris();
      theEphemerisLayer->setRoot(theRootNode.get());
      theEphemerisLayer->setMembers(memberBitMask);
//      planet()->addChild(theEphemerisLayer.get());
      tempPlanet->addChild(theEphemerisLayer.get());
      theRootNode->addChild(tempPlanet);
      theEphemerisCamera = new osg::Camera;
      theEphemerisCamera->setProjectionResizePolicy(getCamera()->getProjectionResizePolicy());
      theEphemerisCamera->setClearColor(getCamera()->getClearColor());
      theEphemerisCamera->setRenderOrder(osg::Camera::PRE_RENDER);
      theEphemerisCamera->setRenderTargetImplementation( getCamera()->getRenderTargetImplementation() );
      //      theEphemerisCamera->setClearMask(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
      //      getCamera()->setClearMask(getCamera()->getClearMask() & ~GL_COLOR_BUFFER_BIT & ~GL_DEPTH_BUFFER_BIT);
      theEphemerisCamera->setClearMask(GL_COLOR_BUFFER_BIT);
      getCamera()->setClearMask(getCamera()->getClearMask() & ~GL_COLOR_BUFFER_BIT);
      if(getCamera()->getViewport())
      {
         theEphemerisCamera->setViewport(new osg::Viewport(*getCamera()->getViewport()));
      }
      else
      {
         theEphemerisCamera->setViewport(new osg::Viewport());
      }
      addSlave(theEphemerisCamera.get(), false);
      theEphemerisLayer->setCamera(theEphemerisCamera.get());
      theEphemerisCamera->setEventCallback(new ossimPlanetTraverseCallback());
      theEphemerisCamera->setUpdateCallback(new ossimPlanetTraverseCallback());
      theEphemerisCamera->setCullCallback(new ossimPlanetTraverseCallback());
      //theEphemerisCamera->addChild(theRootNode.get());
      //getCamera()->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR);
      //theEphemerisCamera->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR);
      //double fov, aspectRatio, near, far;
      //osg::Matrixd& m = getCamera()->getProjectionMatrix();
      //m.getPerspective(fov, aspectRatio, near, far);
      //theEphemerisCamera->setProjectionMatrixAsPerspective(fov, aspectRatio, .2, 5.0);
      //getCamera()->setProjectionMatrixAsPerspective(fov, aspectRatio, .0000001, .2);
   }
}
Esempio n. 6
0
static inline loopSensorMode() {
    while(1) {
        if(twiDataInReceiveBuffer()) {
            uint8_t usiRx = twiReceiveByte();

            if(TWI_GET_CAPACITANCE == usiRx) {
                twiTransmitByte(currCapacitance >> 8);
                twiTransmitByte(currCapacitance &0x00FF);
                currCapacitance = getCapacitance();
            } else if(TWI_SET_ADDRESS == usiRx) {
                uint8_t newAddress = twiReceiveByte();
                if(twiIsValidAddress(newAddress)) {
                    eeprom_write_byte((uint8_t*)0x01, newAddress);
                }

            } else if(TWI_GET_ADDRESS == usiRx) {
                uint8_t newAddress = eeprom_read_byte((uint8_t*) 0x01);
                twiTransmitByte(newAddress);

            } else if(TWI_MEASURE_LIGHT == usiRx) {
                if(!lightMeasurementInProgress()) {
                    getLight();
                }

            } else if(TWI_GET_LIGHT == usiRx) {
                GIMSK &= ~_BV(PCIE0);//disable pin change interrupts
                TCCR1B = 0;          //stop timer
                
                twiTransmitByte(lightCounter >> 8);
                twiTransmitByte(lightCounter & 0x00FF);

                GIMSK |= _BV(PCIE0); 
                TCCR1B = _BV(CS10) | _BV(CS11);                 //start timer1 with prescaler clk/64

            } else if(TWI_GET_TEMPERATURE == usiRx) {
Esempio n. 7
0
void getSensors() {
    int counter1 = 0;
    int counter2 = 0;
    while(true) {
    // Formatted Data  
        acc.getAxis(acc_data);
        mag.getAxis(mag_data);
        printf("ACC: X=%1.4f Y=%1.4f Z=%1.4f\r\n", acc_data.x, acc_data.y, acc_data.z);
        printf("MAG: X=%4.1f Y=%4.1f Z=%4.1f\r\n", mag_data.x, mag_data.y, mag_data.z);
        printf("Light: %f\r\n\n\n", getLight());
        wait(.5);
        if (mag_data.x < 10.0f)
            counter1++;
        printf("Counter = %d\r\n", counter1);
        changeLED(counter2);
        counter2++;
    /*  //raw   
        acc.getAxis(acc_raw);
        mag.getAxis(mag_raw);
        printf("ACC_raw: X=%d Y=%d Z=%d\r\n", acc_raw.x, acc_raw.y, acc_raw.z);
        printf("MAG_raw: X=%d Y=%d Z=%d\r\n", mag_raw.x, mag_raw.y, mag_raw.z);
        wait(5);
    */     
    }       
}
Patch::Patch(const Vertex& a_, const Vertex& b_, const Vertex& c_, const Colour& col, const Plane& p_, float emit_)
    : Triangle(a_, b_, c_, col, p_, emit_), mid(oneThird * (a_ + b_ + c_)),
      area(0.5f * abs(getTrianglePlane().getNormal())),
      sphere(a_,b_,c_)
{
    lastLight = getLight();
}
Esempio n. 9
0
void Scenario::setNew(){
    reset();
    
    
    // ensure the seed is populated before anything else is set
    seed.populate(history);
    
    // set the environment to new seed values
    environment = new Environment(*getSurface(), *getMedium());
    
    // TODO: move mesh into setSurface method for Sprites
    spriteSeed = SpriteSeed(seed, environment->getSurfaceMesh());
    
    // set light to new seed values
    light = getLight();
    
    // set surface first, then set the player to new seed values
    player.setSurface(environment->getSurfaceMesh());
    setPlayer(seed);
    
    sprites.clear();
    setSprites();
//    sound.loadMusic();
//    sound.playMusic();

}
Esempio n. 10
0
void gamehsp::selectLight( int lightid )
{
	if ( lightid >= 0 ) {
		Light *light;
		light = getLight( lightid );
		if ( light == NULL ) return;
	}
	_curlight = lightid;
}
Esempio n. 11
0
 //-----------------------------------------------------------------------------
 Vector4 AutoParamDataSource::getLightAttenuation(size_t index) const
 {
     // range, const, linear, quad
     const Light& l = getLight(index);
     return Vector4(l.getAttenuationRange(),
                    l.getAttenuationConstant(),
                    l.getAttenuationLinear(),
                    l.getAttenuationQuadric());
 }
Esempio n. 12
0
void KisColorSelector::setLight(float light, bool relative)
{
    m_light = qBound(0.0f, light, 1.0f);
    
    m_selectedColor.setX(getLight(m_light, m_selectedColor.getH(), relative));
    m_relativeLight      = relative;
    m_selectedLightPiece = getLightIndex(m_selectedColor.getX());
    update();
}
Esempio n. 13
0
LightStage::Index LightStage::addShadow(Index lightIndex) {
    auto light = getLight(lightIndex);
    Index shadowId = INVALID_INDEX;
    if (light) {
        shadowId = _shadows.newElement(std::make_shared<Shadow>(light));
        _descs[lightIndex].shadowId = shadowId;
    }
    return shadowId;
}
Esempio n. 14
0
    //-----------------------------------------------------------------------------
    const Matrix4& AutoParamDataSource::getSpotlightViewProjMatrix(size_t index) const
    {
        if (index < OGRE_MAX_SIMULTANEOUS_LIGHTS)
        {
            const Light& l = getLight(index);

            if (&l != &mBlankLight && 
                l.getType() == Light::LT_SPOTLIGHT &&
                mSpotlightViewProjMatrixDirty[index])
            {
                Frustum frust;
                SceneNode dummyNode(0);
                dummyNode.attachObject(&frust);

                frust.setProjectionType(PT_PERSPECTIVE);
                frust.setFOVy(l.getSpotlightOuterAngle());
                frust.setAspectRatio(1.0f);
                // set near clip the same as main camera, since they are likely
                // to both reflect the nature of the scene
                frust.setNearClipDistance(mCurrentCamera->getNearClipDistance());
                // Calculate position, which same as spotlight position, in camera-relative coords if required
                dummyNode.setPosition(l.getDerivedPosition(true));
                // Calculate direction, which same as spotlight direction
                Vector3 dir = - l.getDerivedDirection(); // backwards since point down -z
                dir.normalise();
                Vector3 up = Vector3::UNIT_Y;
                // Check it's not coincident with dir
                if (Math::Abs(up.dotProduct(dir)) >= 1.0f)
                {
                    // Use camera up
                    up = Vector3::UNIT_Z;
                }
                // cross twice to rederive, only direction is unaltered
                Vector3 left = dir.crossProduct(up);
                left.normalise();
                up = dir.crossProduct(left);
                up.normalise();
                // Derive quaternion from axes
                Quaternion q;
                q.FromAxes(left, up, dir);
                dummyNode.setOrientation(q);

                // The view matrix here already includes camera-relative changes if necessary
                // since they are built into the frustum position
                mSpotlightViewProjMatrix[index] = 
                    PROJECTIONCLIPSPACE2DTOIMAGESPACE_PERSPECTIVE * 
                    frust.getProjectionMatrixWithRSDepth() * 
                    frust.getViewMatrix();

                mSpotlightViewProjMatrixDirty[index] = false;
            }
            return mSpotlightViewProjMatrix[index];
        }
        else
            return Matrix4::IDENTITY;
    }
Esempio n. 15
0
 //-----------------------------------------------------------------------------
 const ColourValue AutoParamDataSource::getLightSpecularColourWithPower(size_t index) const
 {
     const Light& l = getLight(index);
     ColourValue scaled(l.getSpecularColour());
     Real power = l.getPowerScale();
     // scale, but not alpha
     scaled.r *= power;
     scaled.g *= power;
     scaled.b *= power;
     return scaled;
 }
Esempio n. 16
0
//---------------------------------------------------------------------------
void CLight::add()
{
  // cout << "Adding light" << endl << endl;

  tLight *new_light = new tLight;
  
  initLight (new_light);
  getLight  (new_light);
  linkLight (new_light); // adds light to linked-list of lights

  numLights++;
}
Esempio n. 17
0
void lightArray::tick(float dt)
{

    dt = dt+1;

    lightSource* l1 = getLight(0);
    if(l1!=NULL && (rand() % 10 == 0))
    {
        l1->sourceDiffuse[0] = ((rand() % 40)/100.0)+0.2;
        l1->sourceDiffuse[1] = ((rand() % 40)/100.0)+0.2;
        l1->sourceDiffuse[2] = ((rand() % 40)/100.0)+0.2;
    }

    l1 = getLight(1);
    if(l1!=NULL && (rand() % 10 == 0))
    {
        l1->sourceDiffuse[0] = ((rand() % 40)/100.0)+0.2;
        l1->sourceDiffuse[1] = ((rand() % 40)/100.0)+0.2;
        l1->sourceDiffuse[2] = ((rand() % 40)/100.0)+0.2;
    }

    l1 = getLight(2);
    if(l1!=NULL && (rand() % 10 == 0))
    {
        l1->sourceDiffuse[0] = ((rand() % 40)/100.0)+0.2;
        l1->sourceDiffuse[1] = ((rand() % 40)/100.0)+0.2;
        l1->sourceDiffuse[2] = ((rand() % 40)/100.0)+0.2;
    }

    l1 = getLight(3);
    if(l1!=NULL && (rand() % 10 == 0))
    {
        l1->sourceDiffuse[0] = ((rand() % 40)/100.0)+0.2;
        l1->sourceDiffuse[1] = ((rand() % 40)/100.0)+0.2;
        l1->sourceDiffuse[2] = ((rand() % 40)/100.0)+0.2;
    }
}
Esempio n. 18
0
void Scene::drawLightWall(Shader shader){
    for (int i = 0; i < getLightNumber(); ++i)
    {
        string pointLight = "pointLights[" + to_string(i) + "]";
        Light light = getLight(i);

        glUniform3f(glGetUniformLocation(shader.Program, (pointLight + ".position").c_str()), light.getPosition().x, light.getPosition().y, light.getPosition().z);
        glUniform3f(glGetUniformLocation(shader.Program, (pointLight + ".ambient").c_str()), 0.5f, 0.5f, 0.5f);
        glUniform3f(glGetUniformLocation(shader.Program, (pointLight + ".diffuse").c_str()), 0.5f, 0.5f, 0.5f);
        glUniform3f(glGetUniformLocation(shader.Program, (pointLight + ".specular").c_str()), 1.0f, 1.0f, 1.0f);
        glUniform1f(glGetUniformLocation(shader.Program, (pointLight + ".constant").c_str()), 1.0f);
        glUniform1f(glGetUniformLocation(shader.Program, (pointLight + ".linear").c_str()), 0.09);
        glUniform1f(glGetUniformLocation(shader.Program, (pointLight + ".quadratic").c_str()), 0.032);
    }
}
    bool WindowsManager::setLightingMode (const char* nodeNameCorba,
            const char* lightingModeCorba)
    {
        const std::string nodeName (nodeNameCorba);
        const std::string lightingMode (lightingModeCorba);
        LightingMode light = getLight (lightingMode);
        if (nodes_.find (nodeName) == nodes_.end ()) {
            std::cout << "Node \"" << nodeName << "\" doesn't exist."
                << std::endl;
            return false;
        }
	mtx_.lock();
        nodes_[nodeName]->setLightingMode (light);
	mtx_.unlock();
        return true;
    }
Esempio n. 20
0
 //-----------------------------------------------------------------------------
 Real AutoParamDataSource::getShadowExtrusionDistance(void) const
 {
     const Light& l = getLight(0); // only ever applies to one light at once
     if (l.getType() == Light::LT_DIRECTIONAL)
     {
         // use constant
         return mDirLightExtrusionDistance;
     }
     else
     {
         // Calculate based on object space light distance
         // compared to light attenuation range
         Vector3 objPos = getInverseWorldMatrix().transformAffine(l.getDerivedPosition(true));
         return l.getAttenuationRange() - objPos.length();
     }
 }
Esempio n. 21
0
void ThingType::draw(const Point& dest, float scaleFactor, int layer, int xPattern, int yPattern, int zPattern, int animationPhase, LightView *lightView)
{
    if(m_null)
        return;

    if(animationPhase >= m_animationPhases)
        return;

    const TexturePtr& texture = getTexture(animationPhase); // texture might not exists, neither its rects.
    if(!texture)
        return;

    uint frameIndex = getTextureIndex(layer, xPattern, yPattern, zPattern);
    if(frameIndex >= m_texturesFramesRects[animationPhase].size())
        return;

    Point textureOffset;
    Rect textureRect;

    if(scaleFactor != 1.0f) {
        textureRect = m_texturesFramesOriginRects[animationPhase][frameIndex];
    } else {
        textureOffset = m_texturesFramesOffsets[animationPhase][frameIndex];
        textureRect = m_texturesFramesRects[animationPhase][frameIndex];
    }

    Rect screenRect(dest + (textureOffset - m_displacement - (m_size.toPoint() - Point(1, 1)) * 32) * scaleFactor,
                    textureRect.size() * scaleFactor);

    bool useOpacity = m_opacity < 1.0f;

    if(useOpacity)
        g_painter->setColor(Color(1.0f,1.0f,1.0f,m_opacity));

    g_painter->drawTexturedRect(screenRect, texture, textureRect);

    if(useOpacity)
        g_painter->setColor(Color::white);

    if(lightView && hasLight()) {
        Light light = getLight();
        if(light.intensity > 0)
            lightView->addLightSource(screenRect.center(), scaleFactor, light);
    }
}
Esempio n. 22
0
void SceneNodeWidget::updateSceneNode()
{
    auto target=m_node.lock();
    if(!target){
        return;
    }

    // position
    auto &position=target->position();
    ui->q_x->setValue(position[0]);
    ui->q_y->setValue(position[1]);
    ui->q_z->setValue(position[2]);

    // rotation
    auto &quternion=target->quaternion();


    // mesh
    auto mesh=target->getMesh();
    if(mesh){
        ui->meshWidget->show();
    }
    else{
        ui->meshWidget->hide();
    }

    // camera
    auto camera=target->getCamera();
    if(camera){
        ui->cameraWidget->show();
    }
    else{
        ui->cameraWidget->hide();
    }

    // light
    auto light=target->getLight();
    if(light){
        ui->lightWidget->show();
    }
    else{
        ui->lightWidget->hide();
    }
}
Esempio n. 23
0
    //-----------------------------------------------------------------------------
    const Matrix4& AutoParamDataSource::getSpotlightWorldViewProjMatrix(size_t index) const
    {
        if (index < OGRE_MAX_SIMULTANEOUS_LIGHTS)
        {
            const Light& l = getLight(index);

            if (&l != &mBlankLight && 
                l.getType() == Light::LT_SPOTLIGHT &&
                mSpotlightWorldViewProjMatrixDirty[index])
            {
                mSpotlightWorldViewProjMatrix[index] = 
                    getSpotlightViewProjMatrix(index) * getWorldMatrix();
                mSpotlightWorldViewProjMatrixDirty[index] = false;
            }
            return mSpotlightWorldViewProjMatrix[index];
        }
        else
            return Matrix4::IDENTITY;
    }
Esempio n. 24
0
 //-----------------------------------------------------------------------------
 Vector4 AutoParamDataSource::getSpotlightParams(size_t index) const
 {
     // inner, outer, fallof, isSpot
     const Light& l = getLight(index);
     if (l.getType() == Light::LT_SPOTLIGHT)
     {
         return Vector4(Math::Cos(l.getSpotlightInnerAngle().valueRadians() * 0.5f),
                        Math::Cos(l.getSpotlightOuterAngle().valueRadians() * 0.5f),
                        l.getSpotlightFalloff(),
                        1.0);
     }
     else
     {
         // Use safe values which result in no change to point & dir light calcs
         // The spot factor applied to the usual lighting calc is 
         // pow((dot(spotDir, lightDir) - y) / (x - y), z)
         // Therefore if we set z to 0.0f then the factor will always be 1
         // since pow(anything, 0) == 1
         // However we also need to ensure we don't overflow because of the division
         // therefore set x = 1 and y = 0 so divisor doesn't change scale
         return Vector4(1.0, 0.0, 0.0, 0.0); // since the main op is pow(.., vec4.z), this will result in 1.0
     }
 }
Esempio n. 25
0
void KisColorSelector::mouseReleaseEvent(QMouseEvent* /*event*/)
{
    if (!m_mouseMoved && m_clickedRing >= 0) {
        Radian angle = std::atan2(m_clickPos.x(), m_clickPos.y()) - RAD_90;
        
        m_selectedRing  = m_clickedRing;
        m_selectedPiece = getHueIndex(angle, m_colorRings[m_clickedRing].getShift());
        
        if (getNumPieces() > 1)
            m_selectedColor.setH(getHue(m_selectedPiece, m_colorRings[m_clickedRing].getShift()));
        else
            m_selectedColor.setH(angle.scaled(0.0f, 1.0f));
        
        m_selectedColor.setS(getSaturation(m_selectedRing));
        m_selectedColor.setX(getLight(m_light, m_selectedColor.getH(), m_relativeLight));
        
        setSelectedColor(m_selectedColor, !(m_pressedButtons & Qt::RightButton));
    }
    else if (m_mouseMoved)
        setSelectedColor(m_selectedColor, m_selectedColorIsFgColor);
    
    m_clickedRing = -1;
    update();
}
Esempio n. 26
0
int main(int argc, char** argv)
{
    osg::ArgumentParser arguments( &argc, argv );

    std::string dbPath;
    arguments.read("--db_path", dbPath);

    std::srand ( unsigned ( std::time(0) ) );

    auto board = Board(boardDefinition, boardSizeX, boardSizeY, dbPath);
    auto ghostFactory = GhostFactory();

    auto main_obj = make_ref<osg::Group>();
    main_obj->addChild(board.draw().get());

    auto ghostModel = osgDB::readNodeFile(dbPath + "/cow.osg");
    auto ghostCount = 16;
    while(ghostCount--)
    {
        main_obj->addChild(ghostFactory.drawGhost(board, ghostModel).get());
    }

    // init rotate
    auto init_rotate = make_ref<osg::MatrixTransform>();
    init_rotate->setMatrix( osg::Matrix::rotate(osg::PI * 2, osg::Vec3(1.0f, 0.0f, 0.0f)) );

    // chain rotates
    init_rotate->addChild(main_obj);

    // Root group
    auto root = make_ref<osg::Group>();
    root->addChild(init_rotate);

    // Setup fog
    if(FogEnabled) {
        osg::ref_ptr<osg::Fog> fog = new osg::Fog;
        fog->setMode( osg::Fog::EXP2 );
        fog->setStart( 0.0f );
        fog->setEnd(board.getFieldSizeX() * 20);
        fog->setDensity(0.0135);
        fog->setColor( osg::Vec4(0., 0., 0., 1.0) );

        root->getOrCreateStateSet()->setAttributeAndModes(fog.get());
    }

    // Start viewer
    osgViewer::Viewer viewer;

    // Set up flashlight
    auto lightSource = make_ref<osg::LightSource>();
    lightSource->setReferenceFrame(osg::LightSource::ABSOLUTE_RF);
    auto light = lightSource->getLight();
    const osg::Vec3 lightPosition{1.5, -1, -1}; // right, down, front
    light->setPosition(osg::Vec4{lightPosition, 1});
    light->setDirection(osg::Vec3{0, 0, -1} * 30 - lightPosition);
    light->setSpotExponent(60);
    light->setSpotCutoff(90);
    light->setDiffuse(osg::Vec4(1, 1, 1, 1));
    light->setAmbient(osg::Vec4(0.6, 0.6, 0.6, 1));
    light->setSpecular(osg::Vec4(1, 1, 1, 1));
    light->setLinearAttenuation(0.001);
    light->setConstantAttenuation(0.5);
    root->addChild(lightSource);

    double height = std::min(board.getFieldSizeX(), board.getFieldSizeY()) / 1.5;

    auto fpsManipulator = make_ref<FPSManipulator>(board, viewer, *light);
    fpsManipulator->setHomePosition(
        osg::Vec3d(board.getFieldCenterX(1), board.getFieldCenterY(10), height),
        osg::Vec3d(0.0f, 0.0f, height),
        osg::Vec3d(0.0f, 0.0f, 1.0f)
    );


    auto keySwitch = make_ref<osgGA::KeySwitchMatrixManipulator>();
    keySwitch->addNumberedMatrixManipulator(make_ref<osgGA::OrbitManipulator>());
    keySwitch->addNumberedMatrixManipulator(fpsManipulator);
    viewer.setCameraManipulator(keySwitch);

    viewer.home();
    viewer.setSceneData( root );

    osgViewer::Viewer::Windows windows;
    viewer.getWindows(windows);
    viewer.getCamera()->setClearColor(osg::Vec4{0, 0, 0, 0});

    viewer.getCamera()->getView()->setLightingMode(osg::View::HEADLIGHT);
    auto defaultLight = viewer.getCamera()->getView()->getLight();
    defaultLight->setDiffuse(osg::Vec4(0, 0, 0, 1));
    defaultLight->setAmbient(osg::Vec4(0, 0, 0, 1));
    defaultLight->setSpecular(osg::Vec4(0, 0, 0, 1));

    // Shaders
    auto program = make_ref<osg::Program>();
    auto fragmentObject = make_ref<osg::Shader>(osg::Shader::FRAGMENT);
    loadShaderSource(fragmentObject, dbPath + "/shader.frag");
    auto vertexObject = make_ref<osg::Shader>(osg::Shader::VERTEX);
    loadShaderSource(vertexObject, dbPath + "/shader.vert");
    program->addShader(vertexObject);
    program->addShader(fragmentObject);
    root->getOrCreateStateSet()->setAttributeAndModes(program, osg::StateAttribute::ON);

    root->getOrCreateStateSet()->addUniform(new osg::Uniform("samplerName", TEXTURE_UNIT));
    root->getOrCreateStateSet()->addUniform(new osg::Uniform("Shininess", BoardObjectsShininess));
    root->getOrCreateStateSet()->addUniform(new osg::Uniform("FogEnabled", FogEnabled));

    // Optimize
    osgUtil::Optimizer optimzer;
    optimzer.optimize(root);

    viewer.setUpViewOnSingleScreen(0);

    return viewer.run();
}
Esempio n. 27
0
bool Level::isWithinVision(Vec2 from, Vec2 to, VisionId v) const {
  return Vision::get(v)->isNightVision() || from.distD(to) <= darkViewRadius || getLight(to) > 0.3;
}
Esempio n. 28
0
 //-----------------------------------------------------------------------------
 Real AutoParamDataSource::getLightPowerScale(size_t index) const
 {
     return getLight(index).getPowerScale();
 }
Esempio n. 29
0
 //---------------------------------------------------------------------
 float AutoParamDataSource::getLightCastsShadows(size_t index) const
 {
     return getLight(index).getCastShadows() ? 1.0f : 0.0f;
 }
Esempio n. 30
0
void DirectionalLight::updateUniforms(Shader* shader)
{
	InstanceDirectionalShader* s = (InstanceDirectionalShader*)shader;
	s->setLightColor(getLight());
	s->setLightDirection(m_direction);
}