Discuss Colors in D2D. Native D2D Colors and more.

Hexui Undetected CSGO Cheats PUBG Accounts

proton

Old.
Dank Tier Donator
Apr 20, 2020
21
288
0
How long you been coding/hacking?
On and off 10 Years
A note before we begin: I am not a pro, or even good at any of this; there is some information here that I personally did not know, and did not see anything about on the forum. This shit is super basic, but it helped me. Hopefully this can serve as a reference for people working with D2D.

I recently have been working on/using a pixel logger. The purpose of that specific project is to be able to log pixel colors, positions (static and relative) as well as output a log file in the form of a read-to-use header. Originally I made this up for a bot for a specific D3D9 game so I was using D3D9 (and it's color Macro) in my formatting.

That was all good but then I moved to an external console application and had to convert all my D3D9 colors to another format, easily done with CNTRL+H. Well now I'm working in D2D as well, and decided I want to build something that can cover all three, and instead of just having seperate files I wanted to use the same header for the whole project, there are a lot of colors that I store (~1400, though irrelevant).


So now I use D3DCOLOR_ARGB() for everything. I ignore the Alpha channel for my actual botting functions, but for my GUIS I can still utilize the alpha channel so it's included here.

Working with D2D is great because I can put a pretty little gui on top of everything and manage multiple other applications at once, so this has been my primary focus, however in certain cases it is beneficial to inject directly into D3D applications. This is the specific case that requires a conversion from D3DCOLOR_ARGB to ColorF (d2d).


First off, D2D::ColorF is just a macro to pass along parameters to _D3DCOLORVALUE, defined here:

D3DCOLORVALUE:
typedef struct _D3DCOLORVALUE {
    float r;
    float g;
    float b;
    float a;
} D3DCOLORVALUE;
When we look at ColorF itself we see it will take several different parameter configurations:

ColorF Definitions:
        ColorF(
            UINT32 rgb,
            FLOAT a = 1.0
            )
        {
            Init(rgb, a);
        }
   
        //...
     
        ColorF(
            Enum knownColor,
            FLOAT a = 1.0
            )
        {
            Init(knownColor, a);
        }
     
        //...
     
        ColorF(
            FLOAT red,
            FLOAT green,
            FLOAT blue,
            FLOAT alpha = 1.0 // note here default alpha
            )
        {
            r = red;
            g = green;
            b = blue;
            a = alpha;
        }
ColorF takes color values on a scale of 0 - 1, whereas all my colors are stored as 0 - 255 (and int vs. float)... however our 6 character hex representation of color (UINT32 rgb) may be compatible:

D3DCOLORS:
//What D3DCOLOR_ARGB looks like (in my code I use a structure like this to contain my colors and convert them as needed, so this serves as a good example)
D3DCOLOR_ARGB {
        int a;
        int r;
        int g;
        int b;
    };

//color format for D3D9 w/ alpha channel
[B]D3DCOLOR_ARGB aColor{ 255, 200, 132, 172 };[/B]
So since the easiest conversion is obviously the first of the 3 configurations shown above, I opted to convert them like this:

Convertion:
D2D1::ColorF colorCon_3d2d(D3DCOLOR_ARGB inputColor)
    {
        UINT32 rgb{ ((inputColor.r & 0xFF) << 16) | ((inputColor.g & 0xFF) << 8) | ((inputColor.b & 0xFF) << 0) };
        return {rgb,(float)(inputColor.a / 255),
        };
    }
We use bitwise operators to concatenate our int values into the UINT32, and we use 0xFF to force hex.
And for alpha we still are forces to cast our int value (with the scale of 0-255) to a float. When we do this, we essentially find a percentage by dividing by the maximum value (and then we do NOT multiply the result by 100 like we would if we wanted a percentage of 100). This is as good as saying, get the percentage and divide it by 100, to get a decimal between 0 and 1).

You can use this function for converting any other color to D2D as well, you just need to make sure *your parameters are in the correct order* (Edit: i didnt finish this sentence for some reason)

