Esempio n. 1
0
        protected EffectIntents RenderNodeByLocation(ElementNode node, ref EffectIntents effectIntents)
        {
            int nFrames = GetNumberFrames();

            if (nFrames <= 0 | BufferWi == 0 || BufferHt == 0)
            {
                return(effectIntents);
            }
            PixelLocationFrameBuffer buffer = new PixelLocationFrameBuffer(ElementLocations, nFrames);

            TimeSpan startTime = TimeSpan.Zero;

            // generate all the pixels
            RenderEffectByLocation(nFrames, buffer);

            // create the intents
            var frameTs = new TimeSpan(0, 0, 0, 0, FrameTime);

            foreach (var elementLocation in ElementLocations)
            {
                var     frameData = buffer.GetFrameDataAt(elementLocation.X, elementLocation.Y);
                IIntent intent    = new StaticArrayIntent <RGBValue>(frameTs, frameData, TimeSpan);
                effectIntents.AddIntentForElement(elementLocation.ElementNode.Element.Id, intent, startTime);
            }

            return(effectIntents);
        }
Esempio n. 2
0
        protected EffectIntents RenderNodeByLocation(ElementNode node)
        {
            EffectIntents effectIntents = new EffectIntents();
            int           nFrames       = GetNumberFrames();

            if (nFrames <= 0 | BufferWi == 0 || BufferHt == 0)
            {
                return(effectIntents);
            }
            PixelLocationFrameBuffer buffer = new PixelLocationFrameBuffer(ElementLocations.Distinct().ToList(), nFrames);

            TimeSpan startTime = TimeSpan.Zero;

            // generate all the pixels
            RenderEffectByLocation(nFrames, buffer);

            // create the intents
            var frameTs = new TimeSpan(0, 0, 0, 0, FrameTime);

            foreach (var tuple in buffer.GetElementData())
            {
                if (tuple.Item2.Count != nFrames)
                {
                    Logging.Error("{0} count has {1} instead of {2}", tuple.Item1.ElementNode.Name, tuple.Item2.Count, nFrames);
                }
                IIntent intent = new StaticArrayIntent <RGBValue>(frameTs, tuple.Item2.ToArray(), TimeSpan);
                effectIntents.AddIntentForElement(tuple.Item1.ElementNode.Element.Id, intent, startTime);
            }

            return(effectIntents);
        }
Esempio n. 3
0
        private StaticArrayIntent <DiscreteValue> CreateDiscreteIntentForValues(ColorValue[] values)
        {
            var intentValues = values.Select(x => new DiscreteValue(x.c, x.i));
            var intent       = new StaticArrayIntent <DiscreteValue>(FrameTimespan, intentValues.ToArray(), TimeSpan);

            return(intent);
        }
Esempio n. 4
0
        // renders the given node to the internal ElementData dictionary. If the given node is
        // not a element, will recursively descend until we render its elements.
        private void RenderNode(ElementNode node)
        {
            int wid;
            int ht;

            if (_data.NutcrackerData.StringOrienation == NutcrackerEffects.StringOrientations.Horizontal)
            {
                wid = MaxPixelsPerString;
                ht  = StringCount;
            }
            else
            {
                wid = StringCount;
                ht  = MaxPixelsPerString;
            }
            int nFrames = (int)(TimeSpan.TotalMilliseconds / frameMs);

            if (nFrames <= 0)
            {
                return;
            }
            var nccore = new NutcrackerEffects(_data.NutcrackerData)
            {
                Duration = TimeSpan
            };

            nccore.InitBuffer(wid, ht);
            int numElements = node.Count();

            TimeSpan startTime = TimeSpan.Zero;

            // OK, we're gonna create 1 intent per element
            // that intent will hold framesToRender Color values
            // that it will parcel out as intent states are called for...

            // set up arrays to hold the generated colors
            var pixels = new RGBValue[numElements][];

            for (int eidx = 0; eidx < numElements; eidx++)
            {
                pixels[eidx] = new RGBValue[nFrames];
            }
            // generate all the pixels
            for (int frameNum = 0; frameNum < nFrames; frameNum++)
            {
                nccore.RenderNextEffect(_data.NutcrackerData.CurrentEffect);
                // peel off this frames pixels...
                if (_data.NutcrackerData.StringOrienation == NutcrackerEffects.StringOrientations.Horizontal)
                {
                    int i = 0;
                    for (int y = 0; y < ht; y++)
                    {
                        for (int x = 0; x < _stringPixelCounts[y]; x++)
                        {
                            pixels[i][frameNum] = new RGBValue(nccore.GetPixel(x, y));
                            i++;
                        }
                    }
                }
                else
                {
                    int i = 0;
                    for (int x = 0; x < wid; x++)
                    {
                        for (int y = 0; y < _stringPixelCounts[x]; y++)
                        {
                            pixels[i][frameNum] = new RGBValue(nccore.GetPixel(x, y));
                            i++;
                        }
                    }
                }
            }
            ;

            // create the intents
            var            frameTs  = new TimeSpan(0, 0, 0, 0, frameMs);
            List <Element> elements = node.ToList();

            for (int eidx = 0; eidx < numElements; eidx++)
            {
                IIntent intent = new StaticArrayIntent <RGBValue>(frameTs, pixels[eidx], TimeSpan);
                _elementData.AddIntentForElement(elements[eidx].Id, intent, startTime);
            }

            nccore.Dispose();
        }
