Example #1
0
        public void TakeEnumeratorOutForTestDrive()
        {
            var a = TestVariable.Create(LevelsOne);
            var b = TestVariable.Create(LevelsTwo);

            var c = Synthesis.Create(a, b,
                                     ((resultOne, resultTwo) =>
                                      string.Format("{0}, {1}", resultOne.ToString(), resultTwo.ToString())));

            var d = Synthesis.Create(TestVariable.Create(LevelsOne), input => input.ToString());

            var dWithATwist = Synthesis.Create(new List <IFactory> {
                d
            }, (Converter <Object, Object>)(thing => thing));

            var e = Interleaving.Create(new List <IFactory> {
                dWithATwist, c
            });

            var strength = e.MaximumStrength;

            do
            {
                foreach (var u in e.CreateEnumerable(strength))
                {
                    Console.WriteLine(u.ToString());
                }

                Console.WriteLine("****************");
            } while (--strength != 0U);
        }
        public void TestStuff()
        {
            const int deferralBudget = 4;
            var       historiesForSeveralThingsFactory = HistoriesForSeveralThingsFactory();

            var randomBehaviourSeedFactory = TestVariable.Create(new[] { 67, 890478236, 1123789, 892367 });

            var topLevelTestCaseFactory =
                Synthesis.Create(historiesForSeveralThingsFactory, randomBehaviourSeedFactory, Tuple.Create)
                .WithDeferralBudgetOf(deferralBudget);

            const int strength = 3;

            var numberOfTestCases = topLevelTestCaseFactory.ExecuteParameterisedUnitTestForAllTestCases(strength,
                                                                                                        topLevelTestCase =>
            {
                Console.WriteLine("***************");
                foreach (var thingHistory in topLevelTestCase.Item1)
                {
                    Console.WriteLine("Thing record index: {0} => item index: {1}", thingHistory.ThingRecordIndex,
                                      thingHistory.ItemIndex);
                }
            });

            Console.WriteLine("Number of test cases validated: {0}", numberOfTestCases);
        }
Example #3
0
        // 显示合成
        private void ShowSynthesis(User user, CqGroupMessageEventArgs e, string groupPath)
        {
            List <string> items = iniTool.IniReadSectionKey(devPath, synthesisIni, user.Pos);

            if (items.Count == 0)
            {
                Common.CqApi.SendGroupMessage(e.FromGroup, "[" + user.Name + "] 该位置没有商品");
                return;
            }

            string synthesisItems = "[" + user.Pos + "]" + Environment.NewLine;

            foreach (string item in items)
            {
                string name = iniTool.IniReadValue(devPath, synthesisIni, user.Pos, item);

                Synthesis synthesis = GetSynthesis(name, e, groupPath);

                synthesisItems += item + ":" + name + " 所需材料(" + synthesis.Material.Replace("|", ",") + ")" + Environment.NewLine;
                synthesisItems += "成功率:" + synthesis.SuccessRate + Environment.NewLine + "失败保留:" + synthesis.Retain + Environment.NewLine;
            }

            synthesisItems += "输入:合成 编号";

            Common.CqApi.SendGroupMessage(e.FromGroup, synthesisItems);

            return;
        }
        private static ITypedFactory <TestCase> BuildTestCaseFactory()
        {
            var factoryForLeastItemInSequence =
                TestVariable.Create(Enumerable.Range(-3, 10));

            const int maximumNumberOfDeltas = 4;

            var factoryForNonNegativeDeltasAndPermutation =
                Interleaving.Create(
                    from numberOfDeltas in Enumerable.Range(0, 1 + maximumNumberOfDeltas)
                    select BuildNonNegativeDeltasAndPermutationFactory(numberOfDeltas));

            var testCaseFactoryForTrivialCase = Singleton.Create(new TestCase());

            var testCaseFactoryForNonTrivialCases =
                Synthesis.Create(factoryForLeastItemInSequence,
                                 factoryForNonNegativeDeltasAndPermutation,
                                 (leastItemInSequence, nonNegativeDeltasAndItsPermutation) =>
                                 new TestCase(leastItemInSequence,
                                              nonNegativeDeltasAndItsPermutation.Item1,
                                              nonNegativeDeltasAndItsPermutation.Item2));

            return
                (Interleaving.Create(new[]
                                     { testCaseFactoryForTrivialCase, testCaseFactoryForNonTrivialCases }));
        }
        BuildExpressionFactoryRecursively(Boolean directlyToTheRightOfABinaryOperator)
        {
            var binaryOperatorExpressionFactory =
                Synthesis.Create(
                    Deferral.Create(
                        () =>
                        BuildExpressionFactoryRecursively(
                            directlyToTheRightOfABinaryOperator)),
                    Deferral.Create(() => BuildExpressionFactoryRecursively(true)),
                    BinaryOperatorFactory, BinaryExpressionFrom);

            var negatedExpressionFactory =
                Synthesis.Create(
                    Deferral.Create(() => BuildExpressionFactoryRecursively(true)),
                    expression =>
                    Tuple.Create(expression.Item1,
                                 String.Format(
                                     directlyToTheRightOfABinaryOperator ? "(-{0})" : "-{0}",
                                     expression.Item2)));

            var bracketedExpressionFactory =
                Synthesis.Create(
                    Deferral.Create(() => BuildExpressionFactoryRecursively(false)),
                    expression =>
                    Tuple.Create(false, String.Format("({0})", expression.Item2)));

            return
                (Interleaving.Create(new[]
            {
                ConstantFactory, binaryOperatorExpressionFactory,
                negatedExpressionFactory, bracketedExpressionFactory
            }));
        }
