Explicación

Estoy generando texturas para elementos de la interfaz de usuario que tienen un solo contorno de píxeles en el borde de la textura.

El método para establecer los datos de color en la textura se limita a pasar una matriz unidimensional de valores de color.

Estas texturas son 2D, por lo que son básicamente rectángulos. Necesito poder identificar cuándo el píxel actual está en un borde. Así es como lo hago actualmente:

Color[] colorData = new Color[width * height];
        for (int p = 0; p < colorData.Length; p++) {

            //Top
            if (p < width - 1) {

                colorData[p] = DefaultOutlineColor;
            }    
            //Left
            else if(p % width == 0) {
                colorData[p] = DefaultOutlineColor;
            }
            //Right
            else if(p % height == height - outlineWidth) {
                colorData[p] = DefaultOutlineColor;
            }
            //Bottom
            else if(p >= width * (height - outlineWidth)) {
                colorData[p] = DefaultOutlineColor;
            }
            //Fill
            else {
                colorData[p] = DefaultBaseColor;
            }
        }

El problema

Algún módulo de matemática y qué no. El problema que tengo es con el lado derecho de la textura. Más específicamente calculando el borde lateral derecho. Una imagen vale mas que mil palabras:

UI Texture

Sé que es solo un cálculo erróneo en la parte del borde derecho. Pero no tengo idea de cómo hacerlo funcionar. Cualquier ayuda sería muy apreciada.

EDITAR: Lo descubrí. Aquí está el código de trabajo:

        //Fill
        for (int p = 0; p < colorData.Length; p++) {

            colorData[p] = DefaultBaseColor;
        }

        //Top
        for (int p = 0; width * outlineWidth > p; p++) {

            colorData[p] = DefaultOutlineColor;
        }

        //Left and Right
        for (int p = 1; height > p; p++) {

            for (int i = 0; i < outlineWidth; i++) {

                colorData[(p * width) + i] = DefaultOutlineColor; //Left
                colorData[((p * width) - i) - 1] = DefaultOutlineColor; //Right
            }

        }

        //Bottom
        for (int p = width * height - (width * outlineWidth); colorData.Length > p; p++) {

           colorData[p] = DefaultOutlineColor;
        }
2
Spool 13 ene. 2018 a las 07:43

3 respuestas

La mejor respuesta

¿Por qué no hacerlo en tres bucles? ¿Uno para la parte superior, uno para la izquierda y la derecha y luego uno para la parte inferior? De esa manera, puede omitir todos los elementos que no necesitan ser tocados.

for(int ndx = 0; Width > ndx; ++ndx)
{
  colorData[ndx] = DefaultOutlineColor;
}

for(int ndx = 1; Height > ndx; ++ndx)
{
  colorDatandx * Widthp] = DefaultOutlineColor;
  colorData[ndx*Width + Width] = DefaultOutlineColor;}
}

for(int ndx = Width * Height - Width; Length > ndx; ++ndx)
{
  colorDatandxp] = DefaultOutlineColor;
}
2
Dhaval Asodariya 13 ene. 2018 a las 06:32

Usando el método de SoronelHaetir lo descubrí. Tuve que editar las matemáticas un poco. Aquí está el código de trabajo si alguien está interesado:

        for (int ndx = 0; width > ndx; ndx++) {
            colorData[ndx] = DefaultOutlineColor;
        }
        for (int ndx = 1; height > ndx ; ndx++) {
            colorData[ndx * width] = DefaultOutlineColor;
            colorData[(ndx * width) - 1] = DefaultOutlineColor;
        }
        for (int ndx = width * height - width; colorData.Length > ndx; ndx++) {
            colorData[ndx] = DefaultOutlineColor;
        }
1
Spool 13 ene. 2018 a las 05:20

En la práctica, está haciendo un borde de un píxel, pero usa outlineWidth en su código original, así que aquí hay un método alternativo que funciona bien para tamaños de borde arbitrarios.

for (int p = 0; p < colorData.length; p++) {
    // retrieving the x/y coords isn't expensive if you do this only once
    int x = p % height;
    int y = p / height;

    if (x < outlineSize || y < outlineSize || x >= width - outlineSize || y >= height - outlineSize) {
        colorData[p] = DefaultOutlineColor;
    }
}
0
Matt Rollins 16 ene. 2018 a las 16:35
48236981