示例#1
0
        private void Update(EvaluationContext context)
        {
            var hue = (Hue.GetValue(context) % 1) * 360f;  // + Saturation.GetValue(context);

            var sat        = Saturation.GetValue(context); // + Saturation.GetValue(context);
            var brightness = Brightness.GetValue(context); // + Saturation.GetValue(context);

            float fSatR = 1;
            float fSatG = 1;
            float fSatB = 1;

            if (hue < 120.0f)
            {
                fSatR = (120.0f - hue) / 60.0f;
                fSatG = hue / 60.0f;
                fSatB = 0.0f;
            }
            else if (hue < 240.0f)
            {
                fSatR = 0.0f;
                fSatG = (240.0f - hue) / 60.0f;
                fSatB = (hue - 120.0f) / 60.0f;
            }
            else
            {
                fSatR = (hue - 240.0f) / 60.0f;
                fSatG = 0.0f;
                fSatB = (360.0f - hue) / 60.0f;
            }

            fSatR = (fSatR < 1.0f) ? fSatR : 1.0f;
            fSatG = (fSatG < 1.0f) ? fSatG : 1.0f;
            fSatB = (fSatB < 1.0f) ? fSatB : 1.0f;

            var fTmpR = 2.0f * sat * fSatR + (1.0f - sat);
            var fTmpG = 2.0f * sat * fSatG + (1.0f - sat);
            var fTmpB = 2.0f * sat * fSatB + (1.0f - sat);

            float fR, fG, fB;

            if (brightness < 0.5f)
            {
                fR = brightness * fTmpR;
                fG = brightness * fTmpG;
                fB = brightness * fTmpB;
            }
            else
            {
                fR = (1.0f - brightness) * fTmpR + 2.0f * brightness - 1.0f;
                fG = (1.0f - brightness) * fTmpG + 2.0f * brightness - 1.0f;
                fB = (1.0f - brightness) * fTmpB + 2.0f * brightness - 1.0f;
            }
            //
            // Color.Value.X = brightness;
            // Color.Value.Y = fG;
            // Color.Value.Z = fB;
            Color.Value = new Vector4(fR, fG, fB, Alpha.GetValue(context));
            //Color.Value = new Vector4(hue, sat, brightness, Alpha.GetValue(context));
        }
