Alpine Village Props - 4 Seasons

1. Overview

Alpine Village Props is a collection of 217 props from a historic mountain village in the Alps: the things that stand around a farmhouse, in a garden, in the barn and the workshop, on a village lane and at an inn.

• Each one is modelled from measured real-world examples at real-world scale.
• Each one is textured with tiling sets and a per-asset weathering mask.
• Each one is ready for four seasons; 79 season variant meshes add the shapes a season changes (296 static meshes in all).

The pack is built for first-person and close third-person views: 1024 pixels of texture per metre, rounded edges, weathering where the object is touched and where the rain runs.

What makes it different

• Four seasons from one set of assets.
  • A single parameter collection turns the whole pack to winter, spring, summer or autumn: snow on every up-facing face, wetness, puddles, frost and autumn colour.
  • Where a season changes an object's shape (a snow cap on a bench, flowers grown or wilted, a woodpile half used, a fountain under snow), a separate season variant mesh is included: 79 of them.
  • A season switch Blueprint sets the collection and swaps the variant meshes for you.
• Weathering you control. One master material drives every asset. Edge wear, cavity dirt, ambient occlusion, moss and per-instance colour variation are parameters, not baked into the colour.
• Real proportions. Fences, benches, troughs and hay racks follow the sizes of their real-life counterparts. Documented pivots make them snap together; fence and railing segments chain end to end.

What is in the pack (13 groups; season variants counted separately):

The pack also contains:

• an overview map (every asset on a labelled grid with 1.80 m posts for scale);
• a showcase map (a farmyard corner and a village lane with lighting and the season switch);
• source files for every asset (FBX with four LODs and 4K textures; section 9).

2. Requirements

• Unreal Engine 5.8. The pack was saved with 5.8 and does not open in older versions. Versions for 5.6 and 5.5 are planned as a free update. The Fab listing names 5.8 (tested with 5.8.3).
• Nanite. It is on for 204 of the 217 assets. It needs a DirectX 12 (SM6) or Vulkan GPU. Without Nanite support the engine draws the included LODs automatically.
• Lumen global illumination is recommended (the screenshots use it). The assets also work with baked lighting: UV channel 1 is a clean non-overlapping unwrap.
• No C++ and no third-party plugins. Everything uses native engine features: materials, a Material Parameter Collection, Niagara for the water jet (enabled by default), one Blueprint and one enumeration for the season switch.

3. Installation

The pack is a content-only Unreal project. All of its assets are in a single folder, Content/AlpineVillageKit.

Add it to your project (the usual way)

1. Add the pack to a project from the Fab plugin in the editor or from the Epic Games Launcher, or open the pack's own project.
2. In the Content Browser, right-click the AlpineVillageKit folder and choose Migrate...
3. Pick your project's Content folder as the target.

Every asset keeps its references; the materials, textures, the season collection, the Niagara systems and the season switch come along.

Do not move the folder in the file system (Explorer or Finder). Unreal keeps references by asset path; moved files lose their materials. Use Migrate, or move inside the Content Browser.

Keeping it in a plugin (optional)

Some studios keep third-party content in a plugin:

1. In your project, create an empty content-only plugin (Edit > Plugins > Add > Content Only) named AlpineVillageKit.
2. Migrate the folder into your project as above.
3. In the Content Browser, select everything in /Game/AlpineVillageKit, drag it into the plugin's content folder and choose Move Here.
4. Right-click the old folder, choose Fix Up Redirectors, then delete the empty folder and save all.

The pack works the same in either place.

4. Folder layout and naming

