Avoid warnings during compilation

thomasp85 · thomasp85 · commit 68302d620e37 · 2026-03-05T13:54:14.000+01:00
diff --git a/NEWS.md b/NEWS.md
@@ -6,6 +6,8 @@
 * `agg_capture()` now reports the current "page number" as well as whether any
   drawing has occured since the last time the capture was taken as attributes
   in the return value (but only if you request native raster) (#204)
+* Avoid compile time warnings from implicit casting during enum arithmetic
+* `agg_capture()` and `agg_record()` no longer advance the RNG (#212)
 
 # ragg 1.5.0
 
diff --git a/src/agg/include/agg_basics.h b/src/agg/include/agg_basics.h
@@ -446,8 +446,8 @@ namespace agg
     //----------------------------------------------------------------is_close
     inline bool is_close(unsigned c)
     {
-        return (c & ~(path_flags_cw | path_flags_ccw)) ==
-               (path_cmd_end_poly | path_flags_close); 
+        return (c & ~((unsigned)path_flags_cw | (unsigned)path_flags_ccw)) ==
+               ((unsigned)path_cmd_end_poly | (unsigned)path_flags_close); 
     }
 
     //------------------------------------------------------------is_next_poly
diff --git a/src/agg/include/agg_color_gray.h b/src/agg/include/agg_color_gray.h
@@ -56,7 +56,7 @@ namespace agg
         static value_type luminance(const rgba& c)
         {
             // Calculate grayscale value as per ITU-R BT.709.
-            return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) * base_mask));
+            return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) * double(base_mask)));
         }
 
         static value_type luminance(const rgba8& c)
@@ -215,13 +215,13 @@ namespace agg
         //--------------------------------------------------------------------
         static AGG_INLINE double to_double(value_type a)
         {
-            return double(a) / base_mask;
+            return double(a) / double(base_mask);
         }
 
         //--------------------------------------------------------------------
         static AGG_INLINE value_type from_double(double a)
         {
-            return value_type(uround(a * base_mask));
+            return value_type(uround(a * double(base_mask)));
         }
 
         //--------------------------------------------------------------------
@@ -375,7 +375,7 @@ namespace agg
         self_type gradient(self_type c, double k) const
         {
             self_type ret;
-            calc_type ik = uround(k * base_scale);
+            calc_type ik = uround(k * double(base_scale));
             ret.v = lerp(v, c.v, ik);
             ret.a = lerp(a, c.a, ik);
             return ret;
@@ -436,7 +436,7 @@ namespace agg
         static value_type luminance(const rgba& c)
         {
             // Calculate grayscale value as per ITU-R BT.709.
-            return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) * base_mask));
+            return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) * double(base_mask)));
         }
 
         static value_type luminance(const rgba16& c)
@@ -544,13 +544,13 @@ namespace agg
         //--------------------------------------------------------------------
         static AGG_INLINE double to_double(value_type a)
         {
-            return double(a) / base_mask;
+            return double(a) / double(base_mask);
         }
 
         //--------------------------------------------------------------------
         static AGG_INLINE value_type from_double(double a)
         {
-            return value_type(uround(a * base_mask));
+            return value_type(uround(a * double(base_mask)));
         }
 
         //--------------------------------------------------------------------
@@ -705,7 +705,7 @@ namespace agg
         self_type gradient(self_type c, double k) const
         {
             self_type ret;
-            calc_type ik = uround(k * base_scale);
+            calc_type ik = uround(k * double(base_scale));
             ret.v = lerp(v, c.v, ik);
             ret.a = lerp(a, c.a, ik);
             return ret;
@@ -953,9 +953,9 @@ namespace agg
         }
 
         //--------------------------------------------------------------------
-        static AGG_INLINE value_type mult_cover(value_type a, cover_type b) 
+        static AGG_INLINE value_type mult_cover(value_type a, cover_type b)
         {
-            return value_type(a * b / cover_mask);
+            return value_type(a * b / float(cover_mask));
         }
 
         //--------------------------------------------------------------------
