bool psEffectObjSpire::Update(csTicks elapsed)
{
    if(!anchor || !anchor->IsReady())  // wait for anchor to be ready
        return true;

    if(!psEffectObj::Update(elapsed))
        return false;

    //float scale = 1;
    float topScale = 1;
    float height = 1;
    float padding = 1;

    if(keyFrames->GetSize() > 0)
    {
        // COLOUR
        float lerpfactor = LERP_FACTOR;
        csVector3 lerpColour = LERP_VEC_KEY(KA_COLOUR,lerpfactor);
        float lerpAlpha = LERP_KEY(KA_ALPHA,lerpfactor);
        for(int a=0; a<vertCount; ++a)
            colour[a].Set(lerpColour.x, lerpColour.y, lerpColour.z, lerpAlpha);

        topScale = LERP_KEY(KA_TOPSCALE,lerpfactor);
        height = LERP_KEY(KA_HEIGHT,lerpfactor);
        padding = LERP_KEY(KA_PADDING,lerpfactor);
    }
    CalculateData(shape, segments, vert, texel, topScale, height, padding);

    return true;
}
Exemplo n.º 2
0
//------------------------------------------------------------------------------
Solver::SolverState BatchEstimator::AdvanceState()
{
   switch (currentState)
   {
      case INITIALIZING:
         #ifdef DEBUG_STATE_MACHINE
            MessageInterface::ShowMessage("Entered Estimator state machine: "
                  "INITIALIZING\n");
         #endif
         // ReportProgress();
         CompleteInitialization();
         break;

      case PROPAGATING:
         #ifdef DEBUG_STATE_MACHINE
            MessageInterface::ShowMessage("Entered Estimator state machine: "
                  "PROPAGATING\n");
         #endif
         // ReportProgress();
         FindTimeStep();
         break;

      case CALCULATING:
         #ifdef DEBUG_STATE_MACHINE
            MessageInterface::ShowMessage("Entered Estimator state machine: "
                  "CALCULATING\n");
         #endif
         // ReportProgress();
         CalculateData();
         break;

      case LOCATING:
         #ifdef DEBUG_STATE_MACHINE
            MessageInterface::ShowMessage("Entered Estimator state machine: "
                  "LOCATING\n");
         #endif
         // ReportProgress();
         ProcessEvent();
         break;

      case ACCUMULATING:
         #ifdef DEBUG_STATE_MACHINE
            MessageInterface::ShowMessage("Entered Estimator state machine: "
                  "ACCUMULATING\n");
         #endif
         // ReportProgress();
         Accumulate();
         break;

      case ESTIMATING:
         #ifdef DEBUG_STATE_MACHINE
            MessageInterface::ShowMessage("Entered Estimator state machine: "
                  "ESTIMATING\n");
         #endif
         // ReportProgress();
         Estimate();
         break;

      case CHECKINGRUN:
         #ifdef DEBUG_STATE_MACHINE
            MessageInterface::ShowMessage("Entered Estimator state machine: "
                  "CHECKINGRUN\n");
         #endif
         // ReportProgress();
         CheckCompletion();
         break;

      case FINISHED:
         #ifdef DEBUG_STATE_MACHINE
            MessageInterface::ShowMessage("Entered Estimator state machine: "
                  "FINISHED\n");
         #endif
         RunComplete();
         // ReportProgress();
         break;

      default:
         #ifdef DEBUG_STATE_MACHINE
            MessageInterface::ShowMessage("Entered Estimator state machine: "
               "Bad state for an estimator.\n");
         #endif
         /* throw EstimatorException("Solver state not supported for the simulator")*/;
   }

   return currentState;
}
Exemplo n.º 3
0
//-----------------------------------------------------------------------------
void LineProfileCanvas::RefreshData( const RequestData& data, int x /* = -1 */, int y /* = -1 */, int w /* = -1 */, int h /* = -1 */, bool boForceRefresh /* = false */ )
//-----------------------------------------------------------------------------
{
    wxCriticalSectionLocker locker( m_critSect );

    bool boAOIChanged = false;
    bool boImageFormatChanged = false;
    const ImageBuffer* pIB = data.image_.getBuffer();
    const TBayerMosaicParity bayerParity = GetProcessBayerParity() ? data.bayerParity_ : bmpUndefined;
    const int channelCount = ( ( bayerParity != bmpUndefined ) ? 4 : pIB->iChannelCount );
    if( !MustUpdate( pIB, channelCount, x, y, w, h, boForceRefresh, &boAOIChanged, &boImageFormatChanged ) )
    {
        return;
    }

    if( boImageFormatChanged || ( m_bayerParity != bayerParity ) )
    {
        SetupGDIData( pIB, channelCount, bayerParity );
    }

    if( boAOIChanged || !m_ppData || boImageFormatChanged )
    {
        // free old memory
        DeallocateProfileBuffer();
        // allocate new memory
        m_ppData = new int* [channelCount];
        for( int channel = 0; channel < channelCount; channel++ )
        {
            m_horDataCount = ( bayerParity != bmpUndefined ) ? ( ( m_AOIw + 1 ) / 2 ) : m_AOIw;
            m_verDataCount = ( bayerParity != bmpUndefined ) ? ( ( m_AOIh + 1 ) / 2 ) : m_AOIh;
            m_ppData[channel] = new int[GetDataCount()];
        }

        if( m_pNumericalDisplay )
        {
            const int columnCount = m_pNumericalDisplay->GetTable()->GetNumberCols();
            const int columnsNeeded = channelCount + 1;
            if( columnCount < columnsNeeded )
            {
                m_pNumericalDisplay->AppendCols( columnsNeeded - columnCount );
            }
            else if( columnCount > columnsNeeded )
            {
                m_pNumericalDisplay->DeleteCols( columnCount - 1, columnCount - columnsNeeded );
            }

            int rowCount = m_pNumericalDisplay->GetTable()->GetNumberRows();
            int rowsNeeded = 1 + GetDataCount();
            if( rowCount < rowsNeeded )
            {
                m_pNumericalDisplay->AppendRows( rowsNeeded - rowCount );
            }
            else if( rowCount > rowsNeeded )
            {
                m_pNumericalDisplay->DeleteRows( rowsNeeded - 1, rowCount - rowsNeeded );
            }
            m_pNumericalDisplay->SetCellValue( 0, 0, wxT( "Data Point" ) );
            for( int i = 0; i < channelCount; i++ )
            {
                m_pNumericalDisplay->SetCellBackgroundColour( 0, i + 1, *m_Pens[i].pColour_ );
                m_pNumericalDisplay->SetCellTextColour( 0, i + 1, *wxWHITE );
            }
        }
    }

    assert( ( channelCount <= PLANE_CNT ) && wxT( "A pixel format defines more channels then this tool can handle" ) );
    for( int channel = 0; channel < channelCount; channel++ )
    {
        memset( m_ppData[channel], 0, sizeof( int )*GetDataCount() );
    }

    m_bayerParity = bayerParity;
    m_ChannelCount = channelCount;

    switch( pIB->pixelFormat )
    {
    case ibpfMono10:
    case ibpfBGR101010Packed_V2:
    case ibpfRGB101010Packed:
    case ibpfYUV422_10Packed:
    case ibpfYUV422_UYVY_10Packed:
    case ibpfYUV444_UYV_10Packed:
    case ibpfYUV444_10Packed:
        m_valCount = VAL_COUNT_10_BIT;
        break;
    case ibpfRGB121212Packed:
    case ibpfMono12:
    case ibpfMono12Packed_V1:
    case ibpfMono12Packed_V2:
        m_valCount = VAL_COUNT_12_BIT;
        break;
    case ibpfRGB141414Packed:
    case ibpfMono14:
        m_valCount = VAL_COUNT_14_BIT;
        break;
    case ibpfRGB161616Packed:
    case ibpfMono16:
        m_valCount = VAL_COUNT_16_BIT;
        break;
    case ibpfRGBx888Packed:
    case ibpfBGR888Packed:
    case ibpfRGB888Packed:
    case ibpfRGBx888Planar:
    case ibpfYUV422Packed:
    case ibpfYUV422_UYVYPacked:
    case ibpfYUV444_UYVPacked:
    case ibpfYUV444Packed:
    case ibpfYUV422Planar:
    case ibpfMono8:
    default:
        m_valCount = VAL_COUNT_8_BIT;
        break;
    }

    CalculateData( pIB, bayerParity );
    bool boFullUpdate = boAOIChanged || boImageFormatChanged;
    UpdateAnalysisOutput( boFullUpdate );
}
bool psEffectObjSpire::PostSetup()
{
    static unsigned int uniqueID = 0;
    csString facName = "effect_spire_fac_";
    facName += uniqueID++;
    meshFact = engine->CreateMeshFactory("crystalspace.mesh.object.genmesh", facName.GetData());
    effectsCollection->Add(meshFact->QueryObject());

    // create the actual sprite3d data
    iMeshObjectFactory* fact = meshFact->GetMeshObjectFactory();
    csRef<iGeneralFactoryState> facState =  scfQueryInterface<iGeneralFactoryState> (fact);

    // setup the material
    csRef<iMaterialWrapper> mat = effectsCollection->FindMaterial(materialName);
    if(!mat)
    {
        csReport(psCSSetup::object_reg, CS_REPORTER_SEVERITY_ERROR, "planeshift_effects", "Couldn't find effect material: %s\n", materialName.GetData());
        return false;
    }
    fact->SetMaterialWrapper(mat);

    // ensure the minimum number of segments for the shape
    switch(shape)
    {
        case SPI_CIRCLE:
        case SPI_CYLINDER:
            segments = (segments >= 3 ? segments : 3);
            facState->SetVertexCount(2 * segments + 2);
            break;
        case SPI_ASTERIX:
            segments = (segments >= 3 ? segments : 3);
            facState->SetVertexCount(4 * segments);
            break;
        case SPI_STAR:
            segments = (segments >= 3 ? segments : 3);
            facState->SetVertexCount(6 * segments);
            break;
        case SPI_LAYERED:
            segments = (segments >= 1 ? segments : 1);
            facState->SetVertexCount(4 * segments);
            break;
    }
    vertCount = facState->GetVertexCount();

    CalculateData(shape, segments, facState->GetVertices(), facState->GetTexels());

    animLength = 10;
    if(keyFrames->GetSize() > 0)
        animLength += keyFrames->Get(keyFrames->GetSize()-1)->time;

    // create the tris
    switch(shape)
    {
        case SPI_CIRCLE:
        case SPI_CYLINDER:
            facState->SetTriangleCount(4*segments);
            for(int q=0; q<segments; ++q)
            {
                facState->GetTriangles()[q*4  ].Set(q*2,   q*2+1, q*2+2);
                facState->GetTriangles()[q*4+1].Set(q*2+1, q*2+3, q*2+2);

                facState->GetTriangles()[q*4+2].Set(q*2,   q*2+2, q*2+1);
                facState->GetTriangles()[q*4+3].Set(q*2+1, q*2+2, q*2+3);
            }
            break;
        case SPI_ASTERIX:
            facState->SetTriangleCount(4*segments);
            for(int q=0; q<segments; ++q)
            {
                facState->GetTriangles()[q*4  ].Set(q*4, q*4+2, q*4+1);
                facState->GetTriangles()[q*4+1].Set(q*4, q*4+2, q*4+3);

                facState->GetTriangles()[q*4+2].Set(q*4+2, q*4, q*4+1);
                facState->GetTriangles()[q*4+3].Set(q*4+2, q*4, q*4+3);
            }
            break;
        case SPI_STAR:
            facState->SetTriangleCount(8*segments);
            for(int q=0; q<segments; ++q)
            {
                facState->GetTriangles()[q*8  ].Set(q*8,   q*8+1, q*8+3);
                facState->GetTriangles()[q*8+1].Set(q*8,   q*8+1, q*8+4);
                facState->GetTriangles()[q*8+2].Set(q*8+1, q*8+2, q*8+4);
                facState->GetTriangles()[q*8+3].Set(q*8+1, q*8+2, q*8+5);

                facState->GetTriangles()[q*8+4].Set(q*8,   q*8+3, q*8+1);
                facState->GetTriangles()[q*8+5].Set(q*8,   q*8+4, q*8+1);
                facState->GetTriangles()[q*8+6].Set(q*8+1, q*8+4, q*8+2);
                facState->GetTriangles()[q*8+7].Set(q*8+1, q*8+5, q*8+2);
            }
            break;
        case SPI_LAYERED:
            facState->SetTriangleCount(4*segments);
            for(int q=0; q<segments; ++q)
            {
                facState->GetTriangles()[q*4  ].Set(q*4, q*4+2, q*4+1);
                facState->GetTriangles()[q*4+1].Set(q*4, q*4+2, q*4+3);

                facState->GetTriangles()[q*4+2].Set(q*4, q*4+4, q*4+1);
                facState->GetTriangles()[q*4+3].Set(q*4, q*4+4, q*4+3);
            }
            break;
    }

    return true;
}
Exemplo n.º 5
0
//------------------------------------------------------------------------------
Solver::SolverState SequentialEstimator::AdvanceState()
{
   switch (currentState)
   {
      case INITIALIZING:
         #ifdef WALK_STATE_MACHINE
            MessageInterface::ShowMessage("Executing the INITIALIZING state\n");
         #endif
         CompleteInitialization();
         break;

      case PROPAGATING:
         #ifdef WALK_STATE_MACHINE
            MessageInterface::ShowMessage("Executing the PROPAGATING state\n");
         #endif
         FindTimeStep();
         break;

      case CALCULATING:
         #ifdef WALK_STATE_MACHINE
            MessageInterface::ShowMessage("Executing the CALCULATING state\n");
         #endif
         CalculateData();
         break;

      case LOCATING:
         #ifdef WALK_STATE_MACHINE
            MessageInterface::ShowMessage("Executing the LOCATING state\n");
         #endif
         ProcessEvent();
         break;

      case ESTIMATING:
         #ifdef WALK_STATE_MACHINE
            MessageInterface::ShowMessage("Executing the ESTIMATING state\n");
         #endif
         Estimate();
         break;

      case CHECKINGRUN:
         #ifdef WALK_STATE_MACHINE
            MessageInterface::ShowMessage("Executing the CHECKINGRUN state\n");
         #endif
         CheckCompletion();
         break;

      case FINISHED:
         #ifdef WALK_STATE_MACHINE
            MessageInterface::ShowMessage("Executing the FINISHED state\n");
         #endif
         RunComplete();
         break;

      default:
         throw EstimatorException("Unknown state encountered in the " +
               instanceName + " sequential estimator.");

   }

   return currentState;
}