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:
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;
}
3 respuestas
¿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;
}
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;
}
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;
}
}