示例#2
0
        private void Update(EvaluationContext context)
        {
            var worldToClipSpace = Matrix.Multiply(context.WorldToCamera, context.CameraToClipSpace);
            //Matrix worldToView = context.WorldToCamera * context.CameraProjection;
            //var worldToClipSpace = context.WorldToCamera
            //var viewToWorld = Matrix.Invert(worldToClipSpace);

            var brightness = Brightness.GetValue(context);

            var color             = Color.GetValue(context);
            var randomizeColor    = RandomizeColor.GetValue(context);
            var size              = Size.GetValue(context);
            var randomizeSize     = RandomizeSize.GetValue(context);
            var stretch           = Stretch.GetValue(context);
            var distanceFromLight = DistanceFromLight.GetValue(context);
            var spread            = Spread.GetValue(context);
            var randomizeSpread   = RandomizeSpread.GetValue(context);
            var positionFactor    = PositionFactor.GetValue(context);
            var randomizePosition = RandomizePosition.GetValue(context);

            var mixPointLightColor = MixPointLightColor.GetValue(context);

            var referencedLightIndex = LightIndex.GetValue(context);

            var innerFxZone      = InnerFxZone.GetValue(context);
            var edgeFxZone       = EdgeFxZone.GetValue(context);
            var zoneFxScale      = FxZoneScale.GetValue(context);
            var zoneFxBrightness = FxZoneBrightness.GetValue(context);

            var matteBoxZone = MattBoxZone.GetValue(context);

            var rand       = new Random(RandomSeed.GetValue(context));
            var fxZoneMode = (ZoneFxModes)FxZoneMode.GetValue(context);

            var rotation       = Rotation.GetValue(context);
            var rotationSpread = RotationSpread.GetValue(context);

            var rotateTowards = (Categories)RotateTowards.GetValue(context);

            int startLightIndex = 0;
            int endLightIndex   = context.PointLights.Count;

            _tempList.Clear();


            if (brightness > 0.00001f)
            {
                if (referencedLightIndex >= 0)
                {
                    startLightIndex = referencedLightIndex;
                    endLightIndex   = referencedLightIndex + 1;
                }

                var aspectRatio = (float)context.RequestedResolution.Width / (float)context.RequestedResolution.Height;

                for (int lightIndex = startLightIndex; lightIndex < endLightIndex; lightIndex++)
                {
                    var pointLight = context.PointLights.GetPointLight(lightIndex);
                    var lightPosDx = pointLight.Position.ToSharpDxVector4(1);

                    var posInViewDx = SharpDX.Vector4.Transform(lightPosDx, worldToClipSpace);
                    posInViewDx /= posInViewDx.W;

                    // Ignore light sources behind
                    var hideFactor = posInViewDx.Z < 0 ? 0 : 1;

                    posInViewDx /= posInViewDx.W;
                    var lightPosInView2D = new Vector2(posInViewDx.X, posInViewDx.Y);

                    var count = SpriteCount.GetValue(context).Clamp(0, 1000);
                    if (count != _sprites.NumElements)
                    {
                        _sprites = new StructuredList <Sprite>(count);
                    }

                    // Render Planes
                    for (var i = 0; i < count; ++i)
                    {
                        var f = count <= 1 ? 0 : ((float)i / (count - 1) - 0.5f);
                        var positionOnLine = (float)((-distanceFromLight
                                                      + f * spread * 2
                                                      + randomizeSpread * (rand.NextDouble() - 0.5) + 1));

                        Vector2 objectScreenPos = lightPosInView2D * positionOnLine * positionFactor + (new Vector2(1, 1) - positionFactor) * lightPosInView2D;

                        objectScreenPos += new Vector2((float)(randomizePosition.X * (rand.NextDouble() - 0.5)),
                                                       (float)(randomizePosition.Y * (rand.NextDouble() - 0.5)));

                        var sizeWithRandom = size * (float)(1.0 + randomizeSize * (rand.NextDouble() - 0.5)) / 0.2f;

                        var colorWithLight = new Vector4((color.X + randomizeColor.X * (float)(rand.NextDouble() - 0.5) * 4) * MathUtils.Lerp(1f, pointLight.Color.X, mixPointLightColor),
                                                         (color.Y + randomizeColor.Y * (float)(rand.NextDouble() - 0.5) * 4) * MathUtils.Lerp(1f, pointLight.Color.Y, mixPointLightColor),
                                                         (color.Z + randomizeColor.Z * (float)(rand.NextDouble() - 0.5) * 4) * MathUtils.Lerp(1f, pointLight.Color.Z, mixPointLightColor),
                                                         color.W * (1 - randomizeColor.W * (float)(rand.NextDouble() * 2)));
                        var spriteColor = Vector4.Clamp(colorWithLight, Vector4.Zero, new Vector4(100, 100, 100, 1));

                        var triggerPosition = fxZoneMode == ZoneFxModes.Lights
                                                  ? lightPosInView2D
                                                  : objectScreenPos;

                        var d          = GetDistanceToEdge(triggerPosition);
                        var cInnerZone = MathUtils.SmootherStep(innerFxZone.Y, innerFxZone.X, 1 - d);
                        var cEdgeZone  = MathUtils.SmootherStep(edgeFxZone.X, edgeFxZone.Y, 1 - d);
                        var cMatteBox  = MathUtils.SmootherStep(matteBoxZone.Y, matteBoxZone.X, 1 - d);

                        var totalTriggerAmount = (cInnerZone + cEdgeZone) * cMatteBox;

                        sizeWithRandom *= (1 + zoneFxScale * totalTriggerAmount).Clamp(0, 100);

                        var brightnessEffect = (zoneFxBrightness * totalTriggerAmount).Clamp(0, 100);
                        spriteColor.X += brightnessEffect;
                        spriteColor.Y += brightnessEffect;
                        spriteColor.Z += brightnessEffect;
                        spriteColor.W  = ((spriteColor.W + brightnessEffect)).Clamp(0, 1);

                        spriteColor.W *= cMatteBox * pointLight.Color.W;

                        // This might actually be a good idea. Maybe we should do this later..
                        // Fade with incoming alpha from FlatShaders and Materials
                        //color.W *= materialAlpha;

                        float spriteRotation = rotation;

                        switch (rotateTowards)
                        {
                        case Categories.Object:
                            break;

                        case Categories.Light:
                            spriteRotation -=
                                (float)(Math.Atan2((objectScreenPos.X - lightPosInView2D.X) * aspectRatio, objectScreenPos.Y - lightPosInView2D.Y) +
                                        MathF.PI) * (180 / MathF.PI);
                            break;

                        case Categories.ScreenCenter:
                            spriteRotation -= (float)(Math.Atan2(objectScreenPos.X, objectScreenPos.Y) + MathF.PI) * 180f / MathF.PI;
                            break;

                        default:
                            throw new ArgumentOutOfRangeException();
                        }

                        // // Transforom UV to pick correct texture cell
                        // if (TextureCellsRows == 0)
                        //     TextureCellsRows = 1;
                        //
                        // if (TextureCellsColumns == 0)
                        //     TextureCellsColumns = 1;

                        // int row = (int)(Math.Floor(i / TextureCellsColumns) % TextureCellsRows);
                        // int column = (int)(i % TextureCellsRows);
                        //
                        // var translationUV = new Vector3(1 / TextureCellsColumns * column, 1 / TextureCellsRows * row, 0);
                        // var rotationUV = new Quaternion();
                        // var scaleUV = new Vector3(1 / TextureCellsColumns, 1 / TextureCellsRows, 0);
                        // var pivotUV = new Vector3(0, 0, 0);
                        //
                        // var transformUV = Matrix.Transformation(pivotUV, new Quaternion(), scaleUV, pivotUV, rotationUV, translationUV);
                        // var prevTransformUV = context.TextureMatrix;
                        // context.TextureMatrix = transformUV * prevTransformUV;
                        spriteColor.W *= brightness;

                        _tempList.Add(new Sprite
                        {
                            PosInClipSpace = objectScreenPos,
                            Size           = sizeWithRandom * stretch * hideFactor,
                            Color          = spriteColor,
                            RotationDeg    = spriteRotation + f * rotationSpread * 180,
                            UvMin          = Vector2.Zero,
                            UvMax          = Vector2.One,
                        });
                    }
                }
            }
            // Copy to structured array
            if (_tempList.Count != _sprites.NumElements)
            {
                _sprites = new StructuredList <Sprite>(_tempList.Count);
            }

            for (var spriteIndex = 0; spriteIndex < _tempList.Count; spriteIndex++)
            {
                _sprites.TypedElements[spriteIndex] = _tempList[spriteIndex];
            }
            OutBuffer.Value = _sprites;
        }