Example #6
0
 internal SynthesisEvent InvokeEvent(SynthesisEvent arg)
 {
     if (_api.ValidateEvent(arg))
     {
         Synthesis?.Invoke(_api, arg);
     }
     return(arg);
 }
Example #7
0
 void OnGUI()
 {
     Synthesis.Interface(cl, h, point, ref start, ref speed, "H2+Cl2=2HCL", style);
     if (start)
     {
         StartCoroutine(Change_texts());
     }
 }
Example #8
0
            public void Synthesize()
            {
                Synthesis.Synthesize();
                var count = Math.Min(Synthesis.AudioBufferSize, Samples.Length - GeneratedSamples);

                Synthesis.AudioBuffer.BlockCopy(0, Samples, GeneratedSamples, count);
                GeneratedSamples += count;
            }
Example #9
0
        public double[] Synthesize()
        {
            var yLength   = (int)((F0.Length - 1) * FramePeriod / 1000.0 * SampleRate) + 1;
            var y         = new double[yLength];
            var synthesis = new Synthesis();

            synthesis.Synthesize(F0, F0.Length, Spectrogram, Aperiodicity, FFTSize, FramePeriod, SampleRate, y);

            return(y);
        }
        BuildNonNegativeDeltasAndPermutationFactory(int numberOfDeltas)
        {
            var factoryForNonNegativeDelta =
                TestVariable.Create(from signedDelta in Enumerable.Range(0, 5)
                                    select signedDelta);

            return
                (Synthesis.CreateWithPermutation <Int32, Int32>(
                     Enumerable.Repeat(factoryForNonNegativeDelta, numberOfDeltas)));
        }
        public ITypedFactory <ThingHistory> ThingFactory(int thingRecordIndex, int maximumNumberOfItems)
        {
            var itemIndexFactory          = TestVariable.Create(Enumerable.Range(0, maximumNumberOfItems));
            var numberOfRejectionsFactory = TestVariable.Create(Enumerable.Range(0, 3));

            return(Synthesis.Create(itemIndexFactory, numberOfRejectionsFactory, numberOfRejectionsFactory,
                                    (itemIndex, numberOfRejectionsBeforeAcceptance, numberOfRejectionsBeforeWithdrawal) =>
                                    new ThingHistory(thingRecordIndex, itemIndex, numberOfRejectionsBeforeAcceptance,
                                                     numberOfRejectionsBeforeWithdrawal)));
        }
