}

	assert(IsValidImageIndex<VEH_AIRCRAFT>(spritenum));

	result->Set(direction + _aircraft_sprite[spritenum]);

}

void GetRotorImage(const Aircraft *v, EngineImageType image_type, VehicleSpriteSeq *result)

{

	assert(v->subtype == AIR_HELICOPTER);

	const Aircraft *w = v->Next()->Next();

	if (is_custom_sprite(v->spritenum)) {

		if (result->IsValid()) return;

	}

	/* Return standard rotor sprites if there are no custom sprites for this helicopter */

	result->Set(SPR_ROTOR_STOPPED + w->state);

}

static void GetAircraftIcon(EngineID engine, EngineImageType image_type, VehicleSpriteSeq *result)

{

	const Engine *e = Engine::Get(engine);

	uint8 spritenum = e->u.air.image_index;

	int x_offs = UnScaleGUI(rect.left);

	int x = rtl ? right - width - x_offs : left - x_offs;

	bool helicopter = v->subtype == AIR_HELICOPTER;

	int y_offs = ScaleGUITrad(10);

	int heli_offs = 0;

	PaletteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);

	seq.Draw(x, y + y_offs, pal, (v->vehstatus & VS_CRASHED) != 0);

	if (helicopter) {

		const Aircraft *a = Aircraft::From(v);

		VehicleSpriteSeq rotor_seq;

		if (!rotor_seq.IsValid()) rotor_seq.Set(SPR_ROTOR_STOPPED);

		heli_offs = ScaleGUITrad(5);

		rotor_seq.Draw(x, y + y_offs - heli_offs, PAL_NONE, false);

	}

	if (v->index == selection) {

		x += x_offs;

		y += UnScaleGUI(rect.top) + y_offs - heli_offs;

		DrawFrameRect(x - 1, y - 1, x + width + 1, y + UnScaleGUI(rect.bottom - rect.top + 1) + heli_offs + 1, COLOUR_WHITE, FR_BORDERONLY);

	}

}

		const SpriteGroup *group = object.Resolve();

		uint32 reg100 = sprite_stack ? GetRegister(0x100) : 0;

		if (group != nullptr && group->GetNumResults() != 0) {

			result->seq[result->count].sprite = group->GetResult() + (direction % group->GetNumResults());

			result->seq[result->count].pal    = GB(reg100, 0, 16); // zero means default recolouring

			result->count++;

		}

		if (!HasBit(reg100, 31)) break;

	}

}

{

	const Engine *e = Engine::Get(engine);

	/* Only valid for helicopters */

	assert(e->type == VEH_AIRCRAFT);

	assert(!(e->u.air.subtype & AIR_CTOL));

	VehicleResolverObject object(engine, v, VehicleResolverObject::WO_SELF, info_view, CBID_NO_CALLBACK);

	result->Clear();

	uint rotor_pos = v == nullptr || info_view ? 0 : v->Next()->Next()->state;

	bool sprite_stack = HasBit(e->info.misc_flags, EF_SPRITE_STACK);

	uint max_stack = sprite_stack ? lengthof(result->seq) : 1;

	for (uint stack = 0; stack < max_stack; ++stack) {

		object.ResetState();

		object.callback_param1 = image_type | (stack << 8);

		const SpriteGroup *group = object.Resolve();

		uint32 reg100 = sprite_stack ? GetRegister(0x100) : 0;

		if (group != nullptr && group->GetNumResults() != 0) {

static const uint VEHICLEINFO_FULL_VEHICLE_WIDTH    = 32;

struct VehicleSpriteSeq;

void SetWagonOverrideSprites(EngineID engine, CargoID cargo, const struct SpriteGroup *group, EngineID *train_id, uint trains);

const SpriteGroup *GetWagonOverrideSpriteSet(EngineID engine, CargoID cargo, EngineID overriding_engine);

void SetCustomEngineSprites(EngineID engine, byte cargo, const struct SpriteGroup *group);

void GetCustomEngineSprite(EngineID engine, const Vehicle *v, Direction direction, EngineImageType image_type, VehicleSpriteSeq *result);

#define GetCustomVehicleSprite(v, direction, image_type, result) GetCustomEngineSprite(v->engine_type, v, direction, image_type, result)

#define GetCustomVehicleIcon(et, direction, image_type, result) GetCustomEngineSprite(et, nullptr, direction, image_type, result)

/* Forward declaration of GRFFile, to avoid unnecessary inclusion of newgrf.h

 * elsewhere... */

struct GRFFile;

void SetEngineGRF(EngineID engine, const struct GRFFile *file);

uint16 GetVehicleCallback(CallbackID callback, uint32 param1, uint32 param2, EngineID engine, const Vehicle *v);

uint16 GetVehicleCallbackParent(CallbackID callback, uint32 param1, uint32 param2, EngineID engine, const Vehicle *v, const Vehicle *parent);

bool UsesWagonOverride(const Vehicle *v);

/* Handler to Evaluate callback 36. If the callback fails (i.e. most of the

	_cursor.sprite_count = 0;

	int total_width = 0;

	int y_offset = 0;

	bool rotor_seq = false; // Whether to draw the rotor of the vehicle in this step.

	while (v != nullptr) {

		if (total_width >= ScaleGUITrad(2 * (int)VEHICLEINFO_FULL_VEHICLE_WIDTH)) break;

		PaletteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);

		VehicleSpriteSeq seq;

		if (rotor_seq) {

			if (!seq.IsValid()) seq.Set(SPR_ROTOR_STOPPED);

			y_offset = - ScaleGUITrad(5);

		} else {

			v->GetImage(rtl ? DIR_E : DIR_W, image_type, &seq);

		}

		if (_cursor.sprite_count + seq.count > lengthof(_cursor.sprite_seq)) break;

		for (uint i = 0; i < seq.count; ++i) {

			PaletteID pal2 = (v->vehstatus & VS_CRASHED) || !seq.seq[i].pal ? pal : seq.seq[i].pal;

			_cursor.sprite_seq[_cursor.sprite_count].sprite = seq.seq[i].sprite;

			_cursor.sprite_seq[_cursor.sprite_count].pal = pal2;