/// <summary>
/// init
/// </summary>
/// <param name="functionDict"></param>
public void Init(DictionaryOperand functionDict)
{
var domainArray = functionDict.Dictionary.GetArray(EpsKeys.Domain);
var functionsArray = functionDict.Dictionary.GetArray(EpsKeys.Functions);
var encodeArray = functionDict.Dictionary.GetArray(EpsKeys.Encode);
var e0 = OperandHelper.GetRealValue(encodeArray.Values[0].Operand);
var e1 = OperandHelper.GetRealValue(encodeArray.Values[1].Operand);
// It doesn't make sense to revert only one function
// we assume either none or all functions are reverted
reverse = e0 > e1;
var boundsArray = functionDict.Dictionary.GetArray(EpsKeys.Bounds);
bounds = OperandHelper.GetRealValues(boundsArray);
bounds.Insert(0, OperandHelper.GetRealValue(domainArray.Values[0].Operand));
bounds.Add(OperandHelper.GetRealValue(domainArray.Values[1].Operand));
functions = new List <IFunction>();
for (int i = 0; i < functionsArray.Values.Count; i++)
{
var fDict = (DictionaryOperand)functionsArray.Values[i].Operand;
var function = FunctionActivator.CreateFunction(fDict);
functions.Add(function);
}
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var operand2 = operandStack.Pop();
var operand1 = operandStack.Pop();
var integer1 = operand1 as IntegerOperand;
var integer2 = operand2 as IntegerOperand;
if (integer1 != null && integer2 != null)
{
var res = new IntegerOperand();
res.Value = integer1.Value + integer2.Value;
operandStack.Push(res);
}
else
{
var double1 = OperandHelper.GetRealValue(operand1);
var double2 = OperandHelper.GetRealValue(operand2);
var res = new RealOperand();
res.Value = double1 + double2;
operandStack.Push(res);
}
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var op = operandStack.Pop();
if (op is ArrayOperand arrayOperand)
{
var matrix = OperandHelper.GetMatrix(arrayOperand);
var transY = operandStack.PopRealValue();
var transX = operandStack.PopRealValue();
matrix.Invert();
var vector = matrix.Transform(new Vector(transX, transY));
operandStack.Push(new RealOperand(vector.X));
operandStack.Push(new RealOperand(vector.Y));
}
else
{
var transY = OperandHelper.GetRealValue(op);
var transX = operandStack.PopRealValue();
var ctm = interpreter.GraphicState.TransformationMatrix;
var matrix = new Matrix(ctm.M11, ctm.M12, ctm.M21, ctm.M22, ctm.OffsetX, ctm.OffsetY);
matrix.Invert();
var vector = matrix.Transform(new Point(transX, transY));
operandStack.Push(new RealOperand(vector.X));
operandStack.Push(new RealOperand(vector.Y));
}
}
public override void Execute(EpsInterpreter interpreter)
{
var array = interpreter.OperandStack.PopArray();
var matrix = OperandHelper.GetMatrix(array);
interpreter.GraphicState.TransformationMatrix = matrix;
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var op = operandStack.Pop();
if (op is ArrayOperand arrayOperand)
{
var matrix = OperandHelper.GetMatrix(arrayOperand);
var transY = operandStack.PopRealValue();
var transX = operandStack.PopRealValue();
var point = matrix.Transform(new Point(transX, transY));
operandStack.Push(new RealOperand(point.X));
operandStack.Push(new RealOperand(point.Y));
}
else
{
var transY = OperandHelper.GetRealValue(op);
var transX = operandStack.PopRealValue();
var ctm = interpreter.GraphicState.TransformationMatrix;
var point = ctm.Transform(new Point(transX, transY));
operandStack.Push(new RealOperand(point.X));
operandStack.Push(new RealOperand(point.Y));
}
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var category = operandStack.PopStringValue();
var scratch = operandStack.PopString();
var proc = operandStack.Pop();
var template = operandStack.PopStringValue();
var list = interpreter.ResourceManager.GetFilteredResources(category, template);
foreach (var key in list)
{
var keyName = OperandHelper.TryGetStringValue(key);
if (keyName != null)
{
scratch.Value = keyName;
operandStack.Push(scratch);
}
else
{
operandStack.Push(key);
}
interpreter.Execute(proc);
if (interpreter.BreakCurrentLoop)
{
break;
}
}
}
/// <summary>
/// Constructor
/// </summary>
public RGBDeviceBrushDescriptor(List <Operand> operands)
{
values = new List <double>();
values.Add(OperandHelper.GetRealValue(operands[0]));
values.Add(OperandHelper.GetRealValue(operands[1]));
values.Add(OperandHelper.GetRealValue(operands[2]));
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var topOperand = operandStack.Pop();
var graphicState = interpreter.GraphicState;
var ctm = graphicState.CurrentTransformationMatrix;
var geometry = new GraphicPathGeometry();
switch (topOperand)
{
case IntegerOperand integerOperand:
case RealOperand realOperand:
{
var height = OperandHelper.GetRealValue(topOperand);
var width = operandStack.PopRealValue();
var y = operandStack.PopRealValue();
var x = operandStack.PopRealValue();
AddRectangle(geometry, x, y, width, height, ctm);
break;
}
case ArrayOperand arrayOperand:
{
for (int i = 0; i < arrayOperand.Values.Count; i += 4)
{
var x = OperandHelper.GetRealValue(arrayOperand.Values[i].Operand);
var y = OperandHelper.GetRealValue(arrayOperand.Values[i + 1].Operand);
var height = OperandHelper.GetRealValue(arrayOperand.Values[i + 2].Operand);
var width = OperandHelper.GetRealValue(arrayOperand.Values[i + 3].Operand);
AddRectangle(geometry, x, y, width, height, ctm);
}
break;
}
case StringOperand stringOperand:
{
var values = HomogeneousNumberArrayDecoder.Decode(stringOperand);
for (int i = 0; i < values.Count; i += 4)
{
var x = values[i];
var y = values[i + 1];
var height = values[i + 2];
var width = values[i + 3];
AddRectangle(geometry, x, y, width, height, ctm);
}
break;
}
}
ClipHelper.SetClip(interpreter, geometry);
interpreter.ResetCurrentGeometry();
}
/// <summary>
/// init
/// </summary>
public void Init(EpsInterpreter interpreter, DictionaryOperand patternDict)
{
var shadingDict = patternDict.Dictionary.GetDictionary(EpsKeys.Shading);
shading = ShadingActivator.CreateShading(interpreter, shadingDict);
var matrixArray = patternDict.Dictionary.GetArray(EpsKeys.Matrix);
matrix = OperandHelper.GetMatrix(matrixArray);
}
public override void Execute(EpsInterpreter interpreter)
{
var array = interpreter.OperandStack.PopArray();
var matrix = OperandHelper.GetMatrix(array);
GraphicsState graphicState = interpreter.GraphicState;
var ctm = graphicState.TransformationMatrix;
ctm = matrix * ctm;
graphicState.TransformationMatrix = ctm;
}
public static void Mufu(EmitterContext context)
{
InstMufu op = context.GetOp <InstMufu>();
Operand res = context.FPAbsNeg(GetSrcReg(context, op.SrcA), op.AbsA, op.NegA);
switch (op.MufuOp)
{
case MufuOp.Cos:
res = context.FPCosine(res);
break;
case MufuOp.Sin:
res = context.FPSine(res);
break;
case MufuOp.Ex2:
res = context.FPExponentB2(res);
break;
case MufuOp.Lg2:
res = context.FPLogarithmB2(res);
break;
case MufuOp.Rcp:
res = context.FPReciprocal(res);
break;
case MufuOp.Rsq:
res = context.FPReciprocalSquareRoot(res);
break;
case MufuOp.Rcp64h:
res = context.PackDouble2x32(OperandHelper.Const(0), res);
res = context.UnpackDouble2x32High(context.FPReciprocal(res, Instruction.FP64));
break;
case MufuOp.Rsq64h:
res = context.PackDouble2x32(OperandHelper.Const(0), res);
res = context.UnpackDouble2x32High(context.FPReciprocalSquareRoot(res, Instruction.FP64));
break;
case MufuOp.Sqrt:
res = context.FPSquareRoot(res);
break;
default:
context.Config.GpuAccessor.Log($"Invalid MUFU operation \"{op.MufuOp}\".");
break;
}
context.Copy(GetDest(op.Dest), context.FPSaturate(res, op.Sat));
}
/// <summary>
/// init
/// </summary>
/// <param name="functionDict"></param>
public void Init(DictionaryOperand functionDict)
{
var domainArray = functionDict.Dictionary.GetArray(EpsKeys.Domain);
var c0Array = functionDict.Dictionary.GetArray(EpsKeys.C0);
var c1Array = functionDict.Dictionary.GetArray(EpsKeys.C1);
//var rangeArray = functionDict.Dictionary.GetArray(EpsKeys.Range);
//var n = functionDict.Dictionary.GetInteger(EpsKeys.N);
domain0 = OperandHelper.GetRealValue(domainArray.Values[0].Operand);
domain1 = OperandHelper.GetRealValue(domainArray.Values[1].Operand);
c0 = OperandHelper.GetRealValues(c0Array);
c1 = OperandHelper.GetRealValues(c1Array);
}
/// <summary>
/// Init
/// </summary>
public void Init(EpsInterpreter interpreter, DictionaryOperand shadingDict)
{
var colorSpaceOperand = shadingDict.Dictionary.Find(EpsKeys.ColorSpace);
colorSpace = ColorSpaceActivator.CreateColorSpace(interpreter, colorSpaceOperand);
var functionDict = shadingDict.Dictionary.GetDictionary(EpsKeys.Function);
function = FunctionActivator.CreateFunction(functionDict);
var coordsArray = shadingDict.Dictionary.GetArray(EpsKeys.Coords);
var coords = OperandHelper.GetRealValues(coordsArray);
coords0 = new Point(coords[0], coords[1]);
coords1 = new Point(coords[2], coords[3]);
}
private TranslatedFunction Translate(ulong address, ExecutionMode mode, bool highCq)
{
ArmEmitterContext context = new ArmEmitterContext(_memory, _jumpTable, (long)address, highCq, Aarch32Mode.User);
OperandHelper.PrepareOperandPool(highCq);
OperationHelper.PrepareOperationPool(highCq);
Logger.StartPass(PassName.Decoding);
Block[] blocks = AlwaysTranslateFunctions
? Decoder.DecodeFunction(_memory, address, mode, highCq)
: Decoder.DecodeBasicBlock(_memory, address, mode);
Logger.EndPass(PassName.Decoding);
Logger.StartPass(PassName.Translation);
EmitSynchronization(context);
if (blocks[0].Address != address)
{
context.Branch(context.GetLabel(address));
}
ControlFlowGraph cfg = EmitAndGetCFG(context, blocks);
Logger.EndPass(PassName.Translation);
Logger.StartPass(PassName.RegisterUsage);
RegisterUsage.RunPass(cfg, mode, isCompleteFunction: false);
Logger.EndPass(PassName.RegisterUsage);
OperandType[] argTypes = new OperandType[] { OperandType.I64 };
CompilerOptions options = highCq
? CompilerOptions.HighCq
: CompilerOptions.None;
GuestFunction func = Compiler.Compile <GuestFunction>(cfg, argTypes, OperandType.I64, options);
OperandHelper.ResetOperandPool(highCq);
OperationHelper.ResetOperationPool(highCq);
return(new TranslatedFunction(func, rejit: !highCq));
}
private static Operand GetRegFromBit(int bit, RegisterType baseType, ExecutionMode mode)
{
if (bit < RegsCount)
{
return(OperandHelper.Register(bit, baseType, GetOperandType(baseType, mode)));
}
else if (baseType == RegisterType.Integer)
{
return(OperandHelper.Register(bit & RegsMask, RegisterType.Flag, OperandType.I32));
}
else if (baseType == RegisterType.Vector)
{
return(OperandHelper.Register(bit & RegsMask, RegisterType.FpFlag, OperandType.I32));
}
else
{
throw new ArgumentOutOfRangeException(nameof(bit));
}
}
/// <summary>
/// Sets the dash pattern
/// </summary>
private void SetDashPattern(GraphicsState graphicState, double dashPhase, ArrayOperand dashArray)
{
if (dashArray.Values.Count == 0)
{
graphicState.Dashes = null;
graphicState.DashOffset = 0;
return;
}
var dashes = new List <double>();
foreach (var val in dashArray.Values)
{
var dbl = MatrixUtilities.TransformScale(OperandHelper.GetRealValue(val.Operand), graphicState.CurrentTransformationMatrix);
dashes.Add(dbl);
}
graphicState.Dashes = dashes;
graphicState.DashOffset = dashPhase;
}
/// <summary>
/// init
/// </summary>
/// <param name="functionDict"></param>
public void Init(DictionaryOperand functionDict)
{
var domainArray = functionDict.Dictionary.GetArray(EpsKeys.Domain);
//var rangeArray = functionDict.Dictionary.GetArray(EpsKeys.Range);
//var encodeArray = functionDict.Dictionary.GetArray(EpsKeys.Encode);
var decodeArray = functionDict.Dictionary.GetArray(EpsKeys.Decode);
var sizeArray = functionDict.Dictionary.GetArray(EpsKeys.Size);
var dataSource = functionDict.Dictionary.GetString(EpsKeys.DataSource);
var bitsPerSample = functionDict.Dictionary.GetInteger(EpsKeys.BitsPerSample);
domain0 = OperandHelper.GetRealValue(domainArray.Values[0].Operand);
domain1 = OperandHelper.GetRealValue(domainArray.Values[1].Operand);
var decodes = OperandHelper.GetRealValues(decodeArray);
var size = (IntegerOperand)sizeArray.Values[0].Operand;
var data = RelativeSamplesDecoder.Decode(dataSource, bitsPerSample.Value);
int valuesPerSample = data.Count / size.Value;
c0 = GetSample(data, 0, valuesPerSample, decodes);
c1 = GetSample(data, (data.Count - valuesPerSample), valuesPerSample, decodes);
}
/// <summary>
/// Create a color space
/// </summary>
public static IColorSpace CreateColorSpace(EpsInterpreter interpreter, Operand colorSpaceOperand)
{
string colorSpaceName = null;
ArrayOperand colorSpaceDetails = null;
switch (colorSpaceOperand)
{
case NameOperand nameOperand:
{
colorSpaceName = nameOperand.Value;
break;
}
case ArrayOperand arrayOperand:
{
colorSpaceName = OperandHelper.GetStringValue(arrayOperand.Values[0].Operand);
colorSpaceDetails = arrayOperand;
break;
}
}
return(CreateColorSpace(interpreter, colorSpaceName, colorSpaceDetails));
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var op = operandStack.Pop();
if (op is ArrayOperand arrayOperand)
{
var matrix = OperandHelper.GetMatrix(arrayOperand);
var scaleY = operandStack.PopRealValue();
var scaleX = operandStack.PopRealValue();
matrix.Scale(scaleX, scaleY);
var array = new ArrayOperand();
array.Values.Add(new OperandProxy(new RealOperand(matrix.M11)));
array.Values.Add(new OperandProxy(new RealOperand(matrix.M12)));
array.Values.Add(new OperandProxy(new RealOperand(matrix.M21)));
array.Values.Add(new OperandProxy(new RealOperand(matrix.M22)));
array.Values.Add(new OperandProxy(new RealOperand(matrix.OffsetX)));
array.Values.Add(new OperandProxy(new RealOperand(matrix.OffsetY)));
operandStack.Push(array);
}
else
{
var scaleY = OperandHelper.GetRealValue(op);
var scaleX = operandStack.PopRealValue();
GraphicsState graphicState = interpreter.GraphicState;
var ctm = graphicState.TransformationMatrix;
ctm.Scale(scaleX, scaleY);
graphicState.TransformationMatrix = ctm;
}
}
public Operand CreateCbuf(int slot, int offset)
{
SetUsedConstantBuffer(slot);
return(OperandHelper.Cbuf(slot, offset));
}
/// <summary>
/// Constructor
/// </summary>
public GrayBrushDescriptor(Operand operand)
{
gray = OperandHelper.GetRealValue(operand);
}
/// <summary>
/// Gets the name of the color space
/// </summary>
public ArrayOperand GetColorSpaceName()
{
return(OperandHelper.CreateColorSpaceDescription(EpsKeys.DeviceRGB));
}
