コード例 #1
0
        void SetNormalImage()
        {
            string    smoothTexResource = LevelDataManager.SmoothImageResource(storyMessages[frameId].pictureId);
            Texture2D smoothTex         = Resources.Load <Texture2D>(smoothTexResource);

            normalStoryImage.image.texture = smoothTex;
            SetImageSize(normalStoryImage);
        }
コード例 #2
0
        public void Initialize()
        {
            descriptor = GlobalManager.MLevel.GetDescriptor(GlobalManager.MStorage.GalleryLevel);
            //int width = descriptor.init.width;
            //int height = descriptor.init.height;
            float finalRatioXY = descriptor.init.finalXYScale;
            float screenAspect = Camera.main.aspect;

            // load STRESS and SMOOTH textures
            string    stressImage = StressImageCreator.StressedFinalImageFile(descriptor.init.id);
            Texture2D stressTex   = new Texture2D(2, 2, TextureFormat.RGB24, false);

            stressTex.LoadImage(System.IO.File.ReadAllBytes(stressImage));
            imageParams[0].winImage.texture = stressTex;
            Texture2D smoothTex = Resources.Load <Texture2D>(LevelDataManager.SmoothImageResource(descriptor.init.id));

            imageParams[1].winImage.texture = smoothTex;

            // set up scaling and UV rectangles
            CanvasScaler canvasScaler = GetComponent <CanvasScaler>();
            // the size of the canvas excluding margins
            Rect sourceCanvasRect = new Rect(0, 0, canvasScaler.referenceResolution.x * (1 - marginRatio), canvasScaler.referenceResolution.y * (1 - marginRatio));

            sourceCanvasSize = new Vector2(sourceCanvasRect.width, sourceCanvasRect.height);
            // SourceCanvas matches screen by width, so the final height scaling should be adjusted by:
            float heightAdjustFactor = sourceCanvasRect.width / sourceCanvasRect.height / screenAspect;

            for (int i = 0; i < imageParams.Length; i++)
            {
                imageParams[i].imageTransform.localPosition = imageParams[i].originalPosition;
                Vector2 canvasToImageRatio = new Vector2(
                    sourceCanvasRect.width / imageParams[i].originalRect.width,
                    sourceCanvasRect.height * heightAdjustFactor / imageParams[i].originalRect.height
                    );
                imageParams[i].sourceScale = new Vector2(
                    finalRatioXY > screenAspect ? canvasToImageRatio.y * finalRatioXY : canvasToImageRatio.x,
                    finalRatioXY > screenAspect ? canvasToImageRatio.y : canvasToImageRatio.x / finalRatioXY
                    );
                imageParams[i].effectiveSize             = Vector2.Scale(new Vector2(imageParams[i].originalRect.width, imageParams[i].originalRect.height), imageParams[i].sourceScale);
                imageParams[i].imageTransform.localScale = imageParams[i].sourceScale;
                currentScale = new FloatRange
                {
                    min = scaleRange.min,
                    max = scaleRange.min
                };
                // UV-coordinates of the image
                imageParams[i].winImage.uvRect = new Rect(0, 0, 1, 1);
                // positions
                //imageParams[i].originalPosition = imageParams[i].imageTransform.localPosition;
                imageParams[i].movePosition = new Vector2[2]
                {
                    imageParams[i].originalPosition,
                    imageParams[i].originalPosition
                };
            }
            effectFinished = false;
            GenerateNewStep(true);
        }