diff --git a/src/agg/include/agg_color_rgba.h b/src/agg/include/agg_color_rgba.h
@@ -351,13 +351,13 @@ namespace agg
         //--------------------------------------------------------------------
         static AGG_INLINE double to_double(value_type a)
         {
-            return double(a) / base_mask;
+            return double(a) / double(base_mask);
         }
 
         //--------------------------------------------------------------------
         static AGG_INLINE value_type from_double(double a)
         {
-            return value_type(uround(a * base_mask));
+            return value_type(uround(a * double(base_mask)));
         }
 
         //--------------------------------------------------------------------
@@ -552,7 +552,7 @@ namespace agg
         AGG_INLINE self_type gradient(const self_type& c, double k) const
         {
             self_type ret;
-            calc_type ik = uround(k * base_mask);
+            calc_type ik = uround(k * double(base_mask));
             ret.r = lerp(r, c.r, ik);
             ret.g = lerp(g, c.g, ik);
             ret.b = lerp(b, c.b, ik);
@@ -743,13 +743,13 @@ namespace agg
         //--------------------------------------------------------------------
         static AGG_INLINE double to_double(value_type a)
         {
-            return double(a) / base_mask;
+            return double(a) / double(base_mask);
         }
 
         //--------------------------------------------------------------------
         static AGG_INLINE value_type from_double(double a)
         {
-            return value_type(uround(a * base_mask));
+            return value_type(uround(a * double(base_mask)));
         }
 
         //--------------------------------------------------------------------
@@ -944,7 +944,7 @@ namespace agg
         AGG_INLINE self_type gradient(const self_type& c, double k) const
         {
             self_type ret;
-            calc_type ik = uround(k * base_mask);
+            calc_type ik = uround(k * double(base_mask));
             ret.r = lerp(r, c.r, ik);
             ret.g = lerp(g, c.g, ik);
             ret.b = lerp(b, c.b, ik);
@@ -1181,9 +1181,9 @@ namespace agg
         }
 
         //--------------------------------------------------------------------
-        static AGG_INLINE value_type mult_cover(value_type a, cover_type b) 
+        static AGG_INLINE value_type mult_cover(value_type a, cover_type b)
         {
-            return value_type(a * b / cover_mask);
+            return value_type(a * b / float(cover_mask));
         }
 
         //--------------------------------------------------------------------
diff --git a/src/agg/include/agg_ellipse.h b/src/agg/include/agg_ellipse.h
@@ -103,7 +103,7 @@ namespace agg
         if(m_step == m_num) 
         {
             ++m_step;
-            return path_cmd_end_poly | path_flags_close | path_flags_ccw;
+            return (unsigned)path_cmd_end_poly | (unsigned)path_flags_close | (unsigned)path_flags_ccw;
         }
         if(m_step > m_num) return path_cmd_stop;
         double angle = double(m_step) / double(m_num) * 2.0 * pi;
diff --git a/src/agg/include/agg_gradient_lut.h b/src/agg/include/agg_gradient_lut.h
@@ -209,7 +209,7 @@ namespace agg
         if(m_color_profile.size() >= 2)
         {
             unsigned i;
-            unsigned start = uround(m_color_profile[0].offset * color_lut_size);
+            unsigned start = uround(m_color_profile[0].offset * double(color_lut_size));
             unsigned end;
             color_type c = m_color_profile[0].color;
             for(i = 0; i < start; i++) 
@@ -218,7 +218,7 @@ namespace agg
             }
             for(i = 1; i < m_color_profile.size(); i++)
             {
-                end  = uround(m_color_profile[i].offset * color_lut_size);
+                end  = uround(m_color_profile[i].offset * double(color_lut_size));
                 interpolator_type ci(m_color_profile[i-1].color, 
                                      m_color_profile[i  ].color, 
                                      end - start + 1);
diff --git a/src/agg/include/agg_image_filters.h b/src/agg/include/agg_image_filters.h
@@ -57,7 +57,7 @@ namespace agg
             unsigned pivot = diameter() << (image_subpixel_shift - 1);
             for(i = 0; i < pivot; i++)
             {
-                double x = double(i) / double(image_subpixel_scale);
+                double x = double(i) / double(int(image_subpixel_scale));
                 double y = filter.calc_weight(x);
                 m_weight_array[pivot + i] = 
                 m_weight_array[pivot - i] = (int16)iround(y * image_filter_scale);
diff --git a/src/agg/include/agg_path_storage.h b/src/agg/include/agg_path_storage.h
@@ -397,7 +397,7 @@ namespace agg
             if(m_closed && !m_stop)
             {
                 m_stop = true;
-                return path_cmd_end_poly | path_flags_close;
+                return (unsigned)path_cmd_end_poly | (unsigned)path_flags_close;
             }
             return path_cmd_stop;
         }
@@ -462,7 +462,7 @@ namespace agg
             if(m_closed && !m_stop)
             {
                 m_stop = true;
-                return path_cmd_end_poly | path_flags_close;
+                return (unsigned)path_cmd_end_poly | (unsigned)path_flags_close;
             }
             return path_cmd_stop;
         }
@@ -524,7 +524,7 @@ namespace agg
             if(m_closed && !m_stop)
             {
                 m_stop = true;
-                return path_cmd_end_poly | path_flags_close;
+                return (unsigned)path_cmd_end_poly | (unsigned)path_flags_close;
             }
             return path_cmd_stop;
         }
