Ticket #1029: VariableNames_Colour_to_Color_15728.diff

graphics/GameView.cpp

@@ -481 +481 @@
 
     CheckLightEnv();
 
-    m->Game->CachePlayerColours();
+    m->Game->CachePlayerColors();
 }
 
 void CGameView::Render()

graphics/LOSTexture.cpp

@@ -229 +257 @@
 
     glGenTextures(1, &m_Texture);
 
-    // Initialise texture with SoD colour, for the areas we don't
+    // Initialise texture with SoD color, for the areas we don't
     // overwrite with glTexSubImage2D later
     u8* texData = new u8[m_TextureSize * m_TextureSize * 4];
     memset(texData, 0x00, m_TextureSize * m_TextureSize * 4);

graphics/Model.cpp

@@ -666 +666 @@
         it->m_Model->SetPlayerID(id);
 }
 
-void CModel::SetShadingColor(const CColor& colour)
+void CModel::SetShadingColor(const CColor& color)
 {
-    CModelAbstract::SetShadingColor(colour);
+    CModelAbstract::SetShadingColor(color);
 
     for (std::vector<Prop>::iterator it = m_Props.begin(); it != m_Props.end(); ++it)
-        it->m_Model->SetShadingColor(colour);
+        it->m_Model->SetShadingColor(color);
 }

graphics/Model.h

@@ -103 +103 @@
     // set the model's player ID, recursively through props
     void SetPlayerID(player_id_t id);
     // set the models mod color
-    virtual void SetShadingColor(const CColor& colour);
+    virtual void SetShadingColor(const CColor& color);
     // get the model's material
     CMaterial& GetMaterial() { return m_Material; }
 

graphics/ModelAbstract.h

@@ -154 +154 @@
     // get the model's player ID; initial default is INVALID_PLAYER
     virtual player_id_t GetPlayerID() const { return m_PlayerID; }
 
-    virtual void SetShadingColor(const CColor& colour) { m_ShadingColor = colour; }
+    virtual void SetShadingColor(const CColor& color) { m_ShadingColor = color; }
     virtual CColor GetShadingColor() const { return m_ShadingColor; }
 
 protected:

graphics/ObjectEntry.cpp

@@ -73 +73 @@
         str << variation.color;
         int r, g, b;
         if (! (str >> r >> g >> b)) // Any trailing data is ignored
-            LOGERROR(L"Actor '%ls' has invalid RGB colour '%hs'", m_Base->m_ShortName.c_str(), variation.color.c_str());
+            LOGERROR(L"Actor '%ls' has invalid RGB color '%hs'", m_Base->m_ShortName.c_str(), variation.color.c_str());
         else
             m_Color = CColor(r/255.0f, g/255.0f, b/255.0f, 1.0f);
     }

graphics/ObjectEntry.h

@@ -55 +55 @@
     std::vector<CObjectBase::Samp> m_Samplers;
     // model name
     VfsPath m_ModelName;
-    // colour (used when doing alpha-channel colouring, but not doing player-colour)
+    // color (used when doing alpha-channel coloring, but not doing player-color)
     CColor m_Color;
-        // (probable TODO: make colour a per-model thing, rather than per-objectEntry,
-        // so we can have lots of colour variations without wasting memory on
+        // (probable TODO: make color a per-model thing, rather than per-objectEntry,
+        // so we can have lots of color variations without wasting memory on
         // lots of objectEntries)
 
     std::wstring m_ProjectileModelName;

graphics/ParticleEmitter.cpp

@@ -151 +151 @@
 
         SColor4ub color = m_Particles[i].color;
 
-        // Special case: If the blending depends on the source colour, not the source alpha,
+        // Special case: If the blending depends on the source color, not the source alpha,
         // then pre-multiply by the alpha. (This is kind of a hack.)
         if (m_Type->m_BlendFuncDst == GL_ONE_MINUS_SRC_COLOR)
         {

graphics/Terrain.cpp

@@ -41 +41 @@
 // CTerrain constructor
 CTerrain::CTerrain()
 : m_Heightmap(0), m_Patches(0), m_MapSize(0), m_MapSizePatches(0),
-m_BaseColour(255, 255, 255, 255)
+m_BaseColor(255, 255, 255, 255)
 {
 }
 

graphics/Terrain.h

@@ -147 +147 @@
      */
     CBoundingBoxAligned GetVertexesBound(ssize_t i0, ssize_t j0, ssize_t i1, ssize_t j1);
 
-    // get the base colour for the terrain (typically pure white - other colours
+    // get the base color for the terrain (typically pure white - other colors
     // will interact badly with LOS - but used by the Actor Viewer tool)
-    SColor4ub GetBaseColour() const { return m_BaseColour; }
-    // set the base colour for the terrain
-    void SetBaseColour(SColor4ub colour) { m_BaseColour = colour; }
+    SColor4ub GetBaseColor() const { return m_BaseColor; }
+    // set the base color for the terrain
+    void SetBaseColor(SColor4ub color) { m_BaseColor = color; }
 
     const CHeightMipmap& GetHeightMipmap() const { return m_HeightMipmap; }
 
@@ -169 +169 @@
     CPatch* m_Patches;
     // 16-bit heightmap data
     u16* m_Heightmap;
-    // base colour (usually white)
-    SColor4ub m_BaseColour;
+    // base color (usually white)
+    SColor4ub m_BaseColor;
     // heightmap mipmap
     CHeightMipmap m_HeightMipmap;
 };

graphics/TerrainTextureEntry.cpp

@@ -174 +174 @@
         (*it)->RemoveTerrain(this);
 }
 
-// BuildBaseColor: calculate the root colour of the texture, used for coloring minimap, and store
+// BuildBaseColor: calculate the root color of the texture, used for coloring minimap, and store
 // in m_BaseColor member
 void CTerrainTextureEntry::BuildBaseColor()
 {
@@ -186 +186 @@
         return;
     }
 
-    // Use the texture colour if available
+    // Use the texture color if available
     if (GetTexture()->TryLoad())
     {
-        m_BaseColor = GetTexture()->GetBaseColour();
+        m_BaseColor = GetTexture()->GetBaseColor();
         m_BaseColorValid = true;
     }
 }
@@ -362 +362 @@
     result.m_hCompositeAlphaMap = hCompositeAlphaMap;
     
     m_TerrainAlpha = it;
-}
- No newline at end of file
+}

graphics/TerritoryTexture.cpp

@@ -183 +183 @@
         CColor color(1, 0, 1, 1);
         CmpPtr<ICmpPlayer> cmpPlayer(m_Simulation, cmpPlayerManager->GetPlayerByID(p));
         if (cmpPlayer)
-            color = cmpPlayer->GetColour();
+            color = cmpPlayer->GetColor();
         colors.push_back(color);
     }
 

graphics/TextureConverter.h

@@ -52 +52 @@
  *
  * 'normal' is 'true' or 'false'.
  *
- * 'alpha' is 'transparency' or 'player' (it determines whether the colour value of
+ * 'alpha' is 'transparency' or 'player' (it determines whether the color value of
  * 0-alpha pixels is significant or not).
  *
  * 'filter' is 'box', 'triangle' or 'kaiser'.

graphics/TextureManager.cpp

@@ -189 +189 @@
         size_t flags = 0;
         (void)ogl_tex_get_format(h, &flags, NULL);
 
-        // Initialise base colour from the texture
-        (void)ogl_tex_get_average_colour(h, &texture->m_BaseColour);
+        // Initialise base color from the texture
+        (void)ogl_tex_get_average_color(h, &texture->m_BaseColor);
 
         // Set GL upload properties
         (void)ogl_tex_set_wrap(h, texture->m_Properties.m_WrapS, texture->m_Properties.m_WrapT);
@@ -516 +516 @@
 };
 
 CTexture::CTexture(Handle handle, const CTextureProperties& props, CTextureManagerImpl* textureManager) :
-    m_Handle(handle), m_BaseColour(0), m_State(UNLOADED), m_Properties(props), m_TextureManager(textureManager)
+    m_Handle(handle), m_BaseColor(0), m_State(UNLOADED), m_Properties(props), m_TextureManager(textureManager)
 {
     // Add a reference to the handle (it might be shared by multiple CTextures
     // so we can't take ownership of it)
@@ -613 +613 @@
     return (flags & TEX_ALPHA) != 0;
 }
 