コード例 #3
0
        void InitializeDialog(LevelDataManager.Descriptor descriptor)
        {
            // calculate dialog size
            int   adjustmentIndex    = -1;
            float currentScreenRatio = (float)Screen.width / (float)Screen.height;

            for (int i = 0; i < dialogAdjustments.Length; i++)
            {
                if (currentScreenRatio >= dialogAdjustments[i].screenAspect)
                {
                    adjustmentIndex = i;
                    break;
                }
            }
            if (adjustmentIndex < 0)
            {
                return;
            }
            // get level data
            string levelStr = descriptor.init.id.ToString("D3");

            titleText.GetComponent <Text>().text = GlobalManager.MLanguage.Entry(titlePrefix + levelStr);
            GameObject activeImage, inactiveImage;
            GameObject activeText, inactiveText;

            // adjust dialog height
            descriptionDialog.GetComponent <RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, dialogAdjustments[adjustmentIndex].dialogHeight);

            bool horizontal = descriptor.init.finalXYScale >= 1f;
            // set up image dimensions and the dialog layout depending on "horizontal" or "vertical" image orientation

            float finalImageWidth;
            float finalImageHeight;

            if (horizontal)
            {
                // the maximum height of the image is fixed
                finalImageHeight = dialogAdjustments[adjustmentIndex].maxHorizontalImageSize.y;
                finalImageWidth  = finalImageHeight * descriptor.init.finalXYScale;
                if (finalImageWidth > dialogAdjustments[adjustmentIndex].maxHorizontalImageSize.x)
                {
                    finalImageWidth  = dialogAdjustments[adjustmentIndex].maxHorizontalImageSize.x;
                    finalImageHeight = finalImageWidth / descriptor.init.finalXYScale;
                }
                activeImage   = hDescriptionImage;
                inactiveImage = vDescriptionImage;
                activeText    = hDescriptionText;
                inactiveText  = vDescriptionText;
                // adjust horizontal description text Y-shift
                RectTransform activeTextRectTransform = activeText.GetComponent <RectTransform>();
                Vector2       activeTextPosition      = activeTextRectTransform.localPosition;
                activeTextPosition.y = dialogAdjustments[adjustmentIndex].descriptionYShift;
                activeTextRectTransform.localPosition = activeTextPosition;
            }
            else
            {
                // the maximum width of the image is fixed
                finalImageWidth  = dialogAdjustments[adjustmentIndex].maxVerticalImageSize.x;
                finalImageHeight = finalImageWidth / descriptor.init.finalXYScale;
                if (finalImageHeight > dialogAdjustments[adjustmentIndex].maxVerticalImageSize.y)
                {
                    finalImageHeight = dialogAdjustments[adjustmentIndex].maxVerticalImageSize.y;
                    finalImageWidth  = finalImageHeight * descriptor.init.finalXYScale;
                }
                activeImage   = vDescriptionImage;
                inactiveImage = hDescriptionImage;
                activeText    = vDescriptionText;
                inactiveText  = hDescriptionText;
            }

            activeTextScript          = activeText.GetComponent <Text>();
            activeTextScript.fontSize = dialogAdjustments[adjustmentIndex].descriptionFontSize;
            // activate active objects
            activeImage.SetActive(true);
            activeText.SetActive(true);
            // load "smooth" image
            activeImage.GetComponent <RawImage>().texture = Resources.Load <Texture>(LevelDataManager.SmoothImageResource(descriptor.init.id));
            // and set up its size
            activeImage.GetComponent <RectTransform>().localScale = new Vector3(finalImageWidth, finalImageHeight, 1.0f);
            // set text objects
            activeText.GetComponent <Text>().text = GlobalManager.MLanguage.Entry(descriptionPrefix + levelStr);
            // deactivate inactive objects
            inactiveImage.SetActive(false);
            inactiveText.SetActive(false);
            okButton.GetComponent <Button>().interactable = true;
            Visualize(flashRange.min);
            // now activate the dialog
            gameObject.SetActive(true);
            StartFlash(true);
        }