Example #12
0
        public override void Handle(Synthesis e)
        {
            if (e.Materials == null)
            {
                return;
            }

            foreach (var mat in e.Materials)
            {
                NotifyInventory(mat.Key, -mat.Value, e);
            }
        }
        private static ITypedFactory <IEnumerable <Tuple <Int32, Int32> > > BuildConnectionsFactory(Int32 numberOfVertices)
        {
            var numberOfPotentialUniqueConnectionsWithoutSelfLoops =
                NumberOfPotentialUniqueConnectionsWithoutSelfLoops(numberOfVertices);

            var connectionSwitchFactory = TestVariable.Create(new[] { false, true });

            return
                (Synthesis.Create(
                     Enumerable.Repeat(connectionSwitchFactory, numberOfPotentialUniqueConnectionsWithoutSelfLoops),
                     connectionSwitches => EnumerateConnections(connectionSwitches, numberOfVertices)));
        }
Example #14
0
    // Start is called before the first frame update
    void Start()
    {
        /* if( testé si deja partie existante )
         * else
         *
         */


        Synthesis.synthesis(
            "Bonjour capitaine, voulez vous continuez votre aventure ou bien commencer une nouvelle légende");

        Recognition.start_recognition(react, "nouvelle continuer commencer", 20);
    }
Example #15
0
        public void Ctor()
        {
            dynamic props = new Synthesis
            {
                { "a", 1 },
                { "b", new Func <int, int, int>((arg1, arg2) => arg1 + arg2) }
            };

            int a = props.a, b = props.b(10, 20);

            Assert.AreEqual(a, 1);
            Assert.AreEqual(b, 30);
        }
Example #16
0
        // 合成
        private void Synthesis(string synthesisName, User user, CqGroupMessageEventArgs e, string groupPath)
        {
            synthesisName = iniTool.IniReadValue(devPath, synthesisIni, user.Pos, synthesisName);

            Synthesis synthesis = GetSynthesis(synthesisName, e, groupPath);

            if (synthesis.SuccessRate == 0)
            {
                Common.CqApi.SendGroupMessage(e.FromGroup, "[" + user.Name + "] 该物品不能合成 " + synthesis.Name);
                return;
            }

            string[] allItems = synthesis.Material.Split('|');

            bool isExistence = IsExistenceItems(user, e, groupPath, allItems);

            if (!isExistence)
            {
                Common.CqApi.SendGroupMessage(e.FromGroup, "[" + user.Name + "] 合成失败:您背包里没有合成需要的物品数量!");
                return;
            }

            bool isDeleteItems = DeleteKnapsackItems(user, e, groupPath, allItems);

            if (!isDeleteItems)
            {
                Common.CqApi.SendGroupMessage(e.FromGroup, "[" + user.Name + "] 请稍后再试!");
                return;
            }

            if (user.isVip)
            {
                synthesis.SuccessRate += 20;
            }

            bool isSuccess = IsSuccess(synthesis.SuccessRate);

            if (!isSuccess)
            {
                string[] retain = synthesis.Retain.Split('*');

                SetKnapsackItemNum(retain[0], 1, groupPath, e.FromQQ.ToString());

                Common.CqApi.SendGroupMessage(e.FromGroup, "[" + user.Name + "] 合成失败:长相问题!");
                return;
            }

            SetKnapsackItemNum(synthesis.Name, 1, groupPath, e.FromQQ.ToString());

            Common.CqApi.SendGroupMessage(e.FromGroup, "[" + user.Name + "] 合成成功:" + synthesis.Name);
        }