-u32 CTexture::GetBaseColour() const
+u32 CTexture::GetBaseColor() const
 {
-    return m_BaseColour;
+    return m_BaseColor;
 }
 
 size_t CTexture::GetUploadedSize() const

graphics/TextureManager.h

@@ -237 +237 @@
      * average of the whole texture).
      * Returns 0 if the texture has no mipmaps.
      */
-    u32 GetBaseColour() const;
+    u32 GetBaseColor() const;
 
     /**
      * Returns total number of bytes uploaded for this texture.
@@ -287 +287 @@
     const CTextureProperties m_Properties;
 
     Handle m_Handle;
-    u32 m_BaseColour;
+    u32 m_BaseColor;
 
     enum {
         UNLOADED, // loading has not started

gui/CGUISprite.h

@@ -123 +123 @@
      */
     GLint           m_WrapMode;
 
-    // Visual effects (e.g. colour modulation)
+    // Visual effects (e.g. color modulation)
     SGUIImageEffects* m_Effects;
 
     // Color

gui/GUIRenderer.cpp

@@ -79 +79 @@
         //     "stretched:filename.ext" - stretched image
         //     "stretched:grayscale:filename.ext" - stretched grayscale image
         //     "cropped:(0.5, 0.25)"    - stretch this ratio (x,y) of the top left of the image
-        //     "colour:r g b a"         - solid colour
+        //     "color:r g b a"          - solid color
         //
         // and if so, try to create it as a new sprite.
         if (SpriteName.substr(0, 10) == "stretched:")
@@ -141 +141 @@
             CStrW value = wstring_from_utf8(SpriteName.substr(7));
             CColor color;
 
-            // Check colour is valid
+            // Check color is valid
             if (!GUI<CColor>::ParseString(value, color))
             {
-                LOGERROR(L"GUI: Error parsing sprite 'colour' (\"%ls\")", value.c_str());
+                LOGERROR(L"GUI: Error parsing sprite 'color' (\"%ls\")", value.c_str());
                 return;
             }
 

gui/scripting/JSInterface_IGUIObject.cpp

