diff --git a/R/scale-.r b/R/scale-.r
index 19cc0ca809..f6708a0bf7 100644
--- a/R/scale-.r
+++ b/R/scale-.r
@@ -615,12 +615,49 @@ ScaleContinuous <- ggproto("ScaleContinuous", Scale,
 
   transform = default_transform,
 
-  map = function(self, x, limits = self$get_limits()) {
+  map = function(self, x, limits = self$get_limits(), scale_params = NULL) {
     x <- self$rescale(self$oob(x, range = limits), limits)
-
-    uniq <- unique0(x)
-    pal <- self$palette(uniq)
-    scaled <- pal[match(x, uniq)]
+    if (is.null(scale_params)) {
+      scale_params <- list()
+    }
+    # A mapping method maps the x values in [0-1] range to a continuous aesthetic.
+    # "unique": The default. Find unique values in x, map the unique values to colours,
+    #           match the mapped colours to original x values.
+    # "raw": just map all x values to colours. More efficient if we know there are not
+    #        many repeated values. Usually less efficient if there are some repeated
+    #        values.
+    # "binned": Bin `x` into `mapping_method_bins` levels. Map those levels to colours.
+    #           Assign the colour to each value corresponding to their bin.
+    #           This approach is faster with large vectors, but is lossy.
+    mapping_method <- scale_params[["mapping_method"]]
+    if (is.null(mapping_method)) {
+      mapping_method <- "unique"
+    }
+    if (is.character(mapping_method) && !mapping_method %in% c("unique", "raw", "binned")) {
+      cli::cli_warn(c(
+        "ScaleContinous does not support the mapping method {mapping_method}",
+        "i" = "Using 'unique' instead."
+      ))
+      mapping_method <- "unique"
+    }
+    if (mapping_method == "unique") {
+      uniq <- unique0(x)
+      pal <- self$palette(uniq)
+      scaled <- pal[match(x, uniq)]
+    } else if (mapping_method == "raw") {
+      scaled <- self$palette(x)
+    } else if (mapping_method == "binned") {
+      mapping_method_bins <- scale_params[["mapping_method_bins"]]
+      if (is.null(mapping_method_bins)) {
+        mapping_method_bins <- 1024L
+      }
+      mapping_method_bins <- as.integer(mapping_method_bins[1L])
+      breaks <- seq(from = 0, to = 1, length.out = mapping_method_bins + 1L)
+      colormap <- c(self$na.value, self$palette(breaks), self$na.value)
+      # values below 0 belong to the first bucket, but zero belongs to the second bucket:
+      breaks[1] <- -.Machine$double.eps
+      scaled <- colormap[findInterval(x, breaks, rightmost.closed = TRUE) + 1L]
+    }
 
     # A specific palette can have as attribute "may_return_NA = FALSE"
     # If it has such attribute, we will skip the ifelse(!is.na(scaled), ...)