Esempio n. 5
0
        protected EffectIntents RenderNode(ElementNode node)
        {
            EffectIntents effectIntents = new EffectIntents();
            int nFrames = (int)(TimeSpan.TotalMilliseconds / FrameTime);
            if (nFrames <= 0) return effectIntents;
            var buffer = new PixelFrameBuffer(BufferWi, BufferHt, UseBaseColor?BaseColor:Color.Transparent);

            int bufferSize = StringPixelCounts.Sum();

            TimeSpan startTime = TimeSpan.Zero;

            // set up arrays to hold the generated colors
            var pixels = new RGBValue[bufferSize][];
            for (int eidx = 0; eidx < bufferSize; eidx++)
                pixels[eidx] = new RGBValue[nFrames];

            // generate all the pixels
            for (int frameNum = 0; frameNum < nFrames; frameNum++)
            {
                if (UseBaseColor)
                {
                    var level = BaseLevelCurve.GetValue(GetEffectTimeIntervalPosition(frameNum)*100)/100;
                    buffer.ClearBuffer(level);
                }
                else
                {
                    buffer.ClearBuffer();
                }

                RenderEffect(frameNum, ref buffer);
                // peel off this frames pixels...
                if (StringOrientation == StringOrientation.Horizontal)
                {
                    int i = 0;
                    for (int y = 0; y < BufferHt; y++)
                    {
                        for (int x = 0; x < StringPixelCounts[y]; x++)
                        {
                            pixels[i][frameNum] = new RGBValue(buffer.GetColorAt(x,y));
                            i++;
                        }
                    }
                }
                else
                {
                    int i = 0;
                    for (int x = 0; x < BufferWi; x++)
                    {
                        for (int y = 0; y < StringPixelCounts[x]; y++)
                        {
                            pixels[i][frameNum] = new RGBValue(buffer.GetColorAt(x, y));
                            i++;
                        }
                    }
                }
            };

            // create the intents
            var frameTs = new TimeSpan(0, 0, 0, 0, FrameTime);
            List<Element> elements = node.ToList();
            int numElements = node.Count();
            for (int eidx = 0; eidx < numElements; eidx++)
            {
                IIntent intent = new StaticArrayIntent<RGBValue>(frameTs, pixels[eidx], TimeSpan);
                effectIntents.AddIntentForElement(elements[eidx].Id, intent, startTime);
            }

            return effectIntents;
        }
