コード例 #1
0
ファイル: d3d11resource.cpp プロジェクト: githole/nlSandbox
 /* 全VSの生成 */
 static void LoadAllVS( const ShaderScripts& shaderScripts, nlEngineContext& cxt  )
 {
     const ShaderScriptGroup& vsScripts = shaderScripts.vsScripts;
     const unsigned int numScript = vsScripts.numScript;
     for( int i=0;i<numScript;++i)
     {
         createVS( i, shaderScripts, cxt );
         updateLoading();
     }
 }
コード例 #2
0
//    Mark C. Miller, Wed Aug 22 19:57:54 PDT 2012
//    Removed superfolous code allocating and initializing local variables,
//    score_mins and score_maxs. Nothing in the function was using these
//    variables.  
void
avtModelFitFilter::PostExecute()
{  
    intVector numTups = atts.GetNumTups();
    intVector numVars = atts.GetNumVars();
    stringVector Vars = atts.GetVars();
    doubleVector Tuples = atts.GetTuples();
    doubleVector thold  = atts.GetThold();
    unsignedCharVector StatTuples = atts.GetStatTuples();
    intVector tup_match;
    doubleVector mins;
    doubleVector point;

    int tup_index, var_index;
    vtkDataArray *darray;
    char secVarName[1024];
    int numValues;
    size_t varFinder;

    double distance;
    float *scalars;
    bool good_match;

    int relat_index;

    double opt_distance;

    intVector selectionType = atts.GetSelectionType();
    intVector distanceType  = atts.GetDistanceType();
    intVector inputSpace    = atts.GetInputSpace(); 


    //Since there may be overlap between models in variables specified,
    //create a set of all unique variables
    for(size_t i = 0; i < Vars.size(); i++)
    {
        sprintf(secVarName, "%s", Vars[i].c_str());
        createVS(secVarName);
    }
    
    //determine for each variable whether or not statistics or 
    //histograms need to be calculated
    for(int i = 0, currentVar = 0, num_to_remove = 0; i < num_relats; i++)
    {
        if(selectionType[i] == 1 || inputSpace[i] == 1)
            for(int j = 0; j < numVars[i]; j++, currentVar++, num_to_remove++)
            {
                for(varFinder = 0; varFinder < VS.size(); varFinder++)
                    if(!strcmp(VS[varFinder]->name, Vars[currentVar].c_str()))
                        break;
                VS[varFinder]->calculate_stats = true;
            }
        currentVar -= num_to_remove;
        num_to_remove = 0;

        if(selectionType[i] == 3 || inputSpace[i] == 3)
            for(int j = 0; j < numVars[i]; j++, currentVar++, num_to_remove++)
            {
                for(varFinder = 0; varFinder < VS.size(); varFinder++)
                    if(!strcmp(VS[varFinder]->name, Vars[currentVar].c_str()))
                        break;
                VS[varFinder]->calculate_hists = true;
            }
        currentVar -= num_to_remove;
        num_to_remove = 0;

        currentVar += numVars[i];
    }
    
    //also force stats calculation if stat shortcuts specified
    for(int i = 0; i < num_relats; i++)
    {
        tup_index = 0;
        var_index = 0;
        for(int j = 0; j < i; j++)
        {
            tup_index += numTups[j]*numVars[j];
            var_index += numVars[j];
        }
        for(int j = 0; j < numTups[i]*numVars[i]; j++)
            if(StatTuples[tup_index+j] == 'a' || StatTuples[tup_index+j] == 'M' || 
                    StatTuples[tup_index+j] == 'm')
            {
                for(varFinder = 0; varFinder < VS.size(); varFinder++)
                    if(!strcmp(VS[varFinder]->name, Vars[var_index + (j%numVars[i])].c_str()))
                        break;

                VS[varFinder]->calculate_stats = true;
            }
    }
    
    //Go through all variables specified and calculate
    //statistics for each.
    calculateVariableStats();
    
#ifdef PARALLEL
    int numProcs = 1;
    int myRank   = 0;
    
    MPI_Comm_rank(VISIT_MPI_COMM, &myRank);
    MPI_Comm_size(VISIT_MPI_COMM, &numProcs);

    double     *sum;
    double     *max;
    double     *min;
    double     *non_zero_min;
    int *num_points;
    int totVars  = VS.size();
    int number_on = 0;

    double *temp_hist;
    double *merged_ranges;
    
    num_points = (int    *)malloc(sizeof(int)   *totVars);
    sum        = (double *)malloc(sizeof(double)*totVars);
    max        = (double *)malloc(sizeof(double)*totVars);
    min        = (double *)malloc(sizeof(double)*totVars);
    non_zero_min = (double *)malloc(sizeof(double)*totVars);

    merged_ranges = (double *)malloc(sizeof(double)*(BINS*numProcs));
    temp_hist = (double *)malloc(sizeof(double)*BINS);

    for(int i = 0; i < totVars; i++)
    {
        if(VS[i]->calculate_stats)
        {
            num_points[i] = VS[i]->num_points;
            sum[i]        = VS[i]->sum;
            max[i]        = VS[i]->max;
            min[i]        = VS[i]->min;
            non_zero_min[i] = VS[i]->non_zero_min; 
    
            MPI_Allreduce(&num_points[i], &(VS[i]->num_points), 1, MPI_INT, MPI_SUM, VISIT_MPI_COMM);
            MPI_Allreduce(&sum[i], &(VS[i]->sum), 1, MPI_DOUBLE, MPI_SUM, VISIT_MPI_COMM);
            MPI_Allreduce(&max[i], &(VS[i]->max), 1, MPI_DOUBLE, MPI_MAX, VISIT_MPI_COMM);
            MPI_Allreduce(&min[i], &(VS[i]->min), 1, MPI_DOUBLE, MPI_MIN, VISIT_MPI_COMM);
            MPI_Allreduce(&non_zero_min[i], &(VS[i]->non_zero_min), 1, MPI_DOUBLE, MPI_MIN, VISIT_MPI_COMM);
        }

        if(VS[i]->calculate_hists)
        {
            for(int np = 0; np < numProcs; np++)
            {
                if(np == myRank)
                    memcpy(temp_hist, VS[i]->hist.range_ends, BINS*sizeof(double));
            
                MPI_Bcast(temp_hist, BINS, MPI_DOUBLE, i, VISIT_MPI_COMM);
           
                for(int j = 0; j < BINS; j++)
                    merged_ranges[number_on++] = temp_hist[j];
            }
            
            VS[i]->hist.count      = VS[i]->num_points / BINS;
            VS[i]->hist.mod_number = VS[i]->num_points % BINS;
        
            qsort(merged_ranges, BINS*numProcs, sizeof(double), compare_doubles);
        
            for(int j = 0, k = 0; j < numProcs*BINS; j += numProcs, k++)
                VS[i]->hist.range_ends[k] = merged_ranges[j];
            number_on = 0;
        }
    }

    delete num_points;
    delete sum;
    delete max;
    delete min;
    delete non_zero_min;
    delete(temp_hist);
    delete(merged_ranges);
    
#endif

    for(size_t i = 0; i < VS.size(); i++)
        if(VS[i]->num_points)
            VS[i]->average = VS[i]->sum/VS[i]->num_points;

    /*
    puts("-------before------");
    for(int i = 0; i < Tuples.size(); i++)
        printf("Tuples[%d]: %lf\n", i, Tuples[i]);
        */

    //do space converts on thresholds and tuples
    //for tuples, stick stats in if needed
    for(int i = 0; i < num_relats; i++)
    {
        tup_index = 0;
        var_index = 0;
        for(int j = 0; j < i; j++)
        {
            tup_index += numTups[j]*numVars[j];
            var_index += numVars[j];
        }
        
        for(int j = 0; j < numTups[i]*numVars[i]; j++)
        {
            sprintf(secVarName, "%s", Vars[var_index+(j%numVars[i])].c_str());
            for(varFinder = 0; varFinder < VS.size(); varFinder++)
                if(!strcmp(VS[varFinder]->name, secVarName))
                    break;
 
            //we have a thold specified
            if(thold[tup_index+j] > 0)
                if(inputSpace[i] != selectionType[i])
                {
                    thold[tup_index+j] = convertToVariableSpace(thold[tup_index+j], varFinder, inputSpace[i]);
                    thold[tup_index+j] = spaceConvert(thold[tup_index+j], varFinder, selectionType[i]);
                }

            //replace Tuples with stats
            if(StatTuples[tup_index+j] == 'a' || StatTuples[tup_index+j] == 'M' || 
                    StatTuples[tup_index+j] == 'm')
            {
                if(StatTuples[tup_index+j] == 'a')
                    Tuples[tup_index+j] = VS[varFinder]->average;
                else if (StatTuples[tup_index+j] == 'M')
                    Tuples[tup_index+j] = VS[varFinder]->max;
                else if (StatTuples[tup_index+j] == 'm')
                    Tuples[tup_index+j] = VS[varFinder]->min;

                //printf("Tuples[%d] before: %lf\n", tup_index+j, Tuples[tup_index+j]);
                Tuples[tup_index+j] = spaceConvert(Tuples[tup_index+j], varFinder, selectionType[i]);
                //printf("Tuples[%d] after: %lf\n", tup_index+j, Tuples[tup_index+j]);
            }
            else if(inputSpace[i] != selectionType[i])
            {
                //printf("Tuples[%d] before: %lf\n", tup_index+j, Tuples[tup_index+j]);
                Tuples[tup_index+j] = convertToVariableSpace(Tuples[tup_index+j], varFinder, inputSpace[i]);
                //printf("Tuples[%d] after cTVS: %lf\n", tup_index+j, Tuples[tup_index+j]);
                Tuples[tup_index+j] = spaceConvert(Tuples[tup_index+j], varFinder, selectionType[i]);
                //printf("Tuples[%d] after SC: %lf\n", tup_index+j, Tuples[tup_index+j]);
                //printf("Used %lf for min, %lf for max\n", VS[varFinder]->min, VS[varFinder]->max);
            }
        }
    }
    /*
    puts("-------after------");
    for(int i = 0; i < Tuples.size(); i++)
        printf("Tuples[%d]: %lf\n", i, Tuples[i]);
        */
    atts.SetTuples(Tuples);
    atts.SetThold(thold);

    //
    for(size_t ds = 0; ds < out_ds.size(); ds++){
        numValues = 0;
       
        if(Centering == AVT_NODECENT)
            numValues = out_ds[ds]->GetNumberOfPoints();
        else
            numValues = out_ds[ds]->GetNumberOfCells();
    
        for(int p = 0; p < numValues; p++)
        {
            opt_distance = -1; //added for
            relat_index  = -1; //distance use
        
            for(int i = 0; i < num_relats; i++)
            { //added for distances
                if(numTups[i] < 1)
                    continue;
        
                tup_index = 0;
                var_index = 0;
        
                for(int j = 0; j < i; j++)
                {
                    tup_index += numTups[j]*numVars[j];
                    var_index += numVars[j];
                }
        
                grabOnePoint(&point, numVars[i], var_index, selectionType[i], p, out_ds[ds]->GetPointData(), 
                        out_ds[ds]->GetCellData());

                findMatches(&mins, &tup_match, point, numVars[i], numTups[i], tup_index, var_index);
        
                //Find winning relationship
                if(tup_match.size() > 0)
                {
                    distance = calculateDistance(mins, distanceType[i]);
    
                    good_match = true;
                    for(size_t j = 0; j < mins.size(); j++)
                        if(mins[j] < 0)
                            good_match = false;
            
                    if(good_match)
                        if(distance < opt_distance || opt_distance < 0)
                        {
                            opt_distance = distance;
                            relat_index = i;
                        }
                }
            }
        
            if(num_relats && out_ds.size() && p < numValues){
                if(Centering == AVT_NODECENT)
                    darray = out_ds[ds]->GetPointData()->GetScalars("operators/ModelFit/model");
                else
                    darray = out_ds[ds]->GetCellData()->GetScalars("operators/ModelFit/model");
        
                scalars = (float *)darray->GetVoidPointer(0);
                scalars[p] = relat_index+1;
    
                if(Centering == AVT_NODECENT)
                    darray = out_ds[ds]->GetPointData()->GetScalars("operators/ModelFit/distance");
                else
                    darray = out_ds[ds]->GetCellData()->GetScalars("operators/ModelFit/distance");
        
                scalars = (float *)darray->GetVoidPointer(0);
                if(opt_distance > 0)
                    scalars[p] = opt_distance;
                else
                    scalars[p] = -1;
            }
        }
    }
}
コード例 #3
0
ファイル: OnlineScene.cpp プロジェクト: zoominhao/CountMoney
bool OnlineScene::init()
{

	if (!Layer::init())
	{
		return false;
	}

	Size visibleSize = Director::getInstance()->getVisibleSize();
	Vec2 origin = Director::getInstance()->getVisibleOrigin();


	auto returnItem = MenuItemImage::create(
		"online/icon_back.png",
		"online/icon_back.png",
		CC_CALLBACK_1(OnlineScene::returnCallback, this));

	returnItem->setPosition(Vec2(origin.x + returnItem->getContentSize().width / 2,
		origin.y + visibleSize.height - returnItem->getContentSize().height / 2));


	/*auto pauseItem = MenuItemImage::create(
		"online/icon_pause.png",
		"online/icon_pause.png",
		CC_CALLBACK_1(OnlineScene::pauseCallback, this));

	pauseItem->setPosition(Vec2(origin.x + visibleSize.width - pauseItem->getContentSize().width / 2,
		origin.y + visibleSize.height - pauseItem->getContentSize().height / 2));

	// create menu, it's an autorelease object
	auto menu = Menu::create(returnItem, pauseItem, NULL);*/
	auto menu = Menu::create(returnItem, NULL);
	menu->setPosition(Vec2::ZERO);
	this->addChild(menu, 1);

	//vs band
	createVS();
	m_connected = false;
	m_uScore = 0;

	//add background image
	setBgImage();

	addTimerFrame();

	//添加玩家,该场景为单人模式
	m_player = Player::create();
	m_player->createPlayer(1);
	m_player->setTotalMoneySpritePos(0, -20);
	//m_player->setTotalMoneyNumPos(-100, 10);
	this->addChild(m_player, 1);

	//添加计时器
	m_cmTimer = CMTimer::create();
	m_cmTimer->createLabel(Vec2(origin.x + visibleSize.width / 2 - 5, origin.y + visibleSize.height - 73), m_player, 4);
	this->addChild(m_cmTimer, 2);

	

	//注册单点触屏事件
	auto touchlistenter = EventListenerTouchOneByOne::create();
	touchlistenter->setSwallowTouches(false);

	touchlistenter->onTouchBegan = CC_CALLBACK_2(OnlineScene::onTouchBegan, this);
	touchlistenter->onTouchEnded = CC_CALLBACK_2(OnlineScene::onTouchEnded, this);
	touchlistenter->onTouchMoved = CC_CALLBACK_2(OnlineScene::onTouchMoved, this);
	_eventDispatcher->addEventListenerWithSceneGraphPriority(touchlistenter, this);

	startConnect();

	//播放背景音乐
	AudioControl::playBgMusic(PK_ONLINE);
	//初始化
	m_count_flag = false;
	m_timerStart = false;

	return true;
}