//
// ACS_funcGetCVar
//
static void ACS_funcGetCVar(ACS_FUNCARG)
{
char const *name = ACSVM::GetString(args[0]);
command_t *command;
variable_t *var;
if(!(command = C_GetCmdForName(name)) || !(var = command->variable))
{
*retn++ = 0;
return;
}
switch(var->type)
{
case vt_int: *retn++ = *(int *)var->variable; break;
case vt_float: *retn++ = M_DoubleToFixed(*(double *)var->variable); break;
case vt_string: *retn++ = 0; break;
case vt_chararray: *retn++ = 0; break;
case vt_toggle: *retn++ = *(bool *)var->variable; break;
default:
*retn++ = 0;
break;
}
}
//
// ACS_funcSqrtFixed
//
static void ACS_funcSqrtFixed(ACS_FUNCARG)
{
*retn++ = M_DoubleToFixed(sqrt(M_FixedToDouble(args[0])));
}
//
// ACS_funcTrigHypot
//
static void ACS_funcTrigHypot(ACS_FUNCARG)
{
double x = M_FixedToDouble(args[0]);
double y = M_FixedToDouble(args[1]);
*retn++ = M_DoubleToFixed(sqrt(x * x + y * y));
}
//
// R_divideSegs
//
// Split the input list of segs into left and right lists using one of the segs
// selected as a partition line for the current node.
//
static void R_divideSegs(rpolynode_t *rpn, dseglist_t *ts,
dseglist_t *rs, dseglist_t *ls)
{
dynaseg_t *best, *add_to_rs = NULL, *add_to_ls = NULL;
// select best seg to use as partition line
best = rpn->partition = R_selectPartition(*ts);
best->bsplink.remove();
#ifdef RANGECHECK
// Should not happen.
if(!rpn->partition)
I_Error("R_divideSegs: could not select partition!\n");
#endif
// use the partition line to split any other lines in the list that intersect
// it into left and right halves
double pdx = best->psx - best->pex;
double pdy = best->psy - best->pey;
dseglink_t *cur;
// iterate from beginning until the original list is empty
while((cur = *ts))
{
dynaseg_t *seg = *cur;
add_to_ls = add_to_rs = NULL;
int val = R_classifyDynaSeg(best, seg, pdx, pdy);
if(val == SPLIT_SR_EL || val == SPLIT_SL_ER)
{
double x, y;
v2float_t fbackup;
// seg is split by the partition
R_ComputeIntersection(best, seg, x, y, &fbackup);
// create a new vertex at the intersection point
dynavertex_t *nv = R_GetFreeDynaVertex();
nv->fx = static_cast<float>(x);
nv->fy = static_cast<float>(y);
nv->fbackup = fbackup;
nv->x = M_DoubleToFixed(x);
nv->y = M_DoubleToFixed(y);
nv->backup.x = M_FloatToFixed(nv->fbackup.x);
nv->backup.y = M_FloatToFixed(nv->fbackup.y);
// create a new dynaseg from nv to v2
dynaseg_t *nds = R_CreateDynaSeg(seg, nv, seg->seg.dyv2);
R_setupDSForBSP(*nds);
nds->seg.frontsector = seg->seg.frontsector;
nds->seg.backsector = seg->seg.backsector;
nds->seg.len = static_cast<float>(nds->len);
// modify original seg to run from v1 to nv
bool notmarked = !seg->originalv2;
if(notmarked) // only if not already marked!
R_SetDynaVertexRef(&seg->originalv2, seg->seg.dyv2);
R_SetDynaVertexRef(&seg->seg.dyv2, nv);
R_setupDSForBSP(*seg);
seg->seg.len = static_cast<float>(seg->len);
// add the new seg to the current node's ownership list,
// so it can get freed later
nds->ownerlink.insert(nds, &rpn->owned);
if(notmarked)
seg->alterlink.insert(seg, &rpn->altered);
// classify left or right
if(val == SPLIT_SR_EL)
{
add_to_ls = nds;
add_to_rs = seg;
}
else
{
add_to_ls = seg;
add_to_rs = nds;
}
}
else
{
// Not split; which side?
if(val & CLASSIFY_LEFT)
add_to_ls = seg; // at least one vertex is left, other is left or on
if(val & CLASSIFY_RIGHT)
add_to_rs = seg; // at least one vertex is right, other is right or on
if(val == CLASSIFY_ON)
{
// We know the segs are parallel or nearly so; take their dot
// product to determine their relative orientation
if((seg->psx - seg->pex) * pdx + (seg->psy - seg->pey) * pdy < 0.0)
add_to_ls = seg;
else
add_to_rs = seg;
}
}
// add to right side?
if(add_to_rs)
{
add_to_rs->bsplink.remove();
add_to_rs->bsplink.insert(add_to_rs, rs);
}
// add to left side?
if(add_to_ls)
{
add_to_ls->bsplink.remove();
add_to_ls->bsplink.insert(add_to_ls, ls);
}
}
}
