int
soup_add_face_precomputed(struct soup_s *s, point_t a, point_t b , point_t c, plane_t d, uint32_t foo)
{
struct face_s *f;
vect_t e1, e2, x;
VSUB2(e1, b, a);
VSUB2(e2, c, a);
VCROSS(x, e1, e2);
/* grow face array if needed */
if (s->nfaces >= s->maxfaces)
s->faces = (struct face_s *)bu_realloc(s->faces, (s->maxfaces += faces_per_page) * sizeof(struct face_s), "bot soup faces");
f = s->faces + s->nfaces;
VMOVE(f->vert[0], a);
if (VDOT(x, d) <= 0) {
VMOVE(f->vert[1], b);
VMOVE(f->vert[2], c);
} else {
VMOVE(f->vert[1], c);
VMOVE(f->vert[2], b);
}
HMOVE(f->plane, d);
/* solve the bounding box (should this be VMINMAX?) */
VMOVE(f->min, f->vert[0]); VMOVE(f->max, f->vert[0]);
VMIN(f->min, f->vert[1]); VMAX(f->max, f->vert[1]);
VMIN(f->min, f->vert[2]); VMAX(f->max, f->vert[2]);
/* fluff the bounding box for fp fuzz */
f->min[X]-=.1; f->min[Y]-=.1; f->min[Z]-=.1;
f->max[X]+=.1; f->max[Y]+=.1; f->max[Z]+=.1;
f->foo = foo;
s->nfaces++;
return 0;
}
void ArmJit::NEONApplyPrefixD(DestARMReg dest) {
// Apply clamps to dest.rd
int n = GetNumVectorElements(dest.sz);
int sat1_mask = 0;
int sat3_mask = 0;
int full_mask = (1 << n) - 1;
for (int i = 0; i < n; i++) {
int sat = (js.prefixD >> (i * 2)) & 3;
if (sat == 1)
sat1_mask |= 1 << i;
if (sat == 3)
sat3_mask |= 1 << i;
}
if (sat1_mask && sat3_mask) {
// Why would anyone do this?
ELOG("PREFIXD: Can't have both sat[0-1] and sat[-1-1] at the same time yet");
}
if (sat1_mask) {
if (sat1_mask != full_mask) {
ELOG("PREFIXD: Can't have partial sat1 mask yet (%i vs %i)", sat1_mask, full_mask);
}
if (IsD(dest.rd)) {
VMOV_immf(D0, 0.0);
VMOV_immf(D1, 1.0);
VMAX(F_32, dest.rd, dest.rd, D0);
VMIN(F_32, dest.rd, dest.rd, D1);
} else {
VMOV_immf(Q0, 1.0);
VMIN(F_32, dest.rd, dest.rd, Q0);
VMOV_immf(Q0, 0.0);
VMAX(F_32, dest.rd, dest.rd, Q0);
}
}
if (sat3_mask && sat1_mask != full_mask) {
if (sat3_mask != full_mask) {
ELOG("PREFIXD: Can't have partial sat3 mask yet (%i vs %i)", sat3_mask, full_mask);
}
if (IsD(dest.rd)) {
VMOV_immf(D0, 0.0);
VMOV_immf(D1, 1.0);
VMAX(F_32, dest.rd, dest.rd, D0);
VMIN(F_32, dest.rd, dest.rd, D1);
} else {
VMOV_immf(Q0, 1.0);
VMIN(F_32, dest.rd, dest.rd, Q0);
VMOV_immf(Q0, -1.0);
VMAX(F_32, dest.rd, dest.rd, Q0);
}
}
// Check for actual mask operation (unrelated to the "masks" above).
if (dest.backingRd != dest.rd) {
// This means that we need to apply the write mask, from rd to backingRd.
// What a pain. We can at least shortcut easy cases like half the register.
// And we can generate the masks easily with some of the crazy vector imm modes. (bits2bytes for example).
// So no need to load them from RAM.
int writeMask = (~(js.prefixD >> 8)) & 0xF;
if (writeMask == 3) {
ILOG("Doing writemask = 3");
VMOV(D_0(dest.rd), D_0(dest.backingRd));
} else {
// TODO
ELOG("PREFIXD: Arbitrary write masks not supported (%i / %i)", writeMask, full_mask);
VMOV(dest.backingRd, dest.rd);
}
}
HIDDEN int
wood_setup(register struct region *rp, struct bu_vls *matparm, void **dpp, const struct mfuncs *UNUSED(mfp), struct rt_i *UNUSED(rtip))
/* New since 4.4 release */
{
register int i;
register struct wood_specific *wd;
register struct resource *resp = &rt_uniresource;
/*
* Get the impure storage for the control block
*/
BU_CK_VLS(matparm);
BU_GET(wd, struct wood_specific);
*dpp = wd;
/*
* Load the default values
*/
if (rp->reg_mater.ma_color_valid) {
VSCALE(wd->lt_rgb, rp->reg_mater.ma_color, 255);
} else {
wd->lt_rgb[0] = 255; /* Light yellow */
wd->lt_rgb[1] = 255;
wd->lt_rgb[2] = 224;
}
wd->dk_rgb[0] = 191; /* Brownish-red */
wd->dk_rgb[1] = 97;
wd->dk_rgb[2] = 0;
wd->ident = 0;
wd->forw = WOOD_NULL;
wd->rp = rp;
wd->flags = 0;
wd->overlay = 0; /* Draw only one ring */
wd->ns = 10;
wd->jitter = 0.0;
wd->scale = 1.0;
wd->spacing = 5; /* 5mm space between rings */
wd->dd = 0.0; /* no dither of vertex */
wd->dz = 0.0; /* nor of Z-axis */
wd->qd = 0;
wd->qp = 0;
wd->phase = 5;
wd->depth = 0;
wd->dither[0] = bn_rand0to1(resp->re_randptr);
wd->dither[1] = bn_rand0to1(resp->re_randptr);
wd->dither[2] = bn_rand0to1(resp->re_randptr);
VSETALL(wd->rot, 0);
VSETALL(wd->vertex, 0);
VSETALL(wd->D, 0);
VSETALL(wd->V, 0);
/*
* Parse the MATPARM field
*/
if (bu_struct_parse(matparm, wood_parse, (char *)wd) < 0) {
BU_PUT(wd, struct wood_specific);
return -1;
}
/*
* Do some sundry range and misc. checking
*/
for (i = 0; i < 3; i++) {
if (wd->dither[i] < 0 || wd->dither[i] > 1.0) {
bu_log("wood_setup(%s): dither is out of range.\n",
rp->reg_name);
return -1;
}
}
if (wd->flags == EXPLICIT_VERTEX) {
bu_log("wood_setup(%s): Explicit vertex specified without direction\n", rp->reg_name);
return -1;
}
if (wd->flags == EXPLICIT_DIRECTION) {
bu_log("wood_setup(%s): Explicit direction specified without vertex\n", rp->reg_name);
return -1;
}
/*
* Get the bounding RPP
*/
if (rt_bound_tree(rp->reg_treetop, wd->b_min, wd->b_max) < 0) return -1;
/*
* Add it to the wood chain
*/
wd->forw = Wood_Chain;
Wood_Chain = wd;
/*
* See if the user has flagged this region as a member of a larger
* combination. If so, go ahead and process it
*/
if (wd->ident == 0)
wood_setup_2(wd);
else {
register struct wood_specific *wc;
vect_t c_min, c_max;
/*
* First, process the accumulated chain of wood regions and
* process all regions which have the specified ident field.
*/
VSETALL(c_min, 0);
VSETALL(c_max, 0);
for (wc = Wood_Chain; wc != WOOD_NULL; wc = wc->forw) {
if (wc->ident == wd->ident) {
VMIN(c_min, wc->b_min);
VMAX(c_max, wc->b_max);
}
}
/*
* Now, loop through the chain again this time updating the
* regions' min/max fields with the new values
*/
for (wc = Wood_Chain; wc != WOOD_NULL; wc = wc->forw) {
if (wc->ident == wd->ident) {
VMOVE(wc->b_min, c_min);
VMOVE(wc->b_max, c_max);
wood_setup_2(wc);
}
}
/*
* End of multi-region processing loop
*/
}
/*
* Normalize the RGB colors
*/
for (i = 0; i < 3; i++) {
wd->lt_rgb[i] /= 255.0;
wd->dk_rgb[i] /= 255.0;
}
/*
* Return to the caller
*/
return 1;
}
