Exemplo n.º 1
0
        void UpdateChannel(int channelIndex)
        {
            if (!useLibrary)
            {
                return;
            }

            string     channelName     = channelNames[channelIndex];
            string     channelKey      = FixtureLibrary.ParseTemplateChannelKey(channelName);
            string     channelPixelKey = FixtureLibrary.ParseTemplatePixelKey(channelName);
            JSONObject channel         = GetChannelDef(channelKey, channelPixelKey);

            if (channel == null)
            {
                return;
            }

            JSONObject capability = channel["capability"] as JSONObject;

            if (capability == null)
            {
                JSONArray capabilities = channel["capabilities"] as JSONArray;
                for (int i = 0; i < capabilities.Count; i++)
                {
                    capability = capabilities[i] as JSONObject;
                    if (_values[channelIndex] <= capability["dmxRange"][1])
                    {
                        break;
                    }
                }
            }

            if (capability == null)
            {
                return;
            }

            string capabilityType = capability["type"];

            if (capabilityType == "Pan")
            {
                _panTarget = FixtureLibrary.GetFloatProperty(capability, "angle", FixtureLibrary.Entity.RotationAngle, _values[channelIndex]);

                UpdateTransform();
            }
            else if (capabilityType == "Tilt")
            {
                _tiltTarget = FixtureLibrary.GetFloatProperty(capability, "angle", FixtureLibrary.Entity.RotationAngle, _values[channelIndex]);

                UpdateTransform();
            }
            else if (capabilityType == "PanTiltSpeed")
            {
                _panSpeed = _tiltSpeed = FixtureLibrary.GetFloatProperty(capability, "speed", FixtureLibrary.Entity.Speed, _values[channelIndex]);
            }
            else if (capabilityType == "Intensity")
            {
                _intensity = FixtureLibrary.GetFloatProperty(capability, "brightness", FixtureLibrary.Entity.Brightness, _values[channelIndex]);

                UpdateIntensity();
            }
            else if (capabilityType == "ColorIntensity")
            {
                string colorKey  = capability["color"];
                float  intensity = FixtureLibrary.GetFloatProperty(capability, "brightness", FixtureLibrary.Entity.Brightness, _values[channelIndex]);

                // TODO: not just for color channels
                if (!string.IsNullOrEmpty(channelPixelKey))
                {
                    Transform pixel = transform.Find(channelPixelKey);
                    if (pixel == null)
                    {
                        foreach (JSONString p in fixtureDef["matrix"]["pixelGroups"][channelPixelKey] as JSONArray)
                        {
                            pixel = transform.Find(p);
                            SetPixelColor(pixel, colorKey, intensity);
                        }
                    }
                    else
                    {
                        SetPixelColor(pixel, colorKey, intensity);
                    }
                }
                else
                {
                    if (colorKey == "Red")
                    {
                        _red = intensity;
                    }
                    else if (colorKey == "Green")
                    {
                        _green = intensity;
                    }
                    else if (colorKey == "Blue")
                    {
                        _blue = intensity;
                    }
                    else if (colorKey == "White")
                    {
                        _white = intensity;
                    }
                }

                // TODO: more colors

                UpdateColor();
            }
            else if (capabilityType == "Zoom")
            {
                _beamAngle = FixtureLibrary.GetFloatProperty(capability, "angle", FixtureLibrary.Entity.BeamAngle, _values[channelIndex]);

                UpdateSpotAngle();
            }
            else if (capabilityType == "ShutterStrobe")
            {
                _shutterEffect = FixtureLibrary.ParseEffect(capability["shutterEffect"]);
                _shutterSpeed  = FixtureLibrary.GetFloatProperty(capability, "speed", FixtureLibrary.Entity.Speed, _values[channelIndex]);

                UpdateShutter();
            }
            else if (capabilityType == "ColorTemperature")
            {
                _colorTemperature = FixtureLibrary.GetFloatProperty(capability, "colorTemperature", FixtureLibrary.Entity.ColorTemperature, _values[channelIndex]);

                UpdateColor();
            }
            else if (capabilityType == "ColorPreset")
            {
                if (capability["colors"] != null)
                {
                    Color color = FixtureLibrary.ParseColorArray(capability["colors"] as JSONArray);

                    _red   = color.r;
                    _green = color.g;
                    _blue  = color.b;
                }

                if (capability["colorsTemperature"] != null)
                {
                    _colorTemperature = FixtureLibrary.GetFloatProperty(capability, "colorTemperature", FixtureLibrary.Entity.ColorTemperature, _values[channelIndex]);
                }

                UpdateColor();
            }
            else if (capabilityType == "WheelSlot")
            {
                string wheelName = channelKey;
                if (capability["wheel"] != null)
                {
                    wheelName = capability["wheel"];
                }

                Wheel wheel = GetWheel(wheelName);
                if (wheel != null)
                {
                    wheel.slot  = FixtureLibrary.GetFloatProperty(capability, "slotNumber", FixtureLibrary.Entity.SlotNumber, _values[channelIndex]);
                    wheel.speed = 0;
                }

                UpdateColor();
            }
            else if (capabilityType == "WheelRotation")
            {
                string wheelName = channelKey;
                if (capability["wheel"] != null)
                {
                    wheelName = capability["wheel"];
                }

                Wheel wheel = GetWheel(wheelName);
                if (wheel != null)
                {
                    wheel.speed = FixtureLibrary.GetFloatProperty(capability, "speed", FixtureLibrary.Entity.Speed, _values[channelIndex]);
                }
            }
            else if (capabilityType == "NoFunction")
            {
                // TODO this is a hack for some bad ficture defs
                if (channelKey == "Strobe")
                {
                    _shutterEffect = FixtureLibrary.ShutterEffect.Open;
                }

                UpdateShutter();
            }
        }
