static void calc_total_layout(LAYOUT *base) { calc_layout(base->next); calc_fills(base->next, 0, 0); calc_aligns(base->next); calc_offsets(base->next, 0, 0); }
static void calc_offsets(LAYOUT *layout, int offx, int offy) { do { layout->offx = offx; layout->offy = offy; if (layout->child) { calc_offsets(layout->child, layout->offx + layout->x, layout->offy + layout->y); } layout = layout->next; } while (layout); }
/* This function does no error check. You must check and ensure this function must not fail before calling. */ static void move_conflicts_real(dary *da, const int *conflicts, int move_to) { int i = 0; int offsets[257]; int parent_index = get_parent_index(da, conflicts[0]); calc_offsets(conflicts, offsets); da->base[parent_index] = move_to - (conflicts[0] - da->base[parent_index]); for (i = 0; conflicts[i] != -1; i++) { move_node(da, conflicts[i], move_to + offsets[i]); } // dary_dump(da); }
static dary_status find_movable_location(dary *da, const int *conflicts, int *first_loc) { int i = da->free_head; int offsets[UCHAR_MAX+1]; calc_offsets(conflicts, offsets); // dary_dump(da); // validate_array(da); dprint("free_head %d", da->free_head); if (da->free_head < 0) { *first_loc = -1; return DARY_STATUS_FAIL; } while (i != - da->check[i]) { assert(i > UCHAR_MAX); if (is_movable(da, i, offsets)) { dprint("movable to %d", i); *first_loc = i; return DARY_STATUS_SUCCESS; } i = - da->check[i]; } if (is_movable(da, i, offsets)) { dprint("movable to %d", i); *first_loc = i; return DARY_STATUS_SUCCESS; } else { *first_loc = -1; return DARY_STATUS_FAIL; } }
/** * Initialize fragment shader input attribute info. */ void lp_build_interp_soa_init(struct lp_build_interp_soa_context *bld, struct gallivm_state *gallivm, unsigned num_inputs, const struct lp_shader_input *inputs, boolean pixel_center_integer, LLVMBuilderRef builder, struct lp_type type, LLVMValueRef a0_ptr, LLVMValueRef dadx_ptr, LLVMValueRef dady_ptr, LLVMValueRef x0, LLVMValueRef y0) { struct lp_type coeff_type; struct lp_type setup_type; unsigned attrib; unsigned chan; memset(bld, 0, sizeof *bld); memset(&coeff_type, 0, sizeof coeff_type); coeff_type.floating = TRUE; coeff_type.sign = TRUE; coeff_type.width = 32; coeff_type.length = type.length; memset(&setup_type, 0, sizeof setup_type); setup_type.floating = TRUE; setup_type.sign = TRUE; setup_type.width = 32; setup_type.length = TGSI_NUM_CHANNELS; /* XXX: we don't support interpolating into any other types */ assert(memcmp(&coeff_type, &type, sizeof coeff_type) == 0); lp_build_context_init(&bld->coeff_bld, gallivm, coeff_type); lp_build_context_init(&bld->setup_bld, gallivm, setup_type); /* For convenience */ bld->pos = bld->attribs[0]; bld->inputs = (const LLVMValueRef (*)[TGSI_NUM_CHANNELS]) bld->attribs[1]; /* Position */ bld->mask[0] = TGSI_WRITEMASK_XYZW; bld->interp[0] = LP_INTERP_LINEAR; /* Inputs */ for (attrib = 0; attrib < num_inputs; ++attrib) { bld->mask[1 + attrib] = inputs[attrib].usage_mask; bld->interp[1 + attrib] = inputs[attrib].interp; } bld->num_attribs = 1 + num_inputs; /* Ensure all masked out input channels have a valid value */ for (attrib = 0; attrib < bld->num_attribs; ++attrib) { for (chan = 0; chan < TGSI_NUM_CHANNELS; ++chan) { bld->attribs[attrib][chan] = bld->coeff_bld.undef; } } if (pixel_center_integer) { bld->pos_offset = 0.0; } else { bld->pos_offset = 0.5; } pos_init(bld, x0, y0); /* * Simple method (single step interpolation) may be slower if vector length * is just 4, but the results are different (generally less accurate) with * the other method, so always use more accurate version. */ if (1) { bld->simple_interp = TRUE; { /* XXX this should use a global static table */ unsigned i; unsigned num_loops = 16 / type.length; LLVMValueRef pixoffx, pixoffy, index; LLVMValueRef ptr; bld->xoffset_store = lp_build_array_alloca(gallivm, lp_build_vec_type(gallivm, type), lp_build_const_int32(gallivm, num_loops), ""); bld->yoffset_store = lp_build_array_alloca(gallivm, lp_build_vec_type(gallivm, type), lp_build_const_int32(gallivm, num_loops), ""); for (i = 0; i < num_loops; i++) { index = lp_build_const_int32(gallivm, i); calc_offsets(&bld->coeff_bld, i*type.length/4, &pixoffx, &pixoffy); ptr = LLVMBuildGEP(builder, bld->xoffset_store, &index, 1, ""); LLVMBuildStore(builder, pixoffx, ptr); ptr = LLVMBuildGEP(builder, bld->yoffset_store, &index, 1, ""); LLVMBuildStore(builder, pixoffy, ptr); } } coeffs_init_simple(bld, a0_ptr, dadx_ptr, dady_ptr); } else { bld->simple_interp = FALSE; coeffs_init(bld, a0_ptr, dadx_ptr, dady_ptr); } }
static dary_status move_conflicts2(dary *da, int n, uchar k) { int conflicts[256+1], move_to; /* MAX conflicts 256, +1 is for termination */ int retcode; int i = 0; get_children(da, n, conflicts); dprint("da->base[%d] =%d, k = %d", n, da->base[n], k); // ここはなんとか関数化できないか? if (conflicts[0] < da->base[n] + k) { while (conflicts[i] != -1) { i++; } dprint("last node is k"); conflicts[i] = da->base[n] + k; conflicts[i+1] = -1; } else { int len = length(conflicts); memmove(&conflicts[1], conflicts, (len + 1) * sizeof(int)); conflicts[0] = da->base[n] + k; dprint("first node is k"); } i = 0; while (conflicts[i] != -1) { dprint("conflicts[%d] = %d", i, conflicts[i]); i++; } retcode = find_movable_location(da, conflicts, &move_to); if (retcode != DARY_STATUS_SUCCESS) { dprint("move_conflicts:Could not found movable location. Retrying...\n"); retcode = extend_array(da, da->length + 256); if (retcode != DARY_STATUS_SUCCESS) { return retcode; } /* This find_movable_loc must be success, but ensure return value to make sure. */ retcode = find_movable_location(da, conflicts, &move_to); if (retcode != DARY_STATUS_SUCCESS) { return retcode; } } i = 0; int offsets[257]; calc_offsets(conflicts, offsets); for (i = 0; conflicts[i] != -1; i++) { if (conflicts[i] != da->base[n] + k) { move_node(da, conflicts[i], move_to + offsets[i]); } } da->base[n] = move_to - (conflicts[0] - da->base[n]); dprint("da->base[%d] = da->base[%d] (%d) + move_to %d - %d = %d", n, n, da->base[n], move_to, conflicts[0], da->base[n] + (move_to - conflicts[0])); return DARY_STATUS_SUCCESS; }