Content/AlpineVillageKit/
  Meshes/VillageProps/<Folder>/SM_<Asset>   the static meshes and their season variants
  Materials/
    M_AVK_Surface                    the master for all opaque props
    M_AVK_SurfaceMasked              cut-out parts (leaves and petals, nets, see-through wraps)
    M_AVK_Glass                      glass, ice, clear foil
    M_AVK_Water, M_AVK_WaterStrand   still water; the falling water of the spouts
    MPC_AVK_Season                   the season parameter collection
    Instances/MI_AVK_<Surface>       one instance per surface type (e.g. MI_AVK_TimberWeathered); Appendix B
    Instances/PerAsset/              the per-asset instances that carry each asset's mask
  Textures/
    Tiling/T_AVK_<Set>_{BC,N,ORM}    tiling texture sets
    Foliage/, Signs/                 the leaf and petal atlases, the sign lettering
    Masks/T_AVK_<Asset>_Mask         one weathering mask per asset
  Blueprints/BP_AVK_SeasonController the season switch
  Blueprints/E_AVK_Season            its season list (Spring, Summer, Autumn, Winter)
  FX/NS_AVK_WaterJet                 the water jet of the spouts (Niagara)
  Demo/Maps/L_AVK_Overview          every asset on a labelled grid
  Demo/Maps/L_AVK_Demo              the showcase map with lighting and the season switch
  Demo/Materials/                   the showcase map's ground materials

The mesh folders by group:

Names

• Prefixes: SM_ static mesh, M_ master material, MI_ material instance, T_ texture, MPC_ parameter collection, BP_ Blueprint, E_ enumeration, NS_ Niagara system.
• Texture suffixes: _BC base colour (sRGB), _N normal (DirectX), _ORM occlusion, roughness and metallic packed, _Mask the weathering mask (linear).
• Variants name the difference (_Open, _Closed, _Empty, _Work, _Red, _Grey, _Stack6).
• Season variants end in _Spring, _Autumn or _Winter. The asset without a suffix is the summer version.
• Sizes in the name are centimetres: Fence_Picket_200 is a 2 m segment, Woodpile_33_100 holds 33 cm logs over 1 m, MilkCan_20 holds 20 litres.

Conventions

• 1 unit = 1 cm, Z up.
• Every asset's front faces +Y.
• Every asset sits on its pivot (table below).

5. The materials

5.1 How the master works

Every opaque prop uses one master material, M_AVK_Surface, through instances.

• UV channel 0 carries a tiling texture set or an atlas: real-world scale, 1024 px per metre.
• UV channel 1 carries the asset's own weathering mask T_AVK_<Asset>_Mask:
  • R ambient occlusion (1 = open);
  • G edges (worn paint and corners);
  • B cavities;
  • A dirt, the gradient from the ground up and the grime where hands and rain go.

Because the weathering is a mask and not painted into the colour, you can make an asset cleaner, dirtier, mossier or a different colour without new textures.

5.2 Parameters of M_AVK_Surface

5.3 Making your own look

1. Recolour: duplicate a surface instance (e.g. MI_AVK_PaintGreen), change Tint, and assign it to the asset's slot. Painted wood keeps its grain through Desaturate.
2. Age an asset: on its per-asset instance (Instances/PerAsset/), raise EdgeWear, DirtAmount and CavityDarken.
3. Add moss: raise MossAmount (0.3-0.6 for a damp, shaded place). Moss only grows on up-facing faces and in the cavities the mask marks.
4. Variation in large placements: foliage tools and instanced meshes pick a random value per instance; HueRange and ValueRange set how far neighbours differ.
5. Indoors: for a prop you put inside a building, set Indoor to 1 on its per-asset instance, so winter does not snow on it.

5.4 Other masters

Instanced placement (foliage tool, instanced static meshes): the engine has to compile a material for instanced use. The pack's materials have this enabled, so you do not need to change anything. If you build your own masters from ours, enable Used with Instanced Static Meshes on them.

6. Seasons

6.1 How it works

All season effects read one Material Parameter Collection, MPC_AVK_Season. Change its values and every asset in the level follows: no swapping of materials, and no second texture set.

The collection's 16 scalars:

The presets the season switch uses:

The collection's saved defaults are summer: without the switch everything looks as in summer. The modelled flowers and the clipped hedge keep their green under AutumnTint; their autumn and winter look is in their variant meshes.

6.2 The season switch

Drag BP_AVK_SeasonController (Blueprints/) into your level once. In its details (category Season):