Exemplo n.º 2
0
        void InitFixturePreview()
        {
            JSONObject fixtureDef = FixtureLibrary.Instance.GetFixtureDef(libraryPath);

            if (fixtureDef == null)
            {
                return;
            }

            _isLaser = false;
            foreach (JSONString c in fixtureDef["categories"] as JSONArray)
            {
                if (c == "Laser")
                {
                    _isLaser = true;
                }
            }

            // physical

            JSONArray lens = fixtureDef["physical"]["lens"]["degreesMinMax"] as JSONArray;

            if (lens != null && lens[0] == lens[1])
            {
                _beamAngle = lens[0];
            }
            else
            {
                _beamAngle = 10;
            }

            Vector3   pixelSize  = new Vector3(0.05f, 0.05f, 0);
            JSONArray dimensions = fixtureDef["physical"]["matrixPixels"]["dimensions"] as JSONArray;

            if (dimensions != null)
            {
                pixelSize = new Vector3(dimensions[0], dimensions[1], dimensions[2]) / 1000;
            }

            Vector3   pixelSpacing = Vector3.zero;
            JSONArray spacing      = fixtureDef["physical"]["matrixPixels"]["spacing"] as JSONArray;

            if (spacing != null)
            {
                pixelSpacing = new Vector3(spacing[0], spacing[1], spacing[2]) / 1000;
            }

            // wheels

            wheelNames = new List <string>();
            wheelData  = new List <Wheel>();
            if (fixtureDef["wheels"] != null)
            {
                foreach (KeyValuePair <string, JSONNode> wheel in fixtureDef["wheels"] as JSONObject)
                {
                    wheelNames.Add(wheel.Key);
                    wheelData.Add(new Wheel());
                }
            }

            // pixels

            isMatrix = false;
            for (int i = transform.childCount - 1; i >= 0; i--)
            {
                Transform child = transform.GetChild(i);
                if (Application.isPlaying)
                {
                    Destroy(child.gameObject);
                }
                else
                {
                    DestroyImmediate(child.gameObject);
                }
            }

            if (fixtureDef["matrix"] != null)
            {
                JSONArray pixelKeysZ = fixtureDef["matrix"]["pixelKeys"] as JSONArray;

                if (pixelKeysZ != null)
                {
                    for (int z = 0; z < pixelKeysZ.Count; z++)
                    {
                        JSONArray pixelKeysY = pixelKeysZ[z] as JSONArray;

                        for (int y = 0; y < pixelKeysY.Count; y++)
                        {
                            JSONArray pixelKeysX = pixelKeysY[y] as JSONArray;

                            for (int x = 0; x < pixelKeysX.Count; x++)
                            {
                                JSONString pixelKey = pixelKeysX[x] as JSONString;
                                if (string.IsNullOrEmpty(pixelKey))
                                {
                                    continue;
                                }

                                GameObject pixel = CreatePixel(pixelKey, pixelSize);

                                // TODO: pixel spacing
                                pixel.transform.localPosition = new Vector3(((pixelKeysX.Count - 1) / 2f - x) * pixelSize.x, ((pixelKeysY.Count - 1) / 2f - y) * pixelSize.y, ((pixelKeysZ.Count - 1) / 2f - z) * pixelSize.z);
                                pixel.transform.SetParent(transform, false);
                            }
                        }
                    }
                }
                else
                {
                    JSONArray pixelCount = fixtureDef["matrix"]["pixelCount"] as JSONArray;

                    for (int z = 0; z < pixelCount[2]; z++)
                    {
                        for (int y = 0; y < pixelCount[1]; y++)
                        {
                            for (int x = 0; x < pixelCount[0]; x++)
                            {
                                string pixelKey = null;
                                if (pixelCount[1] > 1)
                                {
                                    if (pixelCount[2] > 1)
                                    {
                                        pixelKey = string.Format("({0}, {1}, {2})", x + 1, y + 1, z + 1);
                                    }
                                    else
                                    {
                                        pixelKey = string.Format("({0}, {1})", x + 1, y + 1);
                                    }
                                }
                                else
                                {
                                    pixelKey = string.Format("{0}", x + 1);
                                }

                                GameObject pixel = CreatePixel(pixelKey, pixelSize);

                                // TODO: pixel spacing
                                pixel.transform.localPosition = new Vector3(((pixelCount[0] - 1) / 2f - x) * pixelSize.x, ((pixelCount[1] - 1) / 2f - y) * pixelSize.y, ((pixelCount[2] - 1) / 2f - z) * pixelSize.z);
                                pixel.transform.SetParent(transform, false);
                            }
                        }
                    }
                }

                pixelGroups = new Dictionary <string, List <string> >();
                if (fixtureDef["matrix"]["pixelGroups"] != null)
                {
                    foreach (KeyValuePair <string, JSONNode> pixelGroup in fixtureDef["matrix"]["pixelGroups"] as JSONObject)
                    {
                        List <string> groupMembers = new List <string>();
                        foreach (JSONString pixelKey in pixelGroup.Value as JSONArray)
                        {
                            groupMembers.Add(pixelKey);
                        }

                        pixelGroups[pixelGroup.Key] = groupMembers;
                    }
                }
            }

            channelNames         = new List <string>();
            templateChannelNames = new List <string>();
            pixelKeys            = new List <string>();
            foreach (JSONNode channelRef in fixtureDef["modes"][modeIndex]["channels"] as JSONArray)
            {
                // matrix insert block
                if (channelRef is JSONObject)
                {
                    // TODO: more repeatFor modes
                    foreach (JSONString pixelKey in channelRef["repeatFor"] as JSONArray)
                    {
                        pixelKeys.Add(pixelKey);
                        foreach (JSONString templateChannelName in channelRef["templateChannels"] as JSONArray)
                        {
                            templateChannelNames.Add(templateChannelName);
                            channelNames.Add(FixtureLibrary.ExpandTemplateChannelName(templateChannelName, pixelKey));
                        }
                    }
                }
                else if (channelRef == null)
                {
                    channelNames.Add("");
                }
                else
                {
                    channelNames.Add(channelRef);
                }
            }

            numChannels = channelNames.Count;

            capabilityNames    = new List <string>();
            capabilityChannels = new List <int>();
            for (int i = 0; i < numChannels; i++)
            {
                string channelName     = channelNames[i];
                string channelKey      = FixtureLibrary.ParseTemplateChannelKey(channelName);
                string channelPixelKey = FixtureLibrary.ParseTemplatePixelKey(channelName);
                if (!string.IsNullOrEmpty(channelPixelKey))
                {
                    isMatrix = true;
                }

                JSONObject channel = GetChannelDef(channelKey, channelPixelKey);
                if (channel == null)
                {
                    continue;
                }

                JSONObject capability = channel["capability"] as JSONObject;
                if (capability != null)
                {
                    string capabilityName = capability["type"];
                    if (capability["type"] == "ColorIntensity")
                    {
                        capabilityName += " " + capability["color"];
                    }

                    capabilityNames.Add(capabilityName);
                    capabilityChannels.Add(i);
                }
            }

            if (useChannelDefaults)
            {
                SetChannelDefaults();
            }
        }