Mercurial > hg > Members > kono > Cerium

comparison TaskManager/Test/test_render/viewer.cc @ 528:541013f7015c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Application ander constructing
author game@henri.cr.ie.u-ryukyu.ac.jp
date Tue, 20 Oct 2009 23:25:22 +0900
parents 99a92f6a1c59
children 997d2a73a758
comparison
equal deleted inserted replaced
526:214cd21049e0 528:541013f7015c
238 Viewer::speLoop() 238 Viewer::speLoop()
239 { 239 {
240 HTaskPtr task_next = initLoop(); 240 HTaskPtr task_next = initLoop();
241 // key の情報を格納する領域を確保する (global_alloc(KEY_STATUS)) 241 // key の情報を格納する領域を確保する (global_alloc(KEY_STATUS))
242 HTaskPtr init_key_task = manager->create_task(INIT_KEY_TASK); 242 HTaskPtr init_key_task = manager->create_task(INIT_KEY_TASK);
243 init_key_task->set_cpu(SPE_0); 243 init_key_task->set_cpu(SPE_0);
244 init_key_task->spawn(); 244 init_key_task->spawn();
245 245
246 // SPE に送信する KEY_STATUS の領域確保 246 // SPE に送信する KEY_STATUS の領域確保
247 key_stat *key = (key_stat*)manager->allocate(sizeof(key_stat)); 247 key_stat *key = (key_stat*)manager->allocate(sizeof(key_stat));
248 this->keyPtr = key; 248 this->keyPtr = key;
249 249
250 // post2runLoop は旧バージョン用なので post2speRunLoop の様なものを別につくるべき
251 //task_next->set_post(post2speRunLoop, (void*)this); // set_post(function(this->run_loop()), NULL)
252 //task_next->spawn();
253 // TASK_INIT_TEXTURE が全て終わったら DUMMY_TASK が Viewer::run_loop() を呼ぶ
254
255 /* test */
256
257 HTaskPtr task_switch = manager->create_task(TASK_SWITCH); 250 HTaskPtr task_switch = manager->create_task(TASK_SWITCH);
258 task_switch->wait_for(task_next); 251 task_switch->wait_for(task_next);
259 task_switch->set_post(post2runMoveDrawLoop, (void*)this); 252 task_switch->set_post(post2runMoveDrawLoop, (void*)this);
260 task_switch->spawn(); 253 task_switch->spawn();
254 task_next->spawn();
261 } 255 }
262 256
263 void 257 void
264 Viewer::getKey() 258 Viewer::getKey()
265 { 259 {
312 306
313 // 同じ PPE 上なので sgroot(ポインタ) を add_param で送る。 307 // 同じ PPE 上なので sgroot(ポインタ) を add_param で送る。
314 //HTaskPtr send_key_task = viewer->manager->create_task(SEND_KEY); 308 //HTaskPtr send_key_task = viewer->manager->create_task(SEND_KEY);
315 //send_key_task->add_param((int)sgroot); 309 //send_key_task->add_param((int)sgroot);
316 // set input data -> viewer keyPtr 310 // set input data -> viewer keyPtr
311
312 sgroot->updateControllerState();
317 viewer->getKey(); 313 viewer->getKey();
318 HTaskPtr update_key = viewer->manager->create_task(UPDATE_KEY); 314 HTaskPtr update_key = viewer->manager->create_task(UPDATE_KEY);
319 update_key->add_inData(viewer->keyPtr, sizeof(key_stat)); 315 update_key->add_inData(viewer->keyPtr, sizeof(key_stat));
320 update_key->set_cpu(SPE_0); 316 update_key->set_cpu(SPE_0);
321 update_key->spawn(); 317 update_key->spawn();
322 318
323 /* TASK_MOVE は外から引数で取ってくるべき */ 319 /* TASK_MOVE は外から引数で取ってくるべき */
324 //HTaskPtr move_task = viewer->manager->create_task(viewer->app->move_taskid); 320 //HTaskPtr move_task = viewer->manager->create_task(viewer->app->move_task_id);
321 /*
322 DUMMY1 app->set_task();
323 DUMMY2 wait_for(DUMMY1)
324 sgroot->speExectute(app);
325 app->property_loop(sg_avairable_list);
326 */
325 //HTaskPtr move_task = viewer->manager->create_task(TASK_MOVE); 327 //HTaskPtr move_task = viewer->manager->create_task(TASK_MOVE);
326 //move_task->add_param(sgroot); 328 //move_task->add_param(sgroot);
327 HTaskPtr move_task = viewer->manager->create_task(TASK_DUMMY); 329 HTaskPtr move_task = viewer->manager->create_task(TASK_DUMMY);
328 move_task->set_post(post2runMove, (void*)viewer); 330 move_task->set_post(post2runMove, (void*)viewer);
329 331
342 switch_task->wait_for(draw_task); 344 switch_task->wait_for(draw_task);
343 move_task->spawn(); 345 move_task->spawn();
344 draw_task->spawn(); 346 draw_task->spawn();
345 347
346 switch_task->set_post(post2runMoveDrawLoop, (void*)viewer); 348 switch_task->set_post(post2runMoveDrawLoop, (void*)viewer);
347 switch_task->spawn(); 349 switch_task->spawn();
348
349 } 350 }
350 351
351 #if 0 352 #if 0
352 static void 353 static void
353 post2speRunLoop(void *viewer_) 354 post2speRunLoop(void *viewer_)
379 380
380 381
381 void 382 void
382 Viewer::run_move(HTaskPtr task_next) 383 Viewer::run_move(HTaskPtr task_next)
383 { 384 {
384 sgroot->updateControllerState(); 385 //sgroot->updateControllerState();
385 sgroot->speExecute(width, height, app); 386 sgroot->speExecute(width, height, app);
386 } 387 }
387 388
388 void 389 void
389 Viewer::run_collision() 390 Viewer::run_collision()
399 } 400 }
400 401
401 void 402 void
402 Viewer::rendering(HTaskPtr task_next) 403 Viewer::rendering(HTaskPtr task_next)
403 { 404 {
404 #if 0 405 common_rendering(task_next);
406
407 // Barrier 同期
408 // run_draw() を呼ぶ post2runDraw
409 task_next->set_post(post2runDraw, (void*)this); // set_post(function(this->run_draw()), NULL)
410 task_next->spawn();
411
412 // TASK_CREATE_SPAN が全て終わったら DUMMY_TASK が Viewer::run_draw() を呼ぶ
413 }
414
415 static void
416 post2runLoop(void *viewer_)
417 {
418 Viewer *viewer = (Viewer*)viewer_;
419 HTaskPtr task_next = viewer->manager->create_task(TASK_DUMMY);
420 viewer->run_loop(task_next);
421
422 }
423
424 void
425 Viewer::run_loop(HTaskPtr task_next)
426 {
427 bool quit_flg;
428 quit_flg = quit_check();
429 if (quit_flg == true) {
430 this_time = get_ticks();
431 run_finish();
432 return;
433 }
434
435 clean_pixels();
436
437 for (int i = 1; i <= spackList_length; i++) {
438 spackList[i-1].reinit(i*split_screen_h);
439 }
440
441 sgroot->updateControllerState();
442 sgroot->allExecute(width, height);
443 //sgroot->checkRemove();
444
445 // ここから下は Rendering という関数にする
446 rendering(task_next);
447 }
448
449 static void
450 post2runDraw(void *viewer_)
451 {
452 Viewer *viewer = (Viewer*)viewer_;
453 HTaskPtr task_next = viewer->manager->create_task(TASK_DUMMY);
454 viewer->run_draw(task_next);
455
456 }
457
458 void
459 Viewer::run_draw(HTaskPtr task_next) // 引数に post2runLoop を入れるようにする
460 {
461 common_draw(task_next);
462
463 task_next->set_post(post2runLoop, (void*)this); // set_post(function(this->run_loop()), NULL)
464 task_next->spawn();
465 // TASK_DRAW_SPAN が全て終わったら DUMMY_TASK が Viewer::run_loop() を呼ぶ
466
467 frames++;
468 }
469
470 void
471 Viewer::run_finish(void)
472 {
473 if (this_time != start_time) {
474 printf("%f FPS\n", (((float)frames)/(this_time-start_time))*1000.0);
475 }
476
477 delete sgroot;
478 // delete sgroot_2;
479 quit();
480 }
481
482 static void
483 post2speRendering(void *viewer_)
484 {
485 Viewer *viewer = (Viewer*)viewer_;
486 HTaskPtr task_next = viewer->manager->create_task(TASK_DUMMY);
487 viewer->spe_rendering(task_next);
488 }
489
490 void
491 Viewer::spe_rendering(HTaskPtr task_next)
492 {
493 common_rendering(task_next);
494
495 this->draw_dummy->wait_for(task_next);
496 task_next->set_post(post2speDraw, (void*)this);
497 task_next->spawn();
498
499 }
500
501 static void
502 post2speDraw(void *viewer_)
503 {
504 Viewer *viewer = (Viewer*)viewer_;
505 HTaskPtr task_next = viewer->manager->create_task(TASK_DUMMY);
506 viewer->spe_draw(task_next);
507 }
508
509 void
510 Viewer::spe_draw(HTaskPtr task_next)
511 {
512 common_draw(task_next);
513
514 this->draw_dummy->wait_for(task_next);
515 task_next->spawn();
516 this->draw_dummy->spawn();
517
518 frames++;
519 }
520
521 void
522 Viewer::common_rendering(HTaskPtr task_next)
523 {
405 HTaskPtr task_create_pp = manager->create_task(TASK_CREATE_PP2); 524 HTaskPtr task_create_pp = manager->create_task(TASK_CREATE_PP2);
406 525
407 // SceneGraph(木構造) -> PolygonPack 526 // SceneGraph(木構造) -> PolygonPack
408 527
409 task_create_pp->add_param((uint32)sgroot->getDrawSceneGraph()); 528 task_create_pp->add_param((uint32)sgroot->getDrawSceneGraph());
425 task_create_sp->add_inData(spackList_ptr, 544 task_create_sp->add_inData(spackList_ptr,
426 sizeof(SpanPack*)*spackList_length_align); 545 sizeof(SpanPack*)*spackList_length_align);
427 task_create_sp->add_inData(&spackList[index_start], sizeof(SpanPack)); 546 task_create_sp->add_inData(&spackList[index_start], sizeof(SpanPack));
428 547
429 task_create_sp->add_param(index_start); 548 task_create_sp->add_param(index_start);
430 549
431 /** 550 /**
432 * ex. screen_height が 480, spenum が 6 の場合、各SPEのy担当範囲 551 * ex. screen_height が 480, spenum が 6 の場合、各SPEのy担当範囲
433 * [ 1.. 80] [ 81..160] [161..240] 552 * [ 1.. 80] [ 81..160] [161..240]
434 * [241..320] [321..400] [401..480] 553 * [241..320] [321..400] [401..480]
435 * 554 *
446 task_create_sp->set_cpu(SPE_ANY); 565 task_create_sp->set_cpu(SPE_ANY);
447 task_create_sp->spawn(); 566 task_create_sp->spawn();
448 } 567 }
449 568
450 task_create_pp->spawn(); 569 task_create_pp->spawn();
451 #else 570 }
452 common_rendering(task_next); 571
453 #endif 572 void
454 573 Viewer::common_draw(HTaskPtr task_next)
455 // Barrier 同期 574 {
456 // run_draw() を呼ぶ post2runDraw
457 task_next->set_post(post2runDraw, (void*)this); // set_post(function(this->run_draw()), NULL)
458 task_next->spawn();
459
460 // TASK_CREATE_SPAN が全て終わったら DUMMY_TASK が Viewer::run_draw() を呼ぶ
461 }
462
463 static void
464 post2runLoop(void *viewer_)
465 {
466 Viewer *viewer = (Viewer*)viewer_;
467 HTaskPtr task_next = viewer->manager->create_task(TASK_DUMMY);
468 viewer->run_loop(task_next);
469
470 }
471
472 void
473 Viewer::run_loop(HTaskPtr task_next)
474 {
475 bool quit_flg;
476 quit_flg = quit_check();
477 if (quit_flg == true) {
478 this_time = get_ticks();
479 run_finish();
480 return;
481 }
482
483 clean_pixels();
484
485 for (int i = 1; i <= spackList_length; i++) {
486 spackList[i-1].reinit(i*split_screen_h);
487 }
488
489 sgroot->updateControllerState();
490 sgroot->allExecute(width, height);
491 //sgroot->checkRemove();
492
493 // ここから下は Rendering という関数にする
494 rendering(task_next);
495 }
496
497 static void
498 post2runDraw(void *viewer_)
499 {
500 Viewer *viewer = (Viewer*)viewer_;
501 HTaskPtr task_next = viewer->manager->create_task(TASK_DUMMY);
502 viewer->run_draw(task_next);
503
504 }
505
506 void
507 Viewer::run_draw(HTaskPtr task_next) // 引数に post2runLoop を入れるようにする
508 {
509 #if 0
510 HTaskPtr task_draw; 575 HTaskPtr task_draw;
511 576
512 //task_next = manager->create_task(TASK_DUMMY); 577 //task_next = manager->create_task(TASK_DUMMY);
513 //task_next->set_post(post2runLoop, (void*)this); 578 //task_next->set_post(post2runLoop, (void*)this);
514 579
553 618
554 if (endx > this->width) { 619 if (endx > this->width) {
555 endx = this->width; 620 endx = this->width;
556 } 621 }
557 } 622 }
558 }
559 #else
560 common_draw(task_next);
561 #endif
562
563 task_next->set_post(post2runLoop, (void*)this); // set_post(function(this->run_loop()), NULL)
564 task_next->spawn();
565 // TASK_DRAW_SPAN が全て終わったら DUMMY_TASK が Viewer::run_loop() を呼ぶ
566
567 frames++;
568 }
569
570 void
571 Viewer::run_finish(void)
572 {
573 if (this_time != start_time) {
574 printf("%f FPS\n", (((float)frames)/(this_time-start_time))*1000.0);
575 }
576
577 delete sgroot;
578 // delete sgroot_2;
579 quit();
580 }
581
582 static void
583 post2speRendering(void *viewer_)
584 {
585 Viewer *viewer = (Viewer*)viewer_;
586 HTaskPtr task_next = viewer->manager->create_task(TASK_DUMMY);
587 viewer->spe_rendering(task_next);
588 }
589
590 void
591 Viewer::spe_rendering(HTaskPtr task_next)
592 {
593 common_rendering(task_next);
594
595 this->draw_dummy->wait_for(task_next);
596 task_next->set_post(post2speDraw, (void*)this);
597 task_next->spawn();
598
599 }
600
601 static void
602 post2speDraw(void *viewer_)
603 {
604 Viewer *viewer = (Viewer*)viewer_;
605 HTaskPtr task_next = viewer->manager->create_task(TASK_DUMMY);
606 viewer->spe_draw(task_next);
607 }
608
609 void
610 Viewer::spe_draw(HTaskPtr task_next)
611 {
612 common_draw(task_next);
613
614 this->draw_dummy->wait_for(task_next);
615 task_next->spawn();
616 this->draw_dummy->spawn();
617
618 frames++;
619 }
620
621 void
622 Viewer::common_rendering(HTaskPtr task_next)
623 {
624 HTaskPtr task_create_pp = manager->create_task(TASK_CREATE_PP2);
625
626 // SceneGraph(木構造) -> PolygonPack
627
628 task_create_pp->add_param((uint32)sgroot->getDrawSceneGraph());
629 task_create_pp->add_param((uint32)ppack);
630
631 task_next->wait_for(task_create_pp);
632
633 int range_base = spe_num;
634 // 切り上げのつもり
635 int range = (spackList_length + range_base - 1) / range_base;
636
637 for (int i = 0; i < range_base; i++) {
638 int index_start = range*i;
639 int index_end = (index_start + range >= spackList_length)
640 ? spackList_length : index_start + range;
641
642 HTaskPtr task_create_sp = manager->create_task(TASK_CREATE_SPAN);
643 task_create_sp->add_inData(ppack, sizeof(PolygonPack));
644 task_create_sp->add_inData(spackList_ptr,
645 sizeof(SpanPack*)*spackList_length_align);
646 task_create_sp->add_inData(&spackList[index_start], sizeof(SpanPack));
647
648 task_create_sp->add_param(index_start);
649
650 /**
651 * ex. screen_height が 480, spenum が 6 の場合、各SPEのy担当範囲
652 * [ 1.. 80] [ 81..160] [161..240]
653 * [241..320] [321..400] [401..480]
654 *
655 * ex. screen_height が 1080, spenum が 5 の場合、
656 * [ 1..216] [217..432] [433..648]
657 * [649..864] [865..1080]
658 */
659 task_create_sp->add_param(index_start*split_screen_h + 1);
660 task_create_sp->add_param(index_end*split_screen_h);
661
662 task_next->wait_for(task_create_sp);
663 task_create_sp->wait_for(task_create_pp);
664
665 task_create_sp->set_cpu(SPE_ANY);
666 task_create_sp->spawn();
667 }
668
669 task_create_pp->spawn();
670 }
671
672 void
673 Viewer::common_draw(HTaskPtr task_next)
674 {
675 HTaskPtr task_draw;
676
677 //task_next = manager->create_task(TASK_DUMMY);
678 //task_next->set_post(post2runLoop, (void*)this);
679
680 ppack->clear();
681 for (int i = 0; i < spackList_length; i++) {
682 SpanPack *spack = &spackList[i];
683 int startx = 1;
684 int endx = split_screen_w;
685
686 int starty = spack->info.y_top - split_screen_h + 1;
687 //int endy = spack->info.y_top;
688 int rangey = (starty + split_screen_h - 1 > this->height)
689 ? this->height - starty + 1 : split_screen_h;
690
691 while (startx < this->width) {
692 if (spack->info.size > 0) {
693 // Draw SpanPack
694 task_draw = manager->create_task(TASK_DRAW_SPAN);
695 task_draw->add_inData(spack, sizeof(SpanPack));
696
697 task_draw->add_param(
698 (uint32)&pixels[(startx-1) + this->width*(starty-1)]);
699 task_draw->add_param(this->width);
700 } else {
701 // 7.7.3 SL1 Data Cache Range Set to Zero コマンド
702 // を使って、DMAでclearするべき... ということは、
703 // それもSPEでやる方が良い?
704 memset(&pixels[(startx-1)+this->width*(starty-1)],
705 0, (this->width)*sizeof(int)*rangey);
706 break;
707 }
708
709 task_draw->add_param(startx);
710 task_draw->add_param(endx);
711 task_draw->add_param(rangey);
712 task_draw->set_cpu(SPE_ANY);
713 task_next->wait_for(task_draw);
714 task_draw->spawn();
715
716 startx += split_screen_w;
717 endx += split_screen_w;
718
719 if (endx > this->width) {
720 endx = this->width;
721 }
722 }
723 } 623 }
724 } 624 }
725 625
726 /* end */ 626 /* end */