@@ -71,7 +71,8 @@ as `effect:<scene>/<layer>/<effect>`, maps to one skybox slot: the theme's
 skybox replaces its six faces.
 
 A custom object, like the 3D terrain, maps some of its properties. An image
-property maps to a texture slot, a color property to a color slot, and the
+property maps to a texture slot, a 3D model property (like the model of
+scattered models) to a model slot, a color property to a color slot, and the
 texture of a terrain layer to a *material* slot, a texture with its normal map,
 along with the property that takes the normal map:
 
@@ -83,14 +84,19 @@ along with the property that takes the normal map:
 "scene:Game Scene/Grass": {
   "BaseColor": "terrain.grass.base",
   "TipColor": "terrain.grass.tip"
+},
+"scene:Game Scene/PineForest": {
+  "Model": "nature.tree"
 }
 ```
 
 A theme whose material has no normal map empties the normal map property: the
-bumps of the starter's texture would not match the theme's. Custom objects
-don't have to be mapped, but the children of a custom object that are 3D models
-or cubes do (list the placeholders of the terrain and the grass in
-`ignoredObjects`).
+bumps of the starter's texture would not match the theme's. A theme model keeps
+the other properties of the object, like the size of the scattered copies.
+Custom objects don't have to be mapped, except those drawing a 3D model (like
+scattered models), which are mapped or listed in `ignoredObjects` like 3D
+models. The children of a custom object that are 3D models or cubes are mapped
+too (list the placeholders of the terrain and the grass in `ignoredObjects`).
 
 **When you add a 3D starter, add its `theme-slots.json`.** The build refuses to
 publish a 3D starter without one, or one where a 3D model or cube is neither
 
@@ -166,7 +166,7 @@ const getSizeRatio = (objectContent, themeContent) => {
  * its name, behaviors, variables, instances, origin and center; a cube face
  * points at the theme image; a skybox effect points at the six theme images;
  * a property of a custom object points at the theme image (and the normal map
- * of a material) or takes the theme color.
+ * of a material) or model, or takes the theme color.
  *
  * Each theme file becomes a resource named like in the asset store, and the
  * resources of the starter that nothing uses anymore are removed.
@@ -251,7 +251,8 @@ const applyThemeToStarter = (projectObject, starterThemeSlots, theme) => {
   /**
    * Theme the properties of a custom object: an image resource takes the
    * texture of a texture or material slot, along with the normal map of the
-   * material if the starter maps one; a color takes the color of a color slot.
+   * material if the starter maps one; a 3D model resource takes the model of
+   * a model slot; a color takes the color of a color slot.
    * @param {any} objectContent
    * @param {Object.<string, string | import('./ThemeSlots.js').MaterialMapping>} mapping
    * @returns {boolean} Whether a property changed.
@@ -274,6 +275,24 @@ const applyThemeToStarter = (projectObject, starterThemeSlots, theme) => {
         changed = true;
         return;
       }
+      if (
+        slot &&
+        slot.kind === 'model' &&
+        typeof propertyMapping === 'string'
+      ) {
+        // The custom object keeps its own settings for the model (like the
+        // size of scattered copies): only the model changes.
+        const themeModelResourceName = useThemeResource(
+          String(objectContent[property] || ''),
+          slotId,
+          slot,
+          { kind: 'model3D', metadata: '', userAdded: false }
+        );
+        if (!themeModelResourceName) return;
+        objectContent[property] = themeModelResourceName;
+        changed = true;
+        return;
+      }
       if (!slot || (slot.kind !== 'texture' && slot.kind !== 'material')) {
         missingSlots.add(slotId);
         return;
 
@@ -48,13 +48,19 @@ const cubeFaceProperties = [
   'bottomFaceResourceName',
 ];
 
+/**
+ * The type of a property of a custom object, and for a resource, its kind
+ * (like "image" or "model3D").
+ * @typedef {{type: string, resourceKind: string}} PropertyType
+ */
+
 /**
  * The properties of each custom object type of a project, by type.
  * @param {any} projectObject
- * @returns {Map<string, Map<string, string>>}
+ * @returns {Map<string, Map<string, PropertyType>>}
  */
 const getCustomObjectPropertyTypes = (projectObject) => {
-  /** @type {Map<string, Map<string, string>>} */
+  /** @type {Map<string, Map<string, PropertyType>>} */
   const propertyTypesByObjectType = new Map();
   (projectObject.eventsFunctionsExtensions || []).forEach(
     /** @param {any} extension */ (extension) =>
@@ -66,7 +72,13 @@ const getCustomObjectPropertyTypes = (projectObject) => {
               (eventsBasedObject.propertyDescriptors || []).map(
                 /** @param {any} property */ (property) => [
                   property.name,
-                  property.type,
+                  {
+                    type: property.type,
+                    resourceKind:
+                      property.type === 'Resource'
+                        ? (property.extraInformation || [])[0] || ''
+                        : '',
+                  },
                 ]
               )
             )
@@ -83,15 +95,15 @@ const getCustomObjectPropertyTypes = (projectObject) => {
  * @param {any} projectObject
  * @returns {{
  *   objects: Array<{path: string, type: string}>,
- *   customObjects: Array<{path: string, type: string, propertyTypes: Map<string, string>}>,
+ *   customObjects: Array<{path: string, type: string, propertyTypes: Map<string, PropertyType>}>,
  *   effects: Array<string>,
  *   is3D: boolean,
  * }}
  */
 const getThemeableObjects = (projectObject) => {
   /** @type {Array<{path: string, type: string}>} */
   const objects = [];
-  /** @type {Array<{path: string, type: string, propertyTypes: Map<string, string>}>} */
+  /** @type {Array<{path: string, type: string, propertyTypes: Map<string, PropertyType>}>} */
   const customObjects = [];
   /** @type {Array<string>} */
   const effects = [];
@@ -260,27 +272,42 @@ const checkStarterThemeSlots = (
 
   /**
    * @param {string} objectPath
-   * @param {Map<string, string>} propertyTypes
+   * @param {Map<string, PropertyType>} propertyTypes
    * @param {string} property
    * @param {string} expectedType
    * @returns {boolean}
    */
   const checkProperty = (objectPath, propertyTypes, property, expectedType) => {
     const propertyType = propertyTypes.get(property);
-    if (propertyType === expectedType) return true;
+    if (propertyType && propertyType.type === expectedType) return true;
     errors.push(
       new Error(
         propertyType
-          ? `Starter "${slug}": "${objectPath}" maps its property "${property}", a ${propertyType}, but only resources and colors can be themed.`
+          ? `Starter "${slug}": "${objectPath}" maps its property "${property}", a ${propertyType.type}, but only resources and colors can be themed.`
           : `Starter "${slug}": "${objectPath}" maps the property "${property}", which its object does not have.`
       )
     );
     return false;
   };
 
-  customObjects.forEach(({ path: objectPath, propertyTypes }) => {
+  customObjects.forEach(({ path: objectPath, type, propertyTypes }) => {
+    if (ignored.has(objectPath)) return;
     const mapping = mapped[objectPath];
-    if (mapping === undefined) return;
+    if (mapping === undefined) {
+      // Like 3D model objects, the models drawn by a custom object (like
+      // scattered trees) must follow the theme or be explicitly kept.
+      const hasModel = [...propertyTypes.values()].some(
+        (propertyType) => propertyType.resourceKind === 'model3D'
+      );
+      if (hasModel) {
+        errors.push(
+          new Error(
+            `Starter "${slug}": the ${type} "${objectPath}" draws a 3D model but is neither mapped to slots nor listed in ignoredObjects in theme-slots.json.`
+          )
+        );
+      }
+      return;
+    }
     if (typeof mapping === 'string') {
       errors.push(
         new Error(
@@ -306,12 +333,18 @@ const checkStarterThemeSlots = (
         return;
       }
       const propertyType = propertyTypes.get(property);
-      if (propertyType === 'Color') {
+      if (propertyType && propertyType.type === 'Color') {
         checkSlot(where, propertyMapping, 'color');
       } else if (
         checkProperty(objectPath, propertyTypes, property, 'Resource')
       ) {
-        checkSlot(where, propertyMapping, 'texture');
+        checkSlot(
+          where,
+          propertyMapping,
+          propertyType && propertyType.resourceKind === 'model3D'
+            ? 'model'
+            : 'texture'
+        );
       }
     });
   });
@@ -326,7 +359,7 @@ const checkStarterThemeSlots = (
     }
   });
   ignored.forEach((objectPath) => {
-    if (!typeByPath.has(objectPath)) {
+    if (!typeByPath.has(objectPath) && !customObjectByPath.has(objectPath)) {
       errors.push(
         new Error(
           `Starter "${slug}": theme-slots.json ignores "${objectPath}", which is not a 3D object of the starter anymore.`
 
@@ -659,6 +659,56 @@ describe('applyThemeToStarter on custom objects', () => {
     expect(terrainContent.Layer2NormalMap).toBe('');
   });
 
+  it('gives scattered models the model of a model slot, keeping their size', () => {
+    /** @type {any} */
+    const projectContent = {
+      resources: {
+        resources: [
+          { name: 'Pine.glb', file: 'assets/Pine.glb', kind: 'model3D' },
+        ],
+      },
+      layouts: [
+        {
+          name: 'Game Scene',
+          layers: [],
+          objects: [
+            {
+              name: 'Forest',
+              type: 'Terrain3D::ScatteredModels',
+              content: { Model: 'Pine.glb', Size: 300 },
+            },
+          ],
+        },
+      ],
+    };
+    const result = applyThemeToStarter(
+      projectContent,
+      {
+        version: 1,
+        objects: { 'scene:Game Scene/Forest': { Model: 'nature.tree' } },
+      },
+      {
+        ...makeTerrainTheme(),
+        slots: {
+          'nature.tree': {
+            kind: 'model',
+            file: 'https://asset-resources.gdevelop.io/public-resources/Palm.glb',
+            resourceName: 'Palm.glb',
+            objectContent: { modelResourceName: 'Palm.glb', rotationX: 90 },
+          },
+        },
+      }
+    );
+
+    expect(projectContent.layouts[0].objects[0].content).toEqual({
+      Model: 'Palm.glb',
+      Size: 300,
+    });
+    expect(getResource(projectContent, 'Palm.glb').kind).toBe('model3D');
+    expect(getResource(projectContent, 'Pine.glb')).toBeUndefined();
+    expect(result.appliedSlots).toEqual(['nature.tree']);
+  });
+
   it('gives a cube face the texture of a material', () => {
     const projectContent = makeProjectContent();
     applyThemeToStarter(projectContent, makeStarterThemeSlots(), {
 
@@ -12,6 +12,7 @@ const vocabulary = {
   version: 1,
   slots: [
     { id: 'character.player', kind: 'model', label: 'Player character' },
+    { id: 'nature.tree', kind: 'model', label: 'Tree' },
     { id: 'env.ground', kind: 'texture', label: 'Ground' },
     { id: 'env.wall', kind: 'texture', label: 'Wall' },
     { id: 'sky.day', kind: 'skybox', label: 'Daytime sky' },
@@ -91,6 +92,30 @@ const createFakeTerrainProjectObject = () => {
   return projectObject;
 };
 
+/** @returns {any} */
+const createFakeForestProjectObject = () => {
+  /** @type {any} */
+  const projectObject = createFakeProjectObject();
+  projectObject.layouts[0].objects.push({
+    name: 'Forest',
+    type: 'Terrain3D::ScatteredModels',
+  });
+  projectObject.eventsFunctionsExtensions.push({
+    name: 'Terrain3D',
+    eventsBasedObjects: [
+      {
+        name: 'ScatteredModels',
+        objects: [],
+        propertyDescriptors: [
+          { name: 'Model', type: 'Resource', extraInformation: ['model3D'] },
+          { name: 'Size', type: 'Number' },
+        ],
+      },
+    ],
+  });
+  return projectObject;
+};
+
 /**
  * @param {StarterThemeSlots['objects'][string]} terrainMapping
  * @returns {StarterThemeSlots}
@@ -326,6 +351,63 @@ describe('checkStarterThemeSlots', () => {
     ]);
   });
 
+  it('accepts a custom object mapping its 3D model to a model slot', () => {
+    const starterThemeSlots = createFakeStarterThemeSlots();
+    starterThemeSlots.objects['scene:Game Scene/Forest'] = {
+      Model: 'nature.tree',
+    };
+
+    expect(
+      checkStarterThemeSlots(
+        vocabulary,
+        'starting-3d-test',
+        createFakeForestProjectObject(),
+        starterThemeSlots
+      )
+    ).toEqual([]);
+  });
+
+  it('requires a model slot for the 3D model of a custom object', () => {
+    const starterThemeSlots = createFakeStarterThemeSlots();
+    starterThemeSlots.objects['scene:Game Scene/Forest'] = {
+      Model: 'env.ground',
+    };
+
+    const errors = checkStarterThemeSlots(
+      vocabulary,
+      'starting-3d-test',
+      createFakeForestProjectObject(),
+      starterThemeSlots
+    );
+
+    expect(errors.map((error) => error.message)).toEqual([
+      'Starter "starting-3d-test": "scene:Game Scene/Forest" property "Model" maps to "env.ground", a texture slot, but needs a model slot.',
+    ]);
+  });
+
+  it('requires a custom object drawing a 3D model to be mapped or ignored', () => {
+    const errors = checkStarterThemeSlots(
+      vocabulary,
+      'starting-3d-test',
+      createFakeForestProjectObject(),
+      createFakeStarterThemeSlots()
+    );
+    const starterThemeSlots = createFakeStarterThemeSlots();
+    (starterThemeSlots.ignoredObjects || []).push('scene:Game Scene/Forest');
+
+    expect(errors.map((error) => error.message)).toEqual([
+      'Starter "starting-3d-test": the Terrain3D::ScatteredModels "scene:Game Scene/Forest" draws a 3D model but is neither mapped to slots nor listed in ignoredObjects in theme-slots.json.',
+    ]);
+    expect(
+      checkStarterThemeSlots(
+        vocabulary,
+        'starting-3d-test',
+        createFakeForestProjectObject(),
+        starterThemeSlots
+      )
+    ).toEqual([]);
+  });
+
   it('requires a custom object to map its properties', () => {
     const errors = checkStarterThemeSlots(
       vocabulary,