If you're looking for a simpler solution to colors in D2D, look back at the second configuration for the ColorF function, it can take an Enum as well, and they provide a pretty extensive pallette as seen here:
knownColor:
enum Enum

        { 
            AliceBlue = 0xF0F8FF,
            AntiqueWhite = 0xFAEBD7,
            Aqua = 0x00FFFF,
            Aquamarine = 0x7FFFD4,
            Azure = 0xF0FFFF,
            Beige = 0xF5F5DC,
            Bisque = 0xFFE4C4,
            Black = 0x000000,
            BlanchedAlmond = 0xFFEBCD,
            Blue = 0x0000FF,
            BlueViolet = 0x8A2BE2,
            Brown = 0xA52A2A,
            BurlyWood = 0xDEB887,
            CadetBlue = 0x5F9EA0,
            Chartreuse = 0x7FFF00,
            Chocolate = 0xD2691E,
            Coral = 0xFF7F50,
            CornflowerBlue = 0x6495ED,
            Cornsilk = 0xFFF8DC,
            Crimson = 0xDC143C,
            Cyan = 0x00FFFF,
            DarkBlue = 0x00008B,
            DarkCyan = 0x008B8B,
            DarkGoldenrod = 0xB8860B,
            DarkGray = 0xA9A9A9,
            DarkGreen = 0x006400,
            DarkKhaki = 0xBDB76B,
            DarkMagenta = 0x8B008B,
            DarkOliveGreen = 0x556B2F,
            DarkOrange = 0xFF8C00,
            DarkOrchid = 0x9932CC,
            DarkRed = 0x8B0000,
            DarkSalmon = 0xE9967A,
            DarkSeaGreen = 0x8FBC8F,
            DarkSlateBlue = 0x483D8B,
            DarkSlateGray = 0x2F4F4F,
            DarkTurquoise = 0x00CED1,
            DarkViolet = 0x9400D3,
            DeepPink = 0xFF1493,
            DeepSkyBlue = 0x00BFFF,
            DimGray = 0x696969,
            DodgerBlue = 0x1E90FF,
            Firebrick = 0xB22222,
            FloralWhite = 0xFFFAF0,
            ForestGreen = 0x228B22,
            Fuchsia = 0xFF00FF,
            Gainsboro = 0xDCDCDC,
            GhostWhite = 0xF8F8FF,
            Gold = 0xFFD700,
            Goldenrod = 0xDAA520,
            Gray = 0x808080,
            Green = 0x008000,
            GreenYellow = 0xADFF2F,
            Honeydew = 0xF0FFF0,
            HotPink = 0xFF69B4,
            IndianRed = 0xCD5C5C,
            Indigo = 0x4B0082,
            Ivory = 0xFFFFF0,
            Khaki = 0xF0E68C,
            Lavender = 0xE6E6FA,
            LavenderBlush = 0xFFF0F5,
            LawnGreen = 0x7CFC00,
            LemonChiffon = 0xFFFACD,
            LightBlue = 0xADD8E6,
            LightCoral = 0xF08080,
            LightCyan = 0xE0FFFF,
            LightGoldenrodYellow = 0xFAFAD2,
            LightGreen = 0x90EE90,
            LightGray = 0xD3D3D3,
            LightPink = 0xFFB6C1,
            LightSalmon = 0xFFA07A,
            LightSeaGreen = 0x20B2AA,
            LightSkyBlue = 0x87CEFA,
            LightSlateGray = 0x778899,
            LightSteelBlue = 0xB0C4DE,
            LightYellow = 0xFFFFE0,
            Lime = 0x00FF00,
            LimeGreen = 0x32CD32,
            Linen = 0xFAF0E6,
            Magenta = 0xFF00FF,
            Maroon = 0x800000,
            MediumAquamarine = 0x66CDAA,
            MediumBlue = 0x0000CD,
            MediumOrchid = 0xBA55D3,
            MediumPurple = 0x9370DB,
            MediumSeaGreen = 0x3CB371,
            MediumSlateBlue = 0x7B68EE,
            MediumSpringGreen = 0x00FA9A,
            MediumTurquoise = 0x48D1CC,
            MediumVioletRed = 0xC71585,
            MidnightBlue = 0x191970,
            MintCream = 0xF5FFFA,
            MistyRose = 0xFFE4E1,
            Moccasin = 0xFFE4B5,
            NavajoWhite = 0xFFDEAD,
            Navy = 0x000080,
            OldLace = 0xFDF5E6,
            Olive = 0x808000,
            OliveDrab = 0x6B8E23,
            Orange = 0xFFA500,
            OrangeRed = 0xFF4500,
            Orchid = 0xDA70D6,
            PaleGoldenrod = 0xEEE8AA,
            PaleGreen = 0x98FB98,
            PaleTurquoise = 0xAFEEEE,
            PaleVioletRed = 0xDB7093,
            PapayaWhip = 0xFFEFD5,
            PeachPuff = 0xFFDAB9,
            Peru = 0xCD853F,
            Pink = 0xFFC0CB,
            Plum = 0xDDA0DD,
            PowderBlue = 0xB0E0E6,
            Purple = 0x800080,
            Red = 0xFF0000,
            RosyBrown = 0xBC8F8F,
            RoyalBlue = 0x4169E1,
            SaddleBrown = 0x8B4513,
            Salmon = 0xFA8072,
            SandyBrown = 0xF4A460,
            SeaGreen = 0x2E8B57,
            SeaShell = 0xFFF5EE,
            Sienna = 0xA0522D,
            Silver = 0xC0C0C0,
            SkyBlue = 0x87CEEB,
            SlateBlue = 0x6A5ACD,
            SlateGray = 0x708090,
            Snow = 0xFFFAFA,
            SpringGreen = 0x00FF7F,
            SteelBlue = 0x4682B4,
            Tan = 0xD2B48C,
            Teal = 0x008080,
            Thistle = 0xD8BFD8,
            Tomato = 0xFF6347,
            Turquoise = 0x40E0D0,
            Violet = 0xEE82EE,
            Wheat = 0xF5DEB3,
            White = 0xFFFFFF,
            WhiteSmoke = 0xF5F5F5,
            Yellow = 0xFFFF00,
            YellowGreen = 0x9ACD32,
        };

A d2d overlay example from the forum: Source Code - Universal Direct2D Overlay For ESP & Menus

Another good resource to check out here: coltonon/D2DOverlay


p.s. not sure the best prefix for this thread, or if anyone cares. More of an explanation nobody asked for than anything.
 
Last edited:
  • Like
Reactions: Petko123 and Rake
Community Mods