Example #17
0
        public ITypedFactory <String> BuildFactoryRecursivelyUsingDeferral()
        {
            var simplerFactoryForShorterStrings =
                Deferral.Create(BuildFactoryRecursivelyUsingDeferral);

            var factoryForNonEmptyStrings = Synthesis.Create(
                _factoryForSingleCharacters, simplerFactoryForShorterStrings,
                (leftmostCharacterToPrepend, shorterString) =>
                leftmostCharacterToPrepend + shorterString);

            return
                (Interleaving.Create(new[]
                                     { _emptyStringFactory, factoryForNonEmptyStrings }));
        }
        public ITypedFactory <IEnumerable <ThingHistory> > HistoriesForSeveralThingsFactory(int minimumNumberOfThings = 1)
        {
            var historiesForSeveralThingsFactory = Synthesis.Create(
                from thingRecordIndex in Enumerable.Range(0, minimumNumberOfThings)
                select ThingFactory(thingRecordIndex, minimumNumberOfThings))
                                                   .WithFilter(ThingsShareItemsEfficiently(minimumNumberOfThings));

            return
                (Interleaving.Create(new[]
            {
                historiesForSeveralThingsFactory,
                Deferral.Create(() => HistoriesForSeveralThingsFactory(1 + minimumNumberOfThings))
            }));
        }
Example #19
0
 void OnGUI()
 {
     Synthesis.Interface(o, c, point, ref start, ref speed, "O2+C=CO2", style);
     if (start)
     {
         StartCoroutine(Change_texts());
     }
     if (start)
     {
         for (int i = 0; i < o.Count; i++)
         {
             Global_Functions.Start_Anim(start, o[i], point[i], speed);
         }
     }
 }
        private static ITypedFactory <TestCase> BuildTestCaseFactory(Int32 numberOfVertices)
        {
            var connectionsFactory =
                BuildConnectionsFactory(numberOfVertices)
                .WithFilter(dictionary => ConnectionsImplyADag(dictionary, numberOfVertices));

            var testCaseFactory = Synthesis.Create(connectionsFactory,
                                                   connections => new TestCase()
            {
                NumberOfVertices = numberOfVertices, Connections = connections
            });

            return
                (Interleaving.Create(new[]
                                     { testCaseFactory, Deferral.Create(() => BuildTestCaseFactory(1 + numberOfVertices)) }));
        }
Example #21
0
        public ITypedFactory <String> BuildFactoryRecursively(Int32 maximumStringLength)
        {
            if (0 == maximumStringLength)
            {
                return(_emptyStringFactory);
            }

            var simplerFactoryForShorterStrings =
                BuildFactoryRecursively(maximumStringLength - 1);

            var factoryForNonEmptyStrings = Synthesis.Create(
                _factoryForSingleCharacters, simplerFactoryForShorterStrings,
                (leftmostCharacterToPrepend, shorterString) =>
                leftmostCharacterToPrepend + shorterString);

            return
                (Interleaving.Create(new[]
                                     { _emptyStringFactory, factoryForNonEmptyStrings }));
        }
        private static ITypedFactory <String> BuildExpressionFactoryRecursively()
        {
            var subexpressionFactory =
                Interleaving.Create(new[]
            {
                ConstantFactory,
                Synthesis.Create(Deferral.Create(BuildExpressionFactoryRecursively),
                                 expression => String.Format("({0})", expression))
            });

            var binaryOperatorExpressionFactory = Synthesis.Create(subexpressionFactory,
                                                                   BinaryOperatorFactory, subexpressionFactory,
                                                                   (lhsOperand, binaryOperator, rhsOperand) =>
                                                                   String.Format("{0} {1} {2}", lhsOperand, binaryOperator, rhsOperand));

            return
                (Interleaving.Create(new[]
                                     { ConstantFactory, binaryOperatorExpressionFactory }));
        }
Example #23
0
        public void MembersAccess()
        {
            var syn = new Synthesis();

            ((IAtomicity)syn).Create("a", 1);
            ((IAtomicity)syn).Create("b", new Func <int, int, int>((arg1, arg2) => arg1 + arg2));

            dynamic props = syn;

            int a = props.a, b = props.b(10, 20);

            Assert.AreEqual(a, 1);
            Assert.AreEqual(b, 30);

            ((IAtomicity)syn).Delete("a");
            Assert.IsNull(props.a);

            ((IAtomicity)syn).Delete("b");
            Assert.IsNull(props.b);
        }