Esempio n. 6
0
        // renders the given node to the internal ElementData dictionary. If the given node is
        // not a element, will recursively descend until we render its elements.
        private void RenderNode(ElementNode node)
        {
            int wid;
            int ht;
            if (_data.NutcrackerData.StringOrienation == NutcrackerEffects.StringOrientations.Horizontal)
            {
                wid = MaxPixelsPerString;
                ht = StringCount;
            }
            else
            {
                wid = StringCount;
                ht = MaxPixelsPerString;
            }
            int nFrames = (int)(TimeSpan.TotalMilliseconds / frameMs);
            var nccore = new NutcrackerEffects(_data.NutcrackerData) {Duration = TimeSpan};
            nccore.InitBuffer( wid, ht);
            int numElements = node.Count();

            TimeSpan startTime = TimeSpan.Zero;

            // OK, we're gonna create 1 intent per element
            // that intent will hold framesToRender Color values
            // that it will parcel out as intent states are called for...

            // set up arrays to hold the generated colors
            var pixels = new RGBValue[numElements][];
            for (int eidx = 0; eidx < numElements; eidx++)
                pixels[eidx] = new RGBValue[nFrames];
            List<ElementNode> nodes = FindLeafParents().ToList();
            // generate all the pixels
            for (int frameNum = 0; frameNum < nFrames; frameNum++)
            {
                nccore.RenderNextEffect(_data.NutcrackerData.CurrentEffect);
                // peel off this frames pixels...
                if (_data.NutcrackerData.StringOrienation == NutcrackerEffects.StringOrientations.Horizontal)
                {
                    int i = 0;
                    for (int y = 0; y < ht; y++)
                    {
                        for (int x = 0; x < _stringPixelCounts[y]; x++)
                        {
                            pixels[i][frameNum] = new RGBValue(nccore.GetPixel(x, y));
                            i++;
                        }
                    }
                }
                else
                {
                    int i = 0;
                    for (int x = 0; x < wid; x++)
                    {
                        for (int y = 0; y < _stringPixelCounts[x]; y++)
                        {
                            pixels[i][frameNum] = new RGBValue(nccore.GetPixel(x, y));
                            i++;
                        }
                    }
                }
            };

            // create the intents
            var frameTs = new TimeSpan(0, 0, 0, 0, frameMs);
            List<Element> elements = node.ToList();
            for (int eidx = 0; eidx < numElements; eidx++)
            {
                IIntent intent = new StaticArrayIntent<RGBValue>(frameTs, pixels[eidx], TimeSpan);
                _elementData.AddIntentForElement(elements[eidx].Id, intent, startTime);
            }

            nccore.Dispose();
        }
Esempio n. 7
0
        protected EffectIntents RenderNodeByLocation(ElementNode node)
        {
            EffectIntents effectIntents = new EffectIntents();
            int nFrames = GetNumberFrames();
            if (nFrames <= 0 | BufferWi == 0 || BufferHt == 0) return effectIntents;
            PixelLocationFrameBuffer buffer = new PixelLocationFrameBuffer(ElementLocations.Distinct().ToList(), nFrames);

            TimeSpan startTime = TimeSpan.Zero;

            // generate all the pixels
            RenderEffectByLocation(nFrames, buffer);

            // create the intents
            var frameTs = new TimeSpan(0, 0, 0, 0, FrameTime);

            foreach (var tuple in buffer.GetElementData())
            {
                if (tuple.Item2.Count != nFrames)
                {
                    Logging.Error("{0} count has {1} instead of {2}", tuple.Item1.ElementNode.Name, tuple.Item2.Count, nFrames );
                }
                IIntent intent = new StaticArrayIntent<RGBValue>(frameTs, tuple.Item2.ToArray(), TimeSpan);
                effectIntents.AddIntentForElement(tuple.Item1.ElementNode.Element.Id, intent, startTime);
            }

            return effectIntents;
        }
