private static void EmitHsetp2(
EmitterContext context,
FComp cmpOp,
BoolOp logicOp,
Operand[] srcA,
Operand[] srcB,
int srcPred,
bool srcPredInv,
int destPred,
int destPredInv,
bool hAnd)
{
Operand p0Res = GetFPComparison(context, cmpOp, srcA[0], srcB[0]);
Operand p1Res = GetFPComparison(context, cmpOp, srcA[1], srcB[1]);
if (hAnd)
{
p0Res = context.BitwiseAnd(p0Res, p1Res);
p1Res = context.BitwiseNot(p0Res);
}
Operand pred = GetPredicate(context, srcPred, srcPredInv);
p0Res = GetPredLogicalOp(context, logicOp, p0Res, pred);
p1Res = GetPredLogicalOp(context, logicOp, p1Res, pred);
context.Copy(Register(destPred, RegisterType.Predicate), p0Res);
context.Copy(Register(destPredInv, RegisterType.Predicate), p1Res);
}
private GameObject Boolean(BoolOp operation)
{
Reset(main_object, operating_object);
current_operation = TransfOp.Spectate;
UpdateTransformationButtons();
Mesh m;
if (CSG_operation_history.Count == 0)
{
StoreCurrentState("start", main_object);
}
switch (operation)
{
case BoolOp.Union:
StoreCurrentState("transformation", main_object);
StoreCurrentState("union", operating_object);
m = CSG.Union(main_object, operating_object);
break;
case BoolOp.Subtract:
StoreCurrentState("transformation", main_object);
StoreCurrentState("subtract", operating_object);
m = CSG.Subtract(main_object, operating_object);
break;
case BoolOp.Intersect:
default:
StoreCurrentState("transformation", main_object);
StoreCurrentState("intersect", operating_object);
m = CSG.Intersect(main_object, operating_object);
break;
}
composite = new GameObject();
composite.name = "Constructed CSG";
composite.AddComponent <MeshFilter>().sharedMesh = m;
composite.AddComponent <MeshRenderer>().sharedMaterial = materials[material_ID];
// Generate new mesh
Mesh mesh = ConstructMesh(composite);
// Generate new meshcollider
composite.AddComponent <MeshCollider>();
composite.GetComponent <MeshCollider>().sharedMesh = mesh;
// Change tag
composite.tag = "csg";
Destroy(main_object);
Destroy(operating_object);
main_object = null;
operating_object = null;
// Switch new composited object to main object
return(composite);
}
void Boolean(BoolOp operation)
{
Mesh m = new Mesh();
switch (operation)
{
case BoolOp.Union:
m = CSG.Union(first, second);
break;
case BoolOp.Subtract:
m = CSG.Subtract(first, second);
break;
case BoolOp.Intersect:
m = CSG.Intersect(first, second);
break;
}
composite = new GameObject();
composite.AddComponent <MeshFilter>().mesh = m;
composite.AddComponent <MeshRenderer>().material = first.GetComponent <MeshRenderer>().material;
GenerateBarycentric(composite);
}
private static void EmitFsetp(
EmitterContext context,
FComp cmpOp,
BoolOp logicOp,
Operand srcA,
Operand srcB,
int srcPred,
bool srcPredInv,
int destPred,
int destPredInv,
bool absoluteA,
bool absoluteB,
bool negateA,
bool negateB,
bool writeCC,
bool isFP64 = false)
{
Instruction fpType = isFP64 ? Instruction.FP64 : Instruction.FP32;
srcA = context.FPAbsNeg(srcA, absoluteA, negateA, fpType);
srcB = context.FPAbsNeg(srcB, absoluteB, negateB, fpType);
Operand p0Res = GetFPComparison(context, cmpOp, srcA, srcB, fpType);
Operand p1Res = context.BitwiseNot(p0Res);
Operand pred = GetPredicate(context, srcPred, srcPredInv);
p0Res = GetPredLogicalOp(context, logicOp, p0Res, pred);
p1Res = GetPredLogicalOp(context, logicOp, p1Res, pred);
context.Copy(Register(destPred, RegisterType.Predicate), p0Res);
context.Copy(Register(destPredInv, RegisterType.Predicate), p1Res);
}
private static void EmitFset(
EmitterContext context,
FComp cmpOp,
BoolOp logicOp,
Operand srcA,
Operand srcB,
int srcPred,
bool srcPredInv,
int rd,
bool absoluteA,
bool absoluteB,
bool negateA,
bool negateB,
bool boolFloat,
bool writeCC,
bool isFP64 = false)
{
Instruction fpType = isFP64 ? Instruction.FP64 : Instruction.FP32;
srcA = context.FPAbsNeg(srcA, absoluteA, negateA, fpType);
srcB = context.FPAbsNeg(srcB, absoluteB, negateB, fpType);
Operand res = GetFPComparison(context, cmpOp, srcA, srcB, fpType);
Operand pred = GetPredicate(context, srcPred, srcPredInv);
res = GetPredLogicalOp(context, logicOp, res, pred);
Operand dest = GetDest(rd);
if (boolFloat)
{
res = context.ConditionalSelect(res, ConstF(1), Const(0));
context.Copy(dest, res);
SetFPZnFlags(context, res, writeCC);
}
else
{
context.Copy(dest, res);
SetZnFlags(context, res, writeCC, extended: false);
}
}
void Boolean(BoolOp operation)
{
Mesh m;
/**
* All boolean operations accept two gameobjects and return a new mesh.
* Order matters - left, right vs. right, left will yield different
* results in some cases.
*/
switch (operation)
{
case BoolOp.Union:
m = CSG.Union(left, right);
break;
case BoolOp.SubtractLR:
m = CSG.Subtract(left, right);
break;
case BoolOp.SubtractRL:
m = CSG.Subtract(right, left);
break;
case BoolOp.Intersect:
default:
m = CSG.Intersect(right, left);
break;
}
composite = new GameObject();
composite.AddComponent <MeshFilter>().sharedMesh = m;
composite.AddComponent <MeshRenderer>().sharedMaterial = left.GetComponent <MeshRenderer>().sharedMaterial;
GenerateBarycentric(composite);
GameObject.Destroy(left);
GameObject.Destroy(right);
}
void Boolean(BoolOp operation)
{
Mesh m;
/**
* All boolean operations accept two gameobjects and return a new mesh.
* Order matters - left, right vs. right, left will yield different
* results in some cases.
*/
switch(operation)
{
case BoolOp.Union:
m = CSG.Union(left, right);
break;
case BoolOp.SubtractLR:
m = CSG.Subtract(left, right);
break;
case BoolOp.SubtractRL:
m = CSG.Subtract(right, left);
break;
case BoolOp.Intersect:
default:
m = CSG.Intersect(right,left);
break;
}
composite = new GameObject();
composite.AddComponent<MeshFilter>().sharedMesh = m;
composite.AddComponent<MeshRenderer>().sharedMaterial = left.GetComponent<MeshRenderer>().sharedMaterial;
GenerateBarycentric( composite );
GameObject.Destroy(left);
GameObject.Destroy(right);
}
private static void EmitHset2(
EmitterContext context,
FComp cmpOp,
BoolOp logicOp,
Operand[] srcA,
Operand[] srcB,
int srcPred,
bool srcPredInv,
int rd,
bool boolFloat)
{
Operand[] res = new Operand[2];
res[0] = GetFPComparison(context, cmpOp, srcA[0], srcB[0]);
res[1] = GetFPComparison(context, cmpOp, srcA[1], srcB[1]);
Operand pred = GetPredicate(context, srcPred, srcPredInv);
res[0] = GetPredLogicalOp(context, logicOp, res[0], pred);
res[1] = GetPredLogicalOp(context, logicOp, res[1], pred);
if (boolFloat)
{
res[0] = context.ConditionalSelect(res[0], ConstF(1), Const(0));
res[1] = context.ConditionalSelect(res[1], ConstF(1), Const(0));
context.Copy(GetDest(rd), context.PackHalf2x16(res[0], res[1]));
}
else
{
Operand low = context.BitwiseAnd(res[0], Const(0xffff));
Operand high = context.ShiftLeft(res[1], Const(16));
Operand packed = context.BitwiseOr(low, high);
context.Copy(GetDest(rd), packed);
}
}
private static void EmitIsetp(
EmitterContext context,
IComp cmpOp,
BoolOp logicOp,
Operand srcA,
Operand srcB,
int srcPred,
bool srcPredInv,
int destPred,
int destPredInv,
bool isSigned,
bool extended)
{
Operand p0Res = GetIntComparison(context, cmpOp, srcA, srcB, isSigned, extended);
Operand p1Res = context.BitwiseNot(p0Res);
Operand pred = GetPredicate(context, srcPred, srcPredInv);
p0Res = GetPredLogicalOp(context, logicOp, p0Res, pred);
p1Res = GetPredLogicalOp(context, logicOp, p1Res, pred);
context.Copy(Register(destPred, RegisterType.Predicate), p0Res);
context.Copy(Register(destPredInv, RegisterType.Predicate), p1Res);
}
void DoBooleanOperation(BoolOp operation)
{
CSG_Model result;
/**
* All boolean operations accept two gameobjects and return a new mesh.
* Order matters - left, right vs. right, left will yield different
* results in some cases.
*/
switch (operation)
{
case BoolOp.Union:
result = Boolean.Union(left, right);
break;
case BoolOp.SubtractLR:
result = Boolean.Subtract(left, right);
break;
case BoolOp.SubtractRL:
result = Boolean.Subtract(right, left);
break;
default:
result = Boolean.Intersect(right, left);
break;
}
composite = new GameObject();
composite.AddComponent <MeshFilter>().sharedMesh = result.mesh;
composite.AddComponent <MeshRenderer>().sharedMaterials = result.materials.ToArray();
GenerateBarycentric(composite);
Destroy(left);
Destroy(right);
}
private static void EmitIset(
EmitterContext context,
IComp cmpOp,
BoolOp logicOp,
Operand srcA,
Operand srcB,
int srcPred,
bool srcPredInv,
int rd,
bool boolFloat,
bool isSigned,
bool extended,
bool writeCC)
{
Operand res = GetIntComparison(context, cmpOp, srcA, srcB, isSigned, extended);
Operand pred = GetPredicate(context, srcPred, srcPredInv);
res = GetPredLogicalOp(context, logicOp, res, pred);
Operand dest = GetDest(rd);
if (boolFloat)
{
res = context.ConditionalSelect(res, ConstF(1), Const(0));
context.Copy(dest, res);
SetFPZnFlags(context, res, writeCC);
}
else
{
context.Copy(dest, res);
SetZnFlags(context, res, writeCC, extended);
}
}
internal static expr Convert(Compiler.Ast.Expression expr, expr_context ctx) {
expr ast;
if (expr is ConstantExpression)
ast = Convert((ConstantExpression)expr);
else if (expr is NameExpression)
ast = new Name((NameExpression)expr, ctx);
else if (expr is UnaryExpression)
ast = new UnaryOp((UnaryExpression)expr);
else if (expr is BinaryExpression)
ast = Convert((BinaryExpression)expr);
else if (expr is AndExpression)
ast = new BoolOp((AndExpression)expr);
else if (expr is OrExpression)
ast = new BoolOp((OrExpression)expr);
else if (expr is CallExpression)
ast = new Call((CallExpression)expr);
else if (expr is ParenthesisExpression)
return Convert(((ParenthesisExpression)expr).Expression);
else if (expr is LambdaExpression)
ast = new Lambda((LambdaExpression)expr);
else if (expr is ListExpression)
ast = new List((ListExpression)expr, ctx);
else if (expr is TupleExpression)
ast = new Tuple((TupleExpression)expr, ctx);
else if (expr is DictionaryExpression)
ast = new Dict((DictionaryExpression)expr);
else if (expr is ListComprehension)
ast = new ListComp((ListComprehension)expr);
else if (expr is GeneratorExpression)
ast = new GeneratorExp((GeneratorExpression)expr);
else if (expr is MemberExpression)
ast = new Attribute((MemberExpression)expr, ctx);
else if (expr is YieldExpression)
ast = new Yield((YieldExpression)expr);
else if (expr is ConditionalExpression)
ast = new IfExp((ConditionalExpression)expr);
else if (expr is IndexExpression)
ast = new Subscript((IndexExpression)expr, ctx);
else if (expr is SliceExpression)
ast = new Slice((SliceExpression)expr);
else if (expr is BackQuoteExpression)
ast = new Repr((BackQuoteExpression)expr);
else
throw new ArgumentTypeException("Unexpected expression type: " + expr.GetType());
ast.GetSourceLocation(expr);
return ast;
}
void pickIntersection()
{
boolType = BoolOp.Intersect;
}
void pickSubtraction()
{
boolType = BoolOp.Subtract;
}
void pickUnion()
{
boolType = BoolOp.Union;
}