• Season: Spring, Summer, Autumn or Winter. The materials show the season at once in the editor viewport.
• Apply Season (button): also swaps the season meshes and shows the season's scenes in the editor. Save the level afterwards: the swapped meshes are saved with it.
• Overrides: fine-tune single values over the season's preset (e.g. a light snow with SnowAmount 0.4).
• Swap Meshes: replaces each summer asset in the level that has a season variant with that variant (e.g. SM_Bench_Back_180 with SM_Bench_Back_180_Winter), and back. In play only movable meshes are swapped; static ones keep the season you applied in the editor.
• Hide Tagged: actors tagged AVK_Season_spring, _summer, _autumn or _winter show only in those seasons (useful for scenes that exist only in one season). Untagged actors are never touched.
• Demo Keys: keys 1-4 switch the season in play (the showcase map uses it; off by default, so your game keeps its keys).

In play the controller applies its season on Begin Play. From your own Blueprints call Apply Season on it (e.g. from a day-night or weather system).

Without the switch: set the collection's values from your own Blueprint with Set Scalar Parameter Value (Collection), e.g. from a day-night or weather system, and place the season variants yourself.

6.3 Season variant meshes

Where a season changes the shape, the pack has a separate mesh. Snow on a flat bench seat is shader snow; a snow cushion, a covered fountain or a half-used woodpile is a mesh. There are 79 season variants (19 spring, 16 autumn, 44 winter) on 44 of the 217 assets:

• flower boxes and geranium pots (15 assets, 45 variants): each in its spring, autumn and winter state;
• woodpiles and the wood shelf (4 assets, 8 variants): burnt down in spring, snow-capped in winter;
• the clipped hedge: its autumn and winter states;
• snow caps on two benches, the inn bench, the beehives, the compost bin, the rabbit hutch, the woodshed, the wayside cross and shrine, the roofed facade cross, bus shelters, the info board, trail signposts, the hoop tunnel, the flower trough, the transporter, the log pile and the lumber stacks;
• water features: the fountain and the log trough iced and snow-capped in winter.

Appendix A lists the variants of every asset.

Place the summer asset and let the switch swap it, or place the variant directly.

6.4 Seasons in your own materials

Add a Collection Parameter node with MPC_AVK_Season to any material to use the same values. Your landscape, trees and buildings then change season together with the pack.

7. Placing the props

• Scale: every asset has its real size; do not scale it. A non-uniform scale stretches the textures and the mask.
• Snapping to the ground: select an asset and press End. The pivot is on the ground, so the asset lands where it should.
• Fences and railings: segments start at their pivot and end at their length along +X; set the grid snap to the segment length (e.g. 200) to chain them, and use the posts and end pieces at the ends. On slopes, tilt a segment about its pivot. Posts reach a little below the ground by design.
• Wall-standing props (flower boxes, wall letter boxes and mailboxes, the wall bench, woodpiles, the wood shelf, the tool rack, the leaning and wall-hung hand tools, the facade crosses, the wall meter box, the metal shelf, the plywood sheet): their pivot is at the back. Snap it to the wall face.
• Variants: open/closed, empty/full, working/parked, standing/leaning, colours, stacks and loaded states are separate meshes with the same pivot, so you can swap them in place (right-click > Replace Selected Actors with).
• Water: the fountain, the log trough, the rain barrel, the wooden gutter, the grindstone and the silage tyre stack carry still water as part of the mesh. The spouts' falling water is a Niagara jet (NS_AVK_WaterJet), placed in the showcase map; place it at the spout when you use the fountain or trough elsewhere.
• No physics or animation: machines, gates and doors are static meshes.

8. Performance: Nanite, LODs and collision