Example #24
0
        public static void Main(string[] args)
        {
            var audioPath    = @"vaiueo2d.wav";
            var audioOutPath = @"vaiueo2d-out.wav";

            var(x, fs, nbit) = AudioIO.WavRead(audioPath);
            var(f0, t)       = Dio.Compute(x, fs);
            f0 = StoneMask.Compute(x, fs, t, f0);
            var fftSize = CheapTrick.GetFftSize(fs);
            var sp      = CheapTrick.Compute(x, fs, t, f0, fftSize: fftSize);
            var ap      = D4C.Compute(x, fs, t, f0, fftSize: fftSize);

            var ndim = 60;
            var mgc  = Codec.CodeSpectralEnvelope(sp, fs, ndim);
            var bap  = Codec.CodeAperiodicity(ap, fs);

            Console.WriteLine($"{audioPath}:");
            Console.WriteLine($"    input samples count: {x.Length}");
            Console.WriteLine($"    sampling rate: {fs}");
            Console.WriteLine($"    bit rate: {nbit}");
            Console.WriteLine();
            Console.WriteLine($"    frame count: {f0.Length}");
            Console.WriteLine($"    fft size: {fftSize}");
            Console.WriteLine($"    sp width: {sp.GetLength(1)}");
            Console.WriteLine();
            Console.WriteLine($"    mgc width: {ndim}");
            Console.WriteLine($"    bap width: {bap.GetLength(1)}");
            Console.WriteLine();

            for (int i = 0; i < f0.Length; i++)
            {
                f0[i] *= 1.6789;
            }

            sp = Codec.DecodeSpectralEnvelope(mgc, fs, fftSize);
            ap = Codec.DecodeAperiodicity(bap, fs, fftSize);
            var y = Synthesis.Compute(f0, sp, ap, fs);

            Console.WriteLine($"--> {audioOutPath}");
            AudioIO.WavWrite(y, fs, nbit, audioOutPath);
        }
        public void TestStandardDictionaryWithJustOneKey()
        {
            var keyFactory = TestVariable.Create(Enumerable.Range(-2, 5));

            var operationFactory =
                TestVariable.Create(
                    from operationKind in
                    ((IEnumerable <OperationKind>)
                     Enum.GetValues(typeof(OperationKind)))
                    select operationKind);

            const Int32 numberOfOperations = 10;

            var randomBehaviour = new Random(0);

            var operationKindSequenceFactory =
                Synthesis.Create(Enumerable.Repeat(operationFactory, numberOfOperations))
                .WithFilter(FilterOutThreeOrMoreConsecutiveIdenticalOperationKinds);

            var operationListBuilderFactory = Synthesis.Create(keyFactory,
                                                               operationKindSequenceFactory, (key, operationKindSequence) =>
            {
                var result = new OperationListBuilder(key, randomBehaviour);

                foreach (var operationKind in operationKindSequence)
                {
                    result.AppendNewOperationOfKind(operationKind);
                }

                return(result);
            });
            const Int32 strength = 4;

            var numberOfTestCasesExercised =
                operationListBuilderFactory.ExecuteParameterisedUnitTestForAllTestCases(
                    strength, ParameterisedUnitTestForStandardDictionaryWithJustOneKey);

            Console.Out.WriteLine("Exercised {0} test cases.", numberOfTestCasesExercised);
        }
Example #26
0
        // 获取Vip信息
        private Synthesis GetSynthesis(string synthesisName, CqGroupMessageEventArgs e, string groupPath)
        {
            Synthesis synthesis = new Synthesis();

            string isItem = iniTool.IniReadValue(devPath, synthesisIni, synthesisName, "合成材料");

            if (isItem == "")
            {
                return(synthesis);
            }

            string synthesisInfo = "";

            foreach (string s in GameConfig.synthesis)
            {
                synthesisInfo += iniTool.IniReadValue(devPath, synthesisIni, synthesisName, s) + ",";
            }

            synthesis.Name = synthesisName;

            synthesis.Add(synthesisInfo);

            return(synthesis);
        }
 public ShieldSparkParticleSystem(Synthesis.Game1 game, int howManyEffects)
     : base(game,howManyEffects)
 {
 }
