Exemple #1
0
    static float MinusPixelColor(int iPoint, int layer, float v, int EdgeColor)
    {
        if (v != 0 && T4MSC.IsPointBrush(iPoint, layer))
        {
            return(Mathf.Max(Mathf.Floor(v) - EdgeColor, 0));
        }

        return(v);
    }
Exemple #2
0
    public static void BrushTerrain_New(ref Color[] terrainBay, ref Color[] terrainBay_sec, int x, int y, int width, int height)
    {
        T4MSC.CreateT4MBrushPoint();

        int CurrentLayer = T4MSC.T4MselTexture;

        for (int i = 0; i < height - 1 && true; i++)
        {
            for (int j = 0; j < width - 1; j++)
            {
                int startIndex = i * width + j;

                int[] IndexList = new int[4] {
                    startIndex, startIndex + 1, startIndex + width, startIndex + width + 1
                };

                int iPoint = (y + i) * (T4MSC.T4MMaskTex.width + 1) + (x + j);
                for (int col = 0; col < 4; col++)
                {
                    int   index      = IndexList[col];
                    Color current    = terrainBay[index] * 255;
                    Color currentSec = terrainBay_sec[index] * 255;
                    int   r          = (int)Mathf.Floor(current.r);
                    int   g          = (int)Mathf.Floor(current.g);
                    int   b          = (int)Mathf.Floor(current.b);
                    int   a          = (int)Mathf.Floor(current.a);

                    int r1 = (int)Mathf.Floor(currentSec.r);
                    int g1 = (int)Mathf.Floor(currentSec.g);
                    int b1 = (int)Mathf.Floor(currentSec.b);
                    int a1 = (int)Mathf.Floor(currentSec.a);

                    int EdgeCol = iEdgeColor[col];
                    if (T4MSC.T4MselTexture == 0)
                    {
                        current.g = MinusPixelColor(iPoint, 1, g, EdgeCol);
                        current.b = MinusPixelColor(iPoint, 2, b, EdgeCol);
                        current.a = MinusPixelColor(iPoint, 3, a, EdgeCol);

                        currentSec.r = MinusPixelColor(iPoint, 4, r1, EdgeCol);
                        currentSec.g = MinusPixelColor(iPoint, 5, g1, EdgeCol);
                        currentSec.b = MinusPixelColor(iPoint, 6, b1, EdgeCol);
                        currentSec.a = MinusPixelColor(iPoint, 7, a1, EdgeCol);

                        if (!T4MSC.IsPointBrush(iPoint, CurrentLayer))
                        {
                            current.r = (Mathf.Floor(current.r) + EdgeCol) % 16;
                        }
                    }
                    else if (T4MSC.T4MselTexture == 1)
                    {
                        current.b = MinusPixelColor(iPoint, 2, b, EdgeCol);
                        current.a = MinusPixelColor(iPoint, 3, a, EdgeCol);

                        currentSec.r = MinusPixelColor(iPoint, 4, r1, EdgeCol);
                        currentSec.g = MinusPixelColor(iPoint, 5, g1, EdgeCol);
                        currentSec.b = MinusPixelColor(iPoint, 6, b1, EdgeCol);
                        currentSec.a = MinusPixelColor(iPoint, 7, a1, EdgeCol);

                        if (!T4MSC.IsPointBrush(iPoint, CurrentLayer))
                        {
                            if (T4MSC.ClearPerviousLayer)
                            {
                                current.r = MinusPixelColor(iPoint, 0, r, EdgeCol);
                            }

                            current.g = (Mathf.Floor(current.g) + EdgeCol) % 16;
                        }
                    }
                    else if (T4MSC.T4MselTexture == 2)
                    {
                        current.a = MinusPixelColor(iPoint, 3, a, EdgeCol);

                        currentSec.r = MinusPixelColor(iPoint, 4, r1, EdgeCol);
                        currentSec.g = MinusPixelColor(iPoint, 5, g1, EdgeCol);
                        currentSec.b = MinusPixelColor(iPoint, 6, b1, EdgeCol);
                        currentSec.a = MinusPixelColor(iPoint, 7, a1, EdgeCol);

                        if (!T4MSC.IsPointBrush(iPoint, CurrentLayer))
                        {
                            if (T4MSC.ClearPerviousLayer)
                            {
                                current.r = MinusPixelColor(iPoint, 0, r, EdgeCol);
                                current.g = MinusPixelColor(iPoint, 1, g, EdgeCol);
                            }

                            current.b = (Mathf.Floor(current.b) + EdgeCol) % 16;
                        }
                    }
                    else if (T4MSC.T4MselTexture == 3)
                    {
                        currentSec.r = MinusPixelColor(iPoint, 4, r1, EdgeCol);
                        currentSec.g = MinusPixelColor(iPoint, 5, g1, EdgeCol);
                        currentSec.b = MinusPixelColor(iPoint, 6, b1, EdgeCol);
                        currentSec.a = MinusPixelColor(iPoint, 7, a1, EdgeCol);

                        if (!T4MSC.IsPointBrush(iPoint, CurrentLayer))
                        {
                            current.a = (Mathf.Floor(current.a) + EdgeCol);
                            if (T4MSC.ClearPerviousLayer)
                            {
                                current.r = MinusPixelColor(iPoint, 0, r, EdgeCol);
                                current.g = MinusPixelColor(iPoint, 1, g, EdgeCol);
                                current.b = MinusPixelColor(iPoint, 2, b, EdgeCol);
                            }
                        }
                    }
                    else if (T4MSC.T4MselTexture == 4)
                    {
                        currentSec.g = MinusPixelColor(iPoint, 5, g1, EdgeCol);
                        currentSec.b = MinusPixelColor(iPoint, 6, b1, EdgeCol);
                        currentSec.a = MinusPixelColor(iPoint, 7, a1, EdgeCol);

                        if (!T4MSC.IsPointBrush(iPoint, CurrentLayer))
                        {
                            currentSec.r = (Mathf.Floor(currentSec.r) + EdgeCol);
                            if (T4MSC.ClearPerviousLayer)
                            {
                                current.r = MinusPixelColor(iPoint, 0, r, EdgeCol);
                                current.g = MinusPixelColor(iPoint, 1, g, EdgeCol);
                                current.b = MinusPixelColor(iPoint, 2, b, EdgeCol);
                                current.a = MinusPixelColor(iPoint, 3, a, EdgeCol);
                            }
                        }
                    }
                    else if (T4MSC.T4MselTexture == 5)
                    {
                        currentSec.b = MinusPixelColor(iPoint, 6, b1, EdgeCol);
                        currentSec.a = MinusPixelColor(iPoint, 7, a1, EdgeCol);

                        if (!T4MSC.IsPointBrush(iPoint, CurrentLayer))
                        {
                            currentSec.g = (Mathf.Floor(currentSec.g) + EdgeCol);
                            if (T4MSC.ClearPerviousLayer)
                            {
                                current.r = MinusPixelColor(iPoint, 0, r, EdgeCol);
                                current.g = MinusPixelColor(iPoint, 1, g, EdgeCol);
                                current.b = MinusPixelColor(iPoint, 2, b, EdgeCol);
                                current.a = MinusPixelColor(iPoint, 3, a, EdgeCol);

                                currentSec.r = MinusPixelColor(iPoint, 4, r1, EdgeCol);
                            }
                        }
                    }
                    else if (T4MSC.T4MselTexture == 6)
                    {
                        currentSec.a = MinusPixelColor(iPoint, 7, a1, EdgeCol);

                        if (!T4MSC.IsPointBrush(iPoint, CurrentLayer))
                        {
                            currentSec.b = (Mathf.Floor(currentSec.b) + EdgeCol);
                            if (T4MSC.ClearPerviousLayer)
                            {
                                current.r = MinusPixelColor(iPoint, 0, r, EdgeCol);
                                current.g = MinusPixelColor(iPoint, 1, g, EdgeCol);
                                current.b = MinusPixelColor(iPoint, 2, b, EdgeCol);
                                current.a = MinusPixelColor(iPoint, 3, a, EdgeCol);

                                currentSec.r = MinusPixelColor(iPoint, 4, r1, EdgeCol);
                                currentSec.g = MinusPixelColor(iPoint, 5, g1, EdgeCol);
                            }
                        }
                    }
                    else if (T4MSC.T4MselTexture == 7)
                    {
                        if (!T4MSC.IsPointBrush(iPoint, CurrentLayer))
                        {
                            currentSec.a = (Mathf.Floor(currentSec.a) + EdgeCol);
                            if (T4MSC.ClearPerviousLayer)
                            {
                                current.r = MinusPixelColor(iPoint, 0, r, EdgeCol);
                                current.g = MinusPixelColor(iPoint, 1, g, EdgeCol);
                                current.b = MinusPixelColor(iPoint, 2, b, EdgeCol);
                                current.a = MinusPixelColor(iPoint, 3, a, EdgeCol);

                                currentSec.r = MinusPixelColor(iPoint, 4, r1, EdgeCol);
                                currentSec.g = MinusPixelColor(iPoint, 5, g1, EdgeCol);
                                currentSec.b = MinusPixelColor(iPoint, 6, g1, EdgeCol);
                            }
                        }
                    }

                    terrainBay[index]     = current / 255;
                    terrainBay_sec[index] = currentSec / 255;
                }

                T4MSC.SetBrushPoint(iPoint, CurrentLayer, true);
                if (T4MSC.ClearPerviousLayer)
                {
                    for (int idx = 0; idx < 8; idx++)
                    {
                        if (idx != CurrentLayer)
                        {
                            T4MSC.SetBrushPoint(iPoint, idx, false);
                        }
                    }
                }
                else
                {
                    for (int idx = CurrentLayer + 1; idx < 8; idx++)
                    {
                        T4MSC.SetBrushPoint(iPoint, idx, false);
                    }
                }
            }
        }
    }