Esempio n. 8
0
        protected EffectIntents RenderNodeByStrings(ElementNode node, ref EffectIntents effectIntents)
        {
            int nFrames = GetNumberFrames();

            if (nFrames <= 0 | BufferWi == 0 || BufferHt == 0)
            {
                return(new EffectIntents());
            }
            var buffer = new PixelFrameBuffer(BufferWi, BufferHt, UseBaseColor?BaseColor:Color.Transparent);

            int bufferSize = StringPixelCounts.Sum();

            TimeSpan startTime = TimeSpan.Zero;

            // set up arrays to hold the generated colors
            var pixels = new RGBValue[bufferSize][];

            for (int eidx = 0; eidx < bufferSize; eidx++)
            {
                pixels[eidx] = new RGBValue[nFrames];
            }

            // generate all the pixels
            for (int frameNum = 0; frameNum < nFrames; frameNum++)
            {
                if (UseBaseColor)
                {
                    var level = BaseLevelCurve.GetValue(GetEffectTimeIntervalPosition(frameNum) * 100) / 100;
                    buffer.ClearBuffer(level);
                }
                else
                {
                    buffer.ClearBuffer();
                }

                RenderEffect(frameNum, buffer);
                // peel off this frames pixels...
                if (StringOrientation == StringOrientation.Horizontal)
                {
                    int i = 0;
                    for (int y = 0; y < BufferHt; y++)
                    {
                        for (int x = 0; x < StringPixelCounts[y]; x++)
                        {
                            if (i >= pixels.Length)
                            {
                                break;
                            }
                            pixels[i][frameNum] = new RGBValue(buffer.GetColorAt(x, y));
                            i++;
                        }
                    }
                }
                else
                {
                    int i = 0;
                    for (int x = 0; x < BufferWi; x++)
                    {
                        for (int y = 0; y < StringPixelCounts[x]; y++)
                        {
                            if (i >= pixels.Length)
                            {
                                break;
                            }
                            pixels[i][frameNum] = new RGBValue(buffer.GetColorAt(x, y));
                            i++;
                        }
                    }
                }
            }

            // create the intents
            var frameTs     = new TimeSpan(0, 0, 0, 0, FrameTime);
            var elements    = _elementsCached?_cachedElements:node.Distinct().ToList();
            int numElements = elements.Count;

            for (int eidx = 0; eidx < numElements; eidx++)
            {
                IIntent intent = new StaticArrayIntent <RGBValue>(frameTs, pixels[eidx], TimeSpan);
                effectIntents.AddIntentForElement(elements[eidx].Id, intent, startTime);
            }

            return(effectIntents);
        }
Esempio n. 9
0
        // renders the given node to the internal ElementData dictionary. If the given node is
        // not a element, will recursively descend until we render its elements.
        private void RenderNode(ElementNode node)
        {
            int wid = 0;
            int ht  = 0;

            if (_data.NutcrackerData.StringOrienation == NutcrackerEffects.StringOrientations.Horizontal)
            {
                wid = PixelsPerString();
                ht  = StringCount;
            }
            else
            {
                wid = StringCount;
                ht  = PixelsPerString();
            }
            int nFrames = (int)(TimeSpan.TotalMilliseconds / frameMs);
            NutcrackerEffects nccore = new NutcrackerEffects(_data.NutcrackerData);

            nccore.InitBuffer(wid, ht);
            int totalPixels = nccore.PixelCount();

            if (totalPixels != wid * ht)
            {
                throw new Exception("bad pixel count");
            }
            int numElements = node.Count();

            if (numElements != totalPixels)
            {
                Logging.Warn("numEle " + numElements + " != totalPixels " + totalPixels);
            }

            TimeSpan startTime = TimeSpan.Zero;
            //TimeSpan ms50 = new TimeSpan(0, 0, 0, 0, frameMs);
            Stopwatch timer = new Stopwatch();

            timer.Start();

            // OK, we're gonna create 1 intent per element
            // that intent will hold framesToRender Color values
            // that it will parcel out as intent states are called for...

            // set up arrays to hold the generated colors
            var pixels = new RGBValue[numElements][];

            for (int eidx = 0; eidx < numElements; eidx++)
            {
                pixels[eidx] = new RGBValue[nFrames];
            }

            // generate all the pixels
            int pps = PixelsPerString();
            int sc  = StringCount;

            for (int frameNum = 0; frameNum < nFrames; frameNum++)
            {
                nccore.RenderNextEffect(_data.NutcrackerData.CurrentEffect);
                // peel off this frames pixels...
                if (_data.NutcrackerData.StringOrienation == NutcrackerEffects.StringOrientations.Horizontal)
                {
                    int i = 0;
                    for (int y = 0; y < sc; y++)
                    {
                        for (int x = 0; x < pps; x++)
                        {
                            pixels[i][frameNum] = new RGBValue(nccore.GetPixel(x, y));
                            i++;
                        }
                    }
                }
                else
                {
                    for (int i = 0; i < numElements; i++)
                    {
                        pixels[i][frameNum] = new RGBValue(nccore.GetPixel(i));
                    }
                }
            }
            ;

            // create the intents
            var            frameTs  = new TimeSpan(0, 0, 0, 0, frameMs);
            List <Element> elements = node.ToList();

            for (int eidx = 0; eidx < numElements; eidx++)
            {
                IIntent intent = new StaticArrayIntent <RGBValue>(frameTs, pixels[eidx], TimeSpan);
                _elementData.AddIntentForElement(elements[eidx].Id, intent, startTime);
            }

            timer.Stop();
            Logging.Debug(" {0}ms, Frames: {1}, wid: {2}, ht: {3},  pix: {4}, intents: {5}",
                          timer.ElapsedMilliseconds, nFrames, wid, ht, totalPixels, _elementData.Count());
        }