コード例 #4
0
        IEnumerator BgStressImage(int level)
        {
            float  startTime             = Time.realtimeSinceStartup;
            string sourceGraphicResource = LevelDataManager.SmoothImageResource(level);

            originalImage = Resources.Load <Texture2D>(sourceGraphicResource);
            //Debug.Log("StressImageCreator.BgStressImage: creating STRESS image from " + sourceGraphicResource + " as " + (originalImage == null ? "null" : originalImage.ToString()));
            int w = originalImage.width;
            int h = originalImage.height;

            //stressedImage = new Texture2D(w, h, originalImage.format, false);
            // only RGBA32 textures are allowed to be written into
            stressedImage = new Texture2D(w, h, TextureFormat.RGBA32, false);
            Color[] ic      = originalImage.GetPixels();
            Color[] oc      = new Color[w * h];
            int     coffset = 0;
            Color   c       = new Color();
            Color   cmin    = c;
            Color   cmax    = c;

            // scan the pixels and calculate the output values
            for (int y = 0; y < h; y++)
            {
                for (int x = 0; x < w; x++, coffset++)
                {
                    c    = ic[coffset];
                    cmin = c;
                    cmax = c;
                    float   range              = 0f;
                    float   brightness         = 0f;
                    float[] relativeBrightness = new float[4];
                    float[] relativeRange      = new float[4];
                    // compute a pixel value
                    for (int j = 0; j < iterationsCount; j++)
                    {
                        // get minimum and maximum color values from the neighbourhood
                        int smax = samplesCount;
                        for (int i = 0; i < smax;)
                        {
                            int xn = x + nbradii[radiusCount, 0];
                            int yn = y + nbradii[radiusCount, 1];
                            if (xn >= 0 && xn < w && yn >= 0 && yn < h)
                            {
                                Color cnb = ic[yn * w + xn];
                                // loop unwrap
                                cmin.r = Mathf.Min(cmin.r, cnb.r);
                                cmin.g = Mathf.Min(cmin.g, cnb.g);
                                cmin.b = Mathf.Min(cmin.b, cnb.b);
                                cmax.r = Mathf.Max(cmax.r, cnb.r);
                                cmax.g = Mathf.Max(cmax.g, cnb.g);
                                cmax.b = Mathf.Max(cmax.b, cnb.b);

                                /*
                                 * for (int ci = 0; ci < 3; ci++)
                                 * {
                                 *  cmin[ci] = Mathf.Min(cmin[ci], cnb[ci]);
                                 *  cmax[ci] = Mathf.Max(cmax[ci], cnb[ci]);
                                 * }
                                 */
                                i++;
                            }

                            /*else
                             * {
                             *  smax--;
                             * }*/
                            radiusCount++;
                            if (radiusCount >= neighboursCount)
                            {
                                radiusCount = 0;
                            }
                        }
                        // now calculate cumulative brightness and dynamic range for every color component
                        // loop unwrap
                        range      = cmax.r - cmin.r;
                        brightness = 0.5f;
                        if (range > eps)
                        {
                            brightness = (c.r - cmin.r) / range;
                        }
                        relativeBrightness[0] += brightness;
                        relativeRange[0]      += range;
                        range      = cmax.g - cmin.g;
                        brightness = 0.5f;
                        if (range > eps)
                        {
                            brightness = (c.g - cmin.g) / range;
                        }
                        relativeBrightness[1] += brightness;
                        relativeRange[1]      += range;
                        range      = cmax.b - cmin.b;
                        brightness = 0.5f;
                        if (range > eps)
                        {
                            brightness = (c.b - cmin.b) / range;
                        }
                        relativeBrightness[2] += brightness;
                        relativeRange[2]      += range;

                        /*
                         * for (int ci = 0; ci < 3; ci++)
                         * {
                         *  range = cmax[ci] - cmin[ci];
                         *  brightness = 0.5f;
                         *  if (range > eps)
                         *  {
                         *      brightness = (c[ci] - cmin[ci]) / range;
                         *  }
                         *  relativeBrightness[ci] += brightness;
                         *  relativeRange[ci] += range;
                         * }
                         */
                    }
                    // now calculate max and min envelopes
                    // loop unwrap
                    brightness = relativeBrightness[0] / iterationsCount;
                    range      = relativeRange[0] / iterationsCount;
                    cmax.r     = c.r + (1.0f - brightness) * range;
                    cmin.r     = c.r - brightness * range;
                    brightness = relativeBrightness[1] / iterationsCount;
                    range      = relativeRange[1] / iterationsCount;
                    cmax.g     = c.g + (1.0f - brightness) * range;
                    cmin.g     = c.g - brightness * range;
                    brightness = relativeBrightness[2] / iterationsCount;
                    range      = relativeRange[2] / iterationsCount;
                    cmax.b     = c.b + (1.0f - brightness) * range;
                    cmin.b     = c.b - brightness * range;
                    // now calculate the final value
                    float delta = cmax.r - cmin.r;
                    if (delta > eps)
                    {
                        c.r = (c.r - cmin.r) / delta;
                    }
                    else
                    {
                        c.r = 0.5f;
                    }
                    delta = cmax.g - cmin.g;
                    if (delta > eps)
                    {
                        c.g = (c.g - cmin.g) / delta;
                    }
                    else
                    {
                        c.g = 0.5f;
                    }
                    delta = cmax.b - cmin.b;
                    if (delta > eps)
                    {
                        c.b = (c.b - cmin.b) / delta;
                    }
                    else
                    {
                        c.b = 0.5f;
                    }

                    /*
                     * for (int ci = 0; ci < 3; ci++)
                     * {
                     *  brightness = relativeBrightness[ci] / iterationsCount;
                     *  range = relativeRange[ci] / iterationsCount;
                     *  cmax[ci] = c[ci] + (1.0f - brightness) * range;
                     *  cmin[ci] = c[ci] - brightness * range;
                     *  float delta = cmax[ci] - cmin[ci];
                     *  if (delta > eps)
                     *  {
                     *      c[ci] = (c[ci] - cmin[ci]) / delta;
                     *  }
                     *  else
                     *  {
                     *      c[ci] = 0.5f;
                     *  }
                     * }
                     */
                    // fill the output buffer
                    oc[coffset] = c;
                    // every n-th pixel do a break for the next frame
                    if (coffset % breakCycle == breakCycle - 1)
                    {
                        //Debug.Log("STRESS pixel " + coffset.ToString());
                        //yield return new WaitForFixedUpdate();
                        yield return(null);
                    }
                }
            }
            stressedImage.SetPixels(oc);
            stressedImage.Apply();
            float endTime = Time.realtimeSinceStartup;

            Debug.Log("stress time " + level.ToString() + ": " + (endTime - startTime).ToString());
            // now try to save the stressed image into a file
            var    bytes         = stressedImage.EncodeToJPG();
            string imageFileName = StressedFinalImageFile(level);

            Debug.Log("Writing data to file " + imageFileName);
            System.IO.File.WriteAllBytes(imageFileName, bytes);
            hasStressFile[level] = true;
        }