@@ -161 +161 @@
 
         case GUIST_CColor:
             {
-                CColor colour;
-                GUI<CColor>::GetSetting(e, propName, colour);
+                CColor color;
+                GUI<CColor>::GetSetting(e, propName, color);
                 JS::RootedObject obj(cx, pScriptInterface->CreateCustomObject("GUIColor"));
                 vp.setObject(*obj);
                 JS::RootedValue c(cx);
                 // Attempt to minimise ugliness through macrosity
-                #define P(x) c = JS::NumberValue(colour.x); \
+                #define P(x) c = JS::NumberValue(color.x); \
                 if (c.isNull()) \
                     return false; \
                 JS_SetProperty(cx, obj, #x, c.address())
@@ -528 +528 @@
             }
             else if (vp.isObject() && JS_InstanceOf(cx, &vp.toObject(), &JSI_GUIColor::JSI_class, NULL))
             {
-                CColor colour;
+                CColor color;
                 JS::RootedObject (cx, &vp.toObject());
                 JS::RootedValue t(cx);
                 double s;
                 #define PROP(x) JS_GetProperty(cx, obj, #x, t.address()); \
                                 s = t.toDouble(); \
-                                colour.x = (float)s
+                                color.x = (float)s
                 PROP(r); PROP(g); PROP(b); PROP(a);
                 #undef PROP
 
-                GUI<CColor>::SetSetting(e, propName, colour);
+                GUI<CColor>::SetSetting(e, propName, color);
             }
             else
             {

lib/res/graphics/ogl_tex.cpp

@@ -1039 +1039 @@
     return INFO::OK;
 }
 
-// retrieve colour of 1x1 mipmap level
-extern Status ogl_tex_get_average_colour(Handle ht, u32* p)
+// retrieve color of 1x1 mipmap level
+extern Status ogl_tex_get_average_color(Handle ht, u32* p)
 {
     H_DEREF(ht, OglTex, ot);
     warn_if_uploaded(ht, ot);
 
-    *p = ot->t.get_average_colour();
+    *p = ot->t.get_average_color();
     return INFO::OK;
 }
 

lib/res/graphics/ogl_tex.h

@@ -408 +408 @@
 
 /**
  * Retrieve ARGB value of 1x1 mipmap level of the texture,
- * i.e. the average colour of the whole texture.
+ * i.e. the average color of the whole texture.
  *
  * @param ht Texture handle
  * @param p will be filled with ARGB value (or 0 if texture does not have mipmaps)
@@ -416 +416 @@
  *
  * Must be called before uploading (raises a warning if called afterwards).
  */
-extern Status ogl_tex_get_average_colour(Handle ht, u32* p);
+extern Status ogl_tex_get_average_color(Handle ht, u32* p);
 
 
 //

lib/sysdep/os/win/wcursor.cpp

@@ -56 +56 @@
     // CreateBitmap; bpp/format must be checked against those of the DC.
     // this is the simplest way and we don't care about slight performance
     // differences because this is typically only called once.
-    HBITMAP hbmColour = CreateBitmap(w, h, 1, 32, bgra_img);
+    HBITMAP hbmColor = CreateBitmap(w, h, 1, 32, bgra_img);
 
     // CreateIconIndirect doesn't access this; we just need to pass
     // an empty bitmap.
@@ -69 +69 @@
     ii.xHotspot = (DWORD)hx;
     ii.yHotspot = (DWORD)hy;
     ii.hbmMask  = hbmMask;
-    ii.hbmColor = hbmColour;
+    ii.hbmColor = hbmColor;
     HICON hIcon = CreateIconIndirect(&ii);
 
     // CreateIconIndirect makes copies, so we no longer need these.
     DeleteObject(hbmMask);
-    DeleteObject(hbmColour);
+    DeleteObject(hbmColor);
 
     if(!wutil_IsValidHandle(hIcon))
         WARN_RETURN(ERR::FAIL);

lib/sysdep/os/win/wsdl.cpp

@@ -330 +330 @@
 static void video_SetPixelFormat(HDC hDC, int bpp)
 {
     const DWORD dwFlags = PFD_SUPPORT_OPENGL|PFD_DRAW_TO_WINDOW|PFD_DOUBLEBUFFER;
-    BYTE cColourBits = (BYTE)bpp;
+    BYTE cColorBits = (BYTE)bpp;
     BYTE cAlphaBits = 0;
     if(bpp == 32)
     {
-        cColourBits = 24;
+        cColorBits = 24;
         cAlphaBits = 8;
     }
     const BYTE cAccumBits   = 0;
@@ -348 +348 @@
         1,                              // version
         dwFlags,
         PFD_TYPE_RGBA,
-        cColourBits, 0, 0, 0, 0, 0, 0,  // c*Bits, c*Shift are unused
+        cColorBits, 0, 0, 0, 0, 0, 0,   // c*Bits, c*Shift are unused
         cAlphaBits, 0,                  // cAlphaShift is unused
         cAccumBits, 0, 0, 0, 0,         // cAccum*Bits are unused
         cDepthBits,

lib/tex/tex.cpp

@@ -637 +637 @@
     return p + m_Ofs;
 }
 
-// returns colour of 1x1 mipmap level
-u32 Tex::get_average_colour() const
+// returns color of 1x1 mipmap level
+u32 Tex::get_average_color() const
 {
     // require mipmaps
     if(!(m_Flags & TEX_MIPMAPS))

lib/tex/tex.h

@@ -337 +337 @@
      *
      * @return ARGB value (or 0 if texture does not have mipmaps)
      **/
-    u32 get_average_colour() const;
+    u32 get_average_color() const;
 
     /**
      * return total byte size of the image pixels. (including mipmaps!)

lib/tex/tex_bmp.cpp

@@ -94 +94 @@
 }
 
 
-// requirements: uncompressed, direct colour, bottom up
+// requirements: uncompressed, direct color, bottom up
 Status TexCodecBmp::decode(rpU8 data, size_t UNUSED(size), Tex* RESTRICT t) const
 {
     const BmpHeader* hdr = (const BmpHeader*)data;

lib/tex/tex_png.cpp

@@ -125 +125 @@
     // read header and determine format
     png_read_info(png_ptr, info_ptr);
     png_uint_32 w, h;
-    int bit_depth, colour_type;
-    png_get_IHDR(png_ptr, info_ptr, &w, &h, &bit_depth, &colour_type, 0, 0, 0);
+    int bit_depth, color_type;
+    png_get_IHDR(png_ptr, info_ptr, &w, &h, &bit_depth, &color_type, 0, 0, 0);
     const size_t pitch = png_get_rowbytes(png_ptr, info_ptr);
     const u32 bpp = (u32)(pitch/w * 8);
 
@@ -133 +133 @@
     size_t flags = 0;
     if(bpp == 32)
         flags |= TEX_ALPHA;
-    if(colour_type == PNG_COLOR_TYPE_GRAY)
+    if(color_type == PNG_COLOR_TYPE_GRAY)
         flags |= TEX_GREY;
 
     // make sure format is acceptable
     if(bit_depth != 8)
         WARN_RETURN(ERR::TEX_NOT_8BIT_PRECISION);
-    if(colour_type & PNG_COLOR_MASK_PALETTE)
+    if(color_type & PNG_COLOR_MASK_PALETTE)
         WARN_RETURN(ERR::TEX_INVALID_COLOR_TYPE);
 
     const size_t img_size = pitch * h;
@@ -165 +165 @@
     const png_uint_32 w = (png_uint_32)t->m_Width, h = (png_uint_32)t->m_Height;
     const size_t pitch = w * t->m_Bpp / 8;
 
-    int colour_type;
+    int color_type;
     switch(t->m_Flags & (TEX_GREY|TEX_ALPHA))
     {
     case TEX_GREY|TEX_ALPHA:
-        colour_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+        color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
         break;
     case TEX_GREY:
-        colour_type = PNG_COLOR_TYPE_GRAY;
+        color_type = PNG_COLOR_TYPE_GRAY;
         break;
     case TEX_ALPHA:
-        colour_type = PNG_COLOR_TYPE_RGB_ALPHA;
+        color_type = PNG_COLOR_TYPE_RGB_ALPHA;
         break;
     default:
-        colour_type = PNG_COLOR_TYPE_RGB;
+        color_type = PNG_COLOR_TYPE_RGB;
         break;
     }
 
     png_set_write_fn(png_ptr, da, io_write, io_flush);
-    png_set_IHDR(png_ptr, info_ptr, w, h, 8, colour_type,
+    png_set_IHDR(png_ptr, info_ptr, w, h, 8, color_type,
         PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 
     u8* data = t->get_data();

lib/tex/tex_tga.cpp

@@ -34 +34 @@
 
 enum TgaImgType
 {
-    TGA_TRUE_COLOUR = 2,    // uncompressed 24 or 32 bit direct RGB
-    TGA_GREY        = 3     // uncompressed 8 bit direct greyscale
+    TGA_TRUE_COLOR = 2, // uncompressed 24 or 32 bit direct RGB
+    TGA_GREY       = 3  // uncompressed 8 bit direct greyscale
 };
 
 enum TgaImgDesc
@@ -47 +47 @@
 typedef struct
 {
     u8 img_id_len;          // 0 - no image identifier present
-    u8 colour_map_type;     // 0 - no colour map present
+    u8 color_map_type;      // 0 - no color map present
     u8 img_type;            // see TgaImgType
-    u8 colour_map[5];       // unused
+    u8 color_map[5];        // unused
 
     u16 x_origin;           // unused
     u16 y_origin;           // unused
@@ -62 +62 @@
 }
 TgaHeader;
 
-// TGA file: header [img id] [colour map] image data
+// TGA file: header [img id] [color map] image data
 
 #pragma pack(pop)
 
@@ -79 +79 @@
 
     // the first TGA header doesn't have a magic field;
     // we can only check if the first 4 bytes are valid
-    // .. not direct colour
-    if(hdr->colour_map_type != 0)
+    // .. not direct color
+    if(hdr->color_map_type != 0)
         return false;
-    // .. wrong colour type (not uncompressed greyscale or RGB)
-    if(hdr->img_type != TGA_TRUE_COLOUR && hdr->img_type != TGA_GREY)
+    // .. wrong color type (not uncompressed greyscale or RGB)
+    if(hdr->img_type != TGA_TRUE_COLOR && hdr->img_type != TGA_GREY)
         return false;
 
-    // note: we can't check img_id_len or colour_map[0] - they are
+    // note: we can't check img_id_len or color_map[0] - they are
     // undefined and may assume any value.
 
     return true;
@@ -127 +127 @@
         flags |= TEX_ALPHA;
     if(bpp == 8)
         flags |= TEX_GREY;
-    if(type == TGA_TRUE_COLOUR)
+    if(type == TGA_TRUE_COLOR)
         flags |= TEX_BGR;
 
     // sanity checks
@@ -151 +151 @@
         img_desc |= TGA_TOP_DOWN;
     if(t->m_Bpp == 32)
         img_desc |= 8;  // size of alpha channel
-    TgaImgType img_type = (t->m_Flags & TEX_GREY)? TGA_GREY : TGA_TRUE_COLOUR;
+    TgaImgType img_type = (t->m_Flags & TEX_GREY)? TGA_GREY : TGA_TRUE_COLOR;
 
     size_t transforms = t->m_Flags;
     transforms &= ~TEX_ORIENTATION; // no flip needed - we can set top-down bit.
@@ -160 +160 @@
     const TgaHeader hdr =
     {
         0,              // no image identifier present
-        0,              // no colour map present
+        0,              // no color map present
         (u8)img_type,
-        {0,0,0,0,0},    // unused (colour map)
+        {0,0,0,0,0},    // unused (color map)
         0, 0,           // unused (origin)
         (u16)t->m_Width,
         (u16)t->m_Height,

ps/CConsole.cpp

@@ -340 +340 @@
         // Cursor character is chosen to be an underscore
         textRenderer.Put(0.0f, 0.0f, L"_");
 
-        // Revert to the standard text colour
+        // Revert to the standard text color
         textRenderer.Color(1.0f, 1.0f, 1.0f);
     }
 }

ps/Game.cpp

@@ -350 +350 @@
 
 static CColor BrokenColor(0.3f, 0.3f, 0.3f, 1.0f);
 
-void CGame::CachePlayerColours()
+void CGame::CachePlayerColors()
 {
-    m_PlayerColours.clear();
+    m_PlayerColors.clear();
 
     CmpPtr<ICmpPlayerManager> cmpPlayerManager(*m_Simulation2, SYSTEM_ENTITY);
     if (!cmpPlayerManager)
@@ -359 +359 @@
         return;
 
     int numPlayers = cmpPlayerManager->GetNumPlayers();
-    m_PlayerColours.resize(numPlayers);
+    m_PlayerColors.resize(numPlayers);
 
     for (int i = 0; i < numPlayers; ++i)
     {
         CmpPtr<ICmpPlayer> cmpPlayer(*m_Simulation2, cmpPlayerManager->GetPlayerByID(i));
         if (!cmpPlayer)
-            m_PlayerColours[i] = BrokenColor;
+            m_PlayerColors[i] = BrokenColor;
         else
-            m_PlayerColours[i] = cmpPlayer->GetColour();
+            m_PlayerColors[i] = cmpPlayer->GetColor();
     }
 }
 
 
-CColor CGame::GetPlayerColour(int player) const
+CColor CGame::GetPlayerColor(int player) const
 {
-    if (player < 0 || player >= (int)m_PlayerColours.size())
+    if (player < 0 || player >= (int)m_PlayerColors.size())
         return BrokenColor;
 
-    return m_PlayerColours[player];
+    return m_PlayerColors[player];
 }

ps/Game.h

@@ -93 +93 @@
     void SetPlayerID(int playerID);
 
     /**
-     * Retrieving player colours from scripts is slow, so this updates an
-     * internal cache of all players' colours.
+     * Retrieving player colors from scripts is slow, so this updates an
+     * internal cache of all players' colors.
      * Call this just before rendering, so it will always have the latest
-     * colours.
+     * colors.
      */
-    void CachePlayerColours();
+    void CachePlayerColors();
 
-    CColor GetPlayerColour(int player) const;
+    CColor GetPlayerColor(int player) const;
 
     /**
      * Get m_GameStarted.
@@ -166 +166 @@
     void RegisterInit(const JS::HandleValue attribs, const std::string& savedState);
     IReplayLogger* m_ReplayLogger;
 
-    std::vector<CColor> m_PlayerColours;
+    std::vector<CColor> m_PlayerColors;
 
     int LoadInitialState();
     std::string m_InitialSavedState; // valid between RegisterInit and LoadInitialState

renderer/OverlayRenderer.cpp

@@ -260 +260 @@
     PROFILE3("prepare overlays");
 
     // This is where we should do something like sort the overlays by
-    // colour/sprite/etc for more efficient rendering
+    // color/sprite/etc for more efficient rendering
 
     for (size_t i = 0; i < m->texlines.size(); ++i)
     {

renderer/PostprocManager.cpp

@@ -37 +37 @@
 #if !CONFIG2_GLES
 
 CPostprocManager::CPostprocManager()
-    : m_IsInitialised(false), m_PingFbo(0), m_PongFbo(0), m_PostProcEffect(L"default"), m_ColourTex1(0), m_ColourTex2(0), 
+    : m_IsInitialised(false), m_PingFbo(0), m_PongFbo(0), m_PostProcEffect(L"default"), m_ColorTex1(0), m_ColorTex2(0),
       m_DepthTex(0), m_BloomFbo(0), m_BlurTex2a(0), m_BlurTex2b(0), m_BlurTex4a(0), m_BlurTex4b(0),
       m_BlurTex8a(0), m_BlurTex8b(0), m_WhichBuffer(true)
 {
@@ -65 +65 @@
         if (m_BloomFbo) pglDeleteFramebuffersEXT(1, &m_BloomFbo);
         m_PingFbo = m_PongFbo = m_BloomFbo = 0;
         
-        if (m_ColourTex1) glDeleteTextures(1, &m_ColourTex1);
-        if (m_ColourTex2) glDeleteTextures(1, &m_ColourTex2);
+        if (m_ColorTex1) glDeleteTextures(1, &m_ColorTex1);
+        if (m_ColorTex2) glDeleteTextures(1, &m_ColorTex2);
         if (m_DepthTex) glDeleteTextures(1, &m_DepthTex);
-        m_ColourTex1 = m_ColourTex2 = m_DepthTex = 0;
+        m_ColorTex1 = m_ColorTex2 = m_DepthTex = 0;
         
         if (m_BlurTex2a) glDeleteTextures(1, &m_BlurTex2a);
         if (m_BlurTex2b) glDeleteTextures(1, &m_BlurTex2b);
@@ -98 +98 @@
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     
     // Two fullscreen ping-pong textures. 
-    GEN_BUFFER_RGBA(m_ColourTex1, m_Width, m_Height);
-    GEN_BUFFER_RGBA(m_ColourTex2, m_Width, m_Height);
+    GEN_BUFFER_RGBA(m_ColorTex1, m_Width, m_Height);
+    GEN_BUFFER_RGBA(m_ColorTex2, m_Width, m_Height);
     
     // Textures for several blur sizes. It would be possible to reuse
     // m_BlurTex2b, thus avoiding the need for m_BlurTex4b and m_BlurTex8b, though given
@@ -134 +134 @@
     
     pglGenFramebuffersEXT(1, &m_PingFbo);
     pglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_PingFbo);
-    pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_ColourTex1, 0);
+    pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_ColorTex1, 0);
     pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_DepthTex, 0);
     
     GLenum status = pglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
@@ -145 +145 @@
     
     pglGenFramebuffersEXT(1, &m_PongFbo);
     pglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_PongFbo);
-    pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_ColourTex2, 0);
+    pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_ColorTex2, 0);
     pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_DepthTex, 0);
     
     status = pglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
@@ -320 +320 @@
         ApplyBlurGauss(tex2, temptex, width, height); 
     
     // We do the same thing for each scale, incrementally adding more and more blur.
-    SCALE_AND_BLUR(m_WhichBuffer ? m_ColourTex1 : m_ColourTex2, m_BlurTex2a, m_BlurTex2b);
+    SCALE_AND_BLUR(m_WhichBuffer ? m_ColorTex1 : m_ColorTex2, m_BlurTex2a, m_BlurTex2b);
     SCALE_AND_BLUR(m_BlurTex2a, m_BlurTex4a, m_BlurTex4b);
     SCALE_AND_BLUR(m_BlurTex4a, m_BlurTex8a, m_BlurTex8b);
     
@@ -403 +403 @@
     // We also bind a bunch of other textures and parameters, but since
     // this only happens once per frame the overhead is negligible.
     if (m_WhichBuffer)
-        shader->BindTexture(str_renderedTex, m_ColourTex1);
+        shader->BindTexture(str_renderedTex, m_ColorTex1);
     else
-        shader->BindTexture(str_renderedTex, m_ColourTex2);
+        shader->BindTexture(str_renderedTex, m_ColorTex2);
     
     shader->BindTexture(str_depthTex, m_DepthTex);
     

renderer/PostprocManager.h

@@ -28 +28 @@
     // Two framebuffers, that we flip between at each shader pass.
     GLuint m_PingFbo, m_PongFbo;
     
-    // Unique colour textures for the framebuffers.
-    GLuint m_ColourTex1, m_ColourTex2;
+    // Unique color textures for the framebuffers.
+    GLuint m_ColorTex1, m_ColorTex2;
     
     // The framebuffers share a depth/stencil texture.
     GLuint m_DepthTex;
@@ -98 +98 @@
     // Matching setter that calls LoadEffect.
     void SetPostEffect(CStrW name);
 
-    // Clears the two colour buffers and depth buffer, and redirects all rendering
+    // Clears the two color buffers and depth buffer, and redirects all rendering
     // to our textures instead of directly to the system framebuffer. 
     void CaptureRenderOutput();
     

renderer/RenderModifiers.cpp

@@ -117 +117 @@
         shader->Uniform(m_BindingShadingColor, model->GetShadingColor());
 
     if (m_BindingPlayerColor.Active())
-        shader->Uniform(m_BindingPlayerColor, g_Game->GetPlayerColour(model->GetPlayerID()));
+        shader->Uniform(m_BindingPlayerColor, g_Game->GetPlayerColor(model->GetPlayerID()));
 }

renderer/Renderer.cpp

@@ -1318 +1318 @@
     // has to be done in a separate pass.
     // First we render all occluders into depth, then render all units with
     // inverted depth test so any behind an occluder will get drawn in a constant
-    // colour.
+    // color.
 
     float silhouetteAlpha = 0.75f;
 
@@ -1369 +1369 @@
     else
     {
         // Since we can't sort, we'll use the stencil buffer to ensure we only draw
-        // a pixel once (using the colour of whatever model happens to be drawn first).
+        // a pixel once (using the color of whatever model happens to be drawn first).
         glEnable(GL_BLEND);
         glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA);
         pglBlendColorEXT(0, 0, 0, silhouetteAlpha);

renderer/SilhouetteRenderer.cpp

@@ -55 +55 @@
 }
 
 /*
- * Silhouettes are the solid-coloured versions of units that are rendered when
+ * Silhouettes are the solid-colored versions of units that are rendered when
  * standing behind a building or terrain, so the player won't lose them.
  *
  * The rendering is done in CRenderer::RenderSilhouettes, by rendering the

renderer/TerrainOverlay.cpp

@@ -180 +180 @@
 #endif
 }
 
-void TerrainOverlay::RenderTile(const CColor& colour, bool draw_hidden)
+void TerrainOverlay::RenderTile(const CColor& color, bool draw_hidden)
 {
-    RenderTile(colour, draw_hidden, m_i, m_j);
+    RenderTile(color, draw_hidden, m_i, m_j);
 }
 
-void TerrainOverlay::RenderTile(const CColor& colour, bool draw_hidden, ssize_t i, ssize_t j)
+void TerrainOverlay::RenderTile(const CColor& color, bool draw_hidden, ssize_t i, ssize_t j)
 {
     // TODO: if this is unpleasantly slow, make it much more efficient
     // (e.g. buffering data and making a single draw call? or at least
@@ -210 +210 @@
 
     CVector3D pos;
     glBegin(GL_TRIANGLES);
-        glColor4fv(colour.FloatArray());
+        glColor4fv(color.FloatArray());
         if (m_Terrain->GetTriangulationDir(i, j))
         {
             m_Terrain->CalcPosition(i,   j,   pos); glVertex3fv(pos.GetFloatArray());
@@ -236 +236 @@
 #endif
 }
 
-void TerrainOverlay::RenderTileOutline(const CColor& colour, int line_width, bool draw_hidden)
+void TerrainOverlay::RenderTileOutline(const CColor& color, int line_width, bool draw_hidden)
 {
-    RenderTileOutline(colour, line_width, draw_hidden, m_i, m_j);
+    RenderTileOutline(color, line_width, draw_hidden, m_i, m_j);
 }
 
-void TerrainOverlay::RenderTileOutline(const CColor& colour, int line_width, bool draw_hidden, ssize_t i, ssize_t j)
+void TerrainOverlay::RenderTileOutline(const CColor& color, int line_width, bool draw_hidden, ssize_t i, ssize_t j)
 {
     if (draw_hidden)
     {
@@ -265 +265 @@
 
     CVector3D pos;
     glBegin(GL_QUADS);
-        glColor4fv(colour.FloatArray());
+        glColor4fv(color.FloatArray());
         m_Terrain->CalcPosition(i,   j,   pos); glVertex3fv(pos.GetFloatArray());
         m_Terrain->CalcPosition(i+1, j,   pos); glVertex3fv(pos.GetFloatArray());
         m_Terrain->CalcPosition(i+1, j+1, pos); glVertex3fv(pos.GetFloatArray());

renderer/TerrainOverlay.h

@@ -128 +128 @@
     /**
      * Draw a filled quad on top of the current tile.
      *
-     * @param colour  colour to draw. May be transparent (alpha < 1)
+     * @param color  color to draw. May be transparent (alpha < 1)
      * @param draw_hidden  true if hidden tiles (i.e. those behind other tiles)
      * should be drawn
      */
-    void RenderTile(const CColor& colour, bool draw_hidden);
+    void RenderTile(const CColor& color, bool draw_hidden);
 
     /**
      * Draw a filled quad on top of the given tile.
      */
-    void RenderTile(const CColor& colour, bool draw_hidden, ssize_t i, ssize_t j);
+    void RenderTile(const CColor& color, bool draw_hidden, ssize_t i, ssize_t j);
 
     /**
      * Draw an outlined quad on top of the current tile.
      *
-     * @param colour  colour to draw. May be transparent (alpha < 1)
+     * @param color  color to draw. May be transparent (alpha < 1)
      * @param line_width  width of lines in pixels. 1 is a sensible value
      * @param draw_hidden  true if hidden tiles (i.e. those behind other tiles)
      * should be drawn
      */
-    void RenderTileOutline(const CColor& colour, int line_width, bool draw_hidden);
+    void RenderTileOutline(const CColor& color, int line_width, bool draw_hidden);
 
     /**
      * Draw an outlined quad on top of the given tile.
      */
-    void RenderTileOutline(const CColor& colour, int line_width, bool draw_hidden, ssize_t i, ssize_t j);
+    void RenderTileOutline(const CColor& color, int line_width, bool draw_hidden, ssize_t i, ssize_t j);
     
 private:
     // Process all tiles

renderer/TerrainRenderer.cpp

@@ -281 +281 @@
     const CLightEnv& lightEnv = g_Renderer.GetLightEnv();
 
     pglClientActiveTextureARB(GL_TEXTURE0);
-    glEnableClientState(GL_COLOR_ARRAY); // diffuse lighting colours
+    glEnableClientState(GL_COLOR_ARRAY); // diffuse lighting colors
 
     // The vertex color is scaled by 0.5 to permit overbrightness without clamping.
     // We therefore need to draw clamp((texture*lighting)*2.0), where 'texture'

tools/atlas/AtlasUI/ActorEditor/ActorEditorListCtrl.cpp

@@ -30 +30 @@
     : DraggableListCtrl(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize,
         wxLC_REPORT | wxLC_HRULES | wxLC_VRULES | wxLC_SINGLE_SEL)
 {
-    // Set colours for row backgrounds (which vary depending on what columns
+    // Set colors for row backgrounds (which vary depending on what columns
     // have some data)
-    #define COLOUR(name, c0, c1) \
-    m_ListItemAttr_##name[0].SetBackgroundColour(wxColour c0); \
-    m_ListItemAttr_##name[1].SetBackgroundColour(wxColour c1)
+    #define COLOR(name, c0, c1) \
+    m_ListItemAttr_##name[0].SetBackgroundColor(wxColor c0); \
+    m_ListItemAttr_##name[1].SetBackgroundColor(wxColor c1)
     
     const int f=0xFF, e=0xEE, c=0xCC;
-    COLOUR(Model,   (f,f,e), (f,f,c));
-    COLOUR(Texture, (f,e,e), (f,c,c));
-    COLOUR(Anim,    (e,f,e), (c,f,c));
-    COLOUR(Prop,    (e,e,f), (c,c,f));
-    COLOUR(Colour,  (f,e,f), (f,c,f));
-    COLOUR(None,    (f,f,f), (f,f,f));
+    COLOR(Model,   (f,f,e), (f,f,c));
+    COLOR(Texture, (f,e,e), (f,c,c));
+    COLOR(Anim,    (e,f,e), (c,f,c));
+    COLOR(Prop,    (e,e,f), (c,c,f));
+    COLOR(Colour,  (f,e,f), (f,c,f));
+    COLOR(None,    (f,f,f), (f,f,f));
 
-    #undef COLOUR
+    #undef COLOR
 
     AddColumnType(_("Variant"),     90,  "@name",       new FieldEditCtrl_Text());
     AddColumnType(_("Ratio"),       50,  "@frequency",  new FieldEditCtrl_Text());
@@ -52 +52 @@
     AddColumnType(_("Textures"),        250, "textures",    new FieldEditCtrl_Dialog(&TexListEditor::Create));
     AddColumnType(_("Animations"),      250, "animations",  new FieldEditCtrl_Dialog(&AnimListEditor::Create));
     AddColumnType(_("Props"),       220, "props",       new FieldEditCtrl_Dialog(&PropListEditor::Create));
-    AddColumnType(_("Colour"),      80,  "colour",      new FieldEditCtrl_Colour());
+    AddColumnType(_("Colour"),      80,  "colour",      new FieldEditCtrl_Color());
 }
 
 void ActorEditorListCtrl::DoImport(AtObj& in)
@@ -104 +104 @@
     {
         AtObj row (m_ListData[item]);
 
-        // Colour-code the row, depending on the first non-empty column,
+        // Color-code the row, depending on the first non-empty column,
         // and also alternate between light/dark.
 
         if (row["mesh"].hasContent())
@@ -116 +116 @@
         else if (row["props"].hasContent())
             return const_cast<wxListItemAttr*>(&m_ListItemAttr_Prop[item%2]);
         else if (row["colour"].hasContent())
-            return const_cast<wxListItemAttr*>(&m_ListItemAttr_Colour[item%2]);
+            return const_cast<wxListItemAttr*>(&m_ListItemAttr_Color[item%2]);
     }
 
     return const_cast<wxListItemAttr*>(&m_ListItemAttr_None[item%2]);

tools/atlas/AtlasUI/CustomControls/ColorDialog/ColorDialog.cpp

@@ -20 +20 @@
 #include "wx/regex.h"
 #include "wx/config.h"
 
-#include "ColourDialog.h"
+#include "ColorDialog.h"
 
-ColourDialog::ColourDialog(wxWindow* parent, const wxString& customColourConfigPath, const wxColour& defaultColour)
-: wxColourDialog(parent), m_ConfigPath(customColourConfigPath)
+ColorDialog::ColorDialog(wxWindow* parent, const wxString& customColorConfigPath, const wxColour& defaultColor)
+: wxColourDialog(parent), m_ConfigPath(customColorConfigPath)
 {
-    GetColourData().SetColour(defaultColour);
+    GetColourData().SetColour(defaultColor);
 
-    // Load custom colours from the config database
+    // Load custom colors from the config database
 
     wxRegEx re (_T("([0-9]+) ([0-9]+) ([0-9]+)"), wxRE_EXTENDED);
 
@@ -36 +36 @@
     {
         for (int i = 0; i < 16; ++i)
         {
-            wxString customColour;
-            if (cfg->Read(wxString::Format(_T("%s%d"), m_ConfigPath.c_str(), i), &customColour)
-                && re.Matches(customColour))
+            wxString customColor;
+            if (cfg->Read(wxString::Format(_T("%s%d"), m_ConfigPath.c_str(), i), &customColor)
+                && re.Matches(customColor))
             {
                 long r, g, b;
-                re.GetMatch(customColour, 1).ToLong(&r);
-                re.GetMatch(customColour, 2).ToLong(&g);
-                re.GetMatch(customColour, 3).ToLong(&b);
+                re.GetMatch(customColor, 1).ToLong(&r);
+                re.GetMatch(customColor, 2).ToLong(&g);
+                re.GetMatch(customColor, 3).ToLong(&b);
                 GetColourData().SetCustomColour(i, wxColour(r, g, b));
             }
         }
@@ -50 +50 @@
     }
 }
 
-int ColourDialog::ShowModal()
+int ColorDialog::ShowModal()
 {
     int ret = wxColourDialog::ShowModal();
     if (ret == wxID_OK)
     {
-        // Save all the custom colours back into the config database
+        // Save all the custom colors back into the config database
 
         wxConfigBase* cfg = wxConfigBase::Get(false);
         if (cfg)
@@ -63 +63 @@
             for (int i = 0; i < 16; ++i)
             {
                 wxString name = wxString::Format(_T("%s%d"), m_ConfigPath.c_str(), i);
-                wxColour colour = GetColourData().GetCustomColour(i);
+                wxColour color = GetColourData().GetCustomColour(i);
 
-                wxString customColour = wxString::Format(_T("%d %d %d"), colour.Red(), colour.Green(), colour.Blue());
-                cfg->Write(name, customColour);
+                wxString customColor = wxString::Format(_T("%d %d %d"), color.Red(), color.Green(), color.Blue());
+                cfg->Write(name, customColor);
             }
         }
     }

tools/atlas/AtlasUI/CustomControls/ColorDialog/ColorDialog.h

@@ -15 +15 @@
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef INCLUDED_COLOURDIALOG
-#define INCLUDED_COLOURDIALOG
+#ifndef INCLUDED_COLORDIALOG
+#define INCLUDED_COLORDIALOG
 
 #include <wx/colordlg.h>
 
-class ColourDialog : public wxColourDialog
+class ColorDialog : public wxColourDialog
 {
 public:
-    // Typical customColourConfigPath would be "Scenario Editor/LightingColour"
-    ColourDialog(wxWindow* parent, const wxString& customColourConfigPath, const wxColour& defaultColour);
+    // A typical customColorConfigPath would be "Scenario Editor/LightingColor"
+    ColorDialog(wxWindow* parent, const wxString& customColorConfigPath, const wxColour& defaultColor);
 
     int ShowModal();
 
@@ -32 +32 @@
     wxString m_ConfigPath;
 };
 
-#endif // INCLUDED_COLOURDIALOG
+#endif // INCLUDED_COLORDIALOG

tools/atlas/AtlasUI/CustomControls/ColourDialog/ColourDialog.cpp

@@ -1 @@
-/* Copyright (C) 2009 Wildfire Games.
- * This file is part of 0 A.D.
- *
- * 0 A.D. is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0 A.D. is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "precompiled.h"
-
-#include "wx/regex.h"
-#include "wx/config.h"
-
-#include "ColourDialog.h"
-
-ColourDialog::ColourDialog(wxWindow* parent, const wxString& customColourConfigPath, const wxColour& defaultColour)
-: wxColourDialog(parent), m_ConfigPath(customColourConfigPath)
-{
-    GetColourData().SetColour(defaultColour);
-
-    // Load custom colours from the config database
-
-    wxRegEx re (_T("([0-9]+) ([0-9]+) ([0-9]+)"), wxRE_EXTENDED);
-
-    wxConfigBase* cfg = wxConfigBase::Get(false);
-    if (cfg)
-    {
-        for (int i = 0; i < 16; ++i)
-        {
-            wxString customColour;
-            if (cfg->Read(wxString::Format(_T("%s%d"), m_ConfigPath.c_str(), i), &customColour)
-                && re.Matches(customColour))
-            {
-                long r, g, b;
-                re.GetMatch(customColour, 1).ToLong(&r);
-                re.GetMatch(customColour, 2).ToLong(&g);
-                re.GetMatch(customColour, 3).ToLong(&b);
-                GetColourData().SetCustomColour(i, wxColour(r, g, b));
-            }
-        }
-    }
-}
-
-int ColourDialog::ShowModal()
-{
-    int ret = wxColourDialog::ShowModal();
-    if (ret == wxID_OK)
-    {
-        // Save all the custom colours back into the config database
-
-        wxConfigBase* cfg = wxConfigBase::Get(false);
-        if (cfg)
-        {
-            for (int i = 0; i < 16; ++i)
-            {
-                wxString name = wxString::Format(_T("%s%d"), m_ConfigPath.c_str(), i);
-                wxColour colour = GetColourData().GetCustomColour(i);
-
-                wxString customColour = wxString::Format(_T("%d %d %d"), colour.Red(), colour.Green(), colour.Blue());
-                cfg->Write(name, customColour);
-            }
-        }
-    }
-
-    return ret;
-}

tools/atlas/AtlasUI/CustomControls/ColourDialog/ColourDialog.h

@@ -1 @@
-/* Copyright (C) 2009 Wildfire Games.
- * This file is part of 0 A.D.
- *
- * 0 A.D. is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0 A.D. is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef INCLUDED_COLOURDIALOG
-#define INCLUDED_COLOURDIALOG
-
-#include <wx/colordlg.h>
-
-class ColourDialog : public wxColourDialog
-{
-public:
-    // Typical customColourConfigPath would be "Scenario Editor/LightingColour"
-    ColourDialog(wxWindow* parent, const wxString& customColourConfigPath, const wxColour& defaultColour);
-
-    int ShowModal();
-
-private:
-    wxString m_ConfigPath;
-};
-
-#endif // INCLUDED_COLOURDIALOG

tools/atlas/AtlasUI/CustomControls/EditableListCtrl/EditableListCtrl.cpp

@@ -37 +37 @@
                                    const wxString& name)
     : wxListCtrl(parent, id, pos, size, style | wxLC_VIRTUAL, validator, name)
 {
-    m_ListItemAttr[0].SetBackgroundColour(wxColour(0xff, 0xff, 0xff));
-    m_ListItemAttr[1].SetBackgroundColour(wxColour(0xee, 0xee, 0xee));
+    m_ListItemAttr[0].SetBackgroundColor(wxColor(0xff, 0xff, 0xff));
+    m_ListItemAttr[1].SetBackgroundColor(wxColor(0xee, 0xee, 0xee));
 
     wxASSERT_MSG(style & wxLC_REPORT, _T("EditableListCtrl must be LC_REPORT"));
     UpdateDisplay();
@@ -277 +277 @@
     if (item >= (long)m_ListData.size())
         return const_cast<wxListItemAttr*>(&m_ListItemAttr[0]);
 
-    // Make the background colours of rows alternate
+    // Make the background colors of rows alternate
     else
         return const_cast<wxListItemAttr*>(&m_ListItemAttr[item%2]);
 }

tools/atlas/AtlasUI/CustomControls/EditableListCtrl/EditableListCtrl.h

@@ -108 +108 @@
 
     bool IsRowBlank(int n);
 
-    wxListItemAttr m_ListItemAttr[2]; // standard+alternate colours
+    wxListItemAttr m_ListItemAttr[2]; // standard+alternate colors
 
     DECLARE_EVENT_TABLE();
 };

tools/atlas/AtlasUI/ScenarioEditor/Sections/Environment/Environment.cpp

@@ -157 +157 @@
     void OnClick(wxCommandEvent& WXUNUSED(evt))
     {
         ColourDialog dlg (this, _T("Scenario Editor/LightingColour"),
-            wxColour(m_Colour->r, m_Colour->g, m_Colour->b));
+            wxColor(m_Color->r, m_Color->g, m_Color->b));
 
         if (dlg.ShowModal() == wxID_OK)
         {
-            wxColour& c = dlg.GetColourData().GetColour();
-            m_Colour = AtlasMessage::Colour(c.Red(), c.Green(), c.Blue());
+            wxColor& c = dlg.GetColourData().GetColour();
+            m_Color = AtlasMessage::Color(c.Red(), c.Green(), c.Blue());
             UpdateButton();
 
             g_EnvironmentSettings.NotifyObserversExcept(m_Conn);
@@ -171 +171 @@
 
     void UpdateButton()
     {
-        m_Button->SetBackgroundColour(wxColour(m_Colour->r, m_Colour->g, m_Colour->b));
+        m_Button->SetBackgroundColor(wxColor(m_Color->r, m_Color->g, m_Color->b));
         m_Button->SetLabel(wxString::Format(_T("%02X %02X %02X"), m_Colour->r, m_Colour->g, m_Colour->b));
 
         int y = 3*m_Colour->r + 6*m_Colour->g + 1*m_Colour->b;

tools/atlas/AtlasUI/ScenarioEditor/Sections/Player/Player.cpp

@@ -33 +33 @@
     ID_PlayerMetal,
     ID_PlayerStone,
     ID_PlayerPop,
-    ID_PlayerColour,
+    ID_PlayerColor,
 
     ID_DefaultName,
     ID_DefaultCiv,
-    ID_DefaultColour,
+    ID_DefaultColor,
     ID_DefaultAI,
     ID_DefaultFood,
     ID_DefaultWood,
@@ -130 +130 @@
             gridSizer->Add(civChoice, wxSizerFlags(1).Expand().Align(wxALIGN_RIGHT));
             m_Controls.civ = civChoice;
 
-            wxButton* colourButton = new wxButton(this, ID_PlayerColour);
-            gridSizer->Add(new DefaultCheckbox(this, ID_DefaultColour, colourButton), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL));
+            wxButton* colorButton = new wxButton(this, ID_PlayerColor);
+            gridSizer->Add(new DefaultCheckbox(this, ID_DefaultColor, colorButton), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL));
             gridSizer->Add(new wxStaticText(this, wxID_ANY, _("Colour")), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT));
-            gridSizer->Add(Tooltipped(colourButton,
+            gridSizer->Add(Tooltipped(colorButton,
                 _("Set player colour")), wxSizerFlags(1).Expand().Align(wxALIGN_RIGHT));
-            m_Controls.colour = colourButton;
+            m_Controls.color = colorButton;
 
             wxChoice* aiChoice = new wxChoice(this, wxID_ANY);
             gridSizer->Add(new DefaultCheckbox(this, ID_DefaultAI, aiChoice), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL));

tools/atlas/AtlasUI/ScenarioEditor/Sections/Player/Player.h

@@ -54 +54 @@
 
     wxTextCtrl* name;
     wxChoice* civ;
-    wxButton* colour;
+    wxButton* color;
     wxSpinCtrl* food;
     wxSpinCtrl* wood;
     wxSpinCtrl* stone;

tools/atlas/AtlasUI/ScenarioEditor/Sections/Terrain/Terrain.cpp

@@ -326 +326 @@
     {
         m_ScrolledPanel = new wxScrolledWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxVSCROLL);
         m_ScrolledPanel->SetScrollRate(0, 10);
-        m_ScrolledPanel->SetBackgroundColour(wxColour(255, 255, 255));
+        m_ScrolledPanel->SetBackgroundColor(wxColor(255, 255, 255));
 
         wxSizer* sizer = new wxBoxSizer(wxVERTICAL);
         sizer->Add(m_ScrolledPanel, wxSizerFlags().Proportion(1).Expand());
@@ -418 +418 @@
         g_SelectedTexture.NotifyObservers();
 
         if (m_LastTerrainSelection)
-            m_LastTerrainSelection->SetBackgroundColour(wxNullColour);
+            m_LastTerrainSelection->SetBackgroundColor(wxNullColor);
 
-        button->SetBackgroundColour(wxColour(255, 255, 0));
+        button->SetBackgroundColor(wxColor(255, 255, 0));
         m_LastTerrainSelection = button;
 
         // Slight hack: Default to Paint mode because that's probably what the user wanted
@@ -449 +449 @@
     wxString m_Name;
     wxScrolledWindow* m_ScrolledPanel;
     wxGridSizer* m_ItemSizer;
-    wxButton* m_LastTerrainSelection; // button that was last selected, so we can undo its colouring
+    wxButton* m_LastTerrainSelection; // button that was last selected, so we can undo its coloring
 
     DECLARE_EVENT_TABLE();
 };

tools/atlas/GameInterface/ActorViewer.cpp

@@ -440 +440 @@
     m.CurrentUnitAnim = animation;
 }
 
-void ActorViewer::SetBackgroundColour(const SColor4ub& colour)
+void ActorViewer::SetBackgroundColor(const SColor4ub& color)
 {
-    m.Background = colour;
-    m.Terrain.SetBaseColour(colour);
+    m.Background = color;
+    m.Terrain.SetBaseColor(color);
 }
 
 void ActorViewer::SetWalkEnabled(bool enabled)    { m.WalkEnabled = enabled; }

tools/atlas/GameInterface/ActorViewer.h

@@ -37 +37 @@
     entity_id_t GetEntity();
     void SetActor(const CStrW& id, const CStrW& animation, player_id_t playerID);
     void UnloadObjects();
-    void SetBackgroundColour(const SColor4ub& colour);
+    void SetBackgroundColor(const SColor4ub& color);
     void SetWalkEnabled(bool enabled);
     void SetGroundEnabled(bool enabled);
     void SetWaterEnabled(bool enabled);

tools/atlas/GameInterface/Brushes.cpp

@@ -56 +56 @@
     {
         ssize_t i0, j0;
         m_Brush->GetBottomLeft(i0, j0);
-        // Colour this tile based on the average of the surrounding vertices
+        // Color this tile based on the average of the surrounding vertices
         float avg = (
             m_Brush->Get(i-i0, j-j0)   + m_Brush->Get(i-i0+1, j-j0) +
             m_Brush->Get(i-i0, j-j0+1) + m_Brush->Get(i-i0+1, j-j0+1)

tools/atlas/GameInterface/Handlers/EnvironmentHandlers.cpp

@@ -49 +49 @@
     s.watermurkiness = wm->m_Murkiness;
     s.windangle = wm->m_WindAngle;
 
-    // CColor colours
-#define COLOUR(A, B) A = Colour((int)(B.r*255), (int)(B.g*255), (int)(B.b*255))
-    COLOUR(s.watercolour, wm->m_WaterColor);
-    COLOUR(s.watertint, wm->m_WaterTint);
-#undef COLOUR
+    // CColor colors
+#define COLOR(A, B) A = Color((int)(B.r*255), (int)(B.g*255), (int)(B.b*255))
+    COLOR(s.watercolor, wm->m_WaterColor);
+    COLOR(s.watertint, wm->m_WaterTint);
+#undef COLOR
 
     float sunrotation = g_LightEnv.GetRotation();
     if (sunrotation > (float)M_PI)
@@ -73 +73 @@
     s.saturation = g_LightEnv.m_Saturation;
     s.bloom = g_LightEnv.m_Bloom;
 
-    // RGBColor (CVector3D) colours
-#define COLOUR(A, B) A = Colour((int)(B.X*255), (int)(B.Y*255), (int)(B.Z*255))
+    // RGBColor (CVector3D) colors
+#define COLOR(A, B) A = Color((int)(B.X*255), (int)(B.Y*255), (int)(B.Z*255))
     s.sunoverbrightness = MaxComponent(g_LightEnv.m_SunColor);
     // clamp color to [0..1] before packing into u8 triplet
     if(s.sunoverbrightness > 1.0f)
@@ -82 +82 @@
     // no component was above 1.0, so reset scale factor (don't want to darken)
     else
         s.sunoverbrightness = 1.0f;
-    COLOUR(s.suncolour, g_LightEnv.m_SunColor);
-    COLOUR(s.terraincolour, g_LightEnv.m_TerrainAmbientColor);
-    COLOUR(s.unitcolour, g_LightEnv.m_UnitsAmbientColor);
-    COLOUR(s.fogcolour, g_LightEnv.m_FogColor);
-#undef COLOUR
+    COLOR(s.suncolor, g_LightEnv.m_SunColor);
+    COLOR(s.terraincolor, g_LightEnv.m_TerrainAmbientColor);
+    COLOR(s.unitcolor, g_LightEnv.m_UnitsAmbientColor);
+    COLOR(s.fogcolor, g_LightEnv.m_FogColor);
+#undef COLOR
 
     return s;
 }
@@ -104 +104 @@
     wm->m_WindAngle = s.windangle;
     wm->m_WaterType = s.watertype._Unwrap();
     
-#define COLOUR(A, B) B = CColor(A->r/255.f, A->g/255.f, A->b/255.f, 1.f)
-    COLOUR(s.watercolour, wm->m_WaterColor);
-    COLOUR(s.watertint, wm->m_WaterTint);
-#undef COLOUR
+#define COLOR(A, B) B = CColor(A->r/255.f, A->g/255.f, A->b/255.f, 1.f)
+    COLOR(s.watercolor, wm->m_WaterColor);
+    COLOR(s.watertint, wm->m_WaterTint);
+#undef COLOR
 
     g_LightEnv.SetRotation(s.sunrotation);
     g_LightEnv.SetElevation(s.sunelevation);
@@ -130 +130 @@
     g_LightEnv.m_Saturation = s.saturation;
     g_LightEnv.m_Bloom = s.bloom;
 
-#define COLOUR(A, B) B = RGBColor(A->r/255.f, A->g/255.f, A->b/255.f)
-    COLOUR(s.suncolour, g_LightEnv.m_SunColor);
+#define COLOR(A, B) B = RGBColor(A->r/255.f, A->g/255.f, A->b/255.f)
+    COLOR(s.suncolor, g_LightEnv.m_SunColor);
     g_LightEnv.m_SunColor *= s.sunoverbrightness;
-    COLOUR(s.terraincolour, g_LightEnv.m_TerrainAmbientColor);
-    COLOUR(s.unitcolour, g_LightEnv.m_UnitsAmbientColor);
-    COLOUR(s.fogcolour, g_LightEnv.m_FogColor);
-#undef COLOUR
+    COLOR(s.terraincolor, g_LightEnv.m_TerrainAmbientColor);
+    COLOR(s.unitcolor, g_LightEnv.m_UnitsAmbientColor);
+    COLOR(s.fogcolor, g_LightEnv.m_FogColor);
+#undef COLOR
 }
 
 BEGIN_COMMAND(SetEnvironmentSettings)

tools/atlas/GameInterface/Handlers/MapHandlers.cpp

@@ -231 +231 @@
         {
             int offset = y * mapLineSkip + x * bytesPP;
             
-            // pick colour channel with highest value
+            // pick color channel with highest value
             u16 value = std::max(mapdata[offset+bytesPP*2], std::max(mapdata[offset], mapdata[offset+bytesPP]));
             
             heightmap[(terrainSize-y-1) * hmSize + x] = clamp(value * 256, 0, 65535);

tools/atlas/GameInterface/Handlers/ObjectHandlers.cpp

@@ -101 +101 @@
 // Helper function to find color of player owning the given entity,
 //  returns white if entity has no owner. Uses caching to avoid
 //  expensive script calls.
-static CColor GetOwnerPlayerColor(PlayerColorMap& colourMap, entity_id_t id)
+static CColor GetOwnerPlayerColor(PlayerColorMap& colorMap, entity_id_t id)
 {
     // Default color - white
     CColor color(1.0f, 1.0f, 1.0f, 1.0f);
@@ -111 +111 @@
     if (cmpOwnership)
     {
         player_id_t owner = cmpOwnership->GetOwner();
-        if (colourMap.find(owner) != colourMap.end())
-            return colourMap[owner];
+        if (colorMap.find(owner) != colorMap.end())
+            return colorMap[owner];
         else
         {
             CmpPtr<ICmpPlayerManager> cmpPlayerManager(sim, SYSTEM_ENTITY);
@@ -119 +119 @@
             entity_id_t playerEnt = cmpPlayerManager->GetPlayerByID(owner);
             CmpPtr<ICmpPlayer> cmpPlayer(sim, playerEnt);
             if (cmpPlayer)
-                color = colourMap[owner] = cmpPlayer->GetColour();
+                color = colorMap[owner] = cmpPlayer->GetColor();
         }
     }
     return color;
@@ -129 +129 @@
 {
     CSimulation2& sim = *g_Game->GetSimulation2();
 
-    // Cache player colours for performance
+    // Cache player colors for performance
     PlayerColorMap playerColors;
 
     // Clear old selection rings

tools/atlas/GameInterface/Messages.h

@@ -60 +60 @@
 MESSAGE(SetViewParamC,
         ((int, view)) // eRenderView
         ((std::wstring, name))
-        ((Colour, value))
+        ((Color, value))
         );
 MESSAGE(SetViewParamS,
         ((int, view)) // eRenderView
@@ -442 +442 @@
     Shareable<float> watermurkiness; // range ???
     Shareable<float> windangle;
 
-    Shareable<Colour> watercolour;
-    Shareable<Colour> watertint;
+    Shareable<Color> watercolor;
+    Shareable<Color> watertint;
 
     Shareable<float> sunrotation; // range -pi..+pi
     Shareable<float> sunelevation; // range -pi/2 .. +pi/2
 
-    // emulate 'HDR' by allowing overly bright suncolour. this is
-    // multiplied on to suncolour after converting to float
-    // (struct Colour stores as normal u8, 0..255)
+    // emulate 'HDR' by allowing overly bright suncolor. this is
+    // multiplied on to suncolor after converting to float
+    // (struct Color stores as normal u8, 0..255)
     Shareable<float> sunoverbrightness; // range 1..3
 
     // support different lighting models ("old" for the version compatible with old scenarios,
@@ -459 +459 @@
 
     Shareable<std::wstring> skyset;
 
-    Shareable<Colour> suncolour;
-    Shareable<Colour> terraincolour;
-    Shareable<Colour> unitcolour;
-    Shareable<Colour> fogcolour;
+    Shareable<Color> suncolor;
+    Shareable<Color> terraincolor;
+    Shareable<Color> unitcolor;
+    Shareable<Color> fogcolor;
     
     Shareable<float> fogfactor;
     Shareable<float> fogmax;

tools/atlas/GameInterface/SharedTypes.h

@@ -66 +66 @@
 SHAREABLE_STRUCT(Position);
 
 
-struct Colour
+struct Color
 {
-    Colour()
+    Color()
         : r(255), g(0), b(255)
     {
     }
 
-    Colour(unsigned char r, unsigned char g, unsigned char b)
+    Color(unsigned char r, unsigned char g, unsigned char b)
         : r(r), g(g), b(b)
     {
     }
@@ -80 +80 @@
 
     unsigned char r, g, b;
 };
-SHAREABLE_STRUCT(Colour);
+SHAREABLE_STRUCT(Color);
 
 
 typedef unsigned int ObjectID;

tools/atlas/GameInterface/View.cpp

@@ -51 +51 @@
 {
 }
 
-void AtlasView::SetParam(const std::wstring& UNUSED(name), const AtlasMessage::Colour& UNUSED(value))
+void AtlasView::SetParam(const std::wstring& UNUSED(name), const AtlasMessage::Color& UNUSED(value))
 {
 }
 
@@ -151 +151 @@
         m_ActorViewer->SetPropPointsMode(value);
 }
 
-void AtlasViewActor::SetParam(const std::wstring& name, const AtlasMessage::Colour& value)
+void AtlasViewActor::SetParam(const std::wstring& name, const AtlasMessage::Color& value)
 {
     if (name == L"background")
     {
-        m_ActorViewer->SetBackgroundColour(SColor4ub(value.r, value.g, value.b, 255));
+        m_ActorViewer->SetBackgroundColor(SColor4ub(value.r, value.g, value.b, 255));
     }
 }
 

tools/atlas/GameInterface/View.h

@@ -48 +48 @@
 
     virtual void SetParam(const std::wstring& name, bool value);
     virtual void SetParam(const std::wstring& name, int value);
-    virtual void SetParam(const std::wstring& name, const AtlasMessage::Colour& value);
+    virtual void SetParam(const std::wstring& name, const AtlasMessage::Color& value);
     virtual void SetParam(const std::wstring& name, const std::wstring& value);
 
     // These always return a valid (not NULL) object
@@ -139 +139 @@
 
     virtual void SetParam(const std::wstring& name, bool value);
     virtual void SetParam(const std::wstring& name, int value);
-    virtual void SetParam(const std::wstring& name, const AtlasMessage::Colour& value);
+    virtual void SetParam(const std::wstring& name, const AtlasMessage::Color& value);
 
     void SetSpeedMultiplier(float speedMultiplier);
     ActorViewer& GetActorViewer();