Example #28
0
        public static async Task StopBusy(bool leaveDuty = true, bool stopFishing = true, bool dismount = true)
        {
            for (var tryStep = 1; tryStep < 6; tryStep++)
            {
                if (!CheckIfBusy(leaveDuty, stopFishing, dismount))
                {
                    break;
                }

                Log($"We're occupied. Trying to exit out. Attempt #{tryStep}");

                if (stopFishing && FishingManager.State != FishingState.None)
                {
                    var quit = ActionManager.CurrentActions.Values.FirstOrDefault(i => i.Id == 299);
                    if (quit != default(SpellData))
                    {
                        Log($"Exiting Fishing.");
                        if (ActionManager.CanCast(quit, Core.Me))
                        {
                            ActionManager.DoAction(quit, Core.Me);
                            await Coroutine.Wait(6000, () => FishingManager.State == FishingState.None);
                        }
                    }
                }

                if (CraftingLog.IsOpen || CraftingManager.IsCrafting || Synthesis.IsOpen)
                {
                    Log($"Closing Crafting Window.");
                    await Lisbeth.ExitCrafting();

                    Synthesis.Close();
                    await Coroutine.Wait(6000, () => !Synthesis.IsOpen);

                    await Coroutine.Wait(1500, () => CraftingLog.IsOpen);

                    CraftingLog.Close();
                    await Coroutine.Wait(6000, () => !CraftingLog.IsOpen);

                    await Coroutine.Wait(6000, () => !CraftingManager.IsCrafting && !MovementManager.IsOccupied);
                }

                if (leaveDuty && DutyManager.InInstance)
                {
                    Log($"Leaving Diadem.");
                    DutyManager.LeaveActiveDuty();

                    if (await Coroutine.Wait(30000, () => CommonBehaviors.IsLoading))
                    {
                        await Coroutine.Yield();

                        await Coroutine.Wait(-1, () => !CommonBehaviors.IsLoading);

                        await Coroutine.Sleep(5000);
                    }
                }

                if (dismount && Core.Me.IsMounted)
                {
                    Log("Dismounting.");
                    ActionManager.Dismount();
                    await Coroutine.Wait(3000, () => !Core.Me.IsMounted);
                }

                if (InSmallTalk)
                {
                    Log("Skipping smalltalk.");
                    await SmallTalk();
                }

                await Coroutine.Sleep(2500);
            }

            if (CheckIfBusy(leaveDuty, stopFishing, dismount))
            {
                Log("Something went wrong, we're still occupied.");
                TreeRoot.Stop("Stopping bot.");
            }
        }
 public ExplosionParticleSystem(Synthesis.Game1 game, int howManyEffects)
     : base(game, howManyEffects)
 {
 }
