/// <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)); }