diff --git a/src/agg/include/agg_path_storage_integer.h b/src/agg/include/agg_path_storage_integer.h
@@ -50,8 +50,8 @@ namespace agg
                         double dx=0, double dy=0,
                         double scale=1.0) const
         {
-            *x_ = dx + (double(x >> 1) / coord_scale) * scale;
-            *y_ = dy + (double(y >> 1) / coord_scale) * scale;
+            *x_ = dx + (double(x >> 1) / double(coord_scale)) * scale;
+            *y_ = dy + (double(y >> 1) / double(coord_scale)) * scale;
             switch(((y & 1) << 1) | (x & 1))
             {
                 case cmd_move_to: return path_cmd_move_to;
@@ -150,15 +150,15 @@ namespace agg
                 *x = 0;
                 *y = 0;
                 ++m_vertex_idx;
-                return path_cmd_end_poly | path_flags_close;
+                return (unsigned)path_cmd_end_poly | (unsigned)path_flags_close;
             }
             unsigned cmd = m_storage[m_vertex_idx].vertex(x, y);
             if(is_move_to(cmd) && !m_closed)
             {
                 *x = 0;
                 *y = 0;
                 m_closed = true;
-                return path_cmd_end_poly | path_flags_close;
+                return (unsigned)path_cmd_end_poly | (unsigned)path_flags_close;
             }
             m_closed = false;
             ++m_vertex_idx;
@@ -262,7 +262,7 @@ namespace agg
                 *x = 0;
                 *y = 0;
                 m_ptr += sizeof(vertex_integer_type);
-                return path_cmd_end_poly | path_flags_close;
+                return (unsigned)path_cmd_end_poly | (unsigned)path_flags_close;
             }
 
             vertex_integer_type v;
@@ -273,7 +273,7 @@ namespace agg
                 *x = 0;
                 *y = 0;
                 m_vertices = 0;
-                return path_cmd_end_poly | path_flags_close;
+                return (unsigned)path_cmd_end_poly | (unsigned)path_flags_close;
             }
             ++m_vertices;
             m_ptr += sizeof(vertex_integer_type);
diff --git a/src/agg/include/agg_pixfmt_base.h b/src/agg/include/agg_pixfmt_base.h
@@ -54,7 +54,7 @@ namespace agg
 
                 if (cover < cover_full)
                 {
-                    double x = double(cover) / cover_full;
+                    double x = double(cover) / double(cover_full);
                     c.r *= x;
                     c.g *= x;
                     c.b *= x;
diff --git a/src/agg/include/agg_rasterizer_scanline_aa.h b/src/agg/include/agg_rasterizer_scanline_aa.h
@@ -133,7 +133,7 @@ namespace agg
             int i;
             for(i = 0; i < aa_scale; i++)
             {
-                m_gamma[i] = uround(gamma_function(double(i) / aa_mask) * aa_mask);
+                m_gamma[i] = uround(gamma_function(double(i) / double(aa_mask)) * double(aa_mask));
             }
         }
 