Example #30
0
    /// <summary>
    /// Create synthesis in specified synthesis object.
    /// </summary>
    /// <param name="synth">The syntesis object to work on.</param>
    /// <param name="levels">From what level to generate the synthesis from.</param>
    /// <param name="synthMode">What kernel to use for synthesis.</param>
    private void SynthesizeCall(Synthesis synth, int levels = 0, SynthesisMode synthMode = SynthesisMode.BiQuadBSpline)
    {
        // Use default value if no value is set ( To be changed later to just synthesize all the way up if nothing else is specific)
        if (levels == 0) levels = _levels;

        int sampleCompensation = !_UseHigherPoT ? 1 : 0;
        //Debug.Log(sampleCompensation);

        // If it is the first level just copy over the top level analysis. (This could be optimized slightly by just directly using it from the analysis list)
        if (levels == 1)
        {
            _cSMain.SetTexture(_cSMain.FindKernel(GetEnumDescription(synthMode)), "source", _analyzeList[synth.SourceLevel - sampleCompensation]);
            _cSMain.SetTexture(_cSMain.FindKernel(GetEnumDescription(synthMode)), "dest", synth.Pyramid[0]);

            if (synth.Pyramid[0].width > 32 || synth.Pyramid[0].height > 32)
                _cSMain.Dispatch(_cSMain.FindKernel(GetEnumDescription(synthMode)), (int)Mathf.Ceil(_analyzeList[synth.SourceLevel - sampleCompensation].width / 32), (int)Mathf.Ceil(_analyzeList[synth.SourceLevel - sampleCompensation].height / 32), 1);
            else
                _cSMain.Dispatch(_cSMain.FindKernel(GetEnumDescription(synthMode)), 1, 1, 1);
        }
        else
        {
            for (int i = 0; i < levels; i++)
            {
                if (i == 0)
                {
                    _cSMain.SetTexture(_cSMain.FindKernel(GetEnumDescription(synthMode)), "source", _analyzeList[synth.SourceLevel - sampleCompensation]);
                    _cSMain.SetTexture(_cSMain.FindKernel(GetEnumDescription(synthMode)), "dest", synth.Pyramid[i]);

                    //Debug.Log("Source: " + _analyzeList[synth.SourceLevel - sampleCompensation].width + " Destination: " + synth.Pyramid[i].width);

                    _cSMain.Dispatch(_cSMain.FindKernel(GetEnumDescription(synthMode)), (int)Mathf.Ceil(_analyzeList[synth.SourceLevel - sampleCompensation].width / 32), (int)Mathf.Ceil(_analyzeList[synth.SourceLevel - sampleCompensation].height / 32), 1);
                }
                else
                {
                    _cSMain.SetTexture(_cSMain.FindKernel(GetEnumDescription(synthMode)), "source", synth.Pyramid[i-1]);
                    _cSMain.SetTexture(_cSMain.FindKernel(GetEnumDescription(synthMode)), "dest", synth.Pyramid[i]);

                    if (synth.Pyramid[i-1].width > 32 || synth.Pyramid[i-1].height > 32)
                        _cSMain.Dispatch(_cSMain.FindKernel(GetEnumDescription(synthMode)), (int)Mathf.Ceil(synth.Pyramid[i-1].width / 32), (int)Mathf.Ceil(synth.Pyramid[i-1].height / 32), 1);
                    else
                        _cSMain.Dispatch(_cSMain.FindKernel(GetEnumDescription(synthMode)), 1, 1, 1);
                }
            }
        }
    }
 public ParticleKillParticleSystem(Synthesis.Game1 game, int howManyEffects)
     : base(game,howManyEffects)
 {
 }
Example #32
0
 public abstract void Handle(Synthesis e);
Example #33
0
 void Start()
 {
     point = new List <Vector3>();
     Synthesis.Init(cl, h, point);
 }
 public SmokePlumeParticleSystem(Synthesis.Game1 game, int howManyEffects)
     : base(game,howManyEffects)
 {
 }
Example #35
0
 void OnGUI()
 {
     GUI.skin = style;
     Synthesis.Draw_UI("О₂+C=СО₂", ref move_body, ref speed, 1, 5);
 }
Example #36
0
 /// <summary>
 /// Constructs a new ParticleSystem.
 /// </summary>
 /// <param name="game">The host for this particle system. The game keeps the 
 /// content manager and sprite batch for us.</param>
 /// <param name="howManyEffects">the maximum number of particle effects that
 /// are expected on screen at once.</param>
 /// <remarks>it is tempting to set the value of howManyEffects very high.
 /// However, this value should be set to the minimum possible, because
 /// it has a large impact on the amount of memory required, and slows down the
 /// Update and Draw functions.</remarks>
 protected ParticleSystem(Synthesis.Game1 game, int howManyEffects)
     : base(game)
 {
     this.game = game;
     this.howManyEffects = howManyEffects;
 }