1 /* libs/pixelflinger/scanline.cpp 2 ** 3 ** Copyright 2006-2011, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 19 #define LOG_TAG "pixelflinger" 20 21 #include <assert.h> 22 #include <stdlib.h> 23 #include <stdio.h> 24 #include <string.h> 25 26 #include <cutils/memory.h> 27 #include <cutils/log.h> 28 29 #ifdef __arm__ 30 #include <machine/cpu-features.h> 31 #endif 32 33 #include "buffer.h" 34 #include "scanline.h" 35 36 #include "codeflinger/CodeCache.h" 37 #include "codeflinger/GGLAssembler.h" 38 #if defined(__arm__) 39 #include "codeflinger/ARMAssembler.h" 40 #elif defined(__aarch64__) 41 #include "codeflinger/Arm64Assembler.h" 42 #elif defined(__mips__) && !defined(__LP64__) && __mips_isa_rev < 6 43 #include "codeflinger/MIPSAssembler.h" 44 #endif 45 //#include "codeflinger/ARMAssemblerOptimizer.h" 46 47 // ---------------------------------------------------------------------------- 48 49 #define ANDROID_CODEGEN_GENERIC 0 // force generic pixel pipeline 50 #define ANDROID_CODEGEN_C 1 // hand-written C, fallback generic 51 #define ANDROID_CODEGEN_ASM 2 // hand-written asm, fallback generic 52 #define ANDROID_CODEGEN_GENERATED 3 // hand-written asm, fallback codegen 53 54 #ifdef NDEBUG 55 # define ANDROID_RELEASE 56 # define ANDROID_CODEGEN ANDROID_CODEGEN_GENERATED 57 #else 58 # define ANDROID_DEBUG 59 # define ANDROID_CODEGEN ANDROID_CODEGEN_GENERATED 60 #endif 61 62 #if defined(__arm__) || (defined(__mips__) && !defined(__LP64__) && __mips_isa_rev < 6) || defined(__aarch64__) 63 # define ANDROID_ARM_CODEGEN 1 64 #else 65 # define ANDROID_ARM_CODEGEN 0 66 #endif 67 68 #define DEBUG__CODEGEN_ONLY 0 69 70 /* Set to 1 to dump to the log the states that need a new 71 * code-generated scanline callback, i.e. those that don't 72 * have a corresponding shortcut function. 73 */ 74 #define DEBUG_NEEDS 0 75 76 #if defined( __mips__) && !defined(__LP64__) && __mips_isa_rev < 6 77 #define ASSEMBLY_SCRATCH_SIZE 4096 78 #elif defined(__aarch64__) 79 #define ASSEMBLY_SCRATCH_SIZE 8192 80 #else 81 #define ASSEMBLY_SCRATCH_SIZE 2048 82 #endif 83 84 // ---------------------------------------------------------------------------- 85 namespace android { 86 // ---------------------------------------------------------------------------- 87 88 static void init_y(context_t*, int32_t); 89 static void init_y_noop(context_t*, int32_t); 90 static void init_y_packed(context_t*, int32_t); 91 static void init_y_error(context_t*, int32_t); 92 93 static void step_y__generic(context_t* c); 94 static void step_y__nop(context_t*); 95 static void step_y__smooth(context_t* c); 96 static void step_y__tmu(context_t* c); 97 static void step_y__w(context_t* c); 98 99 static void scanline(context_t* c); 100 static void scanline_perspective(context_t* c); 101 static void scanline_perspective_single(context_t* c); 102 static void scanline_t32cb16blend(context_t* c); 103 static void scanline_t32cb16blend_dither(context_t* c); 104 static void scanline_t32cb16blend_srca(context_t* c); 105 static void scanline_t32cb16blend_clamp(context_t* c); 106 static void scanline_t32cb16blend_clamp_dither(context_t* c); 107 static void scanline_t32cb16blend_clamp_mod(context_t* c); 108 static void scanline_x32cb16blend_clamp_mod(context_t* c); 109 static void scanline_t32cb16blend_clamp_mod_dither(context_t* c); 110 static void scanline_x32cb16blend_clamp_mod_dither(context_t* c); 111 static void scanline_t32cb16(context_t* c); 112 static void scanline_t32cb16_dither(context_t* c); 113 static void scanline_t32cb16_clamp(context_t* c); 114 static void scanline_t32cb16_clamp_dither(context_t* c); 115 static void scanline_col32cb16blend(context_t* c); 116 static void scanline_t16cb16_clamp(context_t* c); 117 static void scanline_t16cb16blend_clamp_mod(context_t* c); 118 static void scanline_memcpy(context_t* c); 119 static void scanline_memset8(context_t* c); 120 static void scanline_memset16(context_t* c); 121 static void scanline_memset32(context_t* c); 122 static void scanline_noop(context_t* c); 123 static void scanline_set(context_t* c); 124 static void scanline_clear(context_t* c); 125 126 static void rect_generic(context_t* c, size_t yc); 127 static void rect_memcpy(context_t* c, size_t yc); 128 129 #if defined( __arm__) 130 extern "C" void scanline_t32cb16blend_arm(uint16_t*, uint32_t*, size_t); 131 extern "C" void scanline_t32cb16_arm(uint16_t *dst, uint32_t *src, size_t ct); 132 extern "C" void scanline_col32cb16blend_neon(uint16_t *dst, uint32_t *col, size_t ct); 133 extern "C" void scanline_col32cb16blend_arm(uint16_t *dst, uint32_t col, size_t ct); 134 #elif defined(__aarch64__) 135 extern "C" void scanline_t32cb16blend_arm64(uint16_t*, uint32_t*, size_t); 136 extern "C" void scanline_col32cb16blend_arm64(uint16_t *dst, uint32_t col, size_t ct); 137 #elif defined(__mips__) && !defined(__LP64__) && __mips_isa_rev < 6 138 extern "C" void scanline_t32cb16blend_mips(uint16_t*, uint32_t*, size_t); 139 #endif 140 141 // ---------------------------------------------------------------------------- 142 143 static inline uint16_t convertAbgr8888ToRgb565(uint32_t pix) 144 { 145 return uint16_t( ((pix << 8) & 0xf800) | 146 ((pix >> 5) & 0x07e0) | 147 ((pix >> 19) & 0x001f) ); 148 } 149 150 struct shortcut_t { 151 needs_filter_t filter; 152 const char* desc; 153 void (*scanline)(context_t*); 154 void (*init_y)(context_t*, int32_t); 155 }; 156 157 // Keep in sync with needs 158 159 /* To understand the values here, have a look at: 160 * system/core/include/private/pixelflinger/ggl_context.h 161 * 162 * Especially the lines defining and using GGL_RESERVE_NEEDS 163 * 164 * Quick reminders: 165 * - the last nibble of the first value is the destination buffer format. 166 * - the last nibble of the third value is the source texture format 167 * - formats: 4=rgb565 1=abgr8888 2=xbgr8888 168 * 169 * In the descriptions below: 170 * 171 * SRC means we copy the source pixels to the destination 172 * 173 * SRC_OVER means we blend the source pixels to the destination 174 * with dstFactor = 1-srcA, srcFactor=1 (premultiplied source). 175 * This mode is otherwise called 'blend'. 176 * 177 * SRCA_OVER means we blend the source pixels to the destination 178 * with dstFactor=srcA*(1-srcA) srcFactor=srcA (non-premul source). 179 * This mode is otherwise called 'blend_srca' 180 * 181 * clamp means we fetch source pixels from a texture with u/v clamping 182 * 183 * mod means the source pixels are modulated (multiplied) by the 184 * a/r/g/b of the current context's color. Typically used for 185 * fade-in / fade-out. 186 * 187 * dither means we dither 32 bit values to 16 bits 188 */ 189 static shortcut_t shortcuts[] = { 190 { { { 0x03515104, 0x00000077, { 0x00000A01, 0x00000000 } }, 191 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 192 "565 fb, 8888 tx, blend SRC_OVER", scanline_t32cb16blend, init_y_noop }, 193 { { { 0x03010104, 0x00000077, { 0x00000A01, 0x00000000 } }, 194 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 195 "565 fb, 8888 tx, SRC", scanline_t32cb16, init_y_noop }, 196 /* same as first entry, but with dithering */ 197 { { { 0x03515104, 0x00000177, { 0x00000A01, 0x00000000 } }, 198 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 199 "565 fb, 8888 tx, blend SRC_OVER dither", scanline_t32cb16blend_dither, init_y_noop }, 200 /* same as second entry, but with dithering */ 201 { { { 0x03010104, 0x00000177, { 0x00000A01, 0x00000000 } }, 202 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 203 "565 fb, 8888 tx, SRC dither", scanline_t32cb16_dither, init_y_noop }, 204 /* this is used during the boot animation - CHEAT: ignore dithering */ 205 { { { 0x03545404, 0x00000077, { 0x00000A01, 0x00000000 } }, 206 { 0xFFFFFFFF, 0xFFFFFEFF, { 0xFFFFFFFF, 0x0000003F } } }, 207 "565 fb, 8888 tx, blend dst:ONE_MINUS_SRCA src:SRCA", scanline_t32cb16blend_srca, init_y_noop }, 208 /* special case for arbitrary texture coordinates (think scaling) */ 209 { { { 0x03515104, 0x00000077, { 0x00000001, 0x00000000 } }, 210 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 211 "565 fb, 8888 tx, SRC_OVER clamp", scanline_t32cb16blend_clamp, init_y }, 212 { { { 0x03515104, 0x00000177, { 0x00000001, 0x00000000 } }, 213 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 214 "565 fb, 8888 tx, SRC_OVER clamp dither", scanline_t32cb16blend_clamp_dither, init_y }, 215 /* another case used during emulation */ 216 { { { 0x03515104, 0x00000077, { 0x00001001, 0x00000000 } }, 217 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 218 "565 fb, 8888 tx, SRC_OVER clamp modulate", scanline_t32cb16blend_clamp_mod, init_y }, 219 /* and this */ 220 { { { 0x03515104, 0x00000077, { 0x00001002, 0x00000000 } }, 221 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 222 "565 fb, x888 tx, SRC_OVER clamp modulate", scanline_x32cb16blend_clamp_mod, init_y }, 223 { { { 0x03515104, 0x00000177, { 0x00001001, 0x00000000 } }, 224 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 225 "565 fb, 8888 tx, SRC_OVER clamp modulate dither", scanline_t32cb16blend_clamp_mod_dither, init_y }, 226 { { { 0x03515104, 0x00000177, { 0x00001002, 0x00000000 } }, 227 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 228 "565 fb, x888 tx, SRC_OVER clamp modulate dither", scanline_x32cb16blend_clamp_mod_dither, init_y }, 229 { { { 0x03010104, 0x00000077, { 0x00000001, 0x00000000 } }, 230 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 231 "565 fb, 8888 tx, SRC clamp", scanline_t32cb16_clamp, init_y }, 232 { { { 0x03010104, 0x00000077, { 0x00000002, 0x00000000 } }, 233 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 234 "565 fb, x888 tx, SRC clamp", scanline_t32cb16_clamp, init_y }, 235 { { { 0x03010104, 0x00000177, { 0x00000001, 0x00000000 } }, 236 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 237 "565 fb, 8888 tx, SRC clamp dither", scanline_t32cb16_clamp_dither, init_y }, 238 { { { 0x03010104, 0x00000177, { 0x00000002, 0x00000000 } }, 239 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 240 "565 fb, x888 tx, SRC clamp dither", scanline_t32cb16_clamp_dither, init_y }, 241 { { { 0x03010104, 0x00000077, { 0x00000004, 0x00000000 } }, 242 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 243 "565 fb, 565 tx, SRC clamp", scanline_t16cb16_clamp, init_y }, 244 { { { 0x03515104, 0x00000077, { 0x00001004, 0x00000000 } }, 245 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } }, 246 "565 fb, 565 tx, SRC_OVER clamp", scanline_t16cb16blend_clamp_mod, init_y }, 247 { { { 0x03515104, 0x00000077, { 0x00000000, 0x00000000 } }, 248 { 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0xFFFFFFFF } } }, 249 "565 fb, 8888 fixed color", scanline_col32cb16blend, init_y_packed }, 250 { { { 0x00000000, 0x00000000, { 0x00000000, 0x00000000 } }, 251 { 0x00000000, 0x00000007, { 0x00000000, 0x00000000 } } }, 252 "(nop) alpha test", scanline_noop, init_y_noop }, 253 { { { 0x00000000, 0x00000000, { 0x00000000, 0x00000000 } }, 254 { 0x00000000, 0x00000070, { 0x00000000, 0x00000000 } } }, 255 "(nop) depth test", scanline_noop, init_y_noop }, 256 { { { 0x05000000, 0x00000000, { 0x00000000, 0x00000000 } }, 257 { 0x0F000000, 0x00000080, { 0x00000000, 0x00000000 } } }, 258 "(nop) logic_op", scanline_noop, init_y_noop }, 259 { { { 0xF0000000, 0x00000000, { 0x00000000, 0x00000000 } }, 260 { 0xF0000000, 0x00000080, { 0x00000000, 0x00000000 } } }, 261 "(nop) color mask", scanline_noop, init_y_noop }, 262 { { { 0x0F000000, 0x00000077, { 0x00000000, 0x00000000 } }, 263 { 0xFF000000, 0x000000F7, { 0x00000000, 0x00000000 } } }, 264 "(set) logic_op", scanline_set, init_y_noop }, 265 { { { 0x00000000, 0x00000077, { 0x00000000, 0x00000000 } }, 266 { 0xFF000000, 0x000000F7, { 0x00000000, 0x00000000 } } }, 267 "(clear) logic_op", scanline_clear, init_y_noop }, 268 { { { 0x03000000, 0x00000077, { 0x00000000, 0x00000000 } }, 269 { 0xFFFFFF00, 0x000000F7, { 0x00000000, 0x00000000 } } }, 270 "(clear) blending 0/0", scanline_clear, init_y_noop }, 271 { { { 0x00000000, 0x00000000, { 0x00000000, 0x00000000 } }, 272 { 0x0000003F, 0x00000000, { 0x00000000, 0x00000000 } } }, 273 "(error) invalid color-buffer format", scanline_noop, init_y_error }, 274 }; 275 static const needs_filter_t noblend1to1 = { 276 // (disregard dithering, see below) 277 { 0x03010100, 0x00000077, { 0x00000A00, 0x00000000 } }, 278 { 0xFFFFFFC0, 0xFFFFFEFF, { 0xFFFFFFC0, 0x0000003F } } 279 }; 280 static const needs_filter_t fill16noblend = { 281 { 0x03010100, 0x00000077, { 0x00000000, 0x00000000 } }, 282 { 0xFFFFFFC0, 0xFFFFFFFF, { 0x0000003F, 0x0000003F } } 283 }; 284 285 // ---------------------------------------------------------------------------- 286 287 #if ANDROID_ARM_CODEGEN 288 289 #if defined(__mips__) && !defined(__LP64__) && __mips_isa_rev < 6 290 static CodeCache gCodeCache(32 * 1024); 291 #elif defined(__aarch64__) 292 static CodeCache gCodeCache(48 * 1024); 293 #else 294 static CodeCache gCodeCache(12 * 1024); 295 #endif 296 297 class ScanlineAssembly : public Assembly { 298 AssemblyKey<needs_t> mKey; 299 public: 300 ScanlineAssembly(needs_t needs, size_t size) 301 : Assembly(size), mKey(needs) { } 302 const AssemblyKey<needs_t>& key() const { return mKey; } 303 }; 304 #endif 305 306 // ---------------------------------------------------------------------------- 307 308 void ggl_init_scanline(context_t* c) 309 { 310 c->init_y = init_y; 311 c->step_y = step_y__generic; 312 c->scanline = scanline; 313 } 314 315 void ggl_uninit_scanline(context_t* c) 316 { 317 if (c->state.buffers.coverage) 318 free(c->state.buffers.coverage); 319 #if ANDROID_ARM_CODEGEN 320 if (c->scanline_as) 321 c->scanline_as->decStrong(c); 322 #endif 323 } 324 325 // ---------------------------------------------------------------------------- 326 327 static void pick_scanline(context_t* c) 328 { 329 #if (!defined(DEBUG__CODEGEN_ONLY) || (DEBUG__CODEGEN_ONLY == 0)) 330 331 #if ANDROID_CODEGEN == ANDROID_CODEGEN_GENERIC 332 c->init_y = init_y; 333 c->step_y = step_y__generic; 334 c->scanline = scanline; 335 return; 336 #endif 337 338 //printf("*** needs [%08lx:%08lx:%08lx:%08lx]\n", 339 // c->state.needs.n, c->state.needs.p, 340 // c->state.needs.t[0], c->state.needs.t[1]); 341 342 // first handle the special case that we cannot test with a filter 343 const uint32_t cb_format = GGL_READ_NEEDS(CB_FORMAT, c->state.needs.n); 344 if (GGL_READ_NEEDS(T_FORMAT, c->state.needs.t[0]) == cb_format) { 345 if (c->state.needs.match(noblend1to1)) { 346 // this will match regardless of dithering state, since both 347 // src and dest have the same format anyway, there is no dithering 348 // to be done. 349 const GGLFormat* f = 350 &(c->formats[GGL_READ_NEEDS(T_FORMAT, c->state.needs.t[0])]); 351 if ((f->components == GGL_RGB) || 352 (f->components == GGL_RGBA) || 353 (f->components == GGL_LUMINANCE) || 354 (f->components == GGL_LUMINANCE_ALPHA)) 355 { 356 // format must have all of RGB components 357 // (so the current color doesn't show through) 358 c->scanline = scanline_memcpy; 359 c->init_y = init_y_noop; 360 return; 361 } 362 } 363 } 364 365 if (c->state.needs.match(fill16noblend)) { 366 c->init_y = init_y_packed; 367 switch (c->formats[cb_format].size) { 368 case 1: c->scanline = scanline_memset8; return; 369 case 2: c->scanline = scanline_memset16; return; 370 case 4: c->scanline = scanline_memset32; return; 371 } 372 } 373 374 const int numFilters = sizeof(shortcuts)/sizeof(shortcut_t); 375 for (int i=0 ; i<numFilters ; i++) { 376 if (c->state.needs.match(shortcuts[i].filter)) { 377 c->scanline = shortcuts[i].scanline; 378 c->init_y = shortcuts[i].init_y; 379 return; 380 } 381 } 382 383 #if DEBUG_NEEDS 384 ALOGI("Needs: n=0x%08x p=0x%08x t0=0x%08x t1=0x%08x", 385 c->state.needs.n, c->state.needs.p, 386 c->state.needs.t[0], c->state.needs.t[1]); 387 #endif 388 389 #endif // DEBUG__CODEGEN_ONLY 390 391 c->init_y = init_y; 392 c->step_y = step_y__generic; 393 394 #if ANDROID_ARM_CODEGEN 395 // we're going to have to generate some code... 396 // here, generate code for our pixel pipeline 397 const AssemblyKey<needs_t> key(c->state.needs); 398 sp<Assembly> assembly = gCodeCache.lookup(key); 399 if (assembly == 0) { 400 // create a new assembly region 401 sp<ScanlineAssembly> a = new ScanlineAssembly(c->state.needs, 402 ASSEMBLY_SCRATCH_SIZE); 403 // initialize our assembler 404 #if defined(__arm__) 405 GGLAssembler assembler( new ARMAssembler(a) ); 406 //GGLAssembler assembler( 407 // new ARMAssemblerOptimizer(new ARMAssembler(a)) ); 408 #endif 409 #if defined(__mips__) 410 GGLAssembler assembler( new ArmToMipsAssembler(a) ); 411 #elif defined(__aarch64__) 412 GGLAssembler assembler( new ArmToArm64Assembler(a) ); 413 #endif 414 // generate the scanline code for the given needs 415 bool err = assembler.scanline(c->state.needs, c) != 0; 416 if (ggl_likely(!err)) { 417 // finally, cache this assembly 418 err = gCodeCache.cache(a->key(), a) < 0; 419 } 420 if (ggl_unlikely(err)) { 421 ALOGE("error generating or caching assembly. Reverting to NOP."); 422 c->scanline = scanline_noop; 423 c->init_y = init_y_noop; 424 c->step_y = step_y__nop; 425 return; 426 } 427 assembly = a; 428 } 429 430 // release the previous assembly 431 if (c->scanline_as) { 432 c->scanline_as->decStrong(c); 433 } 434 435 //ALOGI("using generated pixel-pipeline"); 436 c->scanline_as = assembly.get(); 437 c->scanline_as->incStrong(c); // hold on to assembly 438 c->scanline = (void(*)(context_t* c))assembly->base(); 439 #else 440 // ALOGW("using generic (slow) pixel-pipeline"); 441 c->scanline = scanline; 442 #endif 443 } 444 445 void ggl_pick_scanline(context_t* c) 446 { 447 pick_scanline(c); 448 if ((c->state.enables & GGL_ENABLE_W) && 449 (c->state.enables & GGL_ENABLE_TMUS)) 450 { 451 c->span = c->scanline; 452 c->scanline = scanline_perspective; 453 if (!(c->state.enabled_tmu & (c->state.enabled_tmu - 1))) { 454 // only one TMU enabled 455 c->scanline = scanline_perspective_single; 456 } 457 } 458 } 459 460 // ---------------------------------------------------------------------------- 461 462 static void blending(context_t* c, pixel_t* fragment, pixel_t* fb); 463 static void blend_factor(context_t* c, pixel_t* r, uint32_t factor, 464 const pixel_t* src, const pixel_t* dst); 465 static void rescale(uint32_t& u, uint8_t& su, uint32_t& v, uint8_t& sv); 466 467 #if ANDROID_ARM_CODEGEN && (ANDROID_CODEGEN == ANDROID_CODEGEN_GENERATED) 468 469 // no need to compile the generic-pipeline, it can't be reached 470 void scanline(context_t*) 471 { 472 } 473 474 #else 475 476 void rescale(uint32_t& u, uint8_t& su, uint32_t& v, uint8_t& sv) 477 { 478 if (su && sv) { 479 if (su > sv) { 480 v = ggl_expand(v, sv, su); 481 sv = su; 482 } else if (su < sv) { 483 u = ggl_expand(u, su, sv); 484 su = sv; 485 } 486 } 487 } 488 489 void blending(context_t* c, pixel_t* fragment, pixel_t* fb) 490 { 491 rescale(fragment->c[0], fragment->s[0], fb->c[0], fb->s[0]); 492 rescale(fragment->c[1], fragment->s[1], fb->c[1], fb->s[1]); 493 rescale(fragment->c[2], fragment->s[2], fb->c[2], fb->s[2]); 494 rescale(fragment->c[3], fragment->s[3], fb->c[3], fb->s[3]); 495 496 pixel_t sf, df; 497 blend_factor(c, &sf, c->state.blend.src, fragment, fb); 498 blend_factor(c, &df, c->state.blend.dst, fragment, fb); 499 500 fragment->c[1] = 501 gglMulAddx(fragment->c[1], sf.c[1], gglMulx(fb->c[1], df.c[1])); 502 fragment->c[2] = 503 gglMulAddx(fragment->c[2], sf.c[2], gglMulx(fb->c[2], df.c[2])); 504 fragment->c[3] = 505 gglMulAddx(fragment->c[3], sf.c[3], gglMulx(fb->c[3], df.c[3])); 506 507 if (c->state.blend.alpha_separate) { 508 blend_factor(c, &sf, c->state.blend.src_alpha, fragment, fb); 509 blend_factor(c, &df, c->state.blend.dst_alpha, fragment, fb); 510 } 511 512 fragment->c[0] = 513 gglMulAddx(fragment->c[0], sf.c[0], gglMulx(fb->c[0], df.c[0])); 514 515 // clamp to 1.0 516 if (fragment->c[0] >= (1LU<<fragment->s[0])) 517 fragment->c[0] = (1<<fragment->s[0])-1; 518 if (fragment->c[1] >= (1LU<<fragment->s[1])) 519 fragment->c[1] = (1<<fragment->s[1])-1; 520 if (fragment->c[2] >= (1LU<<fragment->s[2])) 521 fragment->c[2] = (1<<fragment->s[2])-1; 522 if (fragment->c[3] >= (1LU<<fragment->s[3])) 523 fragment->c[3] = (1<<fragment->s[3])-1; 524 } 525 526 static inline int blendfactor(uint32_t x, uint32_t size, uint32_t def = 0) 527 { 528 if (!size) 529 return def; 530 531 // scale to 16 bits 532 if (size > 16) { 533 x >>= (size - 16); 534 } else if (size < 16) { 535 x = ggl_expand(x, size, 16); 536 } 537 x += x >> 15; 538 return x; 539 } 540 541 void blend_factor(context_t* /*c*/, pixel_t* r, 542 uint32_t factor, const pixel_t* src, const pixel_t* dst) 543 { 544 switch (factor) { 545 case GGL_ZERO: 546 r->c[1] = 547 r->c[2] = 548 r->c[3] = 549 r->c[0] = 0; 550 break; 551 case GGL_ONE: 552 r->c[1] = 553 r->c[2] = 554 r->c[3] = 555 r->c[0] = FIXED_ONE; 556 break; 557 case GGL_DST_COLOR: 558 r->c[1] = blendfactor(dst->c[1], dst->s[1]); 559 r->c[2] = blendfactor(dst->c[2], dst->s[2]); 560 r->c[3] = blendfactor(dst->c[3], dst->s[3]); 561 r->c[0] = blendfactor(dst->c[0], dst->s[0]); 562 break; 563 case GGL_SRC_COLOR: 564 r->c[1] = blendfactor(src->c[1], src->s[1]); 565 r->c[2] = blendfactor(src->c[2], src->s[2]); 566 r->c[3] = blendfactor(src->c[3], src->s[3]); 567 r->c[0] = blendfactor(src->c[0], src->s[0]); 568 break; 569 case GGL_ONE_MINUS_DST_COLOR: 570 r->c[1] = FIXED_ONE - blendfactor(dst->c[1], dst->s[1]); 571 r->c[2] = FIXED_ONE - blendfactor(dst->c[2], dst->s[2]); 572 r->c[3] = FIXED_ONE - blendfactor(dst->c[3], dst->s[3]); 573 r->c[0] = FIXED_ONE - blendfactor(dst->c[0], dst->s[0]); 574 break; 575 case GGL_ONE_MINUS_SRC_COLOR: 576 r->c[1] = FIXED_ONE - blendfactor(src->c[1], src->s[1]); 577 r->c[2] = FIXED_ONE - blendfactor(src->c[2], src->s[2]); 578 r->c[3] = FIXED_ONE - blendfactor(src->c[3], src->s[3]); 579 r->c[0] = FIXED_ONE - blendfactor(src->c[0], src->s[0]); 580 break; 581 case GGL_SRC_ALPHA: 582 r->c[1] = 583 r->c[2] = 584 r->c[3] = 585 r->c[0] = blendfactor(src->c[0], src->s[0], FIXED_ONE); 586 break; 587 case GGL_ONE_MINUS_SRC_ALPHA: 588 r->c[1] = 589 r->c[2] = 590 r->c[3] = 591 r->c[0] = FIXED_ONE - blendfactor(src->c[0], src->s[0], FIXED_ONE); 592 break; 593 case GGL_DST_ALPHA: 594 r->c[1] = 595 r->c[2] = 596 r->c[3] = 597 r->c[0] = blendfactor(dst->c[0], dst->s[0], FIXED_ONE); 598 break; 599 case GGL_ONE_MINUS_DST_ALPHA: 600 r->c[1] = 601 r->c[2] = 602 r->c[3] = 603 r->c[0] = FIXED_ONE - blendfactor(dst->c[0], dst->s[0], FIXED_ONE); 604 break; 605 case GGL_SRC_ALPHA_SATURATE: 606 // XXX: GGL_SRC_ALPHA_SATURATE 607 break; 608 } 609 } 610 611 static GGLfixed wrapping(int32_t coord, uint32_t size, int tx_wrap) 612 { 613 GGLfixed d; 614 if (tx_wrap == GGL_REPEAT) { 615 d = (uint32_t(coord)>>16) * size; 616 } else if (tx_wrap == GGL_CLAMP) { // CLAMP_TO_EDGE semantics 617 const GGLfixed clamp_min = FIXED_HALF; 618 const GGLfixed clamp_max = (size << 16) - FIXED_HALF; 619 if (coord < clamp_min) coord = clamp_min; 620 if (coord > clamp_max) coord = clamp_max; 621 d = coord; 622 } else { // 1:1 623 const GGLfixed clamp_min = 0; 624 const GGLfixed clamp_max = (size << 16); 625 if (coord < clamp_min) coord = clamp_min; 626 if (coord > clamp_max) coord = clamp_max; 627 d = coord; 628 } 629 return d; 630 } 631 632 static inline 633 GGLcolor ADJUST_COLOR_ITERATOR(GGLcolor v, GGLcolor dvdx, int len) 634 { 635 const int32_t end = dvdx * (len-1) + v; 636 if (end < 0) 637 v -= end; 638 v &= ~(v>>31); 639 return v; 640 } 641 642 void scanline(context_t* c) 643 { 644 const uint32_t enables = c->state.enables; 645 const int xs = c->iterators.xl; 646 const int x1 = c->iterators.xr; 647 int xc = x1 - xs; 648 const int16_t* covPtr = c->state.buffers.coverage + xs; 649 650 // All iterated values are sampled at the pixel center 651 652 // reset iterators for that scanline... 653 GGLcolor r, g, b, a; 654 iterators_t& ci = c->iterators; 655 if (enables & GGL_ENABLE_SMOOTH) { 656 r = (xs * c->shade.drdx) + ci.ydrdy; 657 g = (xs * c->shade.dgdx) + ci.ydgdy; 658 b = (xs * c->shade.dbdx) + ci.ydbdy; 659 a = (xs * c->shade.dadx) + ci.ydady; 660 r = ADJUST_COLOR_ITERATOR(r, c->shade.drdx, xc); 661 g = ADJUST_COLOR_ITERATOR(g, c->shade.dgdx, xc); 662 b = ADJUST_COLOR_ITERATOR(b, c->shade.dbdx, xc); 663 a = ADJUST_COLOR_ITERATOR(a, c->shade.dadx, xc); 664 } else { 665 r = ci.ydrdy; 666 g = ci.ydgdy; 667 b = ci.ydbdy; 668 a = ci.ydady; 669 } 670 671 // z iterators are 1.31 672 GGLfixed z = (xs * c->shade.dzdx) + ci.ydzdy; 673 GGLfixed f = (xs * c->shade.dfdx) + ci.ydfdy; 674 675 struct { 676 GGLfixed s, t; 677 } tc[GGL_TEXTURE_UNIT_COUNT]; 678 if (enables & GGL_ENABLE_TMUS) { 679 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; ++i) { 680 if (c->state.texture[i].enable) { 681 texture_iterators_t& ti = c->state.texture[i].iterators; 682 if (enables & GGL_ENABLE_W) { 683 tc[i].s = ti.ydsdy; 684 tc[i].t = ti.ydtdy; 685 } else { 686 tc[i].s = (xs * ti.dsdx) + ti.ydsdy; 687 tc[i].t = (xs * ti.dtdx) + ti.ydtdy; 688 } 689 } 690 } 691 } 692 693 pixel_t fragment; 694 pixel_t texel; 695 pixel_t fb; 696 697 uint32_t x = xs; 698 uint32_t y = c->iterators.y; 699 700 while (xc--) { 701 702 { // just a scope 703 704 // read color (convert to 8 bits by keeping only the integer part) 705 fragment.s[1] = fragment.s[2] = 706 fragment.s[3] = fragment.s[0] = 8; 707 fragment.c[1] = r >> (GGL_COLOR_BITS-8); 708 fragment.c[2] = g >> (GGL_COLOR_BITS-8); 709 fragment.c[3] = b >> (GGL_COLOR_BITS-8); 710 fragment.c[0] = a >> (GGL_COLOR_BITS-8); 711 712 // texturing 713 if (enables & GGL_ENABLE_TMUS) { 714 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; ++i) { 715 texture_t& tx = c->state.texture[i]; 716 if (!tx.enable) 717 continue; 718 texture_iterators_t& ti = tx.iterators; 719 int32_t u, v; 720 721 // s-coordinate 722 if (tx.s_coord != GGL_ONE_TO_ONE) { 723 const int w = tx.surface.width; 724 u = wrapping(tc[i].s, w, tx.s_wrap); 725 tc[i].s += ti.dsdx; 726 } else { 727 u = (((tx.shade.is0>>16) + x)<<16) + FIXED_HALF; 728 } 729 730 // t-coordinate 731 if (tx.t_coord != GGL_ONE_TO_ONE) { 732 const int h = tx.surface.height; 733 v = wrapping(tc[i].t, h, tx.t_wrap); 734 tc[i].t += ti.dtdx; 735 } else { 736 v = (((tx.shade.it0>>16) + y)<<16) + FIXED_HALF; 737 } 738 739 // read texture 740 if (tx.mag_filter == GGL_NEAREST && 741 tx.min_filter == GGL_NEAREST) 742 { 743 u >>= 16; 744 v >>= 16; 745 tx.surface.read(&tx.surface, c, u, v, &texel); 746 } else { 747 const int w = tx.surface.width; 748 const int h = tx.surface.height; 749 u -= FIXED_HALF; 750 v -= FIXED_HALF; 751 int u0 = u >> 16; 752 int v0 = v >> 16; 753 int u1 = u0 + 1; 754 int v1 = v0 + 1; 755 if (tx.s_wrap == GGL_REPEAT) { 756 if (u0<0) u0 += w; 757 if (u1<0) u1 += w; 758 if (u0>=w) u0 -= w; 759 if (u1>=w) u1 -= w; 760 } else { 761 if (u0<0) u0 = 0; 762 if (u1<0) u1 = 0; 763 if (u0>=w) u0 = w-1; 764 if (u1>=w) u1 = w-1; 765 } 766 if (tx.t_wrap == GGL_REPEAT) { 767 if (v0<0) v0 += h; 768 if (v1<0) v1 += h; 769 if (v0>=h) v0 -= h; 770 if (v1>=h) v1 -= h; 771 } else { 772 if (v0<0) v0 = 0; 773 if (v1<0) v1 = 0; 774 if (v0>=h) v0 = h-1; 775 if (v1>=h) v1 = h-1; 776 } 777 pixel_t texels[4]; 778 uint32_t mm[4]; 779 tx.surface.read(&tx.surface, c, u0, v0, &texels[0]); 780 tx.surface.read(&tx.surface, c, u0, v1, &texels[1]); 781 tx.surface.read(&tx.surface, c, u1, v0, &texels[2]); 782 tx.surface.read(&tx.surface, c, u1, v1, &texels[3]); 783 u = (u >> 12) & 0xF; 784 v = (v >> 12) & 0xF; 785 u += u>>3; 786 v += v>>3; 787 mm[0] = (0x10 - u) * (0x10 - v); 788 mm[1] = (0x10 - u) * v; 789 mm[2] = u * (0x10 - v); 790 mm[3] = 0x100 - (mm[0] + mm[1] + mm[2]); 791 for (int j=0 ; j<4 ; j++) { 792 texel.s[j] = texels[0].s[j]; 793 if (!texel.s[j]) continue; 794 texel.s[j] += 8; 795 texel.c[j] = texels[0].c[j]*mm[0] + 796 texels[1].c[j]*mm[1] + 797 texels[2].c[j]*mm[2] + 798 texels[3].c[j]*mm[3] ; 799 } 800 } 801 802 // Texture environnement... 803 for (int j=0 ; j<4 ; j++) { 804 uint32_t& Cf = fragment.c[j]; 805 uint32_t& Ct = texel.c[j]; 806 uint8_t& sf = fragment.s[j]; 807 uint8_t& st = texel.s[j]; 808 uint32_t At = texel.c[0]; 809 uint8_t sat = texel.s[0]; 810 switch (tx.env) { 811 case GGL_REPLACE: 812 if (st) { 813 Cf = Ct; 814 sf = st; 815 } 816 break; 817 case GGL_MODULATE: 818 if (st) { 819 uint32_t factor = Ct + (Ct>>(st-1)); 820 Cf = (Cf * factor) >> st; 821 } 822 break; 823 case GGL_DECAL: 824 if (sat) { 825 rescale(Cf, sf, Ct, st); 826 Cf += ((Ct - Cf) * (At + (At>>(sat-1)))) >> sat; 827 } 828 break; 829 case GGL_BLEND: 830 if (st) { 831 uint32_t Cc = tx.env_color[i]; 832 if (sf>8) Cc = (Cc * ((1<<sf)-1))>>8; 833 else if (sf<8) Cc = (Cc - (Cc>>(8-sf)))>>(8-sf); 834 uint32_t factor = Ct + (Ct>>(st-1)); 835 Cf = ((((1<<st) - factor) * Cf) + Ct*Cc)>>st; 836 } 837 break; 838 case GGL_ADD: 839 if (st) { 840 rescale(Cf, sf, Ct, st); 841 Cf += Ct; 842 } 843 break; 844 } 845 } 846 } 847 } 848 849 // coverage application 850 if (enables & GGL_ENABLE_AA) { 851 int16_t cf = *covPtr++; 852 fragment.c[0] = (int64_t(fragment.c[0]) * cf) >> 15; 853 } 854 855 // alpha-test 856 if (enables & GGL_ENABLE_ALPHA_TEST) { 857 GGLcolor ref = c->state.alpha_test.ref; 858 GGLcolor alpha = (uint64_t(fragment.c[0]) * 859 ((1<<GGL_COLOR_BITS)-1)) / ((1<<fragment.s[0])-1); 860 switch (c->state.alpha_test.func) { 861 case GGL_NEVER: goto discard; 862 case GGL_LESS: if (alpha<ref) break; goto discard; 863 case GGL_EQUAL: if (alpha==ref) break; goto discard; 864 case GGL_LEQUAL: if (alpha<=ref) break; goto discard; 865 case GGL_GREATER: if (alpha>ref) break; goto discard; 866 case GGL_NOTEQUAL: if (alpha!=ref) break; goto discard; 867 case GGL_GEQUAL: if (alpha>=ref) break; goto discard; 868 } 869 } 870 871 // depth test 872 if (c->state.buffers.depth.format) { 873 if (enables & GGL_ENABLE_DEPTH_TEST) { 874 surface_t* cb = &(c->state.buffers.depth); 875 uint16_t* p = (uint16_t*)(cb->data)+(x+(cb->stride*y)); 876 uint16_t zz = uint32_t(z)>>(16); 877 uint16_t depth = *p; 878 switch (c->state.depth_test.func) { 879 case GGL_NEVER: goto discard; 880 case GGL_LESS: if (zz<depth) break; goto discard; 881 case GGL_EQUAL: if (zz==depth) break; goto discard; 882 case GGL_LEQUAL: if (zz<=depth) break; goto discard; 883 case GGL_GREATER: if (zz>depth) break; goto discard; 884 case GGL_NOTEQUAL: if (zz!=depth) break; goto discard; 885 case GGL_GEQUAL: if (zz>=depth) break; goto discard; 886 } 887 // depth buffer is not enabled, if depth-test is not enabled 888 /* 889 fragment.s[1] = fragment.s[2] = 890 fragment.s[3] = fragment.s[0] = 8; 891 fragment.c[1] = 892 fragment.c[2] = 893 fragment.c[3] = 894 fragment.c[0] = 255 - (zz>>8); 895 */ 896 if (c->state.mask.depth) { 897 *p = zz; 898 } 899 } 900 } 901 902 // fog 903 if (enables & GGL_ENABLE_FOG) { 904 for (int i=1 ; i<=3 ; i++) { 905 GGLfixed fc = (c->state.fog.color[i] * 0x10000) / 0xFF; 906 uint32_t& c = fragment.c[i]; 907 uint8_t& s = fragment.s[i]; 908 c = (c * 0x10000) / ((1<<s)-1); 909 c = gglMulAddx(c, f, gglMulx(fc, 0x10000 - f)); 910 s = 16; 911 } 912 } 913 914 // blending 915 if (enables & GGL_ENABLE_BLENDING) { 916 fb.c[1] = fb.c[2] = fb.c[3] = fb.c[0] = 0; // placate valgrind 917 fb.s[1] = fb.s[2] = fb.s[3] = fb.s[0] = 0; 918 c->state.buffers.color.read( 919 &(c->state.buffers.color), c, x, y, &fb); 920 blending( c, &fragment, &fb ); 921 } 922 923 // write 924 c->state.buffers.color.write( 925 &(c->state.buffers.color), c, x, y, &fragment); 926 } 927 928 discard: 929 // iterate... 930 x += 1; 931 if (enables & GGL_ENABLE_SMOOTH) { 932 r += c->shade.drdx; 933 g += c->shade.dgdx; 934 b += c->shade.dbdx; 935 a += c->shade.dadx; 936 } 937 z += c->shade.dzdx; 938 f += c->shade.dfdx; 939 } 940 } 941 942 #endif // ANDROID_ARM_CODEGEN && (ANDROID_CODEGEN == ANDROID_CODEGEN_GENERATED) 943 944 // ---------------------------------------------------------------------------- 945 #if 0 946 #pragma mark - 947 #pragma mark Scanline 948 #endif 949 950 /* Used to parse a 32-bit source texture linearly. Usage is: 951 * 952 * horz_iterator32 hi(context); 953 * while (...) { 954 * uint32_t src_pixel = hi.get_pixel32(); 955 * ... 956 * } 957 * 958 * Use only for one-to-one texture mapping. 959 */ 960 struct horz_iterator32 { 961 horz_iterator32(context_t* c) { 962 const int x = c->iterators.xl; 963 const int y = c->iterators.y; 964 texture_t& tx = c->state.texture[0]; 965 const int32_t u = (tx.shade.is0>>16) + x; 966 const int32_t v = (tx.shade.it0>>16) + y; 967 m_src = reinterpret_cast<uint32_t*>(tx.surface.data)+(u+(tx.surface.stride*v)); 968 } 969 uint32_t get_pixel32() { 970 return *m_src++; 971 } 972 protected: 973 uint32_t* m_src; 974 }; 975 976 /* A variant for 16-bit source textures. */ 977 struct horz_iterator16 { 978 horz_iterator16(context_t* c) { 979 const int x = c->iterators.xl; 980 const int y = c->iterators.y; 981 texture_t& tx = c->state.texture[0]; 982 const int32_t u = (tx.shade.is0>>16) + x; 983 const int32_t v = (tx.shade.it0>>16) + y; 984 m_src = reinterpret_cast<uint16_t*>(tx.surface.data)+(u+(tx.surface.stride*v)); 985 } 986 uint16_t get_pixel16() { 987 return *m_src++; 988 } 989 protected: 990 uint16_t* m_src; 991 }; 992 993 /* A clamp iterator is used to iterate inside a texture with GGL_CLAMP. 994 * After initialization, call get_src16() or get_src32() to get the current 995 * texture pixel value. 996 */ 997 struct clamp_iterator { 998 clamp_iterator(context_t* c) { 999 const int xs = c->iterators.xl; 1000 texture_t& tx = c->state.texture[0]; 1001 texture_iterators_t& ti = tx.iterators; 1002 m_s = (xs * ti.dsdx) + ti.ydsdy; 1003 m_t = (xs * ti.dtdx) + ti.ydtdy; 1004 m_ds = ti.dsdx; 1005 m_dt = ti.dtdx; 1006 m_width_m1 = tx.surface.width - 1; 1007 m_height_m1 = tx.surface.height - 1; 1008 m_data = tx.surface.data; 1009 m_stride = tx.surface.stride; 1010 } 1011 uint16_t get_pixel16() { 1012 int u, v; 1013 get_uv(u, v); 1014 uint16_t* src = reinterpret_cast<uint16_t*>(m_data) + (u + (m_stride*v)); 1015 return src[0]; 1016 } 1017 uint32_t get_pixel32() { 1018 int u, v; 1019 get_uv(u, v); 1020 uint32_t* src = reinterpret_cast<uint32_t*>(m_data) + (u + (m_stride*v)); 1021 return src[0]; 1022 } 1023 private: 1024 void get_uv(int& u, int& v) { 1025 int uu = m_s >> 16; 1026 int vv = m_t >> 16; 1027 if (uu < 0) 1028 uu = 0; 1029 if (uu > m_width_m1) 1030 uu = m_width_m1; 1031 if (vv < 0) 1032 vv = 0; 1033 if (vv > m_height_m1) 1034 vv = m_height_m1; 1035 u = uu; 1036 v = vv; 1037 m_s += m_ds; 1038 m_t += m_dt; 1039 } 1040 1041 GGLfixed m_s, m_t; 1042 GGLfixed m_ds, m_dt; 1043 int m_width_m1, m_height_m1; 1044 uint8_t* m_data; 1045 int m_stride; 1046 }; 1047 1048 /* 1049 * The 'horizontal clamp iterator' variant corresponds to the case where 1050 * the 'v' coordinate doesn't change. This is useful to avoid one mult and 1051 * extra adds / checks per pixels, if the blending/processing operation after 1052 * this is very fast. 1053 */ 1054 static int is_context_horizontal(const context_t* c) { 1055 return (c->state.texture[0].iterators.dtdx == 0); 1056 } 1057 1058 struct horz_clamp_iterator { 1059 uint16_t get_pixel16() { 1060 int u = m_s >> 16; 1061 m_s += m_ds; 1062 if (u < 0) 1063 u = 0; 1064 if (u > m_width_m1) 1065 u = m_width_m1; 1066 const uint16_t* src = reinterpret_cast<const uint16_t*>(m_data); 1067 return src[u]; 1068 } 1069 uint32_t get_pixel32() { 1070 int u = m_s >> 16; 1071 m_s += m_ds; 1072 if (u < 0) 1073 u = 0; 1074 if (u > m_width_m1) 1075 u = m_width_m1; 1076 const uint32_t* src = reinterpret_cast<const uint32_t*>(m_data); 1077 return src[u]; 1078 } 1079 protected: 1080 void init(const context_t* c, int shift); 1081 GGLfixed m_s; 1082 GGLfixed m_ds; 1083 int m_width_m1; 1084 const uint8_t* m_data; 1085 }; 1086 1087 void horz_clamp_iterator::init(const context_t* c, int shift) 1088 { 1089 const int xs = c->iterators.xl; 1090 const texture_t& tx = c->state.texture[0]; 1091 const texture_iterators_t& ti = tx.iterators; 1092 m_s = (xs * ti.dsdx) + ti.ydsdy; 1093 m_ds = ti.dsdx; 1094 m_width_m1 = tx.surface.width-1; 1095 m_data = tx.surface.data; 1096 1097 GGLfixed t = (xs * ti.dtdx) + ti.ydtdy; 1098 int v = t >> 16; 1099 if (v < 0) 1100 v = 0; 1101 else if (v >= (int)tx.surface.height) 1102 v = (int)tx.surface.height-1; 1103 1104 m_data += (tx.surface.stride*v) << shift; 1105 } 1106 1107 struct horz_clamp_iterator16 : horz_clamp_iterator { 1108 horz_clamp_iterator16(const context_t* c) { 1109 init(c,1); 1110 }; 1111 }; 1112 1113 struct horz_clamp_iterator32 : horz_clamp_iterator { 1114 horz_clamp_iterator32(context_t* c) { 1115 init(c,2); 1116 }; 1117 }; 1118 1119 /* This is used to perform dithering operations. 1120 */ 1121 struct ditherer { 1122 ditherer(const context_t* c) { 1123 const int x = c->iterators.xl; 1124 const int y = c->iterators.y; 1125 m_line = &c->ditherMatrix[ ((y & GGL_DITHER_MASK)<<GGL_DITHER_ORDER_SHIFT) ]; 1126 m_index = x & GGL_DITHER_MASK; 1127 } 1128 void step(void) { 1129 m_index++; 1130 } 1131 int get_value(void) { 1132 int ret = m_line[m_index & GGL_DITHER_MASK]; 1133 m_index++; 1134 return ret; 1135 } 1136 uint16_t abgr8888ToRgb565(uint32_t s) { 1137 uint32_t r = s & 0xff; 1138 uint32_t g = (s >> 8) & 0xff; 1139 uint32_t b = (s >> 16) & 0xff; 1140 return rgb888ToRgb565(r,g,b); 1141 } 1142 /* The following assumes that r/g/b are in the 0..255 range each */ 1143 uint16_t rgb888ToRgb565(uint32_t& r, uint32_t& g, uint32_t &b) { 1144 int threshold = get_value(); 1145 /* dither in on GGL_DITHER_BITS, and each of r, g, b is on 8 bits */ 1146 r += (threshold >> (GGL_DITHER_BITS-8 +5)); 1147 g += (threshold >> (GGL_DITHER_BITS-8 +6)); 1148 b += (threshold >> (GGL_DITHER_BITS-8 +5)); 1149 if (r > 0xff) 1150 r = 0xff; 1151 if (g > 0xff) 1152 g = 0xff; 1153 if (b > 0xff) 1154 b = 0xff; 1155 return uint16_t(((r & 0xf8) << 8) | ((g & 0xfc) << 3) | (b >> 3)); 1156 } 1157 protected: 1158 const uint8_t* m_line; 1159 int m_index; 1160 }; 1161 1162 /* This structure is used to blend (SRC_OVER) 32-bit source pixels 1163 * onto 16-bit destination ones. Usage is simply: 1164 * 1165 * blender.blend(<32-bit-src-pixel-value>,<ptr-to-16-bit-dest-pixel>) 1166 */ 1167 struct blender_32to16 { 1168 blender_32to16(context_t* /*c*/) { } 1169 void write(uint32_t s, uint16_t* dst) { 1170 if (s == 0) 1171 return; 1172 s = GGL_RGBA_TO_HOST(s); 1173 int sA = (s>>24); 1174 if (sA == 0xff) { 1175 *dst = convertAbgr8888ToRgb565(s); 1176 } else { 1177 int f = 0x100 - (sA + (sA>>7)); 1178 int sR = (s >> ( 3))&0x1F; 1179 int sG = (s >> ( 8+2))&0x3F; 1180 int sB = (s >> (16+3))&0x1F; 1181 uint16_t d = *dst; 1182 int dR = (d>>11)&0x1f; 1183 int dG = (d>>5)&0x3f; 1184 int dB = (d)&0x1f; 1185 sR += (f*dR)>>8; 1186 sG += (f*dG)>>8; 1187 sB += (f*dB)>>8; 1188 *dst = uint16_t((sR<<11)|(sG<<5)|sB); 1189 } 1190 } 1191 void write(uint32_t s, uint16_t* dst, ditherer& di) { 1192 if (s == 0) { 1193 di.step(); 1194 return; 1195 } 1196 s = GGL_RGBA_TO_HOST(s); 1197 int sA = (s>>24); 1198 if (sA == 0xff) { 1199 *dst = di.abgr8888ToRgb565(s); 1200 } else { 1201 int threshold = di.get_value() << (8 - GGL_DITHER_BITS); 1202 int f = 0x100 - (sA + (sA>>7)); 1203 int sR = (s >> ( 3))&0x1F; 1204 int sG = (s >> ( 8+2))&0x3F; 1205 int sB = (s >> (16+3))&0x1F; 1206 uint16_t d = *dst; 1207 int dR = (d>>11)&0x1f; 1208 int dG = (d>>5)&0x3f; 1209 int dB = (d)&0x1f; 1210 sR = ((sR << 8) + f*dR + threshold)>>8; 1211 sG = ((sG << 8) + f*dG + threshold)>>8; 1212 sB = ((sB << 8) + f*dB + threshold)>>8; 1213 if (sR > 0x1f) sR = 0x1f; 1214 if (sG > 0x3f) sG = 0x3f; 1215 if (sB > 0x1f) sB = 0x1f; 1216 *dst = uint16_t((sR<<11)|(sG<<5)|sB); 1217 } 1218 } 1219 }; 1220 1221 /* This blender does the same for the 'blend_srca' operation. 1222 * where dstFactor=srcA*(1-srcA) srcFactor=srcA 1223 */ 1224 struct blender_32to16_srcA { 1225 blender_32to16_srcA(const context_t* /*c*/) { } 1226 void write(uint32_t s, uint16_t* dst) { 1227 if (!s) { 1228 return; 1229 } 1230 uint16_t d = *dst; 1231 s = GGL_RGBA_TO_HOST(s); 1232 int sR = (s >> ( 3))&0x1F; 1233 int sG = (s >> ( 8+2))&0x3F; 1234 int sB = (s >> (16+3))&0x1F; 1235 int sA = (s>>24); 1236 int f1 = (sA + (sA>>7)); 1237 int f2 = 0x100-f1; 1238 int dR = (d>>11)&0x1f; 1239 int dG = (d>>5)&0x3f; 1240 int dB = (d)&0x1f; 1241 sR = (f1*sR + f2*dR)>>8; 1242 sG = (f1*sG + f2*dG)>>8; 1243 sB = (f1*sB + f2*dB)>>8; 1244 *dst = uint16_t((sR<<11)|(sG<<5)|sB); 1245 } 1246 }; 1247 1248 /* Common init code the modulating blenders */ 1249 struct blender_modulate { 1250 void init(const context_t* c) { 1251 const int r = c->iterators.ydrdy >> (GGL_COLOR_BITS-8); 1252 const int g = c->iterators.ydgdy >> (GGL_COLOR_BITS-8); 1253 const int b = c->iterators.ydbdy >> (GGL_COLOR_BITS-8); 1254 const int a = c->iterators.ydady >> (GGL_COLOR_BITS-8); 1255 m_r = r + (r >> 7); 1256 m_g = g + (g >> 7); 1257 m_b = b + (b >> 7); 1258 m_a = a + (a >> 7); 1259 } 1260 protected: 1261 int m_r, m_g, m_b, m_a; 1262 }; 1263 1264 /* This blender does a normal blend after modulation. 1265 */ 1266 struct blender_32to16_modulate : blender_modulate { 1267 blender_32to16_modulate(const context_t* c) { 1268 init(c); 1269 } 1270 void write(uint32_t s, uint16_t* dst) { 1271 // blend source and destination 1272 if (!s) { 1273 return; 1274 } 1275 s = GGL_RGBA_TO_HOST(s); 1276 1277 /* We need to modulate s */ 1278 uint32_t sA = (s >> 24); 1279 uint32_t sB = (s >> 16) & 0xff; 1280 uint32_t sG = (s >> 8) & 0xff; 1281 uint32_t sR = s & 0xff; 1282 1283 sA = (sA*m_a) >> 8; 1284 /* Keep R/G/B scaled to 5.8 or 6.8 fixed float format */ 1285 sR = (sR*m_r) >> (8 - 5); 1286 sG = (sG*m_g) >> (8 - 6); 1287 sB = (sB*m_b) >> (8 - 5); 1288 1289 /* Now do a normal blend */ 1290 int f = 0x100 - (sA + (sA>>7)); 1291 uint16_t d = *dst; 1292 int dR = (d>>11)&0x1f; 1293 int dG = (d>>5)&0x3f; 1294 int dB = (d)&0x1f; 1295 sR = (sR + f*dR)>>8; 1296 sG = (sG + f*dG)>>8; 1297 sB = (sB + f*dB)>>8; 1298 *dst = uint16_t((sR<<11)|(sG<<5)|sB); 1299 } 1300 void write(uint32_t s, uint16_t* dst, ditherer& di) { 1301 // blend source and destination 1302 if (!s) { 1303 di.step(); 1304 return; 1305 } 1306 s = GGL_RGBA_TO_HOST(s); 1307 1308 /* We need to modulate s */ 1309 uint32_t sA = (s >> 24); 1310 uint32_t sB = (s >> 16) & 0xff; 1311 uint32_t sG = (s >> 8) & 0xff; 1312 uint32_t sR = s & 0xff; 1313 1314 sA = (sA*m_a) >> 8; 1315 /* keep R/G/B scaled to 5.8 or 6.8 fixed float format */ 1316 sR = (sR*m_r) >> (8 - 5); 1317 sG = (sG*m_g) >> (8 - 6); 1318 sB = (sB*m_b) >> (8 - 5); 1319 1320 /* Scale threshold to 0.8 fixed float format */ 1321 int threshold = di.get_value() << (8 - GGL_DITHER_BITS); 1322 int f = 0x100 - (sA + (sA>>7)); 1323 uint16_t d = *dst; 1324 int dR = (d>>11)&0x1f; 1325 int dG = (d>>5)&0x3f; 1326 int dB = (d)&0x1f; 1327 sR = (sR + f*dR + threshold)>>8; 1328 sG = (sG + f*dG + threshold)>>8; 1329 sB = (sB + f*dB + threshold)>>8; 1330 if (sR > 0x1f) sR = 0x1f; 1331 if (sG > 0x3f) sG = 0x3f; 1332 if (sB > 0x1f) sB = 0x1f; 1333 *dst = uint16_t((sR<<11)|(sG<<5)|sB); 1334 } 1335 }; 1336 1337 /* same as 32to16_modulate, except that the input is xRGB, instead of ARGB */ 1338 struct blender_x32to16_modulate : blender_modulate { 1339 blender_x32to16_modulate(const context_t* c) { 1340 init(c); 1341 } 1342 void write(uint32_t s, uint16_t* dst) { 1343 s = GGL_RGBA_TO_HOST(s); 1344 1345 uint32_t sB = (s >> 16) & 0xff; 1346 uint32_t sG = (s >> 8) & 0xff; 1347 uint32_t sR = s & 0xff; 1348 1349 /* Keep R/G/B in 5.8 or 6.8 format */ 1350 sR = (sR*m_r) >> (8 - 5); 1351 sG = (sG*m_g) >> (8 - 6); 1352 sB = (sB*m_b) >> (8 - 5); 1353 1354 int f = 0x100 - m_a; 1355 uint16_t d = *dst; 1356 int dR = (d>>11)&0x1f; 1357 int dG = (d>>5)&0x3f; 1358 int dB = (d)&0x1f; 1359 sR = (sR + f*dR)>>8; 1360 sG = (sG + f*dG)>>8; 1361 sB = (sB + f*dB)>>8; 1362 *dst = uint16_t((sR<<11)|(sG<<5)|sB); 1363 } 1364 void write(uint32_t s, uint16_t* dst, ditherer& di) { 1365 s = GGL_RGBA_TO_HOST(s); 1366 1367 uint32_t sB = (s >> 16) & 0xff; 1368 uint32_t sG = (s >> 8) & 0xff; 1369 uint32_t sR = s & 0xff; 1370 1371 sR = (sR*m_r) >> (8 - 5); 1372 sG = (sG*m_g) >> (8 - 6); 1373 sB = (sB*m_b) >> (8 - 5); 1374 1375 /* Now do a normal blend */ 1376 int threshold = di.get_value() << (8 - GGL_DITHER_BITS); 1377 int f = 0x100 - m_a; 1378 uint16_t d = *dst; 1379 int dR = (d>>11)&0x1f; 1380 int dG = (d>>5)&0x3f; 1381 int dB = (d)&0x1f; 1382 sR = (sR + f*dR + threshold)>>8; 1383 sG = (sG + f*dG + threshold)>>8; 1384 sB = (sB + f*dB + threshold)>>8; 1385 if (sR > 0x1f) sR = 0x1f; 1386 if (sG > 0x3f) sG = 0x3f; 1387 if (sB > 0x1f) sB = 0x1f; 1388 *dst = uint16_t((sR<<11)|(sG<<5)|sB); 1389 } 1390 }; 1391 1392 /* Same as above, but source is 16bit rgb565 */ 1393 struct blender_16to16_modulate : blender_modulate { 1394 blender_16to16_modulate(const context_t* c) { 1395 init(c); 1396 } 1397 void write(uint16_t s16, uint16_t* dst) { 1398 uint32_t s = s16; 1399 1400 uint32_t sR = s >> 11; 1401 uint32_t sG = (s >> 5) & 0x3f; 1402 uint32_t sB = s & 0x1f; 1403 1404 sR = (sR*m_r); 1405 sG = (sG*m_g); 1406 sB = (sB*m_b); 1407 1408 int f = 0x100 - m_a; 1409 uint16_t d = *dst; 1410 int dR = (d>>11)&0x1f; 1411 int dG = (d>>5)&0x3f; 1412 int dB = (d)&0x1f; 1413 sR = (sR + f*dR)>>8; 1414 sG = (sG + f*dG)>>8; 1415 sB = (sB + f*dB)>>8; 1416 *dst = uint16_t((sR<<11)|(sG<<5)|sB); 1417 } 1418 }; 1419 1420 /* This is used to iterate over a 16-bit destination color buffer. 1421 * Usage is: 1422 * 1423 * dst_iterator16 di(context); 1424 * while (di.count--) { 1425 * <do stuff with dest pixel at di.dst> 1426 * di.dst++; 1427 * } 1428 */ 1429 struct dst_iterator16 { 1430 dst_iterator16(const context_t* c) { 1431 const int x = c->iterators.xl; 1432 const int width = c->iterators.xr - x; 1433 const int32_t y = c->iterators.y; 1434 const surface_t* cb = &(c->state.buffers.color); 1435 count = width; 1436 dst = reinterpret_cast<uint16_t*>(cb->data) + (x+(cb->stride*y)); 1437 } 1438 int count; 1439 uint16_t* dst; 1440 }; 1441 1442 1443 static void scanline_t32cb16_clamp(context_t* c) 1444 { 1445 dst_iterator16 di(c); 1446 1447 if (is_context_horizontal(c)) { 1448 /* Special case for simple horizontal scaling */ 1449 horz_clamp_iterator32 ci(c); 1450 while (di.count--) { 1451 uint32_t s = ci.get_pixel32(); 1452 *di.dst++ = convertAbgr8888ToRgb565(s); 1453 } 1454 } else { 1455 /* General case */ 1456 clamp_iterator ci(c); 1457 while (di.count--) { 1458 uint32_t s = ci.get_pixel32(); 1459 *di.dst++ = convertAbgr8888ToRgb565(s); 1460 } 1461 } 1462 } 1463 1464 static void scanline_t32cb16_dither(context_t* c) 1465 { 1466 horz_iterator32 si(c); 1467 dst_iterator16 di(c); 1468 ditherer dither(c); 1469 1470 while (di.count--) { 1471 uint32_t s = si.get_pixel32(); 1472 *di.dst++ = dither.abgr8888ToRgb565(s); 1473 } 1474 } 1475 1476 static void scanline_t32cb16_clamp_dither(context_t* c) 1477 { 1478 dst_iterator16 di(c); 1479 ditherer dither(c); 1480 1481 if (is_context_horizontal(c)) { 1482 /* Special case for simple horizontal scaling */ 1483 horz_clamp_iterator32 ci(c); 1484 while (di.count--) { 1485 uint32_t s = ci.get_pixel32(); 1486 *di.dst++ = dither.abgr8888ToRgb565(s); 1487 } 1488 } else { 1489 /* General case */ 1490 clamp_iterator ci(c); 1491 while (di.count--) { 1492 uint32_t s = ci.get_pixel32(); 1493 *di.dst++ = dither.abgr8888ToRgb565(s); 1494 } 1495 } 1496 } 1497 1498 static void scanline_t32cb16blend_dither(context_t* c) 1499 { 1500 dst_iterator16 di(c); 1501 ditherer dither(c); 1502 blender_32to16 bl(c); 1503 horz_iterator32 hi(c); 1504 while (di.count--) { 1505 uint32_t s = hi.get_pixel32(); 1506 bl.write(s, di.dst, dither); 1507 di.dst++; 1508 } 1509 } 1510 1511 static void scanline_t32cb16blend_clamp(context_t* c) 1512 { 1513 dst_iterator16 di(c); 1514 blender_32to16 bl(c); 1515 1516 if (is_context_horizontal(c)) { 1517 horz_clamp_iterator32 ci(c); 1518 while (di.count--) { 1519 uint32_t s = ci.get_pixel32(); 1520 bl.write(s, di.dst); 1521 di.dst++; 1522 } 1523 } else { 1524 clamp_iterator ci(c); 1525 while (di.count--) { 1526 uint32_t s = ci.get_pixel32(); 1527 bl.write(s, di.dst); 1528 di.dst++; 1529 } 1530 } 1531 } 1532 1533 static void scanline_t32cb16blend_clamp_dither(context_t* c) 1534 { 1535 dst_iterator16 di(c); 1536 ditherer dither(c); 1537 blender_32to16 bl(c); 1538 1539 clamp_iterator ci(c); 1540 while (di.count--) { 1541 uint32_t s = ci.get_pixel32(); 1542 bl.write(s, di.dst, dither); 1543 di.dst++; 1544 } 1545 } 1546 1547 void scanline_t32cb16blend_clamp_mod(context_t* c) 1548 { 1549 dst_iterator16 di(c); 1550 blender_32to16_modulate bl(c); 1551 1552 clamp_iterator ci(c); 1553 while (di.count--) { 1554 uint32_t s = ci.get_pixel32(); 1555 bl.write(s, di.dst); 1556 di.dst++; 1557 } 1558 } 1559 1560 void scanline_t32cb16blend_clamp_mod_dither(context_t* c) 1561 { 1562 dst_iterator16 di(c); 1563 blender_32to16_modulate bl(c); 1564 ditherer dither(c); 1565 1566 clamp_iterator ci(c); 1567 while (di.count--) { 1568 uint32_t s = ci.get_pixel32(); 1569 bl.write(s, di.dst, dither); 1570 di.dst++; 1571 } 1572 } 1573 1574 /* Variant of scanline_t32cb16blend_clamp_mod with a xRGB texture */ 1575 void scanline_x32cb16blend_clamp_mod(context_t* c) 1576 { 1577 dst_iterator16 di(c); 1578 blender_x32to16_modulate bl(c); 1579 1580 clamp_iterator ci(c); 1581 while (di.count--) { 1582 uint32_t s = ci.get_pixel32(); 1583 bl.write(s, di.dst); 1584 di.dst++; 1585 } 1586 } 1587 1588 void scanline_x32cb16blend_clamp_mod_dither(context_t* c) 1589 { 1590 dst_iterator16 di(c); 1591 blender_x32to16_modulate bl(c); 1592 ditherer dither(c); 1593 1594 clamp_iterator ci(c); 1595 while (di.count--) { 1596 uint32_t s = ci.get_pixel32(); 1597 bl.write(s, di.dst, dither); 1598 di.dst++; 1599 } 1600 } 1601 1602 void scanline_t16cb16_clamp(context_t* c) 1603 { 1604 dst_iterator16 di(c); 1605 1606 /* Special case for simple horizontal scaling */ 1607 if (is_context_horizontal(c)) { 1608 horz_clamp_iterator16 ci(c); 1609 while (di.count--) { 1610 *di.dst++ = ci.get_pixel16(); 1611 } 1612 } else { 1613 clamp_iterator ci(c); 1614 while (di.count--) { 1615 *di.dst++ = ci.get_pixel16(); 1616 } 1617 } 1618 } 1619 1620 1621 1622 template <typename T, typename U> 1623 static inline __attribute__((const)) 1624 T interpolate(int y, T v0, U dvdx, U dvdy) { 1625 // interpolates in pixel's centers 1626 // v = v0 + (y + 0.5) * dvdy + (0.5 * dvdx) 1627 return (y * dvdy) + (v0 + ((dvdy + dvdx) >> 1)); 1628 } 1629 1630 // ---------------------------------------------------------------------------- 1631 #if 0 1632 #pragma mark - 1633 #endif 1634 1635 void init_y(context_t* c, int32_t ys) 1636 { 1637 const uint32_t enables = c->state.enables; 1638 1639 // compute iterators... 1640 iterators_t& ci = c->iterators; 1641 1642 // sample in the center 1643 ci.y = ys; 1644 1645 if (enables & (GGL_ENABLE_DEPTH_TEST|GGL_ENABLE_W|GGL_ENABLE_FOG)) { 1646 ci.ydzdy = interpolate(ys, c->shade.z0, c->shade.dzdx, c->shade.dzdy); 1647 ci.ydwdy = interpolate(ys, c->shade.w0, c->shade.dwdx, c->shade.dwdy); 1648 ci.ydfdy = interpolate(ys, c->shade.f0, c->shade.dfdx, c->shade.dfdy); 1649 } 1650 1651 if (ggl_unlikely(enables & GGL_ENABLE_SMOOTH)) { 1652 ci.ydrdy = interpolate(ys, c->shade.r0, c->shade.drdx, c->shade.drdy); 1653 ci.ydgdy = interpolate(ys, c->shade.g0, c->shade.dgdx, c->shade.dgdy); 1654 ci.ydbdy = interpolate(ys, c->shade.b0, c->shade.dbdx, c->shade.dbdy); 1655 ci.ydady = interpolate(ys, c->shade.a0, c->shade.dadx, c->shade.dady); 1656 c->step_y = step_y__smooth; 1657 } else { 1658 ci.ydrdy = c->shade.r0; 1659 ci.ydgdy = c->shade.g0; 1660 ci.ydbdy = c->shade.b0; 1661 ci.ydady = c->shade.a0; 1662 // XXX: do only if needed, or make sure this is fast 1663 c->packed = ggl_pack_color(c, c->state.buffers.color.format, 1664 ci.ydrdy, ci.ydgdy, ci.ydbdy, ci.ydady); 1665 c->packed8888 = ggl_pack_color(c, GGL_PIXEL_FORMAT_RGBA_8888, 1666 ci.ydrdy, ci.ydgdy, ci.ydbdy, ci.ydady); 1667 } 1668 1669 // initialize the variables we need in the shader 1670 generated_vars_t& gen = c->generated_vars; 1671 gen.argb[GGLFormat::ALPHA].c = ci.ydady; 1672 gen.argb[GGLFormat::ALPHA].dx = c->shade.dadx; 1673 gen.argb[GGLFormat::RED ].c = ci.ydrdy; 1674 gen.argb[GGLFormat::RED ].dx = c->shade.drdx; 1675 gen.argb[GGLFormat::GREEN].c = ci.ydgdy; 1676 gen.argb[GGLFormat::GREEN].dx = c->shade.dgdx; 1677 gen.argb[GGLFormat::BLUE ].c = ci.ydbdy; 1678 gen.argb[GGLFormat::BLUE ].dx = c->shade.dbdx; 1679 gen.dzdx = c->shade.dzdx; 1680 gen.f = ci.ydfdy; 1681 gen.dfdx = c->shade.dfdx; 1682 1683 if (enables & GGL_ENABLE_TMUS) { 1684 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; ++i) { 1685 texture_t& t = c->state.texture[i]; 1686 if (!t.enable) continue; 1687 1688 texture_iterators_t& ti = t.iterators; 1689 if (t.s_coord == GGL_ONE_TO_ONE && t.t_coord == GGL_ONE_TO_ONE) { 1690 // we need to set all of these to 0 because in some cases 1691 // step_y__generic() or step_y__tmu() will be used and 1692 // therefore will update dtdy, however, in 1:1 mode 1693 // this is always done by the scanline rasterizer. 1694 ti.dsdx = ti.dsdy = ti.dtdx = ti.dtdy = 0; 1695 ti.ydsdy = t.shade.is0; 1696 ti.ydtdy = t.shade.it0; 1697 } else { 1698 const int adjustSWrap = ((t.s_wrap==GGL_CLAMP)?0:16); 1699 const int adjustTWrap = ((t.t_wrap==GGL_CLAMP)?0:16); 1700 ti.sscale = t.shade.sscale + adjustSWrap; 1701 ti.tscale = t.shade.tscale + adjustTWrap; 1702 if (!(enables & GGL_ENABLE_W)) { 1703 // S coordinate 1704 const int32_t sscale = ti.sscale; 1705 const int32_t sy = interpolate(ys, 1706 t.shade.is0, t.shade.idsdx, t.shade.idsdy); 1707 if (sscale>=0) { 1708 ti.ydsdy= sy << sscale; 1709 ti.dsdx = t.shade.idsdx << sscale; 1710 ti.dsdy = t.shade.idsdy << sscale; 1711 } else { 1712 ti.ydsdy= sy >> -sscale; 1713 ti.dsdx = t.shade.idsdx >> -sscale; 1714 ti.dsdy = t.shade.idsdy >> -sscale; 1715 } 1716 // T coordinate 1717 const int32_t tscale = ti.tscale; 1718 const int32_t ty = interpolate(ys, 1719 t.shade.it0, t.shade.idtdx, t.shade.idtdy); 1720 if (tscale>=0) { 1721 ti.ydtdy= ty << tscale; 1722 ti.dtdx = t.shade.idtdx << tscale; 1723 ti.dtdy = t.shade.idtdy << tscale; 1724 } else { 1725 ti.ydtdy= ty >> -tscale; 1726 ti.dtdx = t.shade.idtdx >> -tscale; 1727 ti.dtdy = t.shade.idtdy >> -tscale; 1728 } 1729 } 1730 } 1731 // mirror for generated code... 1732 generated_tex_vars_t& gen = c->generated_vars.texture[i]; 1733 gen.width = t.surface.width; 1734 gen.height = t.surface.height; 1735 gen.stride = t.surface.stride; 1736 gen.data = uintptr_t(t.surface.data); 1737 gen.dsdx = ti.dsdx; 1738 gen.dtdx = ti.dtdx; 1739 } 1740 } 1741 1742 // choose the y-stepper 1743 c->step_y = step_y__nop; 1744 if (enables & GGL_ENABLE_FOG) { 1745 c->step_y = step_y__generic; 1746 } else if (enables & GGL_ENABLE_TMUS) { 1747 if (enables & GGL_ENABLE_SMOOTH) { 1748 c->step_y = step_y__generic; 1749 } else if (enables & GGL_ENABLE_W) { 1750 c->step_y = step_y__w; 1751 } else { 1752 c->step_y = step_y__tmu; 1753 } 1754 } else { 1755 if (enables & GGL_ENABLE_SMOOTH) { 1756 c->step_y = step_y__smooth; 1757 } 1758 } 1759 1760 // choose the rectangle blitter 1761 c->rect = rect_generic; 1762 if ((c->step_y == step_y__nop) && 1763 (c->scanline == scanline_memcpy)) 1764 { 1765 c->rect = rect_memcpy; 1766 } 1767 } 1768 1769 void init_y_packed(context_t* c, int32_t y0) 1770 { 1771 uint8_t f = c->state.buffers.color.format; 1772 c->packed = ggl_pack_color(c, f, 1773 c->shade.r0, c->shade.g0, c->shade.b0, c->shade.a0); 1774 c->packed8888 = ggl_pack_color(c, GGL_PIXEL_FORMAT_RGBA_8888, 1775 c->shade.r0, c->shade.g0, c->shade.b0, c->shade.a0); 1776 c->iterators.y = y0; 1777 c->step_y = step_y__nop; 1778 // choose the rectangle blitter 1779 c->rect = rect_generic; 1780 if (c->scanline == scanline_memcpy) { 1781 c->rect = rect_memcpy; 1782 } 1783 } 1784 1785 void init_y_noop(context_t* c, int32_t y0) 1786 { 1787 c->iterators.y = y0; 1788 c->step_y = step_y__nop; 1789 // choose the rectangle blitter 1790 c->rect = rect_generic; 1791 if (c->scanline == scanline_memcpy) { 1792 c->rect = rect_memcpy; 1793 } 1794 } 1795 1796 void init_y_error(context_t* c, int32_t y0) 1797 { 1798 // woooops, shoud never happen, 1799 // fail gracefully (don't display anything) 1800 init_y_noop(c, y0); 1801 ALOGE("color-buffer has an invalid format!"); 1802 } 1803 1804 // ---------------------------------------------------------------------------- 1805 #if 0 1806 #pragma mark - 1807 #endif 1808 1809 void step_y__generic(context_t* c) 1810 { 1811 const uint32_t enables = c->state.enables; 1812 1813 // iterate... 1814 iterators_t& ci = c->iterators; 1815 ci.y += 1; 1816 1817 if (enables & GGL_ENABLE_SMOOTH) { 1818 ci.ydrdy += c->shade.drdy; 1819 ci.ydgdy += c->shade.dgdy; 1820 ci.ydbdy += c->shade.dbdy; 1821 ci.ydady += c->shade.dady; 1822 } 1823 1824 const uint32_t mask = 1825 GGL_ENABLE_DEPTH_TEST | 1826 GGL_ENABLE_W | 1827 GGL_ENABLE_FOG; 1828 if (enables & mask) { 1829 ci.ydzdy += c->shade.dzdy; 1830 ci.ydwdy += c->shade.dwdy; 1831 ci.ydfdy += c->shade.dfdy; 1832 } 1833 1834 if ((enables & GGL_ENABLE_TMUS) && (!(enables & GGL_ENABLE_W))) { 1835 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; ++i) { 1836 if (c->state.texture[i].enable) { 1837 texture_iterators_t& ti = c->state.texture[i].iterators; 1838 ti.ydsdy += ti.dsdy; 1839 ti.ydtdy += ti.dtdy; 1840 } 1841 } 1842 } 1843 } 1844 1845 void step_y__nop(context_t* c) 1846 { 1847 c->iterators.y += 1; 1848 c->iterators.ydzdy += c->shade.dzdy; 1849 } 1850 1851 void step_y__smooth(context_t* c) 1852 { 1853 iterators_t& ci = c->iterators; 1854 ci.y += 1; 1855 ci.ydrdy += c->shade.drdy; 1856 ci.ydgdy += c->shade.dgdy; 1857 ci.ydbdy += c->shade.dbdy; 1858 ci.ydady += c->shade.dady; 1859 ci.ydzdy += c->shade.dzdy; 1860 } 1861 1862 void step_y__w(context_t* c) 1863 { 1864 iterators_t& ci = c->iterators; 1865 ci.y += 1; 1866 ci.ydzdy += c->shade.dzdy; 1867 ci.ydwdy += c->shade.dwdy; 1868 } 1869 1870 void step_y__tmu(context_t* c) 1871 { 1872 iterators_t& ci = c->iterators; 1873 ci.y += 1; 1874 ci.ydzdy += c->shade.dzdy; 1875 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; ++i) { 1876 if (c->state.texture[i].enable) { 1877 texture_iterators_t& ti = c->state.texture[i].iterators; 1878 ti.ydsdy += ti.dsdy; 1879 ti.ydtdy += ti.dtdy; 1880 } 1881 } 1882 } 1883 1884 // ---------------------------------------------------------------------------- 1885 #if 0 1886 #pragma mark - 1887 #endif 1888 1889 void scanline_perspective(context_t* c) 1890 { 1891 struct { 1892 union { 1893 struct { 1894 int32_t s, sq; 1895 int32_t t, tq; 1896 } sqtq; 1897 struct { 1898 int32_t v, q; 1899 } st[2]; 1900 }; 1901 } tc[GGL_TEXTURE_UNIT_COUNT] __attribute__((aligned(16))); 1902 1903 // XXX: we should have a special case when dwdx = 0 1904 1905 // 32 pixels spans works okay. 16 is a lot better, 1906 // but hey, it's a software renderer... 1907 const uint32_t SPAN_BITS = 5; 1908 const uint32_t ys = c->iterators.y; 1909 const uint32_t xs = c->iterators.xl; 1910 const uint32_t x1 = c->iterators.xr; 1911 const uint32_t xc = x1 - xs; 1912 uint32_t remainder = xc & ((1<<SPAN_BITS)-1); 1913 uint32_t numSpans = xc >> SPAN_BITS; 1914 1915 const iterators_t& ci = c->iterators; 1916 int32_t w0 = (xs * c->shade.dwdx) + ci.ydwdy; 1917 int32_t q0 = gglRecipQ(w0, 30); 1918 const int iwscale = 32 - gglClz(q0); 1919 1920 const int32_t dwdx = c->shade.dwdx << SPAN_BITS; 1921 int32_t xl = c->iterators.xl; 1922 1923 // We process s & t with a loop to reduce the code size 1924 // (and i-cache pressure). 1925 1926 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; ++i) { 1927 const texture_t& tmu = c->state.texture[i]; 1928 if (!tmu.enable) continue; 1929 int32_t s = tmu.shade.is0 + 1930 (tmu.shade.idsdy * ys) + (tmu.shade.idsdx * xs) + 1931 ((tmu.shade.idsdx + tmu.shade.idsdy)>>1); 1932 int32_t t = tmu.shade.it0 + 1933 (tmu.shade.idtdy * ys) + (tmu.shade.idtdx * xs) + 1934 ((tmu.shade.idtdx + tmu.shade.idtdy)>>1); 1935 tc[i].sqtq.s = s; 1936 tc[i].sqtq.t = t; 1937 tc[i].sqtq.sq = gglMulx(s, q0, iwscale); 1938 tc[i].sqtq.tq = gglMulx(t, q0, iwscale); 1939 } 1940 1941 int32_t span = 0; 1942 do { 1943 int32_t w1; 1944 if (ggl_likely(numSpans)) { 1945 w1 = w0 + dwdx; 1946 } else { 1947 if (remainder) { 1948 // finish off the scanline... 1949 span = remainder; 1950 w1 = (c->shade.dwdx * span) + w0; 1951 } else { 1952 break; 1953 } 1954 } 1955 int32_t q1 = gglRecipQ(w1, 30); 1956 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; ++i) { 1957 texture_t& tmu = c->state.texture[i]; 1958 if (!tmu.enable) continue; 1959 texture_iterators_t& ti = tmu.iterators; 1960 1961 for (int j=0 ; j<2 ; j++) { 1962 int32_t v = tc[i].st[j].v; 1963 if (span) v += (tmu.shade.st[j].dx)*span; 1964 else v += (tmu.shade.st[j].dx)<<SPAN_BITS; 1965 const int32_t v0 = tc[i].st[j].q; 1966 const int32_t v1 = gglMulx(v, q1, iwscale); 1967 int32_t dvdx = v1 - v0; 1968 if (span) dvdx /= span; 1969 else dvdx >>= SPAN_BITS; 1970 tc[i].st[j].v = v; 1971 tc[i].st[j].q = v1; 1972 1973 const int scale = ti.st[j].scale + (iwscale - 30); 1974 if (scale >= 0) { 1975 ti.st[j].ydvdy = v0 << scale; 1976 ti.st[j].dvdx = dvdx << scale; 1977 } else { 1978 ti.st[j].ydvdy = v0 >> -scale; 1979 ti.st[j].dvdx = dvdx >> -scale; 1980 } 1981 } 1982 generated_tex_vars_t& gen = c->generated_vars.texture[i]; 1983 gen.dsdx = ti.st[0].dvdx; 1984 gen.dtdx = ti.st[1].dvdx; 1985 } 1986 c->iterators.xl = xl; 1987 c->iterators.xr = xl = xl + (span ? span : (1<<SPAN_BITS)); 1988 w0 = w1; 1989 q0 = q1; 1990 c->span(c); 1991 } while(numSpans--); 1992 } 1993 1994 void scanline_perspective_single(context_t* c) 1995 { 1996 // 32 pixels spans works okay. 16 is a lot better, 1997 // but hey, it's a software renderer... 1998 const uint32_t SPAN_BITS = 5; 1999 const uint32_t ys = c->iterators.y; 2000 const uint32_t xs = c->iterators.xl; 2001 const uint32_t x1 = c->iterators.xr; 2002 const uint32_t xc = x1 - xs; 2003 2004 const iterators_t& ci = c->iterators; 2005 int32_t w = (xs * c->shade.dwdx) + ci.ydwdy; 2006 int32_t iw = gglRecipQ(w, 30); 2007 const int iwscale = 32 - gglClz(iw); 2008 2009 const int i = 31 - gglClz(c->state.enabled_tmu); 2010 generated_tex_vars_t& gen = c->generated_vars.texture[i]; 2011 texture_t& tmu = c->state.texture[i]; 2012 texture_iterators_t& ti = tmu.iterators; 2013 const int sscale = ti.sscale + (iwscale - 30); 2014 const int tscale = ti.tscale + (iwscale - 30); 2015 int32_t s = tmu.shade.is0 + 2016 (tmu.shade.idsdy * ys) + (tmu.shade.idsdx * xs) + 2017 ((tmu.shade.idsdx + tmu.shade.idsdy)>>1); 2018 int32_t t = tmu.shade.it0 + 2019 (tmu.shade.idtdy * ys) + (tmu.shade.idtdx * xs) + 2020 ((tmu.shade.idtdx + tmu.shade.idtdy)>>1); 2021 int32_t s0 = gglMulx(s, iw, iwscale); 2022 int32_t t0 = gglMulx(t, iw, iwscale); 2023 int32_t xl = c->iterators.xl; 2024 2025 int32_t sq, tq, dsdx, dtdx; 2026 int32_t premainder = xc & ((1<<SPAN_BITS)-1); 2027 uint32_t numSpans = xc >> SPAN_BITS; 2028 if (c->shade.dwdx == 0) { 2029 // XXX: we could choose to do this if the error is small enough 2030 numSpans = 0; 2031 premainder = xc; 2032 goto no_perspective; 2033 } 2034 2035 if (premainder) { 2036 w += c->shade.dwdx * premainder; 2037 iw = gglRecipQ(w, 30); 2038 no_perspective: 2039 s += tmu.shade.idsdx * premainder; 2040 t += tmu.shade.idtdx * premainder; 2041 sq = gglMulx(s, iw, iwscale); 2042 tq = gglMulx(t, iw, iwscale); 2043 dsdx = (sq - s0) / premainder; 2044 dtdx = (tq - t0) / premainder; 2045 c->iterators.xl = xl; 2046 c->iterators.xr = xl = xl + premainder; 2047 goto finish; 2048 } 2049 2050 while (numSpans--) { 2051 w += c->shade.dwdx << SPAN_BITS; 2052 s += tmu.shade.idsdx << SPAN_BITS; 2053 t += tmu.shade.idtdx << SPAN_BITS; 2054 iw = gglRecipQ(w, 30); 2055 sq = gglMulx(s, iw, iwscale); 2056 tq = gglMulx(t, iw, iwscale); 2057 dsdx = (sq - s0) >> SPAN_BITS; 2058 dtdx = (tq - t0) >> SPAN_BITS; 2059 c->iterators.xl = xl; 2060 c->iterators.xr = xl = xl + (1<<SPAN_BITS); 2061 finish: 2062 if (sscale >= 0) { 2063 ti.ydsdy = s0 << sscale; 2064 ti.dsdx = dsdx << sscale; 2065 } else { 2066 ti.ydsdy = s0 >>-sscale; 2067 ti.dsdx = dsdx >>-sscale; 2068 } 2069 if (tscale >= 0) { 2070 ti.ydtdy = t0 << tscale; 2071 ti.dtdx = dtdx << tscale; 2072 } else { 2073 ti.ydtdy = t0 >>-tscale; 2074 ti.dtdx = dtdx >>-tscale; 2075 } 2076 s0 = sq; 2077 t0 = tq; 2078 gen.dsdx = ti.dsdx; 2079 gen.dtdx = ti.dtdx; 2080 c->span(c); 2081 } 2082 } 2083 2084 // ---------------------------------------------------------------------------- 2085 2086 void scanline_col32cb16blend(context_t* c) 2087 { 2088 int32_t x = c->iterators.xl; 2089 size_t ct = c->iterators.xr - x; 2090 int32_t y = c->iterators.y; 2091 surface_t* cb = &(c->state.buffers.color); 2092 union { 2093 uint16_t* dst; 2094 uint32_t* dst32; 2095 }; 2096 dst = reinterpret_cast<uint16_t*>(cb->data) + (x+(cb->stride*y)); 2097 2098 #if ((ANDROID_CODEGEN >= ANDROID_CODEGEN_ASM) && defined(__arm__)) 2099 #if defined(__ARM_HAVE_NEON) && BYTE_ORDER == LITTLE_ENDIAN 2100 scanline_col32cb16blend_neon(dst, &(c->packed8888), ct); 2101 #else // defined(__ARM_HAVE_NEON) && BYTE_ORDER == LITTLE_ENDIAN 2102 scanline_col32cb16blend_arm(dst, GGL_RGBA_TO_HOST(c->packed8888), ct); 2103 #endif // defined(__ARM_HAVE_NEON) && BYTE_ORDER == LITTLE_ENDIAN 2104 #elif ((ANDROID_CODEGEN >= ANDROID_CODEGEN_ASM) && defined(__aarch64__)) 2105 scanline_col32cb16blend_arm64(dst, GGL_RGBA_TO_HOST(c->packed8888), ct); 2106 #else 2107 uint32_t s = GGL_RGBA_TO_HOST(c->packed8888); 2108 int sA = (s>>24); 2109 int f = 0x100 - (sA + (sA>>7)); 2110 while (ct--) { 2111 uint16_t d = *dst; 2112 int dR = (d>>11)&0x1f; 2113 int dG = (d>>5)&0x3f; 2114 int dB = (d)&0x1f; 2115 int sR = (s >> ( 3))&0x1F; 2116 int sG = (s >> ( 8+2))&0x3F; 2117 int sB = (s >> (16+3))&0x1F; 2118 sR += (f*dR)>>8; 2119 sG += (f*dG)>>8; 2120 sB += (f*dB)>>8; 2121 *dst++ = uint16_t((sR<<11)|(sG<<5)|sB); 2122 } 2123 #endif 2124 2125 } 2126 2127 void scanline_t32cb16(context_t* c) 2128 { 2129 int32_t x = c->iterators.xl; 2130 size_t ct = c->iterators.xr - x; 2131 int32_t y = c->iterators.y; 2132 surface_t* cb = &(c->state.buffers.color); 2133 union { 2134 uint16_t* dst; 2135 uint32_t* dst32; 2136 }; 2137 dst = reinterpret_cast<uint16_t*>(cb->data) + (x+(cb->stride*y)); 2138 2139 surface_t* tex = &(c->state.texture[0].surface); 2140 const int32_t u = (c->state.texture[0].shade.is0>>16) + x; 2141 const int32_t v = (c->state.texture[0].shade.it0>>16) + y; 2142 uint32_t *src = reinterpret_cast<uint32_t*>(tex->data)+(u+(tex->stride*v)); 2143 int sR, sG, sB; 2144 uint32_t s, d; 2145 2146 if (ct==1 || uintptr_t(dst)&2) { 2147 last_one: 2148 s = GGL_RGBA_TO_HOST( *src++ ); 2149 *dst++ = convertAbgr8888ToRgb565(s); 2150 ct--; 2151 } 2152 2153 while (ct >= 2) { 2154 #if BYTE_ORDER == BIG_ENDIAN 2155 s = GGL_RGBA_TO_HOST( *src++ ); 2156 d = convertAbgr8888ToRgb565_hi16(s); 2157 2158 s = GGL_RGBA_TO_HOST( *src++ ); 2159 d |= convertAbgr8888ToRgb565(s); 2160 #else 2161 s = GGL_RGBA_TO_HOST( *src++ ); 2162 d = convertAbgr8888ToRgb565(s); 2163 2164 s = GGL_RGBA_TO_HOST( *src++ ); 2165 d |= convertAbgr8888ToRgb565(s) << 16; 2166 #endif 2167 *dst32++ = d; 2168 ct -= 2; 2169 } 2170 2171 if (ct > 0) { 2172 goto last_one; 2173 } 2174 } 2175 2176 void scanline_t32cb16blend(context_t* c) 2177 { 2178 #if ((ANDROID_CODEGEN >= ANDROID_CODEGEN_ASM) && (defined(__arm__) || (defined(__mips__) && !defined(__LP64__) && __mips_isa_rev < 6) || defined(__aarch64__))) 2179 int32_t x = c->iterators.xl; 2180 size_t ct = c->iterators.xr - x; 2181 int32_t y = c->iterators.y; 2182 surface_t* cb = &(c->state.buffers.color); 2183 uint16_t* dst = reinterpret_cast<uint16_t*>(cb->data) + (x+(cb->stride*y)); 2184 2185 surface_t* tex = &(c->state.texture[0].surface); 2186 const int32_t u = (c->state.texture[0].shade.is0>>16) + x; 2187 const int32_t v = (c->state.texture[0].shade.it0>>16) + y; 2188 uint32_t *src = reinterpret_cast<uint32_t*>(tex->data)+(u+(tex->stride*v)); 2189 2190 #ifdef __arm__ 2191 scanline_t32cb16blend_arm(dst, src, ct); 2192 #elif defined(__aarch64__) 2193 scanline_t32cb16blend_arm64(dst, src, ct); 2194 #elif defined(__mips__) 2195 scanline_t32cb16blend_mips(dst, src, ct); 2196 #endif 2197 #else 2198 dst_iterator16 di(c); 2199 horz_iterator32 hi(c); 2200 blender_32to16 bl(c); 2201 while (di.count--) { 2202 uint32_t s = hi.get_pixel32(); 2203 bl.write(s, di.dst); 2204 di.dst++; 2205 } 2206 #endif 2207 } 2208 2209 void scanline_t32cb16blend_srca(context_t* c) 2210 { 2211 dst_iterator16 di(c); 2212 horz_iterator32 hi(c); 2213 blender_32to16_srcA blender(c); 2214 2215 while (di.count--) { 2216 uint32_t s = hi.get_pixel32(); 2217 blender.write(s,di.dst); 2218 di.dst++; 2219 } 2220 } 2221 2222 void scanline_t16cb16blend_clamp_mod(context_t* c) 2223 { 2224 const int a = c->iterators.ydady >> (GGL_COLOR_BITS-8); 2225 if (a == 0) { 2226 return; 2227 } 2228 2229 if (a == 255) { 2230 scanline_t16cb16_clamp(c); 2231 return; 2232 } 2233 2234 dst_iterator16 di(c); 2235 blender_16to16_modulate blender(c); 2236 clamp_iterator ci(c); 2237 2238 while (di.count--) { 2239 uint16_t s = ci.get_pixel16(); 2240 blender.write(s, di.dst); 2241 di.dst++; 2242 } 2243 } 2244 2245 void scanline_memcpy(context_t* c) 2246 { 2247 int32_t x = c->iterators.xl; 2248 size_t ct = c->iterators.xr - x; 2249 int32_t y = c->iterators.y; 2250 surface_t* cb = &(c->state.buffers.color); 2251 const GGLFormat* fp = &(c->formats[cb->format]); 2252 uint8_t* dst = reinterpret_cast<uint8_t*>(cb->data) + 2253 (x + (cb->stride * y)) * fp->size; 2254 2255 surface_t* tex = &(c->state.texture[0].surface); 2256 const int32_t u = (c->state.texture[0].shade.is0>>16) + x; 2257 const int32_t v = (c->state.texture[0].shade.it0>>16) + y; 2258 uint8_t *src = reinterpret_cast<uint8_t*>(tex->data) + 2259 (u + (tex->stride * v)) * fp->size; 2260 2261 const size_t size = ct * fp->size; 2262 memcpy(dst, src, size); 2263 } 2264 2265 void scanline_memset8(context_t* c) 2266 { 2267 int32_t x = c->iterators.xl; 2268 size_t ct = c->iterators.xr - x; 2269 int32_t y = c->iterators.y; 2270 surface_t* cb = &(c->state.buffers.color); 2271 uint8_t* dst = reinterpret_cast<uint8_t*>(cb->data) + (x+(cb->stride*y)); 2272 uint32_t packed = c->packed; 2273 memset(dst, packed, ct); 2274 } 2275 2276 void scanline_memset16(context_t* c) 2277 { 2278 int32_t x = c->iterators.xl; 2279 size_t ct = c->iterators.xr - x; 2280 int32_t y = c->iterators.y; 2281 surface_t* cb = &(c->state.buffers.color); 2282 uint16_t* dst = reinterpret_cast<uint16_t*>(cb->data) + (x+(cb->stride*y)); 2283 uint32_t packed = c->packed; 2284 android_memset16(dst, packed, ct*2); 2285 } 2286 2287 void scanline_memset32(context_t* c) 2288 { 2289 int32_t x = c->iterators.xl; 2290 size_t ct = c->iterators.xr - x; 2291 int32_t y = c->iterators.y; 2292 surface_t* cb = &(c->state.buffers.color); 2293 uint32_t* dst = reinterpret_cast<uint32_t*>(cb->data) + (x+(cb->stride*y)); 2294 uint32_t packed = GGL_HOST_TO_RGBA(c->packed); 2295 android_memset32(dst, packed, ct*4); 2296 } 2297 2298 void scanline_clear(context_t* c) 2299 { 2300 int32_t x = c->iterators.xl; 2301 size_t ct = c->iterators.xr - x; 2302 int32_t y = c->iterators.y; 2303 surface_t* cb = &(c->state.buffers.color); 2304 const GGLFormat* fp = &(c->formats[cb->format]); 2305 uint8_t* dst = reinterpret_cast<uint8_t*>(cb->data) + 2306 (x + (cb->stride * y)) * fp->size; 2307 const size_t size = ct * fp->size; 2308 memset(dst, 0, size); 2309 } 2310 2311 void scanline_set(context_t* c) 2312 { 2313 int32_t x = c->iterators.xl; 2314 size_t ct = c->iterators.xr - x; 2315 int32_t y = c->iterators.y; 2316 surface_t* cb = &(c->state.buffers.color); 2317 const GGLFormat* fp = &(c->formats[cb->format]); 2318 uint8_t* dst = reinterpret_cast<uint8_t*>(cb->data) + 2319 (x + (cb->stride * y)) * fp->size; 2320 const size_t size = ct * fp->size; 2321 memset(dst, 0xFF, size); 2322 } 2323 2324 void scanline_noop(context_t* /*c*/) 2325 { 2326 } 2327 2328 void rect_generic(context_t* c, size_t yc) 2329 { 2330 do { 2331 c->scanline(c); 2332 c->step_y(c); 2333 } while (--yc); 2334 } 2335 2336 void rect_memcpy(context_t* c, size_t yc) 2337 { 2338 int32_t x = c->iterators.xl; 2339 size_t ct = c->iterators.xr - x; 2340 int32_t y = c->iterators.y; 2341 surface_t* cb = &(c->state.buffers.color); 2342 const GGLFormat* fp = &(c->formats[cb->format]); 2343 uint8_t* dst = reinterpret_cast<uint8_t*>(cb->data) + 2344 (x + (cb->stride * y)) * fp->size; 2345 2346 surface_t* tex = &(c->state.texture[0].surface); 2347 const int32_t u = (c->state.texture[0].shade.is0>>16) + x; 2348 const int32_t v = (c->state.texture[0].shade.it0>>16) + y; 2349 uint8_t *src = reinterpret_cast<uint8_t*>(tex->data) + 2350 (u + (tex->stride * v)) * fp->size; 2351 2352 if (cb->stride == tex->stride && ct == size_t(cb->stride)) { 2353 memcpy(dst, src, ct * fp->size * yc); 2354 } else { 2355 const size_t size = ct * fp->size; 2356 const size_t dbpr = cb->stride * fp->size; 2357 const size_t sbpr = tex->stride * fp->size; 2358 do { 2359 memcpy(dst, src, size); 2360 dst += dbpr; 2361 src += sbpr; 2362 } while (--yc); 2363 } 2364 } 2365 // ---------------------------------------------------------------------------- 2366 }; // namespace android 2367 2368
