/// <summary> /// Renders the specified Emitter, applying the specified transformation offset. /// </summary> public override void RenderEmitter(Emitter emitter, ref Matrix transform) { Guard.ArgumentNull("emitter", emitter); Guard.IsTrue(this.Batch == null, "SpriteBatchRenderer is not ready! Did you forget to LoadContent?"); if (emitter.ParticleTexture != null && emitter.ActiveParticlesCount > 0) { // Bail if the emitter blend mode is "None"... if (emitter.BlendMode == EmitterBlendMode.None) return; // Calculate the source rectangle and origin offset of the Particle texture... Rectangle source = new Rectangle(0, 0, emitter.ParticleTexture.Width, emitter.ParticleTexture.Height); Vector2 origin = new Vector2(source.Width / 2f, source.Height / 2f); BlendState blendState = this.GetBlendState(emitter.BlendMode); this.Batch.Begin(SpriteSortMode.Deferred, blendState); for (int i = 0; i < emitter.ActiveParticlesCount; i++) { Particle particle = emitter.Particles[i]; float scale = particle.Scale / emitter.ParticleTexture.Width; this.Batch.Draw(emitter.ParticleTexture, particle.Position, source, new Color(particle.Colour), particle.Rotation, origin, scale, SpriteEffects.None, 0f); } this.Batch.End(); } }
public void ListenersWithoutHandlers() { LogManager.SetupLogManager(); var emitter = new Emitter(); var expected = new IListener[] {}; Assert.Equal(expected, emitter.Listeners("foo").ToArray()); }
public override void Compile(Emitter.Emitter emitter) { var method = emitter.AssemblyImport(typeof(MirelleStdlib.Events.Simulation).GetMethod("Process", new[] { typeof(int), typeof(int) })); // processor count if(Processors == null) emitter.EmitLoadInt(1); else { if(Processors.GetExpressionType(emitter) != "int") Error(Resources.errSimulateProcessorsInt); Processors.Compile(emitter); } // queue length if(MaxQueue == null) emitter.EmitLoadInt(0); else { if(MaxQueue.GetExpressionType(emitter) != "int") Error(Resources.errSimulateQueueInt); MaxQueue.Compile(emitter); } emitter.EmitCall(method); }
public void TestHostedInstance() { var r = GetRealSink(); var emitter = new Emitter(r); var evt = CreateIdSrvEvent(DateTimeOffset.UtcNow); emitter.Emit(evt); }
public override void Compile(Emitter.Emitter emitter) { var leftType = Left.GetExpressionType(emitter); var rightType = Right.GetExpressionType(emitter); var type = GetExpressionType(emitter); // subtract matrices if(type == "matrix") { Left.Compile(emitter); Right.Compile(emitter); var matrixType = typeof(MN.Matrix<double>); var method = emitter.AssemblyImport(matrixType.GetMethod("Subtract", new [] { matrixType } )); emitter.EmitCall(method); } // subtract dicts else if (type == "dict") { Left.Compile(emitter); Right.Compile(emitter); var dictType = typeof(Dict); var method = emitter.AssemblyImport(dictType.GetMethod("Subtract", new[] { dictType })); emitter.EmitCall(method); } // subtract complex numbers else if (type == "complex") { Left.Compile(emitter); if (leftType != "complex") { emitter.EmitUpcastBasicType(leftType, "float"); emitter.EmitLoadFloat(0); emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float")); } Right.Compile(emitter); if (rightType != "complex") { emitter.EmitUpcastBasicType(rightType, "float"); emitter.EmitLoadFloat(0); emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float")); } emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("op_Subtraction", new[] { typeof(SN.Complex), typeof(SN.Complex) }))); } // add floating point numbers or integers else if (type.IsAnyOf("int", "float")) { Left.Compile(emitter); emitter.EmitUpcastBasicType(leftType, type); Right.Compile(emitter); emitter.EmitUpcastBasicType(rightType, type); emitter.EmitSub(); } }
public override string GetExpressionType(Emitter.Emitter emitter) { if (ExpressionType != "") return ExpressionType; var leftType = Left.GetExpressionType(emitter); var rightType = Right.GetExpressionType(emitter); // mathematic operations var supportedTypes = new[] { "int", "float", "complex" }; // subtract matrices if (leftType == "matrix" && rightType == "matrix") ExpressionType = "matrix"; // subtract dicts else if (leftType == "dict" && rightType == "dict") ExpressionType = "dict"; else if (leftType.IsAnyOf(supportedTypes) && rightType.IsAnyOf(supportedTypes)) { if ("complex".IsAnyOf(leftType, rightType)) ExpressionType = "complex"; else if ("float".IsAnyOf(leftType, rightType)) ExpressionType = "float"; else ExpressionType = "int"; } else Error(String.Format(Resources.errOperatorTypesMismatch, "-", leftType, rightType)); return ExpressionType; }
static MethodDefinition CreateTestMethod(Emitter emitter) { TypeReference type = new TypeReference("", "Test", null, null); MethodDefinition test = new MethodDefinition("Test", MethodAttributes.Public, type); emitter(test.Body.GetILProcessor()); return test; }
public override void Compile(Emitter.Emitter emitter) { var numTypes = new[] { "int", "float" }; var fromType = From.GetExpressionType(emitter); var toType = To.GetExpressionType(emitter); var stepType = Step.GetExpressionType(emitter); // validate parameters if (!fromType.IsAnyOf(numTypes) || !toType.IsAnyOf(numTypes) || !stepType.IsAnyOf(numTypes)) Error(Resources.errIntFloatExpected); // from, to, step From.Compile(emitter); if (fromType != "float") emitter.EmitConvertToFloat(); To.Compile(emitter); if (toType != "float") emitter.EmitConvertToFloat(); Step.Compile(emitter); if (stepType != "float") emitter.EmitConvertToFloat(); // invoke method var method = typeof(MirelleStdlib.ArrayHelper).GetMethod("CreateRangedArray", new[] { typeof(double), typeof(double), typeof(double) }); emitter.EmitCall(emitter.AssemblyImport(method)); }
public override void Compile(Emitter.Emitter emitter) { foreach (var curr in Types) Types[curr].Compile(emitter); GlobalMethod.Compile(emitter); }
public override void Compile(Emitter.Emitter emitter) { // ensure this is a matrix if (ExpressionPrefix.GetExpressionType(emitter) != "matrix") Error(Resources.errIndexingNotAMatrix); // ensure indexes are integers if (Index1.GetExpressionType(emitter) != "int") Error(Resources.errIntIndexExpected, Index1.Lexem); if (Index2.GetExpressionType(emitter) != "int") Error(Resources.errIntIndexExpected, Index2.Lexem); // ensure assigned value is either int or float var exprType = Expression.GetExpressionType(emitter); if (!exprType.IsAnyOf("int", "float")) Error(Resources.errMatrixItemTypeMismatch); ExpressionPrefix.Compile(emitter); Index1.Compile(emitter); Index2.Compile(emitter); Expression.Compile(emitter); if(exprType != "float") emitter.EmitConvertToFloat(); var method = emitter.AssemblyImport(typeof(MN.DenseMatrix).GetMethod("At", new[] { typeof(int), typeof(int), typeof(double) })); emitter.EmitCall(method); }
public override void Compile(Emitter.Emitter emitter) { try { Resolve(emitter); if (!emitter.TypeIsParent(IdentifierType, Expression.GetExpressionType(emitter))) Error(String.Format(Resources.errAssignTypeMismatch, Expression.GetExpressionType(emitter), IdentifierType)); } catch(CompilerException ex) { ex.AffixToLexem(Lexem); throw; } switch (Kind) { case IdentifierKind.StaticField: Expression.Compile(emitter); emitter.EmitSaveField(emitter.FindField(OwnerType, Name)); break; case IdentifierKind.Field: if (ExpressionPrefix != null) ExpressionPrefix.Compile(emitter); else emitter.EmitLoadThis(); Expression.Compile(emitter); emitter.EmitSaveField(emitter.FindField(OwnerType, Name)); break; case IdentifierKind.Variable: Expression.Compile(emitter); emitter.EmitSaveVariable(emitter.CurrentMethod.Scope.Find(Name)); break; case IdentifierKind.Parameter: Expression.Compile(emitter); emitter.EmitSaveParameter(emitter.CurrentMethod.Parameters[Name].Id); break; } }
public override void Compile(Emitter.Emitter emitter) { var leftType = Left.GetExpressionType(emitter); var rightType = Right.GetExpressionType(emitter); // an array of values if (rightType == leftType + "[]") { Right.Compile(emitter); Left.Compile(emitter); if (leftType.IsAnyOf("int", "bool", "float", "complex")) emitter.EmitBox(emitter.ResolveType(leftType)); var method = typeof(MirelleStdlib.ArrayHelper).GetMethod("Has", new[] { typeof(object), typeof(object) }); emitter.EmitCall(emitter.AssemblyImport(method)); } // an object has a "has" method that accepts the lefthand expression else { try { Expr.IdentifierInvoke("has", Right, Left).Compile(emitter); return; } catch { } Error(String.Format(Resources.errOperatorTypesMismatch, "in", leftType, rightType)); } }
public override void Compile(Emitter.Emitter emitter) { // declare variables and methods var tmpVar = emitter.CurrentMethod.Scope.Introduce("dict", emitter.ResolveType("dict")); var ctor = emitter.AssemblyImport(typeof(MirelleStdlib.Dict).GetConstructor(new Type[] { })); var set = emitter.FindMethod("dict", "set", "string", "string"); // var tmp = new dict emitter.EmitNewObj(ctor); emitter.EmitSaveVariable(tmpVar); // tmp[key] = value foreach(var curr in Data) { var keyType = curr.Item1.GetExpressionType(emitter); var valueType = curr.Item2.GetExpressionType(emitter); if (keyType != "string") Error(Resources.errDictItemTypeMismatch, curr.Item1.Lexem); if (valueType != "string") Error(Resources.errDictItemTypeMismatch, curr.Item2.Lexem); emitter.EmitLoadVariable(tmpVar); curr.Item1.Compile(emitter); curr.Item2.Compile(emitter); emitter.EmitCall(set); } emitter.EmitLoadVariable(tmpVar); }
public void CompileArray(Emitter.Emitter emitter) { // make sure it's an array var type = emitter.GetArrayItemType(ExpressionPrefix.GetExpressionType(emitter)); if (type == "") Error(Resources.errIndexingNotAnArray); // make sure expression type matches array type var exprType = Expression.GetExpressionType(emitter); if (!emitter.TypeIsParent(type, exprType)) Error(String.Format(Resources.errAssignTypeMismatch, exprType, type)); ExpressionPrefix.Compile(emitter); Index.Compile(emitter); if (type == "complex") { // special case of valuetypes var typeRef = emitter.ResolveType(type); emitter.EmitLoadIndexAddress(typeRef); Expression.Compile(emitter); emitter.EmitSaveObject(typeRef); } else { Expression.Compile(emitter); emitter.EmitSaveIndex(type); } }
public override void Compile(Emitter.Emitter emitter) { if (emitter.CurrentLoop == null) Error(Resources.errBreakRedoOutsideLoop); emitter.EmitBranch(emitter.CurrentLoop.BodyStart); }
public override void Compile(Emitter.Emitter emitter) { try { Resolve(emitter); } catch (CompilerException ex) { ex.AffixToLexem(Lexem); throw; } var method = emitter.FindMethod(OwnerType, Name, GetSignature(emitter)); // load 'this' if (ExpressionPrefix != null) ExpressionPrefix.Compile(emitter); else if (!Static) emitter.EmitLoadThis(); // load parameters for (int idx = 0; idx < Parameters.Count; idx++) { Parameters[idx].Compile(emitter); emitter.EmitUpcastBasicType(Parameters[idx].GetExpressionType(emitter), method.Parameters[idx].Type.Signature); } // invoke emitter.EmitCall(method); }
public override void Compile(Emitter.Emitter emitter) { // check for variable definitions being the only expressions in a block if (Statements.Count == 1 && (Statements[0] is VarDeclarationNode || Statements[0] is VarSplatNode)) Error(Resources.errVariableDefinitionOnly, Statements[0].Lexem); emitter.CurrentMethod.Scope.EnterSubScope(); foreach (var curr in Statements) { curr.Compile(emitter); // eliminate dead code if (curr is ReturnNode || (curr is IfNode && (curr as IfNode).AllPathsReturn)) { AllPathsReturn = true; break; } // remove clutter from stack if (!curr.GetExpressionType(emitter).IsAnyOf("", "void")) emitter.EmitPop(); } emitter.CurrentMethod.Scope.LeaveSubScope(); }
public override void Compile(Emitter.Emitter emitter) { var type = ExpressionPrefix.GetExpressionType(emitter); if (type == "dict") CompileDict(emitter); else CompileArray(emitter); }
/// <summary> /// Renders the specified Emitter. /// </summary> public virtual void RenderEmitter(Emitter emitter) { Guard.ArgumentNull("emitter", emitter); Matrix ident = Matrix.Identity; this.RenderEmitter(emitter, ref ident); }
public void Emit(Emitter e) { Expr.Emit(e); e.EmitLine("stloc " + id); if (ExprMode) e.EmitLine("ldloc " + id); }
public void HasListenersWithoutHandlers() { var log = LogManager.GetLogger(Global.CallerName()); log.Info("Start"); var emitter = new Emitter(); Assert.AreEqual(false, emitter.HasListeners("foo")); }
public void ListenersWithoutHandlers() { var emitter = new Emitter(); var expected = new IListener[] {}; //Assert.AreEqual(expected, emitter.Listeners("foo").ToArray()); Assert.AreEqual(expected.Count(), emitter.Listeners("foo").ToArray().Count()); CollectionAssert.AreEqual(expected, emitter.Listeners("foo").ToArray()); }
public override void Compile(Emitter.Emitter emitter) { var leftType = Left.GetExpressionType(emitter); var rightType = Right.GetExpressionType(emitter); var type = GetExpressionType(emitter); // divide matrix by a number if(type == "matrix") { Left.Compile(emitter); // division is broken, therefore multiply by an inverse value emitter.EmitLoadFloat(1); Right.Compile(emitter); if (rightType != "float") emitter.EmitConvertToFloat(); emitter.EmitDiv(); var matrixType = typeof(MN.Matrix<double>); var method = emitter.AssemblyImport(matrixType.GetMethod("Multiply", new[] { typeof(double) })); emitter.EmitCall(method); } // divide complex numbers else if (type == "complex") { Left.Compile(emitter); if (leftType != "complex") { emitter.EmitUpcastBasicType(leftType, "float"); emitter.EmitLoadFloat(0); emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float")); } Right.Compile(emitter); if (rightType != "complex") { emitter.EmitUpcastBasicType(rightType, "float"); emitter.EmitLoadFloat(0); emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float")); } emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("op_Division", new[] { typeof(SN.Complex), typeof(SN.Complex) }))); } // divide floating point numbers or integers else if (type.IsAnyOf("int", "float")) { Left.Compile(emitter); emitter.EmitUpcastBasicType(leftType, type); Right.Compile(emitter); emitter.EmitUpcastBasicType(rightType, type); emitter.EmitDiv(); } }
public void Map(IDictionary<string, object> document, Emitter emitter) { bool vacant = (bool)document.Get("vacant"); string name = (string)document.Get("name"); if (vacant && name != null) { emitter.Emit(name, vacant); } }
public void HasListenersWithoutHandlers() { LogManager.SetupLogManager(); var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod()); log.Info("Start"); var emitter = new Emitter(); Assert.Equal(false, emitter.HasListeners("foo")); }
public override string GetExpressionType(Emitter.Emitter emitter) { if (Expression == null) return "void"; if(ExpressionType == "") ExpressionType = Expression.GetExpressionType(emitter); return ExpressionType; }
public override void Compile(Emitter.Emitter emitter) { if (Expression.GetExpressionType(emitter) != "bool") Error(Resources.errBoolExpected); Expression.Compile(emitter); emitter.EmitLoadBool(false); emitter.EmitCompareEqual(); }
/// <summary> /// Creates an instance of the Transmitter class that can be used to transmit IR codes. /// </summary> /// <param name="defaultEmitter">The emitter to transmit the IR code with</param> /// <param name="defaultCodeFormat">The format of the IR code.</param> /// <param name="defaultRepeatCount">Indicates how many iterations of the code should be /// sent (in the case of a 2-piece code, the first stream is sent once followed /// by the second stream sent repeatCount times).</param> /// <param name="defaultInactivityWaitTime">Time in milliseconds since the last received /// IR activity to wait before sending an IR code. Normally, pass 0 for this parameter.</param> /// <remarks>This class should be disposed if using this constructor.</remarks> public Transmitter(Emitter defaultEmitter = Emitter.All, CodeFormat defaultCodeFormat = CodeFormat.Pronto, int defaultRepeatCount = 1, int defaultInactivityWaitTime = 0) { _defaultEmitter = defaultEmitter; _defaultCodeFormat = defaultCodeFormat; _defaultRepeatCount = defaultRepeatCount; _defaultInactivityWaitTime = defaultInactivityWaitTime; }
public Fireball(Texture2D[] textures, Vector2 position, Vector2 direction, FireballConfig config = null) : this(position, direction, config) { Random = new Random((int) (textures.GetHashCode() + position.GetHashCode() + direction.GetHashCode() + DateTime.Now.Ticks)); _one = new Emitter(textures); _two = new Emitter(textures); _three = new Emitter(textures); _smokeOne = new Emitter(textures); _smokeTwo = new Emitter(textures); }
public override string GetExpressionType(Emitter.Emitter emitter) { if (ExpressionType == "") { if (Values.Count > 0) ExpressionType = Values[0].GetExpressionType(emitter) + "[]"; } return ExpressionType; }
public override void PreUpdate(Emitter emitter, float time) { _limitSq = Limit * Limit; }
protected void Init() { //added 2012.6.24 InitCollision(); Owner = transform.parent.gameObject.GetComponent <XffectComponent>(); if (Owner == null) { Debug.LogError("you must set EffectLayer to be XffectComponent's child."); } //fixed 2012.6.2. ignoring the red errors. if (ClientTransform == null) { Debug.LogWarning("effect layer: " + gameObject.name + " haven't assign a client transform, automaticly set to itself."); ClientTransform = transform; } AvailableENodes = new EffectNode[MaxENodes]; ActiveENodes = new EffectNode[MaxENodes]; for (int i = 0; i < MaxENodes; i++) { EffectNode n = new EffectNode(i, ClientTransform, SyncClient, this); List <Affector> afts = InitAffectors(n); n.SetAffectorList(afts); if (RenderType == 0) { n.SetType(SpriteWidth, SpriteHeight, (STYPE)SpriteType, (ORIPOINT)OriPoint, SpriteUVStretch, 60f); } else if (RenderType == 1) { float rwidth = RibbonWidth; float rlen = RibbonLen; if (UseRandomRibbon) { rwidth = Random.Range(RibbonWidthMin, RibbonWidthMax); rlen = Random.Range(RibbonLenMin, RibbonLenMax); } n.SetType(FaceToObject, FaceObject, rwidth, MaxRibbonElements, rlen, ClientTransform.position + EmitPoint, StretchType, 60f, IsWeapon, IsScale); } else if (RenderType == 2) { n.SetType(ConeSize, ConeSegment, ConeAngle, transform.rotation * OriVelocityAxis, 0, 60f, UseConeAngleChange, ConeDeltaAngle); } else if (RenderType == 3) { Vector3 dir = Vector3.zero; if (OriVelocityAxis == Vector3.zero) { OriVelocityAxis = Vector3.up; } dir = transform.rotation * OriVelocityAxis; n.SetType(CMesh, dir, 60f); } AvailableENodes[i] = n; } AvailableNodeCount = MaxENodes; emitter = new Emitter(this); mStopped = false; }
public void TestEvaluation() { object evaluated = mExpressionParser.EvaluateExpression("3.1f", new CodeContext(null)); if ((evaluated is float) == false) { throw new Exception("Values with 'f' should be floats"); } TestEvaluation("-16", -16); TestEvaluation("1+1", 2); TestEvaluation("2.3f - 1", 2.3f - 1); TestEvaluation("1 + (2 * 3.0)", 1 + (2 * 3.0)); TestEvaluation("4/2.0f", 4 / 2.0f); TestEvaluation("true || false", true || false); TestEvaluation("true && false", true && false); // Test full evaluations and verify the results TestEvaluation("System.Math.Max(3, 5)", 5); TestEvaluation("System.Math.Min(8-1, 8)", 7); TestEvaluation("this", mElementRuntime, mElementRuntime); TestEvaluation("this.X", mElementRuntime.X, mElementRuntime); TestEvaluation("this.SomeNewVar", 3.333, mElementRuntime); TestEvaluation("System.Math.Max(this.X, this.Y)", System.Math.Max(mElementRuntime.X, mElementRuntime.Y), mElementRuntime); TestEvaluation("float.PositiveInfinity", float.PositiveInfinity); TestEvaluation("System.Math.Max(float.PositiveInfinity, 0)", float.PositiveInfinity); TestEvaluation("VariableState.Left", mElementRuntime.GetStateRecursively("Left"), mElementRuntime); TestEvaluation("new Vector3()", new Vector3()); TestEvaluation("Color.Red", Color.Red); // need this, but first need to be able to reorder cast properly TestEvaluation("new Color(.3f, .4f, .5f, .6f)", new Color(.3f, .4f, .5f, .6f)); TestEvaluation("\"a\" + \"b\"", "ab", null); TestEvaluation("1 + \"a\" + 2", "1a2", null); TestEvaluation("this.SpriteObject.ScaleX", 3.0f, mElementRuntime); EmitterList emitterList = new EmitterList(); var first = new Emitter(); first.Name = "First"; emitterList.Add(first); var second = new Emitter(); second.Name = "Second"; emitterList.Add(second); TestEvaluation("FindByName(\"First\")", emitterList.FindByName("First"), emitterList); }
/// <summary> /// Sets the audio output level. /// </summary> /// <param name="level">The audio level.</param> public void SetAudioLevel(Message <double> level) { this.wasapiRender.AudioLevel = (float)level.Data; }
/// <summary> /// Saves the current node to the specified emitter. /// </summary> /// <param name="emitter">The emitter where the node is to be saved.</param> /// <param name="state">The state.</param> internal abstract void Emit(Emitter emitter, EmitterState state);
public void Emit_InvalidOpCode_ThrowsNotSupportedException() { var emitter = new Emitter(null, new Type[] {}); Assert.Throws <NotSupportedException>(() => emitter.Emit(OpCodes.Xor)); }
public override void updateEmitter(Emitter emitter) { EmitterData emitterData = (EmitterData)emitter.data(); GeneratorPeriodic generator = (GeneratorPeriodic)emitter.generator(); GeneratorImpl generatorImpl = (GeneratorImpl)generator.impl(); }
public HandleImpl(Emitter obj, string ev, IListener fn) { _obj = obj; _ev = ev; _fn = fn; }
public override bool TestTrigger(Emitter emitter, Particle particle, float time) { return(particle.IsDeflected); }
public bool IsPrintable(int offset) { char character = buffer.Peek(offset); return(Emitter.IsPrintable(character)); }
/// <summary> /// Serializes the specified object. /// </summary> /// <param name="emitter">The <see cref="Emitter" /> where to serialize the object.</param> /// <param name="graph">The object to serialize.</param> public void Serialize(Emitter emitter, object graph) { Serialize(emitter, graph, graph != null ? graph.GetType() : typeof(object)); }
private static void Same(Emitter _) => Assert.AreSame(emitter, _);
public override void updateParticle(Emitter emitter, Particle particle, float dt) { ParticleImpl particleImpl = (ParticleImpl)particle; EmitterData emitterData = (EmitterData)emitter.data(); GeneratorPeriodic generator = (GeneratorPeriodic)emitter.generator(); GeneratorImpl generatorImpl = (GeneratorImpl)generator.impl(); particleImpl._lifetime += dt; _math.vec3 value_ = _math.vec3_(0F, -100F, 0F); _math.vec3 noise_a = _math.mulv3scalar_(_math.vec3_(100F, 50F, 30F), emitter.effect().time()); _math.addv3(out noise_a, noise_a, particleImpl._Position); _math.vec3 noise_i = _math.mulv3scalar_(noise_a, 1.0F / 1000F); _math.vec3 noise = _math.noisePixelLinear3_(noise_i); _math.mulv3(out noise, noise, _math.vec3_(0.0078125F, 0.0078125F, 0.0078125F)); _math.addv3(out noise, noise, _math.vec3_(-1F, -1F, -1F)); _math.mulv3scalar(out noise, noise, 400F); _math.vec3 fmove_fs = value_; _math.addv3(out fmove_fs, fmove_fs, noise); _math.vec3 fmove_vs = _math.vec3_(0F, 0F, 0F); float fmove_dtl = dt; _math.vec3 fmove_v = particleImpl._Velocity; _math.vec3 fmove_p = particleImpl._Position; while (fmove_dtl > 0.0001F) { float fmove_dtp = fmove_dtl; _math.vec3 fmove_fsd = fmove_fs; _math.vec3 fmove_rw = _math.subv3_(fmove_vs, fmove_v); float fmove_rwl = _math.lengthv3sq_(fmove_rw); if (fmove_rwl > 0.0001F) { fmove_rwl = (float)Math.Sqrt(fmove_rwl); _math.vec3 fmove_rwn = _math.divv3scalar_(fmove_rw, fmove_rwl); float fmove_df = 0.01F * 1F * fmove_rwl; if (fmove_df * fmove_dtp > 0.2F) { fmove_dtp = 0.2F / fmove_df; } _math.addv3(out fmove_fsd, fmove_fsd, _math.mulv3scalar_(fmove_rwn, fmove_rwl * fmove_df)); } _math.addv3(out fmove_v, fmove_v, _math.mulv3scalar_(fmove_fsd, fmove_dtp)); _math.addv3(out fmove_p, fmove_p, _math.mulv3scalar_(fmove_v, fmove_dtp)); fmove_dtl -= fmove_dtp; } particleImpl._Position = fmove_p; particleImpl._Velocity = fmove_v; particle.position_ = particleImpl._Position; float value_a = 2F; if (particleImpl._lifetime > value_a) { particle.dead_ = true; } float expr_ = (particleImpl._lifetime / value_a); float _plota_out; float _plota_in0 = (expr_ < 0F?0F:(expr_ > 1F?1F:expr_)); _math.PathRes _plota_srch0 = _plota_in0 < 0.956383?_math.pathRes(0, (_plota_in0 - 0F) * 1.04561F):_math.pathRes(1, (_plota_in0 - 0.956383F) * 22.9268F); _math.funcLerp(out _plota_out, this._plota[0][_plota_srch0.s], _plota_srch0.i); particleImpl.alpha_ = _plota_out; }
public void Read(AssetReader reader) { Emitter.Read(reader); Type = (ParticleSystemSubEmitterType)reader.ReadInt32(); Properties = (ParticleSystemSubEmitterProperties)reader.ReadInt32(); }
/// <a href="http://bit.ly/2QNmw2q">On a change the listener needs a copy of the changed data to react to</a> protected override void OnChange(Emitter emitter) => componentValueToSet.Invoke(Asset.Value);
public void Emit_InvalidOpCodeWithConstructorInfo_ThrowsNotSupportedException() { var emitter = new Emitter(null, new Type[] {}); Assert.Throws <NotSupportedException>(() => emitter.Emit(OpCodes.Ldarg_0, (ConstructorInfo)null)); }
public void StackType_EmptyMethod_IsNull() { var emitter = new Emitter(null, new Type[] {}); Assert.Null(emitter.StackType); }
public void Emit_InvalidOpCodeWithSignedByte_ThrowsNotSupportedException() { var emitter = new Emitter(null, new Type[] {}); Assert.Throws <NotSupportedException>(() => emitter.Emit(OpCodes.Ldarg_0, (sbyte)42)); }
public static IHandle Create(Emitter obj, string ev, IListener fn) { obj.On(ev, fn); return(new HandleImpl(obj, ev, fn)); }
public IEnumerable <Object> FetchDependencies(ISerializedFile file, bool isLog = false) { yield return(Emitter.FetchDependency(file, isLog, () => nameof(SubEmitterData), "emitter")); }
private void Emit(int opcode) { Emitter.EmitBeUInt16(opcode); EmitConstants(); }
internal void Cnop(int extra, int align) { Emitter.Align(extra, align); }
public void Nop() { Emitter.EmitBeUInt16(0x4E71); }
protected override AutoCastMode DoEmitWithoutCast(CancellationToken cancellationToken = default(CancellationToken)) { if (Node.Expression is IdentifierNameSyntax) { var value = Emitter.GetConstantValue(Node); if (value.HasValue) { Write(value.Value); return(AutoCastMode.Default); } } var symbol = Emitter.GetSymbolInfo(Node.Expression).Symbol; var methodSymbol = symbol as IMethodSymbol; if (methodSymbol == null && symbol != null) { switch (symbol.Kind) { case SymbolKind.Parameter: if (((IParameterSymbol)symbol).Type != null && ((IParameterSymbol)symbol).Type.TypeKind == TypeKind.Delegate) { methodSymbol = ((INamedTypeSymbol)((IParameterSymbol)symbol).Type).DelegateInvokeMethod; } break; case SymbolKind.Property: if (((IPropertySymbol)symbol).Type != null && ((IPropertySymbol)symbol).Type.TypeKind == TypeKind.Delegate) { methodSymbol = ((INamedTypeSymbol)((IPropertySymbol)symbol).Type).DelegateInvokeMethod; } break; case SymbolKind.Field: if (((IFieldSymbol)symbol).Type != null && ((IFieldSymbol)symbol).Type.TypeKind == TypeKind.Delegate) { methodSymbol = ((INamedTypeSymbol)((IFieldSymbol)symbol).Type).DelegateInvokeMethod; } break; case SymbolKind.Local: if (((ILocalSymbol)symbol).Type != null && ((ILocalSymbol)symbol).Type.TypeKind == TypeKind.Delegate) { methodSymbol = ((INamedTypeSymbol)((ILocalSymbol)symbol).Type).DelegateInvokeMethod; } break; } } var arguments = Node.ArgumentList.Arguments.Select(a => new ParameterInvocationInfo(a)).ToList(); if (methodSymbol != null) { if (methodSymbol.IsExtensionMethod) { methodSymbol = methodSymbol.ReducedFrom; arguments.Insert(0, new ParameterInvocationInfo(GetInvokeExpression(Node.Expression))); } var template = Emitter.GetTemplate(methodSymbol); if (template != null) { SkipSemicolonOnStatement = template.SkipSemicolonOnStatements; if (template.Variables.TryGetValue("this", out var thisVar)) { PushWriter(); if (methodSymbol.IsStatic) { Write(Emitter.GetTypeName(methodSymbol.ContainingType, false, true)); } else { EmitTree(Node.Expression, cancellationToken); } thisVar.RawValue = PopWriter(); } var methodInvocation = BuildMethodInvocation(methodSymbol, arguments); foreach (var param in methodSymbol.Parameters) { if (template.Variables.TryGetValue(param.Name, out var variable)) { var values = methodInvocation[param.Name].ToArray(); PushWriter(); if (param.IsParams) { if (values.Length == 1) { var singleParamType = Emitter.GetTypeInfo(values[0]); if (singleParamType.ConvertedType.Equals(param.Type)) { EmitTree(values[0], cancellationToken); } else { if (variable.Modifier != "raw") { Write("["); } EmitTree(values[0], cancellationToken); if (variable.Modifier != "raw") { Write("]"); } } } else { if (variable.Modifier != "raw") { Write("["); } for (int j = 0; j < values.Length; j++) { if (j > 0) { WriteComma(); } EmitTree(values[0], cancellationToken); } if (variable.Modifier != "raw") { Write("]"); } } } else { if (variable.Modifier == "raw") { var constValue = Emitter.GetConstantValue(values[0], cancellationToken); if (constValue.HasValue) { Write(constValue); } else { EmitTree(values[0], cancellationToken); } } else { EmitTree(values[0], cancellationToken); } } var paramOutput = PopWriter(); variable.RawValue = paramOutput; } } for (int i = 0; i < methodSymbol.TypeArguments.Length; i++) { var argument = methodSymbol.TypeArguments[i]; var param = methodSymbol.TypeParameters[i]; if (template.Variables.TryGetValue(param.Name, out var variable)) { variable.RawValue = Emitter.GetTypeName(argument); } } Write(template.ToString()); } else if (Emitter.IsMethodRedirected(methodSymbol, out var targetType)) { Write(targetType); WriteDot(); Write(Emitter.GetMethodName(methodSymbol)); if (methodSymbol.IsStatic) { WriteMethodInvocation(methodSymbol, arguments, Node, cancellationToken); } else { arguments.Insert(0, new ParameterInvocationInfo(GetInvokeExpression(Node.Expression), true)); WriteMethodInvocation(methodSymbol, arguments, Node, cancellationToken); } } else if (methodSymbol.IsStatic) { Write(Emitter.GetTypeName(methodSymbol.ContainingType, false, true)); WriteDot(); Write(Emitter.GetMethodName(methodSymbol)); WriteMethodInvocation(methodSymbol, arguments, Node, cancellationToken); } else { EmitTree(Node.Expression, cancellationToken); WriteMethodInvocation(methodSymbol, arguments, Node, cancellationToken); } } else { EmitTree(Node.Expression, cancellationToken); WriteMethodInvocation(null, arguments, Node, cancellationToken); } return(AutoCastMode.Default); }
public void Bchg(int c, MachineOperand eaDst) { Emit(0x0840 | Ea(eaDst)); Emitter.EmitBeUInt16(c); }
public void Emit_InvalidOpCodeWithType_ThrowsNotSupportedException() { var emitter = new Emitter(null, new Type[] {}); Assert.Throws <NotSupportedException>(() => emitter.Emit(OpCodes.Ldarg_0, typeof(object))); }
public override void Emit(Emitter emitter, int index, float x, float y) { emitter.Recycle <ForceParticle>().Reset(x, y); }
public ParticleEditorScreen() { cam = new Camera(); leftPanel = new GUIFrame(new RectTransform(new Vector2(0.07f, 1.0f), Frame.RectTransform) { MinSize = new Point(150, 0) }, style: "GUIFrameLeft"); var paddedLeftPanel = new GUILayoutGroup(new RectTransform(new Vector2(0.9f, 0.95f), leftPanel.RectTransform, Anchor.CenterLeft) { RelativeOffset = new Vector2(0.02f, 0.0f) }) { Stretch = true }; rightPanel = new GUIFrame(new RectTransform(new Vector2(0.25f, 1.0f), Frame.RectTransform, Anchor.TopRight) { MinSize = new Point(450, 0) }, style: "GUIFrameRight"); var paddedRightPanel = new GUILayoutGroup(new RectTransform(new Vector2(0.95f, 0.95f), rightPanel.RectTransform, Anchor.Center) { RelativeOffset = new Vector2(0.02f, 0.0f) }) { Stretch = true, RelativeSpacing = 0.01f }; var saveAllButton = new GUIButton(new RectTransform(new Vector2(1.0f, 0.03f), paddedRightPanel.RectTransform), TextManager.Get("ParticleEditorSaveAll")) { OnClicked = (btn, obj) => { SerializeAll(); return(true); } }; var serializeToClipBoardButton = new GUIButton(new RectTransform(new Vector2(1.0f, 0.03f), paddedRightPanel.RectTransform), TextManager.Get("ParticleEditorCopyToClipboard")) { OnClicked = (btn, obj) => { SerializeToClipboard(selectedPrefab); return(true); } }; emitter = new Emitter(); var emitterEditorContainer = new GUIFrame(new RectTransform(new Vector2(1.0f, 0.25f), paddedRightPanel.RectTransform), style: null); var emitterEditor = new SerializableEntityEditor(emitterEditorContainer.RectTransform, emitter, false, true, elementHeight: 20); emitterEditor.RectTransform.RelativeSize = Vector2.One; emitterEditorContainer.RectTransform.Resize(new Point(emitterEditorContainer.RectTransform.NonScaledSize.X, emitterEditor.ContentHeight), false); var listBox = new GUIListBox(new RectTransform(new Vector2(1.0f, 0.6f), paddedRightPanel.RectTransform)); prefabList = new GUIListBox(new RectTransform(new Vector2(1.0f, 0.8f), paddedLeftPanel.RectTransform)); prefabList.OnSelected += (GUIComponent component, object obj) => { selectedPrefab = obj as ParticlePrefab; listBox.ClearChildren(); particlePrefabEditor = new SerializableEntityEditor(listBox.Content.RectTransform, selectedPrefab, false, true, elementHeight: 20); //listBox.Content.RectTransform.NonScaledSize = particlePrefabEditor.RectTransform.NonScaledSize; //listBox.UpdateScrollBarSize(); return(true); }; }
protected override void CreateChildren() { _shield = new NinePatch(Assets.STATUS, 80, 0, 30 + 18, 0); Add(_shield); var touchArea = new TouchArea(0, 1, 30, 30); touchArea.ClickAction = touch => { var sprite = Dungeon.Hero.Sprite; if (!sprite.Visible) { Camera.Main.FocusOn(sprite); } GameScene.Show(new WndHero()); }; Add(touchArea); _btnMenu = new MenuButton(); Add(_btnMenu); _avatar = HeroSprite.Avatar(Dungeon.Hero.heroClass, _lastTier); Add(_avatar); _blood = new Emitter(); _blood.Pos(_avatar); _blood.Pour(BloodParticle.Factory, 0.3f); _blood.AutoKill = false; _blood.On = false; Add(_blood); _compass = new Compass(Dungeon.Level.exit); Add(_compass); _hp = new Image(Assets.HP_BAR); Add(_hp); _exp = new Image(Assets.XP_BAR); Add(_exp); _level = new BitmapText(PixelScene.font1x); _level.Hardlight(0xFFEBA4); Add(_level); _depth = new BitmapText(Dungeon.Depth.ToString(CultureInfo.InvariantCulture), PixelScene.font1x); _depth.Hardlight(0xCACFC2); _depth.Measure(); Add(_depth); Dungeon.Hero.Belongings.CountIronKeys(); _keys = new BitmapText(PixelScene.font1x); _keys.Hardlight(0xCACFC2); Add(_keys); _danger = new DangerIndicator(); Add(_danger); _loot = new LootIndicator(); Add(_loot); _buffs = new BuffIndicator(Dungeon.Hero); Add(_buffs); }
public void Emit_InvalidOpCodeWithLocalBuilder_ThrowsNotSupportedException() { var emitter = new Emitter(null, new Type[] {}); Assert.Throws <NotSupportedException>(() => emitter.Emit(OpCodes.Ldarg_0, (LocalBuilder)null)); }