Mercurial > hg > Game > Cerium

comparison TaskManager/Test/test_render/spe/DrawSpan.cpp @ 210:e75f9eb97180 draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fix DrawSpan
author gongo@localhost.localdomain
date Fri, 30 Jan 2009 14:55:04 +0900
parents de235e3ef9d3
children 53cd9cf3ab99
comparison
equal deleted inserted replaced
209:6107b8c95307 210:e75f9eb97180
5 #include "polygon_pack.h" 5 #include "polygon_pack.h"
6 #include "texture.h" 6 #include "texture.h"
7 #include "viewer_types.h" 7 #include "viewer_types.h"
8 #include "Func.h" 8 #include "Func.h"
9 9
10 #define SPAN_PACK_LOAD 0
11 #define TEX_LOAD 1
12 #define FB_STORE 2
13
14 SchedDefineTask(DrawSpan); 10 SchedDefineTask(DrawSpan);
11
12 #define TEX_LOAD1 0
13 #define TEX_LOAD2 1
14 #define SPAN_PACK_LOAD 2
15 #define FB_STORE 3
15 16
16 DrawSpan::~DrawSpan(void) 17 DrawSpan::~DrawSpan(void)
17 { 18 {
18 smanager->dma_wait(FB_STORE); 19 smanager->dma_wait(FB_STORE);
19 free((void*)((int)linebuf*doneWrite)); 20 free((void*)((int)linebuf*doneWrite));
138 #if 0 139 #if 0
139 for (int i = 0; i < width*height; i++) { 140 for (int i = 0; i < width*height; i++) {
140 buf[i] = def; 141 buf[i] = def;
141 } 142 }
142 #else 143 #else
143 vector float init = {0.0f, 0.0f, 0.0f, 0.0f}; 144 vector float init = spu_splats(0.0f);
144 vector float defi = {def, def, def, def}; 145 vector float defi = spu_splats(def);
145 146
146 for (int i = 0; i < width*height; i += 4) { 147 for (int i = 0; i < width*height; i += 4) {
147 vector float *out = (vector float *)&buf[i]; 148 vector float *out = (vector float *)&buf[i];
148 149
149 *out = spu_add(init, defi); 150 *out = spu_add(init, defi);
165 { 166 {
166 return hash->get(addr); 167 return hash->get(addr);
167 } 168 }
168 169
169 void 170 void
170 DrawSpan::set_rgb(uint32 *addr) 171 DrawSpan::set_rgb(uint32 *addr, int tag)
171 { 172 {
172 TilePtr tile; 173 TilePtr tile;
174
175 if (isAvailableTile(addr)) {
176 return;
177 }
173 178
174 tile = tileList->nextTile(); 179 tile = tileList->nextTile();
175 /** 180 /**
176 * FIFO なので、もし前のが残っていれば削除 181 * FIFO なので、もし前のが残っていれば削除
177 */ 182 */
178 hash->remove(tile->texture_addr); 183 hash->remove(tile->texture_addr);
179 184
180 tile->texture_addr = addr; 185 tile->texture_addr = addr;
181 186
182 hash->put(tile->texture_addr, tile); 187 int index = hash->put(tile->texture_addr, tile);
183
184 smanager->dma_load(tile->pixel, (uint32)addr, 188 smanager->dma_load(tile->pixel, (uint32)addr,
185 sizeof(uint32)*TEXTURE_BLOCK_SIZE, TEX_LOAD); 189 sizeof(uint32)*TEXTURE_BLOCK_SIZE, tag);
186 } 190 }
187 191
192 /**
193 *
194 */
188 void 195 void
189 DrawSpan::set_rgbs(uint32 *addr, uint32 *max_addr) 196 DrawSpan::set_rgbs(uint32 *cur_addr, uint32 *max_addr, int wait_tag)
190 { 197 {
191 uint32 start = (uint32)addr; 198 uint32 curp = (uint32)cur_addr;
192 uint32 end = (uint32)max_addr; 199 uint32 maxp = (uint32)max_addr;
193 int length = (int)end-start; 200 uint32 startp = curp;
194 int diff = sizeof(int)*TEXTURE_BLOCK_SIZE; 201 uint32 diff = sizeof(int)*TEXTURE_BLOCK_SIZE;
195 int max_tile = 16; 202 int length = (int)maxp-(int)curp;
196 203
197 for (int i = 0, j = 0; i <= length && j < max_tile; i += diff, j++) { 204 int cmp = (length < 0);
198 set_rgb((uint32*)(start + i)); 205
206 #if 1
207 length += cmp*(-1)*length*2;
208 startp = cmp*maxp + !cmp*curp;
209 #else
210 if (length < 0) {
211 length = -length;
212 startp = maxp;
213 }
214 #endif
215
216 for (int i = 0; i <= length; i += diff) {
217 set_rgb((uint32*)(startp + i), wait_tag);
199 } 218 }
200 } 219 }
201 220
202 uint32 221 uint32
203 DrawSpan::get_rgb(int tx, int ty, uint32 *addr) 222 DrawSpan::get_rgb(int tx, int ty, uint32 *addr)
267 286
268 doneWrite = 1; 287 doneWrite = 1;
269 } 288 }
270 289
271 /** 290 /**
291 * zRow と Linebuf を更新する
292 *
293 * @param zpos 更新する pixel のZ座標
294 * @param rangex このタスクが処理する描画領域の x の長さ
295 * @param x pixel の、描画領域内での x 座標
296 * @param y 〃 の、y 座標
297 * @param tex_x pixel が使用するテクスチャの、Tile (8x8) 内での x 座標
298 * @param tex_y 〃 の y 座標
299 * @param tex_addr テクスチャのアドレス(MainMemory)
300 */
301 void
302 DrawSpan::updateBuffer(float zpos, int rangex, int x, int y,
303 int tex_x, int tex_y, uint32 *tex_addr)
304 {
305 int rgb = get_rgb(tex_x, tex_y, tex_addr);
306
307 zRow[x + (rangex*y)] = zpos;
308 linebuf[x + (rangex*y)] = rgb;
309 }
310
311 /**
272 * 長さが 1 の Span の描画 (要するに 1 pixel) 312 * 長さが 1 の Span の描画 (要するに 1 pixel)
273 * 313 *
274 * @param span Span 314 * @param span Span
275 * @param startx 描画開始範囲 315 * @param startx 描画開始範囲
276 * @param endx 描画終了範囲 316 * @param endx 描画終了範囲
277 */ 317 */
278 void 318 int
279 DrawSpan::drawDot(SpanPtr span, int startx, int endx) 319 DrawSpan::drawDot1(SpanPtr span, int startx, int endx, int wait_tag)
280 { 320 {
281 int rangex = endx - startx + 1; 321 int rangex = endx - startx + 1;
282 322
283 /* span->x に対応する Texture の座標 (tex_xpos, tex_ypos) */ 323 /* span->x に対応する Texture の座標 (tex_xpos, tex_ypos) */
284 int tex_xpos, tex_ypos; 324 int tex_xpos, tex_ypos;
301 int tex_localx; 341 int tex_localx;
302 int tex_localy; 342 int tex_localy;
303 uint32 *tex_addr; 343 uint32 *tex_addr;
304 344
305 if (span->x < startx || endx < span->x) { 345 if (span->x < startx || endx < span->x) {
306 return; 346 return -1;
307 } 347 }
308 348
309 tex_xpos = (int)((span->tex_width-1) * tex); 349 tex_xpos = (int)((span->tex_width-1) * tex);
310 tex_ypos = (int)((span->tex_height-1) * tey); 350 tex_ypos = (int)((span->tex_height-1) * tey);
311 351
314 span->tex_width, span->tex_addr); 354 span->tex_width, span->tex_addr);
315 tex_localx = tex_xpos % TEXTURE_SPLIT_PIXEL; 355 tex_localx = tex_xpos % TEXTURE_SPLIT_PIXEL;
316 tex_localy = tex_ypos % TEXTURE_SPLIT_PIXEL; 356 tex_localy = tex_ypos % TEXTURE_SPLIT_PIXEL;
317 357
318 if (!isAvailableTile(tex_addr)) { 358 if (!isAvailableTile(tex_addr)) {
319 set_rgb(tex_addr); 359 set_rgb(tex_addr, wait_tag);
320 smanager->dma_wait(TEX_LOAD); 360 smanager->dma_wait(wait_tag);
361 //return startx;
321 } 362 }
322 363
323 int rgb = get_rgb(tex_localx, tex_localy, tex_addr); 364 updateBuffer(zpos, rangex, localx, localy,
324 365 tex_localx, tex_localy, tex_addr);
325 zRow[localx + (rangex*localy)] = zpos; 366 }
326 linebuf[localx + (rangex*localy)] = rgb; 367
327 } 368 return -1;
328 } 369 }
329 370
330 void 371 void
331 DrawSpan::drawLine(SpanPtr span, int startx, int endx) 372 DrawSpan::drawDot2(SpanPtr span, int startx, int end, int js, int wait_tag)
373 {
374 //printf("%d\n", js);
375 }
376
377 int
378 DrawSpan::drawLine1(SpanPtr span, int startx, int endx, int wait_tag)
332 { 379 {
333 int x = span->x; 380 int x = span->x;
334 int rangex = endx - startx + 1; 381 int rangex = endx - startx + 1;
335 int x_len = span->length_x; 382 int x_len = span->length_x;
336 383
353 float zpos2 = span->end_z; 400 float zpos2 = span->end_z;
354 401
355 // Tile 内での座標 402 // Tile 内での座標
356 int localx, localy = getLocalY(span->y-1); 403 int localx, localy = getLocalY(span->y-1);
357 404
358 // (tex_xpos, tex_ypos) の、Tile 内(上の図参照)での座標と 405 int ret = je+1;
359 // そのブロックのアドレス(MainMemory) 406
360 int tex_localx; 407 //for (int j = js; j <= je; j++) {
361 int tex_localy; 408 for (int j = je; j >= js; j--) {
362 uint32 *tex_addr; 409 float tex_x, tex_y, tex_z;
363 410
364 float tex_x, tex_y, tex_z;
365
366 #if 0
367 for (int j = js; j <= je; j++) {
368 localx = getLocalX(x-1+j); 411 localx = getLocalX(x-1+j);
369 412
370 tex_z = zpos1*(x_len-1-j)/(x_len-1) + zpos2*j/(x_len-1); 413 tex_z = zpos1*(x_len-1-j)/(x_len-1) + zpos2*j/(x_len-1);
371 414
372 tex_x = tex1*(x_len-1-j)/(x_len-1) + tex2*j/(x_len-1); 415 tex_x = tex1*(x_len-1-j)/(x_len-1) + tex2*j/(x_len-1);
377 if (tex_y < 0) tex_y = 0; 420 if (tex_y < 0) tex_y = 0;
378 tex_xpos = (int)((span->tex_width-1) * tex_x); 421 tex_xpos = (int)((span->tex_width-1) * tex_x);
379 tex_ypos = (int)((span->tex_height-1) * tex_y); 422 tex_ypos = (int)((span->tex_height-1) * tex_y);
380 423
381 if (tex_z < zRow[localx + (rangex*localy)]) { 424 if (tex_z < zRow[localx + (rangex*localy)]) {
425 // (tex_xpos, tex_ypos) の、Tile 内(上の図参照)での座標と
426 // そのブロックのアドレス(MainMemory)
427 uint32 *tex_addr;
428 int tex_localx;
429 int tex_localy;
430
382 tex_addr = getTile(tex_xpos, tex_ypos, 431 tex_addr = getTile(tex_xpos, tex_ypos,
383 span->tex_width, span->tex_addr); 432 span->tex_width, span->tex_addr);
384 tex_localx = tex_xpos % TEXTURE_SPLIT_PIXEL; 433 tex_localx = tex_xpos % TEXTURE_SPLIT_PIXEL;
385 tex_localy = tex_ypos % TEXTURE_SPLIT_PIXEL; 434 tex_localy = tex_ypos % TEXTURE_SPLIT_PIXEL;
386 435
387 /** 436 set_rgb(tex_addr, wait_tag);
388 * Tile が無い場合、一旦タスクはここで中断し、 437 ret = j;
389 * Tile をロードするタスクを走らせた後に再起動する 438 continue;
390 */ 439
391 if (!isAvailableTile(tex_addr)) { 440 if (!isAvailableTile(tex_addr)) {
392 set_rgb(tex_addr); 441 #if 1
393 smanager->dma_wait(TEX_LOAD); 442 tex_x = tex1*(x_len-1-js)/(x_len-1) + tex2*js/(x_len-1);
443 if (tex_x > 1) tex_x = 1;
444 if (tex_x < 0) tex_x = 0;
445 tex_xpos = (int)((span->tex_width-1) * tex_x);
446
447 uint32 *max_addr = getTile(tex_xpos, tex_ypos,
448 span->tex_width, span->tex_addr);
449
450 set_rgbs(tex_addr, max_addr, wait_tag);
451 return js;
452 #else
453 set_rgb(tex_addr, wait_tag);
454 ret = j;
455 //j -= 3;
456 continue;
457 #endif
394 } 458 }
395 459
396 int rgb = get_rgb(tex_localx, tex_localy, tex_addr); 460 updateBuffer(tex_z, rangex, localx, localy,
397 461 tex_localx, tex_localy, tex_addr);
398 zRow[localx + (rangex*localy)] = tex_z;
399 linebuf[localx + (rangex*localy)] = rgb;
400 } 462 }
401 } 463 }
402 #else 464
403 for (int j = js; j <= je; j += 4) { 465 return ret;
404 vector signed int vec_offset_i = {j, j+1, j+2, j+3}; 466 }
405 vector float vec_offset_f = {j, j+1, j+2, j+3}; 467
406 vector float len1 = spu_splats((float)(x_len-1)); 468 void
407 vector float len2 = spu_sub(len1, vec_offset_f); 469 DrawSpan::drawLine2(SpanPtr span, int startx, int endx, int js, int wait_tag)
408 470 {
409 vector float vec_zpos1 = spu_splats(zpos1); 471 int x = span->x;
410 vector float vec_zpos2 = spu_splats(zpos2); 472 int rangex = endx - startx + 1;
411 vector float vec_tex1 = spu_splats(tex1); 473 int x_len = span->length_x;
412 vector float vec_tex2 = spu_splats(tex2);; 474
413 vector float vec_tey1 = spu_splats(tey1); 475 //int js = startx;
414 vector float vec_tey2 = spu_splats(tey2); 476 int je = (x + x_len > endx) ? endx - x : x_len;
415 477
416 vector float vec_tex_x; 478 /* span->x に対応する Texture の座標 (tex_xpos, tex_ypos) */
417 vector float vec_tex_y; 479 int tex_xpos, tex_ypos;
418 vector float vec_tex_z; 480
419 481 // span の始点に対応する座標 (tex1, tey1)
420 // localx = getLocalX(x-1+j); 482 float tex1 = span->tex_x1;
421 vector signed int vec_localx 483 float tey1 = span->tex_y1;
422 = getLocalXVec(spu_add(spu_splats(x-1), vec_offset_i)); 484
423 vector signed int vec_localy = spu_splats(localy); 485 // span の終点に対応する座標 (tex2, tey2)
424 486 float tex2 = span->tex_x2;
425 // tex_z = zpos1*(x_len-1-j)/(x_len-1) + zpos2*j/(x_len-1); 487 float tey2 = span->tex_y2;
426 vec_tex_z = spu_madd(spu_mul(vec_zpos1, len2), spu_re_nrm(len1), 488
427 spu_mul(spu_mul(vec_zpos2, vec_offset_f), 489 // span の始点、終点に対応する z 座標
428 spu_re_nrm(len1))); 490 float zpos1 = span->start_z;
429 491 float zpos2 = span->end_z;
430 // tex_x = tex1*(x_len-1-j)/(x_len-1) + tex2*j/(x_len-1); 492
431 vec_tex_x = spu_madd(spu_mul(vec_tex1, len2), spu_re_nrm(len1), 493 // Tile 内での座標
432 spu_mul(spu_mul(vec_tex2, vec_offset_f), 494 int localx, localy = getLocalY(span->y-1);
433 spu_re_nrm(len1))); 495
434 496 // (tex_xpos, tex_ypos) の、Tile 内(上の図参照)での座標と
435 //tex_y = tey1*(x_len-1-j)/(x_len-1) + tey2*j/(x_len-1); 497 // そのブロックのアドレス(MainMemory)
436 vec_tex_y = spu_madd(spu_mul(vec_tey1, len2), spu_re_nrm(len1), 498 int tex_localx;
437 spu_mul(spu_mul(vec_tey2, vec_offset_f), 499 int tex_localy;
438 spu_re_nrm(len1))); 500 uint32 *tex_addr;
439 501
440 #if 0 502 float tex_x, tex_y, tex_z;
441 { 503
442 vector float ov1 = spu_splats(1.0f); 504 smanager->dma_wait(wait_tag);
443 vector float ov0 = spu_splats(0.0f); 505
444 506 for (int j = js; j <= je; j++) {
445 // spu_cmpgt() true = 0xffffffff, false = 0x00000000 507 localx = getLocalX(x-1+j);
446 vector unsigned int ovflag_1 = spu_cmpgt(vec_tex_x, ov1); 508
447 vector unsigned int ovflag_0 = spu_cmpgt(vec_tex_x, ov0); 509 tex_z = zpos1*(x_len-1-j)/(x_len-1) + zpos2*j/(x_len-1);
448 510
449 // *_t = 0xffffffff を 1 に変換 511 tex_x = tex1*(x_len-1-j)/(x_len-1) + tex2*j/(x_len-1);
450 // *_f = spu_cmpgt() の 論理否定 vector 512 tex_y = tey1*(x_len-1-j)/(x_len-1) + tey2*j/(x_len-1);
451 // {0, 1, 0, 1} => {1, 0, 1, 0} 513 if (tex_x > 1) tex_x = 1;
452 // *_t 同様 0xffffffff => 1 に変換 514 if (tex_x < 0) tex_x = 0;
453 vector signed int ovflag_1_t = spu_and(ovflag_1, 0x1); 515 if (tex_y > 1) tex_y = 1;
454 vector signed int ovflag_1_f 516 if (tex_y < 0) tex_y = 0;
455 = spu_and(spu_nor(ovflag_1, ovflag_1), 0x1); 517 tex_xpos = (int)((span->tex_width-1) * tex_x);
456 518 tex_ypos = (int)((span->tex_height-1) * tex_y);
457 for (int h = 0; h < 4; h++) { 519
458 signed int fl = spu_extract(ovflag_1_f, h); 520 if (tex_z < zRow[localx + (rangex*localy)]) {
459 //float x = spu_extract((spu_mul(vec_tex_x, (vector float)ovflag_1_t)), h); 521 tex_addr = getTile(tex_xpos, tex_ypos,
460 printf("[%d] %f %d\n", h, 3.3, fl); 522 span->tex_width, span->tex_addr);
461 } 523 tex_localx = tex_xpos % TEXTURE_SPLIT_PIXEL;
462 524 tex_localy = tex_ypos % TEXTURE_SPLIT_PIXEL;
463 vector unsigned int ovflag_0_t = spu_and(ovflag_0, 0x1); 525
464 526 updateBuffer(tex_z, rangex, localx, localy,
465 //vec_tex_x = spu_add(spu_mul(ov1, (vector float)ovflag_1_t), 527 tex_localx, tex_localy, tex_addr);
466 //spu_mul(vec_tex_x, (vector float)ovflag_1_f));
467 //vec_tex_x = spu_mul(vec_tex_x, (vector float)ovflag_0_t);
468 } 528 }
469 #endif 529 }
470 int cnt = (je - j > 4) ? 4 : je - j + 1;
471
472 for (int i = 0; i < cnt; i++) {
473 tex_x = spu_extract(vec_tex_x, i);
474 tex_y = spu_extract(vec_tex_y, i);
475 tex_z = spu_extract(vec_tex_z, i);
476 localx = spu_extract(vec_localx, i);
477
478 if (tex_x > 1) tex_x = 1;
479 if (tex_x < 0) tex_x = 0;
480 if (tex_y > 1) tex_y = 1;
481 if (tex_y < 0) tex_y = 0;
482 tex_xpos = (int)((span->tex_width-1) * tex_x);
483 tex_ypos = (int)((span->tex_height-1) * tex_y);
484
485 if (tex_z < zRow[localx + (rangex*localy)]) {
486 tex_addr = getTile(tex_xpos, tex_ypos,
487 span->tex_width, span->tex_addr);
488 tex_localx = tex_xpos % TEXTURE_SPLIT_PIXEL;
489 tex_localy = tex_ypos % TEXTURE_SPLIT_PIXEL;
490
491 /**
492 * Tile が無い場合、一旦タスクはここで中断し、
493 * Tile をロードするタスクを走らせた後に再起動する
494 */
495 if (!isAvailableTile(tex_addr)) {
496 set_rgb(tex_addr);
497 smanager->dma_wait(TEX_LOAD);
498 }
499
500 int rgb = get_rgb(tex_localx, tex_localy, tex_addr);
501
502 zRow[localx + (rangex*localy)] = tex_z;
503 linebuf[localx + (rangex*localy)] = rgb;
504 }
505 }
506 }
507 #endif
508 } 530 }
509 531
510 int 532 int
511 DrawSpan::run(void *rbuf, void *wbuf) 533 DrawSpan::run(void *rbuf, void *wbuf)
512 { 534 {
513 SpanPackPtr spack = (SpanPackPtr)smanager->get_input(0); 535 SpanPackPtr spack = (SpanPackPtr)smanager->get_input(0);
514 SpanPackPtr next_spack = (SpanPackPtr)smanager->allocate(sizeof(SpanPack)); 536 SpanPackPtr next_spack = (SpanPackPtr)smanager->allocate(sizeof(SpanPack));
515 SpanPackPtr free_spack = next_spack; // next_spack の free() 用 537 SpanPackPtr free_spack = next_spack; // next_spack の free() 用
516 Span *span; 538 Span *span;
517 539
518 void (DrawSpan::*drawFunc[2])(SpanPtr, int, int) = { 540 Span nop_span;
519 &DrawSpan::drawDot, &DrawSpan::drawLine 541 nop_span.length_x = 1;
542
543 int (DrawSpan::*drawFunc1[2])(SpanPtr, int, int, int) = {
544 &DrawSpan::drawDot1, &DrawSpan::drawLine1
545 };
546
547 void (DrawSpan::*drawFunc2[2])(SpanPtr, int, int, int, int) = {
548 &DrawSpan::drawDot2, &DrawSpan::drawLine2
520 }; 549 };
521 550
522 uint32 display = smanager->get_param(0); 551 uint32 display = smanager->get_param(0);
523 int screen_width = smanager->get_param(1); 552 int screen_width = smanager->get_param(1);
524 int rangex_start = smanager->get_param(2); 553 int rangex_start = smanager->get_param(2);
525 int rangex_end = smanager->get_param(3); 554 int rangex_end = smanager->get_param(3);
526 555
527 // このタスクが担当する x の範囲 556 // このタスクが担当する x の範囲
528 int rangex = rangex_end - rangex_start + 1; 557 int rangex = rangex_end - rangex_start + 1;
529 558
530 // y の範囲 559 // y の範囲
531 int rangey = smanager->get_param(4); 560 int rangey = smanager->get_param(4);
535 564
536 zRow = zRow_init(rangex, rangey); 565 zRow = zRow_init(rangex, rangey);
537 linebuf = linebuf_init(rangex, rangey, 0x00ffffff); 566 linebuf = linebuf_init(rangex, rangey, 0x00ffffff);
538 567
539 doneWrite = 0; 568 doneWrite = 0;
569
570 int tl_tag[2] = {TEX_LOAD1, TEX_LOAD2};
571 int tl_tag_flg1 = 0;
572 int tl_tag_flg2 = 1;
540 573
541 do { 574 do {
542 /** 575 /**
543 * SpanPack->next が存在する場合、 576 * SpanPack->next が存在する場合、
544 * 現在の SpanPack を処理してる間に 577 * 現在の SpanPack を処理してる間に
549 sizeof(SpanPack), SPAN_PACK_LOAD); 582 sizeof(SpanPack), SPAN_PACK_LOAD);
550 } else { 583 } else {
551 next_spack = NULL; 584 next_spack = NULL;
552 } 585 }
553 586
587 SpanPtr resume_span = &nop_span;
588 int resume_span_x = 0;
589
554 for (int t = 0; t < spack->info.size; t++) { 590 for (int t = 0; t < spack->info.size; t++) {
591 SpanPtr next_span;
592 int next_span_x;
593
555 span = &spack->span[t]; 594 span = &spack->span[t];
556 595
557 int x_len = span->length_x; 596 next_span_x
558 597 = (this->*drawFunc1[(span->length_x != 1)])(
559 (this->*drawFunc[(x_len != 1)])(span, rangex_start, rangex_end); 598 span, rangex_start, rangex_end, tl_tag[tl_tag_flg1]);
599 next_span = span;
600
601 (this->*drawFunc2[(resume_span->length_x != 1)])(
602 resume_span, rangex_start, rangex_end, resume_span_x,
603 tl_tag[tl_tag_flg2]);
604
605 resume_span = next_span;
606 resume_span_x = next_span_x;
607
608 //smanager->dma_wait(tl_tag[tl_tag_flg1]);
609
610 tl_tag_flg1 ^= 1;
611 tl_tag_flg2 ^= 1;
560 } 612 }
613
614 (this->*drawFunc2[(resume_span->length_x != 1)])(
615 resume_span, rangex_start, rangex_end, resume_span_x,
616 tl_tag[tl_tag_flg1]);
561 617
562 smanager->dma_wait(SPAN_PACK_LOAD); 618 smanager->dma_wait(SPAN_PACK_LOAD);
563 619
564 SpanPackPtr tmp_spack = spack; 620 SpanPackPtr tmp_spack = spack;
565 spack = next_spack; 621 spack = next_spack;
571 // linebuf は、writebuffer() の dma_store を wait する 627 // linebuf は、writebuffer() の dma_store を wait する
572 // DrawSpan::~DrawSpan() 内で free する。 628 // DrawSpan::~DrawSpan() 内で free する。
573 //free(linebuf); 629 //free(linebuf);
574 free(zRow); 630 free(zRow);
575 631
576 FINISH: 632 //FINISH:
577 /** 633 /**
578 * goto FINISH; の時は reboot なので 634 * goto FINISH; の時は reboot なので
579 * linebuf, zRow は free() しない 635 * linebuf, zRow は free() しない
580 */ 636 */
637
581 free(free_spack); 638 free(free_spack);
582
583 return 0; 639 return 0;
584 } 640 }