diff --git a/src/agg/include/agg_rasterizer_sl_clip.h b/src/agg/include/agg_rasterizer_sl_clip.h
@@ -35,7 +35,7 @@ namespace agg
         }
         static int xi(int v) { return v; }
         static int yi(int v) { return v; }
-        static int upscale(double v) { return iround(v * poly_subpixel_scale); }
+        static int upscale(double v) { return iround(v * double(poly_subpixel_scale)); }
         static int downscale(int v)  { return v; }
     };
 
@@ -49,9 +49,9 @@ namespace agg
         }
         static int xi(int v) { return v; }
         static int yi(int v) { return v; }
-        static int upscale(double v) 
-        { 
-            return saturation<poly_max_coord>::iround(v * poly_subpixel_scale); 
+        static int upscale(double v)
+        {
+            return saturation<poly_max_coord>::iround(v * double(poly_subpixel_scale));
         }
         static int downscale(int v) { return v; }
     };
@@ -66,7 +66,7 @@ namespace agg
         }
         static int xi(int v) { return v * 3; }
         static int yi(int v) { return v; }
-        static int upscale(double v) { return iround(v * poly_subpixel_scale); }
+        static int upscale(double v) { return iround(v * double(poly_subpixel_scale)); }
         static int downscale(int v)  { return v; }
     };
 
@@ -78,10 +78,10 @@ namespace agg
         {
             return a * b / c;
         }
-        static int xi(double v) { return iround(v * poly_subpixel_scale); }
-        static int yi(double v) { return iround(v * poly_subpixel_scale); }
+        static int xi(double v) { return iround(v * double(poly_subpixel_scale)); }
+        static int yi(double v) { return iround(v * double(poly_subpixel_scale)); }
         static double upscale(double v) { return v; }
-        static double downscale(int v)  { return v / double(poly_subpixel_scale); }
+        static double downscale(int v)  { return v / double(int(poly_subpixel_scale)); }
     };
 
     //--------------------------------------------------------ras_conv_dbl_3x
@@ -92,10 +92,10 @@ namespace agg
         {
             return a * b / c;
         }
-        static int xi(double v) { return iround(v * poly_subpixel_scale * 3); }
-        static int yi(double v) { return iround(v * poly_subpixel_scale); }
+        static int xi(double v) { return iround(v * double(poly_subpixel_scale) * 3); }
+        static int yi(double v) { return iround(v * double(poly_subpixel_scale)); }
         static double upscale(double v) { return v; }
-        static double downscale(int v)  { return v / double(poly_subpixel_scale); }
+        static double downscale(int v)  { return v / double(int(poly_subpixel_scale)); }
     };
 
 
diff --git a/src/agg/include/agg_span_gradient.h b/src/agg/include/agg_span_gradient.h
diff --git a/src/agg/include/agg_span_image_filter.h b/src/agg/include/agg_span_image_filter.h
diff --git a/src/agg/include/agg_span_interpolator_linear.h b/src/agg/include/agg_span_interpolator_linear.h
diff --git a/src/agg/src/agg_vcgen_stroke.cpp b/src/agg/src/agg_vcgen_stroke.cpp

Original file line number	Diff line number	Diff line change
`@@ -446,8 +446,8 @@ namespace agg`
`446`	`446`	`//----------------------------------------------------------------is_close`
`447`	`447`	`inline bool is_close(unsigned c)`
`448`	`448`	`{`
`449`		`- return (c & ~(path_flags_cw \| path_flags_ccw)) ==`
`450`		`- (path_cmd_end_poly \| path_flags_close);`
	`449`	`+ return (c & ~((unsigned)path_flags_cw \| (unsigned)path_flags_ccw)) ==`
	`450`	`+ ((unsigned)path_cmd_end_poly \| (unsigned)path_flags_close);`