• Nanite is on for 204 of 217 assets (277 of the 296 meshes). It is off for the 13 assets with translucent parts (glass, clear foil, water: the bus shelter with glass, the bus stop sign, the shrine pillar, the rabbit hutch, the tractor, the transporter, the greenhouse, the fountain, the log trough, the rain barrel, the wooden gutter, the grindstone, the silage tyre stack) and the winter variants of six of them (19 meshes), which draw their LODs.
• LODs: every asset has LOD0-3, most at about 50 / 25 / 10 % of LOD0's triangles; assets with thin parts keep more (up to all of LOD0 on the low-poly fence posts; Appendix A has every count). Without Nanite the engine uses them; with Nanite they serve as fallback meshes.
• Triangles at LOD0: from 14 (a picket fence post) to 68,272 (a planted vegetable bed); median 5,604; all 217 together 2.79 million. Per-asset counts for all four LODs are in Appendix A.
• Collision:
  • simple convex hulls on 213 assets (162 with one hull, 33 with two, 13 with three, 5 with four; the open parasol's four hulls keep its canopy apart from the pole, so you can walk under it);
  • none by design on 4: the marigold row, the vegetable bed and the two snow poles (walk-through plants and thin poles);
  • fences, gates and railings collide segment by segment.
• Large placements: for scattered small props (flower pots, buckets, cones) set a cull distance in the foliage tool (e.g. 5000-8000 cm). The props carry no wind animation (World Position Offset), so they cost nothing extra in the distance and their shadows stay stable.
• Measured in the showcase map: packaged Win64 Development build, 1920 x 1080, engine default scalability, Lumen and Nanite on, RTX 2070 SUPER: 5.5 ms per frame on average (183 fps; GPU 5.0 ms, 99th percentile 6.5 ms), about 0.9 GB of GPU memory for the scene. The content folder is 815 MB on disk.

9. Textures and source files

Texture sets.

• The engine textures are 2K (2048 px).
• Tiling sets cover real surfaces at 1024 px per metre: wood grain, sawn, old and weathered boards, pine bark, iron, galvanised, rusty and corrugated metal, rubber, plastic, fabric, straw, soil, render and limewash, concrete, rock and rubble stone, roof boards and concrete tiles.
• Atlases carry the leaves and petals of the plants and the lettering of the signs.
• Every asset adds its own weathering mask (1024 px on 115 assets, 512 px on 102).
• Normal maps are DirectX convention.

Source files (AlpineVillageKit_VillageProps_Sources_1.0.zip, a separate download in the Fab listing, 2.1 GB):

• FBX/<Group>/<Asset>_LOD0-3.fbx: every mesh with its four LODs, in metres, Z up, front -Y in Blender terms (+Y in Unreal);
• Textures/Tiling: the texture sets at 4K (4096 px) PNG;
• Textures/Masks: the weathering masks as PNG;
• README.txt: the import settings.

Use them for other engines, for editing in a 3D program, or to re-import at 4K.

10. Licence and credits

The pack is sold under the Fab Standard License. You may use the assets in your projects, commercial ones included, as Fab's licence describes. You may not resell or redistribute the assets themselves, on their own or as an asset pack.

Credits. The tiling texture sets are made from CC0 (public-domain) photo scans by Poly Haven and ambientCG. We processed them:

• resized for the engine;
• normals converted to DirectX;
• occlusion, roughness and metallic packed into one texture.

CC0 needs no credit; we name the sources as a courtesy and as Fab asks for public-domain content:

Fonts. The lettering on the signs was drawn with Noto Sans (SIL Open Font License 1.1); the font itself is not included.

Everything else (models, masks, the leaf and lettering atlases, the generated plain and net textures, the materials and the season system) is our own work.

11. Known limitations

• Engine: 5.8 only at launch (5.6 and 5.5 planned).
• Static only: gates, doors, barriers and machines do not open or move.
• Shader snow:
  • snow on up-facing faces is a material effect, so it does not add volume;
  • the season variant meshes add snow caps where volume matters;
  • snow is not simulated (it does not react to the player).
• Season meshes: without the season switch the swap is manual (place the variant). In play the switch swaps only movable meshes; apply the season in the editor for static ones.
• Not every asset has every season: 44 of 217 assets have variant meshes; the rest change season through the materials only (section 6.3, Appendix A).
• Flowers and leaves: two-sided cards for petals and leaves; seen edge-on from very close they show as thin planes. They do not move in the wind.
• Lighting: the showcase map is set up for Lumen. With baked lighting, build lighting once after placing.

Release check: the pack was added to a blank Unreal Engine 5.8.3 project the way Fab adds it and packaged as a Win64 Development build: no missing references, no errors; both maps load and the season switch works in play.

12. FAQ

Which engine versions are supported? Unreal Engine 5.8. 5.6 and 5.5 versions are planned as a free update.

Do I need C++ or a plugin? No. The pack is content only: meshes, textures, materials, a parameter collection, a Niagara system and one Blueprint. It works in Blueprint-only projects.

How do I add it to an existing project? Migrate the AlpineVillageKit folder (section 3). Do not copy the folder in the file system.

How do I switch the season? Place BP_AVK_SeasonController once and pick the season (section 6.2), or set MPC_AVK_Season from your own Blueprint.

Will it run on lower-end hardware? Nanite needs an SM6 / Vulkan GPU; without it the engine draws the four included LODs. Large placements of small props should get a cull distance (section 8). The showcase map runs at about 5.5 ms per frame on an RTX 2070 SUPER at 1920 x 1080 (section 8).

Can I use it with baked lighting? Yes. UV channel 1 is a clean unwrap; build lighting after placing.

Can I change colours and wear? Yes, through the instance parameters, without new textures (section 5.3).

Can I use the assets in other engines? Yes: the source files hold every mesh as FBX with four LODs and the 4K textures (section 9). The materials and the season system are Unreal-only.

May I use it commercially? Yes, under the Fab Standard License (section 10).

13. Version history and support

Planned free updates: UE 5.6 / 5.5 versions; more season variants.

Support: max@maxlworks.com. Please include your engine version and, for a visual problem, a screenshot. We answer within a few working days.

14. The free sample

Alpine Village Props - Free Sample is eight props of this pack with their season variant meshes, for free. This documentation covers it too: the folder layout, the materials, the season switch and the placing rules are the same.

What differs from the full pack

• 18 static meshes: the eight props and 10 season variants (6 winter, 2 spring, 2 autumn), each with LOD0-3 and simple collision.
• Nanite is on for 14 of the 18 meshes. It is off on the log trough, the shrine pillar and their winter variants (water, ice and glass), which draw their LODs.
• Materials: the masters M_AVK_Surface, M_AVK_SurfaceMasked, M_AVK_Glass, M_AVK_Water and M_AVK_WaterStrand, the surface instances these props use and their per-asset instances with the weathering masks.
• Seasons: MPC_AVK_Season and the season switch BP_AVK_SeasonController with E_AVK_Season (section 6.2). The switch knows the sample's own 10 variants only.
• Water: one Niagara system, NS_AVK_WaterJet, for the trough's spout.
• Maps: a showcase map and an overview map.
• No source files: the FBX and 4K texture sources (section 9) come with the full pack only.
• Licence: the Fab Standard License, free. The same terms as the full pack (section 10).

Want the whole village? The full pack, Alpine Village Props - 4 Seasons, holds every asset of Appendix A in four seasons, with the same materials and season switch: the props of the sample fit right in.

Appendix A: asset list

217 assets, by group. Size: the bounding box in centimetres (X x Y x Z, front +Y). Triangles: LOD0 / LOD1 / LOD2 / LOD3. Collision: convex hulls (count) or none. Season variants: the meshes SM_<Asset>_<Season>.

Appendix B: material instances

The 160 surface instances in Materials/Instances/. Texture set: the tiling set or atlas on UV0 (section 9); tile: metres per texture tile; colour: the instance's Tint (sRGB hex). Glass, clear foil and still water have no instance of their own: those parts draw with M_AVK_Glass and M_AVK_Water (section 5.4). MI_AVK_WaterDrop and MI_AVK_WaterStrand belong to the water jet. The per-asset instances in Instances/PerAsset/ add each asset's mask.