mirror of
https://github.com/jmarshall23/DoomRTX.git
synced 2026-08-16 00:01:53 +02:00
Justin Marshall
703 lines
24 KiB
C++
703 lines
24 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
IceTech GPL Source Code
|
|
Copyright (C) 2026 Justin Marshall
|
|
|
|
This file is part of the IceTech GPL Source Code.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "qe3.h"
|
|
#include "CityBuilder.h"
|
|
#include "../../framework/DeclEntityDef.h"
|
|
|
|
extern int mapModified;
|
|
|
|
namespace {
|
|
|
|
struct cityStats_t {
|
|
int brushes;
|
|
int entities;
|
|
int buildings;
|
|
int streets;
|
|
};
|
|
|
|
struct cityBounds_t {
|
|
idVec3 mins;
|
|
idVec3 maxs;
|
|
};
|
|
|
|
struct cityMesh_t {
|
|
idStr model;
|
|
idBounds bounds;
|
|
idVec3 size;
|
|
};
|
|
|
|
static const float CITY_DEFAULT_HALF_SIZE = 6144.0f;
|
|
static const float CITY_MIN_SIZE = 4096.0f;
|
|
static const float CITY_MAX_SIZE = 65536.0f;
|
|
static const float CITY_ROAD_PITCH = 1408.0f;
|
|
static const float CITY_ROAD_WIDTH = 384.0f;
|
|
static const float CITY_SIDEWALK_WIDTH = 128.0f;
|
|
static const float CITY_CURB_WIDTH = 16.0f;
|
|
static const float CITY_CEILING_HEIGHT = 1536.0f;
|
|
static const float CITY_TEXTURE_SIZE = 1024.0f;
|
|
static const float CITY_ROAD_TEXTURE_LENGTH = 512.0f;
|
|
static const float CITY_SIDEWALK_TEXTURE_LENGTH = 256.0f;
|
|
static const float CITY_BUILDING_EDGE_SETBACK = 0.0f;
|
|
static const float CITY_BUILDING_ALLEY = 0.0f;
|
|
static const float CITY_MODEL_LOT_EXTRA = 64.0f;
|
|
static const float CITY_POINT_LIGHT_RADIUS = 300000.0f;
|
|
|
|
static const char* CITY_MAT_MARS_DIRT = "textures/mars_citybuilder/mars_dirt";
|
|
static const char* CITY_MAT_MARS_ROAD = "textures/mars_citybuilder/mars_road_dusty_center";
|
|
static const char* CITY_MAT_MARS_ROAD_EAST_WEST = "textures/mars_citybuilder/mars_road_dusty_center_east_west";
|
|
static const char* CITY_MAT_MARS_ROAD_INTERSECTION = "textures/mars_citybuilder/mars_road_dusty_intersection";
|
|
static const char* CITY_MAT_MARS_SIDEWALK = "textures/mars_citybuilder/mars_sidewalk_dusty";
|
|
static const char* CITY_MESH_DEF = "citybuilder_meshes";
|
|
static const char* CITY_FALLBACK_MESH = "models/offices/office.md5static";
|
|
static const idVec3 CITY_POINT_LIGHT_ORIGIN(-3200.0f, 3336.0f, 0.0f);
|
|
static const idVec3 CITY_POINT_LIGHT_COLOR(242.0f / 255.0f, 160.0f / 255.0f, 130.0f / 255.0f);
|
|
|
|
static float City_ClampFloat(float v, float minValue, float maxValue) {
|
|
if (v < minValue) {
|
|
return minValue;
|
|
}
|
|
if (v > maxValue) {
|
|
return maxValue;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
static int City_ClampInt(int v, int minValue, int maxValue) {
|
|
if (v < minValue) {
|
|
return minValue;
|
|
}
|
|
if (v > maxValue) {
|
|
return maxValue;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
static unsigned int City_Hash(int x, int y, int salt) {
|
|
unsigned int h = (unsigned int)(x * 73856093) ^ (unsigned int)(y * 19349663) ^ (unsigned int)(salt * 83492791);
|
|
h ^= h >> 13;
|
|
h *= 1274126177u;
|
|
h ^= h >> 16;
|
|
return h;
|
|
}
|
|
|
|
static float City_Random01(int x, int y, int salt) {
|
|
return (City_Hash(x, y, salt) & 0xffff) / 65535.0f;
|
|
}
|
|
|
|
static float City_TexScale(float worldUnits) {
|
|
return worldUnits / CITY_TEXTURE_SIZE;
|
|
}
|
|
|
|
static float City_TexShift(float worldCoord, float scale) {
|
|
if (scale == 0.0f) {
|
|
return 0.0f;
|
|
}
|
|
|
|
float shift = fmod(-worldCoord / scale, CITY_TEXTURE_SIZE);
|
|
if (shift < 0.0f) {
|
|
shift += CITY_TEXTURE_SIZE;
|
|
}
|
|
return shift;
|
|
}
|
|
|
|
static float City_TexShiftFloorXCenter(float worldCenter, float scale) {
|
|
if (scale == 0.0f) {
|
|
return 0.0f;
|
|
}
|
|
|
|
float shift = fmod(CITY_TEXTURE_SIZE * 0.5f - worldCenter / scale, CITY_TEXTURE_SIZE);
|
|
if (shift < 0.0f) {
|
|
shift += CITY_TEXTURE_SIZE;
|
|
}
|
|
return shift;
|
|
}
|
|
|
|
static float City_TexShiftFloorYCenter(float worldCenter, float scale) {
|
|
if (scale == 0.0f) {
|
|
return 0.0f;
|
|
}
|
|
|
|
float shift = fmod(CITY_TEXTURE_SIZE * 0.5f + worldCenter / scale, CITY_TEXTURE_SIZE);
|
|
if (shift < 0.0f) {
|
|
shift += CITY_TEXTURE_SIZE;
|
|
}
|
|
return shift;
|
|
}
|
|
|
|
static void City_SetTexdef(texdef_t& td, const char* material, float scale0 = 0.5f, float scale1 = 0.5f, float rotate = 0.0f, float shift0 = 0.0f, float shift1 = 0.0f) {
|
|
td.SetName(material);
|
|
td.shift[0] = shift0;
|
|
td.shift[1] = shift1;
|
|
td.rotate = rotate;
|
|
td.scale[0] = scale0;
|
|
td.scale[1] = scale1;
|
|
}
|
|
|
|
static idEditorBrush* City_AddWorldBrushUV(const idVec3& mins, const idVec3& maxs, const char* material, float scale0, float scale1, float rotate, float shift0, float shift1, cityStats_t& stats) {
|
|
if (mins.x >= maxs.x || mins.y >= maxs.y || mins.z >= maxs.z || world_entity == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
texdef_t td;
|
|
City_SetTexdef(td, material, scale0, scale1, rotate, shift0, shift1);
|
|
|
|
idEditorBrush* b = Brush_Create(mins, maxs, &td);
|
|
if (b == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
b->Brush_AddToList(&active_brushes);
|
|
world_entity->Entity_LinkBrush(b);
|
|
b->Brush_Build();
|
|
Undo_EndBrush(b);
|
|
stats.brushes++;
|
|
return b;
|
|
}
|
|
|
|
static idEditorBrush* City_AddWorldBrush(const idVec3& mins, const idVec3& maxs, const char* material, cityStats_t& stats) {
|
|
return City_AddWorldBrushUV(mins, maxs, material, 0.5f, 0.5f, 0.0f, 0.0f, 0.0f, stats);
|
|
}
|
|
|
|
static idEditorBrush* City_AddVerticalRoadBrush(float x, float y0, float y1, const cityBounds_t& bounds, cityStats_t& stats) {
|
|
const float roadHalf = CITY_ROAD_WIDTH * 0.5f;
|
|
const float scale0 = City_TexScale(CITY_ROAD_WIDTH);
|
|
const float scale1 = City_TexScale(CITY_ROAD_TEXTURE_LENGTH);
|
|
const idVec3 mins(x - roadHalf, y0, bounds.mins.z);
|
|
const idVec3 maxs(x + roadHalf, y1, bounds.mins.z + 8.0f);
|
|
return City_AddWorldBrushUV(mins, maxs, CITY_MAT_MARS_ROAD_EAST_WEST, scale0, scale1, 0.0f, City_TexShiftFloorXCenter(x, scale0), City_TexShift(maxs.y, scale1), stats);
|
|
}
|
|
|
|
static idEditorBrush* City_AddHorizontalRoadBrush(float x0, float x1, float y, const cityBounds_t& bounds, cityStats_t& stats) {
|
|
const float roadHalf = CITY_ROAD_WIDTH * 0.5f;
|
|
const float scale0 = City_TexScale(CITY_ROAD_TEXTURE_LENGTH);
|
|
const float scale1 = City_TexScale(CITY_ROAD_WIDTH);
|
|
const idVec3 mins(x0, y - roadHalf, bounds.mins.z);
|
|
const idVec3 maxs(x1, y + roadHalf, bounds.mins.z + 8.0f);
|
|
return City_AddWorldBrushUV(mins, maxs, CITY_MAT_MARS_ROAD, scale0, scale1, 0.0f, City_TexShift(mins.x, scale0), City_TexShiftFloorYCenter(y, scale1), stats);
|
|
}
|
|
|
|
static idEditorBrush* City_AddIntersectionRoadBrush(float x, float y, const cityBounds_t& bounds, cityStats_t& stats) {
|
|
const float roadHalf = CITY_ROAD_WIDTH * 0.5f;
|
|
const float scale = City_TexScale(CITY_ROAD_WIDTH);
|
|
const idVec3 mins(x - roadHalf, y - roadHalf, bounds.mins.z);
|
|
const idVec3 maxs(x + roadHalf, y + roadHalf, bounds.mins.z + 8.0f);
|
|
return City_AddWorldBrushUV(mins, maxs, CITY_MAT_MARS_ROAD_INTERSECTION, scale, scale, 0.0f, City_TexShiftFloorXCenter(x, scale), City_TexShiftFloorYCenter(y, scale), stats);
|
|
}
|
|
|
|
static idEditorBrush* City_AddVerticalSidewalkBrush(float x0, float x1, float y0, float y1, const cityBounds_t& bounds, cityStats_t& stats) {
|
|
const float scale0 = City_TexScale(CITY_SIDEWALK_WIDTH);
|
|
const float scale1 = City_TexScale(CITY_SIDEWALK_TEXTURE_LENGTH);
|
|
const idVec3 mins(x0, y0, bounds.mins.z);
|
|
const idVec3 maxs(x1, y1, bounds.mins.z + 8.0f);
|
|
return City_AddWorldBrushUV(mins, maxs, CITY_MAT_MARS_SIDEWALK, scale0, scale1, 0.0f, City_TexShift(mins.x, scale0), City_TexShift(mins.y, scale1), stats);
|
|
}
|
|
|
|
static idEditorBrush* City_AddHorizontalSidewalkBrush(float x0, float x1, float y0, float y1, const cityBounds_t& bounds, cityStats_t& stats) {
|
|
const float scale0 = City_TexScale(CITY_SIDEWALK_TEXTURE_LENGTH);
|
|
const float scale1 = City_TexScale(CITY_SIDEWALK_WIDTH);
|
|
const idVec3 mins(x0, y0, bounds.mins.z);
|
|
const idVec3 maxs(x1, y1, bounds.mins.z + 8.0f);
|
|
return City_AddWorldBrushUV(mins, maxs, CITY_MAT_MARS_SIDEWALK, scale0, scale1, 0.0f, City_TexShift(mins.x, scale0), City_TexShift(mins.y, scale1), stats);
|
|
}
|
|
|
|
static idEditorBrush* City_AddSidewalkCornerBrush(float x0, float x1, float y0, float y1, const cityBounds_t& bounds, cityStats_t& stats) {
|
|
const float scale = City_TexScale(CITY_SIDEWALK_WIDTH);
|
|
const idVec3 mins(x0, y0, bounds.mins.z);
|
|
const idVec3 maxs(x1, y1, bounds.mins.z + 8.0f);
|
|
return City_AddWorldBrushUV(mins, maxs, CITY_MAT_MARS_SIDEWALK, scale, scale, 0.0f, City_TexShift(mins.x, scale), City_TexShift(maxs.y, scale), stats);
|
|
}
|
|
|
|
static void City_SetVecKey(idEditorEntity* ent, const char* key, const idVec3& value) {
|
|
ent->SetKeyValue(key, va("%i %i %i", (int)value.x, (int)value.y, (int)value.z));
|
|
}
|
|
|
|
static idEditorEntity* City_AddFixedEntity(const char* classname, const idVec3& origin, cityStats_t& stats) {
|
|
idEditorEntity* ent = idEditorEntity::Entity_New();
|
|
if (ent == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
ent->brushes.onext = ent->brushes.oprev = &ent->brushes;
|
|
ent->origin = origin;
|
|
ent->SetKeyValue("classname", classname);
|
|
City_SetVecKey(ent, "origin", origin);
|
|
ent->Entity_Name(false);
|
|
ent->Entity_PostParse(&active_brushes);
|
|
ent->Entity_AddToList(&entities);
|
|
g_qeglobals.d_num_entities++;
|
|
|
|
Undo_EndEntity(ent);
|
|
for (idEditorBrush* b = ent->brushes.onext; b != &ent->brushes; b = b->onext) {
|
|
b->Brush_Build();
|
|
Undo_EndBrush(b);
|
|
stats.brushes++;
|
|
}
|
|
|
|
stats.entities++;
|
|
return ent;
|
|
}
|
|
|
|
static idEditorEntity* City_AddModelEntity(const cityMesh_t& mesh, const idVec3& origin, cityStats_t& stats) {
|
|
idEditorEntity* ent = idEditorEntity::Entity_New();
|
|
if (ent == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
ent->brushes.onext = ent->brushes.oprev = &ent->brushes;
|
|
ent->origin = origin;
|
|
ent->SetKeyValue("classname", "func_static");
|
|
ent->SetKeyValue("model", mesh.model.c_str());
|
|
City_SetVecKey(ent, "origin", origin);
|
|
ent->Entity_Name(false);
|
|
ent->Entity_PostParse(&active_brushes);
|
|
ent->Entity_AddToList(&entities);
|
|
g_qeglobals.d_num_entities++;
|
|
|
|
Undo_EndEntity(ent);
|
|
for (idEditorBrush* b = ent->brushes.onext; b != &ent->brushes; b = b->onext) {
|
|
b->Brush_Build();
|
|
Undo_EndBrush(b);
|
|
stats.brushes++;
|
|
}
|
|
|
|
stats.entities++;
|
|
stats.buildings++;
|
|
return ent;
|
|
}
|
|
|
|
static bool City_AddMeshToCatalog(const char* modelName, idList<cityMesh_t>& meshes) {
|
|
if (modelName == NULL || modelName[0] == '\0') {
|
|
return false;
|
|
}
|
|
|
|
idRenderModel* model = renderModelManager->FindModel(modelName);
|
|
if (model == NULL || model->IsDefaultModel()) {
|
|
common->Printf("Automatic City Builder: could not load mesh '%s'\n", modelName);
|
|
return false;
|
|
}
|
|
|
|
cityMesh_t& mesh = meshes.Alloc();
|
|
mesh.model = modelName;
|
|
mesh.bounds = model->Bounds(NULL);
|
|
mesh.size = mesh.bounds[1] - mesh.bounds[0];
|
|
if (mesh.size.x <= 0.0f) {
|
|
mesh.size.x = 1.0f;
|
|
}
|
|
if (mesh.size.y <= 0.0f) {
|
|
mesh.size.y = 1.0f;
|
|
}
|
|
if (mesh.size.z <= 0.0f) {
|
|
mesh.size.z = 1.0f;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static void City_LoadMeshCatalog(idList<cityMesh_t>& meshes) {
|
|
meshes.Clear();
|
|
|
|
const idDeclEntityDef* decl = static_cast<const idDeclEntityDef*>(declManager->FindType(DECL_ENTITYDEF, CITY_MESH_DEF, false));
|
|
if (decl != NULL) {
|
|
const idKeyValue* kv = decl->dict.MatchPrefix("mesh", NULL);
|
|
while (kv != NULL) {
|
|
City_AddMeshToCatalog(kv->GetValue().c_str(), meshes);
|
|
kv = decl->dict.MatchPrefix("mesh", kv);
|
|
}
|
|
}
|
|
|
|
if (meshes.Num() == 0) {
|
|
City_AddMeshToCatalog(CITY_FALLBACK_MESH, meshes);
|
|
}
|
|
}
|
|
|
|
static const cityMesh_t* City_ChooseMesh(const idList<cityMesh_t>& meshes, int blockX, int blockY, int lotX, int lotY) {
|
|
if (meshes.Num() == 0) {
|
|
return NULL;
|
|
}
|
|
return &meshes[City_Hash(blockX * 41 + lotX, blockY * 43 + lotY, 97) % meshes.Num()];
|
|
}
|
|
|
|
static float City_ModelLotSize(const idList<cityMesh_t>& meshes) {
|
|
float lotSize = 0.0f;
|
|
for (int i = 0; i < meshes.Num(); i++) {
|
|
float required = meshes[i].size.x;
|
|
if (meshes[i].size.y > required) {
|
|
required = meshes[i].size.y;
|
|
}
|
|
required += CITY_MODEL_LOT_EXTRA;
|
|
if (required > lotSize) {
|
|
lotSize = required;
|
|
}
|
|
}
|
|
if (lotSize <= 0.0f) {
|
|
lotSize = CITY_ROAD_PITCH;
|
|
}
|
|
return lotSize;
|
|
}
|
|
|
|
static float City_RequiredRoadPitch(const idList<cityMesh_t>& meshes) {
|
|
const float clearHalf = CITY_ROAD_WIDTH * 0.5f + CITY_SIDEWALK_WIDTH;
|
|
return City_ModelLotSize(meshes) + 2.0f * (CITY_BUILDING_EDGE_SETBACK + CITY_BUILDING_ALLEY + clearHalf);
|
|
}
|
|
|
|
static cityBounds_t City_GetTargetBounds() {
|
|
cityBounds_t bounds;
|
|
bounds.mins.Set(-CITY_DEFAULT_HALF_SIZE, -CITY_DEFAULT_HALF_SIZE, 0.0f);
|
|
bounds.maxs.Set(CITY_DEFAULT_HALF_SIZE, CITY_DEFAULT_HALF_SIZE, CITY_CEILING_HEIGHT);
|
|
|
|
if (selected_brushes.next != NULL && selected_brushes.next != &selected_brushes) {
|
|
idVec3 mins(999999.0f, 999999.0f, 999999.0f);
|
|
idVec3 maxs(-999999.0f, -999999.0f, -999999.0f);
|
|
for (idEditorBrush* b = selected_brushes.next; b != &selected_brushes; b = b->next) {
|
|
for (int i = 0; i < 3; i++) {
|
|
if (b->mins[i] < mins[i]) {
|
|
mins[i] = b->mins[i];
|
|
}
|
|
if (b->maxs[i] > maxs[i]) {
|
|
maxs[i] = b->maxs[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((maxs.x - mins.x) >= 128.0f && (maxs.y - mins.y) >= 128.0f) {
|
|
bounds.mins.x = mins.x;
|
|
bounds.mins.y = mins.y;
|
|
bounds.mins.z = mins.z;
|
|
bounds.maxs.x = maxs.x;
|
|
bounds.maxs.y = maxs.y;
|
|
bounds.maxs.z = mins.z + CITY_CEILING_HEIGHT;
|
|
}
|
|
}
|
|
|
|
const float centerX = (bounds.mins.x + bounds.maxs.x) * 0.5f;
|
|
const float centerY = (bounds.mins.y + bounds.maxs.y) * 0.5f;
|
|
float width = City_ClampFloat(bounds.maxs.x - bounds.mins.x, CITY_MIN_SIZE, CITY_MAX_SIZE);
|
|
float depth = City_ClampFloat(bounds.maxs.y - bounds.mins.y, CITY_MIN_SIZE, CITY_MAX_SIZE);
|
|
width = floor(width / 64.0f) * 64.0f;
|
|
depth = floor(depth / 64.0f) * 64.0f;
|
|
|
|
bounds.mins.x = centerX - width * 0.5f;
|
|
bounds.maxs.x = centerX + width * 0.5f;
|
|
bounds.mins.y = centerY - depth * 0.5f;
|
|
bounds.maxs.y = centerY + depth * 0.5f;
|
|
bounds.maxs.z = bounds.mins.z + CITY_CEILING_HEIGHT;
|
|
return bounds;
|
|
}
|
|
|
|
static void City_AddVerticalStreetEdges(float x, float y0, float y1, const cityBounds_t& bounds, cityStats_t& stats) {
|
|
if (y1 <= y0) {
|
|
return;
|
|
}
|
|
|
|
const float z0 = bounds.mins.z;
|
|
const float roadHalf = CITY_ROAD_WIDTH * 0.5f;
|
|
const float sideHalf = roadHalf + CITY_SIDEWALK_WIDTH;
|
|
|
|
City_AddVerticalSidewalkBrush(x - sideHalf, x - roadHalf, y0, y1, bounds, stats);
|
|
City_AddVerticalSidewalkBrush(x + roadHalf, x + sideHalf, y0, y1, bounds, stats);
|
|
City_AddWorldBrush(
|
|
idVec3(x - roadHalf - CITY_CURB_WIDTH, y0, z0 + 8.0f),
|
|
idVec3(x - roadHalf, y1, z0 + 14.0f),
|
|
"textures/base_wall/steel",
|
|
stats);
|
|
City_AddWorldBrush(
|
|
idVec3(x + roadHalf, y0, z0 + 8.0f),
|
|
idVec3(x + roadHalf + CITY_CURB_WIDTH, y1, z0 + 14.0f),
|
|
"textures/base_wall/steel",
|
|
stats);
|
|
}
|
|
|
|
static void City_AddHorizontalStreetEdges(float y, float x0, float x1, const cityBounds_t& bounds, cityStats_t& stats) {
|
|
if (x1 <= x0) {
|
|
return;
|
|
}
|
|
|
|
const float z0 = bounds.mins.z;
|
|
const float roadHalf = CITY_ROAD_WIDTH * 0.5f;
|
|
const float sideHalf = roadHalf + CITY_SIDEWALK_WIDTH;
|
|
|
|
City_AddHorizontalSidewalkBrush(x0, x1, y - sideHalf, y - roadHalf, bounds, stats);
|
|
City_AddHorizontalSidewalkBrush(x0, x1, y + roadHalf, y + sideHalf, bounds, stats);
|
|
City_AddWorldBrush(
|
|
idVec3(x0, y - roadHalf - CITY_CURB_WIDTH, z0 + 8.0f),
|
|
idVec3(x1, y - roadHalf, z0 + 14.0f),
|
|
"textures/base_wall/steel",
|
|
stats);
|
|
City_AddWorldBrush(
|
|
idVec3(x0, y + roadHalf, z0 + 8.0f),
|
|
idVec3(x1, y + roadHalf + CITY_CURB_WIDTH, z0 + 14.0f),
|
|
"textures/base_wall/steel",
|
|
stats);
|
|
}
|
|
|
|
static void City_AddVerticalStreetEdges(float x, const cityBounds_t& bounds, const idList<float>& blockers, cityStats_t& stats) {
|
|
const float clearHalf = CITY_ROAD_WIDTH * 0.5f + CITY_SIDEWALK_WIDTH;
|
|
float y0 = bounds.mins.y;
|
|
|
|
for (int i = 0; i < blockers.Num(); i++) {
|
|
const float y1 = blockers[i] - clearHalf;
|
|
City_AddVerticalStreetEdges(x, y0, y1, bounds, stats);
|
|
y0 = blockers[i] + clearHalf;
|
|
}
|
|
|
|
City_AddVerticalStreetEdges(x, y0, bounds.maxs.y, bounds, stats);
|
|
}
|
|
|
|
static void City_AddHorizontalStreetEdges(float y, const cityBounds_t& bounds, const idList<float>& blockers, cityStats_t& stats) {
|
|
const float clearHalf = CITY_ROAD_WIDTH * 0.5f + CITY_SIDEWALK_WIDTH;
|
|
float x0 = bounds.mins.x;
|
|
|
|
for (int i = 0; i < blockers.Num(); i++) {
|
|
const float x1 = blockers[i] - clearHalf;
|
|
City_AddHorizontalStreetEdges(y, x0, x1, bounds, stats);
|
|
x0 = blockers[i] + clearHalf;
|
|
}
|
|
|
|
City_AddHorizontalStreetEdges(y, x0, bounds.maxs.x, bounds, stats);
|
|
}
|
|
|
|
static void City_AddIntersectionSidewalkCorners(float x, float y, const cityBounds_t& bounds, cityStats_t& stats) {
|
|
const float roadHalf = CITY_ROAD_WIDTH * 0.5f;
|
|
const float sideHalf = roadHalf + CITY_SIDEWALK_WIDTH;
|
|
|
|
City_AddSidewalkCornerBrush(x - sideHalf, x - roadHalf, y - sideHalf, y - roadHalf, bounds, stats);
|
|
City_AddSidewalkCornerBrush(x + roadHalf, x + sideHalf, y - sideHalf, y - roadHalf, bounds, stats);
|
|
City_AddSidewalkCornerBrush(x - sideHalf, x - roadHalf, y + roadHalf, y + sideHalf, bounds, stats);
|
|
City_AddSidewalkCornerBrush(x + roadHalf, x + sideHalf, y + roadHalf, y + sideHalf, bounds, stats);
|
|
}
|
|
|
|
static void City_AddStreetSign(float x, float y, int avenue, int street, const cityBounds_t& bounds, cityStats_t& stats) {
|
|
const float z0 = bounds.mins.z;
|
|
const float poleX = x + CITY_ROAD_WIDTH * 0.5f + 44.0f;
|
|
const float poleY = y - CITY_ROAD_WIDTH * 0.5f - 44.0f;
|
|
|
|
City_AddWorldBrush(idVec3(poleX - 4.0f, poleY - 4.0f, z0 + 8.0f), idVec3(poleX + 4.0f, poleY + 4.0f, z0 + 128.0f), "textures/base_wall/steel", stats);
|
|
City_AddWorldBrush(idVec3(poleX - 56.0f, poleY - 5.0f, z0 + 112.0f), idVec3(poleX + 56.0f, poleY + 5.0f, z0 + 136.0f), "textures/base_wall/greenpanel1", stats);
|
|
City_AddWorldBrush(idVec3(poleX - 5.0f, poleY - 56.0f, z0 + 140.0f), idVec3(poleX + 5.0f, poleY + 56.0f, z0 + 164.0f), "textures/base_wall/greenpanel1", stats);
|
|
common->Printf("Automatic City Builder: street node A%i / S%i at %.0f %.0f\n", avenue + 1, street + 1, x, y);
|
|
}
|
|
|
|
static void City_AddRoads(const cityBounds_t& bounds, const idList<cityMesh_t>& meshes, idList<float>& roadX, idList<float>& roadY, cityStats_t& stats) {
|
|
const float roadHalf = CITY_ROAD_WIDTH * 0.5f;
|
|
float roadPitch = City_RequiredRoadPitch(meshes);
|
|
if (roadPitch <= 0.0f) {
|
|
roadPitch = CITY_ROAD_PITCH;
|
|
}
|
|
const int xRoads = City_ClampInt((int)((bounds.maxs.x - bounds.mins.x) / roadPitch), 2, 64);
|
|
const int yRoads = City_ClampInt((int)((bounds.maxs.y - bounds.mins.y) / roadPitch), 2, 64);
|
|
const float xStep = (bounds.maxs.x - bounds.mins.x) / (float)xRoads;
|
|
const float yStep = (bounds.maxs.y - bounds.mins.y) / (float)yRoads;
|
|
|
|
for (int i = 1; i < xRoads; i++) {
|
|
roadX.Append(bounds.mins.x + xStep * i);
|
|
}
|
|
|
|
for (int i = 1; i < yRoads; i++) {
|
|
roadY.Append(bounds.mins.y + yStep * i);
|
|
}
|
|
|
|
for (int i = 0; i < roadX.Num(); i++) {
|
|
const float x = roadX[i];
|
|
for (int segment = 0; segment <= roadY.Num(); segment++) {
|
|
const float y0 = (segment == 0) ? bounds.mins.y : roadY[segment - 1] + roadHalf;
|
|
const float y1 = (segment == roadY.Num()) ? bounds.maxs.y : roadY[segment] - roadHalf;
|
|
City_AddVerticalRoadBrush(x, y0, y1, bounds, stats);
|
|
}
|
|
City_AddVerticalStreetEdges(x, bounds, roadY, stats);
|
|
stats.streets++;
|
|
}
|
|
|
|
for (int i = 0; i < roadY.Num(); i++) {
|
|
const float y = roadY[i];
|
|
for (int segment = 0; segment <= roadX.Num(); segment++) {
|
|
const float x0 = (segment == 0) ? bounds.mins.x : roadX[segment - 1] + roadHalf;
|
|
const float x1 = (segment == roadX.Num()) ? bounds.maxs.x : roadX[segment] - roadHalf;
|
|
City_AddHorizontalRoadBrush(x0, x1, y, bounds, stats);
|
|
}
|
|
City_AddHorizontalStreetEdges(y, bounds, roadX, stats);
|
|
stats.streets++;
|
|
}
|
|
|
|
for (int x = 0; x < roadX.Num(); x++) {
|
|
for (int y = 0; y < roadY.Num(); y++) {
|
|
City_AddIntersectionRoadBrush(roadX[x], roadY[y], bounds, stats);
|
|
City_AddIntersectionSidewalkCorners(roadX[x], roadY[y], bounds, stats);
|
|
if (((x + y) & 1) == 0) {
|
|
City_AddStreetSign(roadX[x], roadY[y], x, y, bounds, stats);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void City_AddDirtLot(const cityBounds_t& bounds, float minX, float minY, float maxX, float maxY, cityStats_t& stats) {
|
|
if (maxX - minX <= 1.0f || maxY - minY <= 1.0f) {
|
|
return;
|
|
}
|
|
|
|
City_AddWorldBrush(
|
|
idVec3(minX, minY, bounds.mins.z),
|
|
idVec3(maxX, maxY, bounds.mins.z + 8.0f),
|
|
CITY_MAT_MARS_DIRT,
|
|
stats);
|
|
}
|
|
|
|
static void City_AddDirtLots(const cityBounds_t& bounds, const idList<float>& roadX, const idList<float>& roadY, cityStats_t& stats) {
|
|
const float clearHalf = CITY_ROAD_WIDTH * 0.5f + CITY_SIDEWALK_WIDTH;
|
|
float y0 = bounds.mins.y;
|
|
|
|
for (int y = 0; y <= roadY.Num(); y++) {
|
|
const float y1 = (y == roadY.Num()) ? bounds.maxs.y : roadY[y] - clearHalf;
|
|
float x0 = bounds.mins.x;
|
|
|
|
for (int x = 0; x <= roadX.Num(); x++) {
|
|
const float x1 = (x == roadX.Num()) ? bounds.maxs.x : roadX[x] - clearHalf;
|
|
City_AddDirtLot(bounds, x0, y0, x1, y1, stats);
|
|
|
|
if (x < roadX.Num()) {
|
|
x0 = roadX[x] + clearHalf;
|
|
}
|
|
}
|
|
|
|
if (y < roadY.Num()) {
|
|
y0 = roadY[y] + clearHalf;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void City_AddBlockBuildings(const cityBounds_t& bounds, const idList<cityMesh_t>& meshes, float minX, float minY, float maxX, float maxY, int blockX, int blockY, cityStats_t& stats) {
|
|
minX += CITY_BUILDING_EDGE_SETBACK;
|
|
minY += CITY_BUILDING_EDGE_SETBACK;
|
|
maxX -= CITY_BUILDING_EDGE_SETBACK;
|
|
maxY -= CITY_BUILDING_EDGE_SETBACK;
|
|
if (maxX - minX < 128.0f || maxY - minY < 128.0f) {
|
|
return;
|
|
}
|
|
|
|
const float modelLotSize = City_ModelLotSize(meshes);
|
|
const int lotsX = City_ClampInt((int)((maxX - minX) / modelLotSize), 1, 2);
|
|
const int lotsY = City_ClampInt((int)((maxY - minY) / modelLotSize), 1, 2);
|
|
const float stepX = (maxX - minX) / (float)lotsX;
|
|
const float stepY = (maxY - minY) / (float)lotsY;
|
|
|
|
for (int y = 0; y < lotsY; y++) {
|
|
for (int x = 0; x < lotsX; x++) {
|
|
if ((City_Hash(blockX * 17 + x, blockY * 19 + y, 7) % 100) < 8) {
|
|
continue;
|
|
}
|
|
|
|
const cityMesh_t* mesh = City_ChooseMesh(meshes, blockX, blockY, x, y);
|
|
if (mesh == NULL) {
|
|
continue;
|
|
}
|
|
|
|
float cellMinX = minX + x * stepX + CITY_BUILDING_ALLEY;
|
|
float cellMinY = minY + y * stepY + CITY_BUILDING_ALLEY;
|
|
float cellMaxX = minX + (x + 1) * stepX - CITY_BUILDING_ALLEY;
|
|
float cellMaxY = minY + (y + 1) * stepY - CITY_BUILDING_ALLEY;
|
|
const float roomX = cellMaxX - cellMinX;
|
|
const float roomY = cellMaxY - cellMinY;
|
|
if (roomX < mesh->size.x + CITY_MODEL_LOT_EXTRA || roomY < mesh->size.y + CITY_MODEL_LOT_EXTRA) {
|
|
continue;
|
|
}
|
|
|
|
const float centerX = (cellMinX + cellMaxX) * 0.5f;
|
|
const float centerY = (cellMinY + cellMaxY) * 0.5f;
|
|
const idVec3 modelCenter = (mesh->bounds[0] + mesh->bounds[1]) * 0.5f;
|
|
idVec3 origin;
|
|
origin.x = centerX - modelCenter.x;
|
|
origin.y = centerY - modelCenter.y;
|
|
origin.z = bounds.mins.z + 8.0f - mesh->bounds[0].z;
|
|
City_AddModelEntity(*mesh, origin, stats);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void City_AddBuildings(const cityBounds_t& bounds, const idList<float>& roadX, const idList<float>& roadY, const idList<cityMesh_t>& meshes, cityStats_t& stats) {
|
|
const float clearHalf = CITY_ROAD_WIDTH * 0.5f + CITY_SIDEWALK_WIDTH;
|
|
float y0 = bounds.mins.y;
|
|
|
|
for (int y = 0; y <= roadY.Num(); y++) {
|
|
const float y1 = (y == roadY.Num()) ? bounds.maxs.y : roadY[y] - clearHalf;
|
|
float x0 = bounds.mins.x;
|
|
|
|
for (int x = 0; x <= roadX.Num(); x++) {
|
|
const float x1 = (x == roadX.Num()) ? bounds.maxs.x : roadX[x] - clearHalf;
|
|
City_AddBlockBuildings(bounds, meshes, x0, y0, x1, y1, x, y, stats);
|
|
|
|
if (x < roadX.Num()) {
|
|
x0 = roadX[x] + clearHalf;
|
|
}
|
|
}
|
|
|
|
if (y < roadY.Num()) {
|
|
y0 = roadY[y] + clearHalf;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void City_AddPlayerStart(const cityBounds_t& bounds, cityStats_t& stats) {
|
|
City_AddFixedEntity("info_player_start", idVec3(bounds.mins.x + 192.0f, bounds.mins.y + 192.0f, bounds.mins.z + 48.0f), stats);
|
|
}
|
|
|
|
static void City_AddPointLight(cityStats_t& stats) {
|
|
idEditorEntity* ent = City_AddFixedEntity("light", CITY_POINT_LIGHT_ORIGIN, stats);
|
|
if (ent == NULL) {
|
|
return;
|
|
}
|
|
|
|
ent->SetKeyValue("_color", va("%.3f %.3f %.3f", CITY_POINT_LIGHT_COLOR.x, CITY_POINT_LIGHT_COLOR.y, CITY_POINT_LIGHT_COLOR.z));
|
|
ent->SetKeyValue("light_radius", va("%i %i %i", (int)CITY_POINT_LIGHT_RADIUS, (int)CITY_POINT_LIGHT_RADIUS, (int)CITY_POINT_LIGHT_RADIUS));
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void Radiant_GenerateAutomaticCity() {
|
|
if (world_entity == NULL) {
|
|
Sys_Status("Automatic City Builder needs an open map\n");
|
|
Sys_Beep();
|
|
return;
|
|
}
|
|
|
|
Sys_BeginWait();
|
|
Undo_Start("automatic city");
|
|
|
|
cityStats_t stats;
|
|
stats.brushes = 0;
|
|
stats.entities = 0;
|
|
stats.buildings = 0;
|
|
stats.streets = 0;
|
|
|
|
idList<float> roadX;
|
|
idList<float> roadY;
|
|
idList<cityMesh_t> meshes;
|
|
const cityBounds_t bounds = City_GetTargetBounds();
|
|
City_LoadMeshCatalog(meshes);
|
|
|
|
Select_Deselect();
|
|
City_AddRoads(bounds, meshes, roadX, roadY, stats);
|
|
City_AddDirtLots(bounds, roadX, roadY, stats);
|
|
City_AddBuildings(bounds, roadX, roadY, meshes, stats);
|
|
City_AddPlayerStart(bounds, stats);
|
|
City_AddPointLight(stats);
|
|
|
|
Map_BuildBrushData();
|
|
Sys_UpdateWindows(W_ALL);
|
|
mapModified = 1;
|
|
|
|
Undo_End();
|
|
Sys_EndWait();
|
|
common->Printf("Automatic City Builder: %i streets, %i buildings, %i brushes, %i entities\n", stats.streets, stats.buildings, stats.brushes, stats.entities);
|
|
Sys_Status(va("Automatic City Builder: %i streets, %i buildings generated", stats.streets, stats.buildings), 0);
|
|
}
|