示例#3
0
        static void Main(string[] args)
        {
            //Mutex名を決める(必ずアプリケーション固有の文字列に変更すること!)
            string mutexName = Process.GetCurrentProcess().ProcessName;

            //Mutexオブジェクトを作成する
            System.Threading.Mutex mutex = new System.Threading.Mutex(false, mutexName);

            bool hasHandle = false;

            try
            {
                //ミューテックスの所有権を要求する
                hasHandle = mutex.WaitOne(0, false);

                //ミューテックスを得られたか調べる
                if (hasHandle == false)
                {
                    Console.WriteLine("多重起動できませんでした");
                    var now_id = Process.GetCurrentProcess().Id;
                    if (now_id == Process.GetProcessesByName(mutexName)[0].Id)
                    {
                        // first other kill,
                        Process.GetProcessesByName(mutexName)[1].Kill();
                        Process.GetProcessesByName(mutexName)[0].Kill();
                    }
                    else
                    {
                        Process.GetProcessesByName(mutexName)[0].Kill();
                        Process.GetProcessesByName(mutexName)[1].Kill();
                    }
                }

                // Main
                Console.WriteLine("\"Escape\"で終了");

                var current = Environment.CurrentDirectory;
                var log     = Path.Combine(current, "brightness.log");

                if (File.Exists(log))
                {
                    File.Delete(log);
                }

                Console.WriteLine($"output folder : {log}");

                var n             = new Brightness();
                var nowBrightness = n.GetValue();

                using (var f = File.Create(log))
                {
                    while (true)
                    {
                        if (nowBrightness != n.GetValue())
                        {
                            AddText(f, "[" + DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss") + "] " + "Brightness " + n.GetValue() + "\n");
                            Console.WriteLine("[" + DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss") + "] " + "Brightness " + n.GetValue());
                            nowBrightness = n.GetValue();
                        }

                        // ブロックせずにキー入力受付
                        if (Console.KeyAvailable)
                        {
                            var k = Console.ReadKey();
                            if (k.Key.ToString() == "Escape")
                            {
                                break;
                            }
                        }
                    }
                }
            }
            finally
            {
                if (hasHandle)
                {
                    //ミューテックスを解放する
                    mutex.ReleaseMutex();
                }
                mutex.Close();
            }
        }