`451`	`451`	`}`
`452`	`452`
`453`	`453`	`//------------------------------------------------------------is_next_poly`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ namespace agg`
`56`	`56`	`static value_type luminance(const rgba& c)`
`57`	`57`	`{`
`58`	`58`	`// Calculate grayscale value as per ITU-R BT.709.`
`59`		`- return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) * base_mask));`
	`59`	`+ return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) * double(base_mask)));`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`static value_type luminance(const rgba8& c)`
`@@ -215,13 +215,13 @@ namespace agg`
`215`	`215`	`//--------------------------------------------------------------------`
`216`	`216`	`static AGG_INLINE double to_double(value_type a)`
`217`	`217`	`{`
`218`		`- return double(a) / base_mask;`
	`218`	`+ return double(a) / double(base_mask);`
`219`	`219`	`}`
`220`	`220`
`221`	`221`	`//--------------------------------------------------------------------`
`222`	`222`	`static AGG_INLINE value_type from_double(double a)`
`223`	`223`	`{`
`224`		`- return value_type(uround(a * base_mask));`
	`224`	`+ return value_type(uround(a * double(base_mask)));`
`225`	`225`	`}`
`226`	`226`
`227`	`227`	`//--------------------------------------------------------------------`
`@@ -375,7 +375,7 @@ namespace agg`
`375`	`375`	`self_type gradient(self_type c, double k) const`
`376`	`376`	`{`
`377`	`377`	`self_type ret;`
`378`		`- calc_type ik = uround(k * base_scale);`
	`378`	`+ calc_type ik = uround(k * double(base_scale));`
`379`	`379`	`ret.v = lerp(v, c.v, ik);`
`380`	`380`	`ret.a = lerp(a, c.a, ik);`
`381`	`381`	`return ret;`
`@@ -436,7 +436,7 @@ namespace agg`
`436`	`436`	`static value_type luminance(const rgba& c)`
`437`	`437`	`{`
`438`	`438`	`// Calculate grayscale value as per ITU-R BT.709.`
`439`		`- return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) * base_mask));`
	`439`	`+ return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) * double(base_mask)));`
`440`	`440`	`}`
`441`	`441`
`442`	`442`	`static value_type luminance(const rgba16& c)`
`@@ -544,13 +544,13 @@ namespace agg`
`544`	`544`	`//--------------------------------------------------------------------`
`545`	`545`	`static AGG_INLINE double to_double(value_type a)`
`546`	`546`	`{`
`547`		`- return double(a) / base_mask;`
	`547`	`+ return double(a) / double(base_mask);`
`548`	`548`	`}`
`549`	`549`
`550`	`550`	`//--------------------------------------------------------------------`
`551`	`551`	`static AGG_INLINE value_type from_double(double a)`
`552`	`552`	`{`
`553`		`- return value_type(uround(a * base_mask));`
	`553`	`+ return value_type(uround(a * double(base_mask)));`
`554`	`554`	`}`
`555`	`555`
`556`	`556`	`//--------------------------------------------------------------------`
`@@ -705,7 +705,7 @@ namespace agg`
`705`	`705`	`self_type gradient(self_type c, double k) const`
`706`	`706`	`{`
`707`	`707`	`self_type ret;`
`708`		`- calc_type ik = uround(k * base_scale);`
	`708`	`+ calc_type ik = uround(k * double(base_scale));`
`709`	`709`	`ret.v = lerp(v, c.v, ik);`
`710`	`710`	`ret.a = lerp(a, c.a, ik);`
`711`	`711`	`return ret;`
`@@ -953,9 +953,9 @@ namespace agg`
`953`	`953`	`}`
`954`	`954`
`955`	`955`	`//--------------------------------------------------------------------`
`956`		`- static AGG_INLINE value_type mult_cover(value_type a, cover_type b)`
	`956`	`+ static AGG_INLINE value_type mult_cover(value_type a, cover_type b)`
`957`	`957`	`{`
`958`		`- return value_type(a * b / cover_mask);`
	`958`	`+ return value_type(a * b / float(cover_mask));`
`959`	`959`	`}`
`960`	`960`
`961`	`961`	`//--------------------------------------------------------------------`
Original file line number	Diff line number	Diff line change
`@@ -351,13 +351,13 @@ namespace agg`
`351`	`351`	`//--------------------------------------------------------------------`
`352`	`352`	`static AGG_INLINE double to_double(value_type a)`
`353`	`353`	`{`
`354`		`- return double(a) / base_mask;`
	`354`	`+ return double(a) / double(base_mask);`
`355`	`355`	`}`
`356`	`356`
`357`	`357`	`//--------------------------------------------------------------------`
`358`	`358`	`static AGG_INLINE value_type from_double(double a)`
`359`	`359`	`{`
`360`		`- return value_type(uround(a * base_mask));`
	`360`	`+ return value_type(uround(a * double(base_mask)));`
`361`	`361`	`}`
`362`	`362`
`363`	`363`	`//--------------------------------------------------------------------`
`@@ -552,7 +552,7 @@ namespace agg`
`552`	`552`	`AGG_INLINE self_type gradient(const self_type& c, double k) const`
`553`	`553`	`{`
`554`	`554`	`self_type ret;`
`555`		`- calc_type ik = uround(k * base_mask);`
	`555`	`+ calc_type ik = uround(k * double(base_mask));`
`556`	`556`	`ret.r = lerp(r, c.r, ik);`
`557`	`557`	`ret.g = lerp(g, c.g, ik);`
`558`	`558`	`ret.b = lerp(b, c.b, ik);`
`@@ -743,13 +743,13 @@ namespace agg`
`743`	`743`	`//--------------------------------------------------------------------`
`744`	`744`	`static AGG_INLINE double to_double(value_type a)`
`745`	`745`	`{`
`746`		`- return double(a) / base_mask;`
	`746`	`+ return double(a) / double(base_mask);`
`747`	`747`	`}`
`748`	`748`
`749`	`749`	`//--------------------------------------------------------------------`
`750`	`750`	`static AGG_INLINE value_type from_double(double a)`
`751`	`751`	`{`
`752`		`- return value_type(uround(a * base_mask));`
	`752`	`+ return value_type(uround(a * double(base_mask)));`
`753`	`753`	`}`
`754`	`754`
`755`	`755`	`//--------------------------------------------------------------------`
`@@ -944,7 +944,7 @@ namespace agg`
`944`	`944`	`AGG_INLINE self_type gradient(const self_type& c, double k) const`
`945`	`945`	`{`
`946`	`946`	`self_type ret;`
`947`		`- calc_type ik = uround(k * base_mask);`
	`947`	`+ calc_type ik = uround(k * double(base_mask));`
`948`	`948`	`ret.r = lerp(r, c.r, ik);`
`949`	`949`	`ret.g = lerp(g, c.g, ik);`
`950`	`950`	`ret.b = lerp(b, c.b, ik);`
`@@ -1181,9 +1181,9 @@ namespace agg`
`1181`	`1181`	`}`
`1182`	`1182`
`1183`	`1183`	`//--------------------------------------------------------------------`
`1184`		`- static AGG_INLINE value_type mult_cover(value_type a, cover_type b)`
	`1184`	`+ static AGG_INLINE value_type mult_cover(value_type a, cover_type b)`
`1185`	`1185`	`{`
`1186`		`- return value_type(a * b / cover_mask);`
	`1186`	`+ return value_type(a * b / float(cover_mask));`
`1187`	`1187`	`}`
`1188`	`1188`
`1189`	`1189`	`//--------------------------------------------------------------------`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ namespace agg`
`103`	`103`	`if(m_step == m_num)`
`104`	`104`	`{`
`105`	`105`	`++m_step;`
`106`		`- return path_cmd_end_poly \| path_flags_close \| path_flags_ccw;`
	`106`	`+ return (unsigned)path_cmd_end_poly \| (unsigned)path_flags_close \| (unsigned)path_flags_ccw;`
`107`	`107`	`}`
`108`	`108`	`if(m_step > m_num) return path_cmd_stop;`
`109`	`109`	`double angle = double(m_step) / double(m_num) * 2.0 * pi;`
Original file line number	Diff line number	Diff line change
`@@ -209,7 +209,7 @@ namespace agg`
`209`	`209`	`if(m_color_profile.size() >= 2)`
`210`	`210`	`{`
`211`	`211`	`unsigned i;`
`212`		`- unsigned start = uround(m_color_profile[0].offset * color_lut_size);`
	`212`	`+ unsigned start = uround(m_color_profile[0].offset * double(color_lut_size));`
`213`	`213`	`unsigned end;`
`214`	`214`	`color_type c = m_color_profile[0].color;`
`215`	`215`	`for(i = 0; i < start; i++)`
`@@ -218,7 +218,7 @@ namespace agg`
`218`	`218`	`}`
`219`	`219`	`for(i = 1; i < m_color_profile.size(); i++)`
`220`	`220`	`{`
`221`		`- end = uround(m_color_profile[i].offset * color_lut_size);`
	`221`	`+ end = uround(m_color_profile[i].offset * double(color_lut_size));`
`222`	`222`	`interpolator_type ci(m_color_profile[i-1].color,`
`223`	`223`	`m_color_profile[i ].color,`
`224`	`224`	`end - start + 1);`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ namespace agg`
`57`	`57`	`unsigned pivot = diameter() << (image_subpixel_shift - 1);`
`58`	`58`	`for(i = 0; i < pivot; i++)`
`59`	`59`	`{`
`60`		`- double x = double(i) / double(image_subpixel_scale);`
	`60`	`+ double x = double(i) / double(int(image_subpixel_scale));`
`61`	`61`	`double y = filter.calc_weight(x);`
`62`	`62`	`m_weight_array[pivot + i] =`
`63`	`63`	`m_weight_array[pivot - i] = (int16)iround(y * image_filter_scale);`
Original file line number	Diff line number	Diff line change
`@@ -397,7 +397,7 @@ namespace agg`
`397`	`397`	`if(m_closed && !m_stop)`
`398`	`398`	`{`
`399`	`399`	`m_stop = true;`
`400`		`- return path_cmd_end_poly \| path_flags_close;`
	`400`	`+ return (unsigned)path_cmd_end_poly \| (unsigned)path_flags_close;`
`401`	`401`	`}`
`402`	`402`	`return path_cmd_stop;`
`403`	`403`	`}`
`@@ -462,7 +462,7 @@ namespace agg`
`462`	`462`	`if(m_closed && !m_stop)`
`463`	`463`	`{`
`464`	`464`	`m_stop = true;`
`465`		`- return path_cmd_end_poly \| path_flags_close;`
	`465`	`+ return (unsigned)path_cmd_end_poly \| (unsigned)path_flags_close;`
`466`	`466`	`}`
`467`	`467`	`return path_cmd_stop;`
`468`	`468`	`}`
`@@ -524,7 +524,7 @@ namespace agg`
`524`	`524`	`if(m_closed && !m_stop)`
`525`	`525`	`{`
`526`	`526`	`m_stop = true;`
`527`		`- return path_cmd_end_poly \| path_flags_close;`
	`527`	`+ return (unsigned)path_cmd_end_poly \| (unsigned)path_flags_close;`
`528`	`528`	`}`
`529`	`529`	`return path_cmd_stop;`
`530`	`530`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ namespace agg`
`54`	`54`
`55`	`55`	`if (cover < cover_full)`
`56`	`56`	`{`
`57`		`- double x = double(cover) / cover_full;`
	`57`	`+ double x = double(cover) / double(cover_full);`
`58`	`58`	`c.r *= x;`
`59`	`59`	`c.g *= x;`
`60`	`60`	`c.b *= x;`