Esempio n. 10
0
        // renders the given node to the internal ElementData dictionary. If the given node is
        // not a element, will recursively descend until we render its elements.
        private void RenderNode(ElementNode node)
        {
            int wid = 0;
            int ht = 0;
            if (_data.NutcrackerData.StringOrienation == NutcrackerEffects.StringOrientations.Horizontal)
            {
                wid = PixelsPerString();
                ht = StringCount;
            }
            else
            {
                wid = StringCount;
                ht = PixelsPerString();
            }
            int nFrames = (int)(TimeSpan.TotalMilliseconds / frameMs);
            NutcrackerEffects nccore = new NutcrackerEffects(_data.NutcrackerData);
            nccore.InitBuffer( wid, ht);
            int totalPixels = nccore.PixelCount();
            if( totalPixels != wid * ht)
                throw new Exception("bad pixel count");
            int numElements = node.Count();
            if (numElements != totalPixels)
                Logging.Warn( "numEle " + numElements + " != totalPixels " + totalPixels);

            TimeSpan startTime = TimeSpan.Zero;
            //TimeSpan ms50 = new TimeSpan(0, 0, 0, 0, frameMs);
            Stopwatch timer = new Stopwatch();
            timer.Start();

            // OK, we're gonna create 1 intent per element
            // that intent will hold framesToRender Color values
            // that it will parcel out as intent states are called for...

            // set up arrays to hold the generated colors
            var pixels = new RGBValue[numElements][];
            for (int eidx = 0; eidx < numElements; eidx++)
                pixels[eidx] = new RGBValue[nFrames];

            // generate all the pixels
            int pps = PixelsPerString();
            int sc = StringCount;
            for (int frameNum = 0; frameNum < nFrames; frameNum++)
            {
                nccore.RenderNextEffect(_data.NutcrackerData.CurrentEffect);
                // peel off this frames pixels...
                if (_data.NutcrackerData.StringOrienation == NutcrackerEffects.StringOrientations.Horizontal)
                {
                    int i = 0;
                    for (int y = 0; y < sc; y++)
                    {
                        for (int x = 0; x < pps; x++)
                        {
                            pixels[i][frameNum] = new RGBValue(nccore.GetPixel(x, y));
                            i++;
                        }
                    }
                }
                else
                {
                    for (int i = 0; i < numElements; i++)
                    {
                        pixels[i][frameNum] = new RGBValue(nccore.GetPixel(i));
                    }
                }
            };

            // create the intents
            var frameTs = new TimeSpan(0, 0, 0, 0, frameMs);
            List<Element> elements = node.ToList();
            for (int eidx = 0; eidx < numElements; eidx++)
            {
                IIntent intent = new StaticArrayIntent<RGBValue>(frameTs, pixels[eidx], TimeSpan);
                _elementData.AddIntentForElement(elements[eidx].Id, intent, startTime);
            }

            timer.Stop();
            Logging.Debug(" {0}ms, Frames: {1}, wid: {2}, ht: {3},  pix: {4}, intents: {5}",
                            timer.ElapsedMilliseconds, nFrames, wid, ht, totalPixels, _elementData.Count());
        }