Skip to content

Commit 388a4e1

Browse files
niknal357niknal357
committed
fix spelling
1 parent 341a005 commit 388a4e1

File tree

7 files changed

+85
-85
lines changed

7 files changed

+85
-85
lines changed

‎src/backend/circuit/circuit.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -150,8 +150,8 @@ void Circuit::tryInsertOverArea(Position cellA, Position cellB, Orientation tran
150150
if (cellA.y > cellB.y) std::swap(cellA.y, cellB.y);
151151

152152
DifferenceSharedPtr difference = std::make_shared<Difference>();
153-
for (cord_t x = cellA.x; x <= cellB.x; x++) {
154-
for (cord_t y = cellA.y; y <= cellB.y; y++) {
153+
for (coordinate_t x = cellA.x; x <= cellB.x; x++) {
154+
for (coordinate_t y = cellA.y; y <= cellB.y; y++) {
155155
blockContainer.tryInsertBlock(Position(x, y), transformAmount, blockType, difference.get());
156156
}
157157
}
@@ -166,8 +166,8 @@ void Circuit::tryRemoveOverArea(Position cellA, Position cellB) {
166166
if (cellA.y > cellB.y) std::swap(cellA.y, cellB.y);
167167

168168
DifferenceSharedPtr difference = std::make_shared<Difference>();
169-
for (cord_t x = cellA.x; x <= cellB.x; x++) {
170-
for (cord_t y = cellA.y; y <= cellB.y; y++) {
169+
for (coordinate_t x = cellA.x; x <= cellB.x; x++) {
170+
for (coordinate_t y = cellA.y; y <= cellB.y; y++) {
171171
blockContainer.tryRemoveBlock(Position(x, y), difference.get());
172172
}
173173
}

‎src/backend/position/position.h

Lines changed: 56 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -3,8 +3,8 @@
33

44
#include "util/fastMath.h"
55

6-
typedef int cord_t;
7-
typedef float f_cord_t;
6+
typedef int coordinate_t;
7+
typedef float f_coordinate_t;
88

99
struct Vector;
1010
struct FVector;
@@ -17,9 +17,9 @@ struct Vector {
1717
class Iterator;
1818

1919
inline Vector() noexcept : dx(0), dy(0) { }
20-
inline Vector(cord_t dx, cord_t dy) noexcept : dx(dx), dy(dy) { }
20+
inline Vector(coordinate_t dx, coordinate_t dy) noexcept : dx(dx), dy(dy) { }
2121
// allows the easy creation of vectors that are all the same value
22-
inline Vector(cord_t d) noexcept : dx(d), dy(d) { }
22+
inline Vector(coordinate_t d) noexcept : dx(d), dy(d) { }
2323
inline FVector free() const noexcept;
2424

2525
inline void extentToFit(Vector vector) noexcept {
@@ -34,9 +34,9 @@ struct Vector {
3434
inline bool hasZeros() const noexcept { return !(dx && dy); }
3535
inline bool widthInSize(Size size) const noexcept;
3636

37-
inline cord_t manhattenlength() const noexcept { return Abs(dx) + Abs(dy); }
38-
inline f_cord_t lengthSquared() const noexcept { return FastPower<2>(dx) + FastPower<2>(dy); }
39-
inline f_cord_t length() const noexcept { return sqrt(lengthSquared()); }
37+
inline coordinate_t manhattenlength() const noexcept { return Abs(dx) + Abs(dy); }
38+
inline f_coordinate_t lengthSquared() const noexcept { return FastPower<2>(dx) + FastPower<2>(dy); }
39+
inline f_coordinate_t length() const noexcept { return sqrt(lengthSquared()); }
4040

4141
inline Vector operator+(Vector other) const noexcept { return Vector(dx + other.dx, dy + other.dy); }
4242
inline Vector& operator+=(Vector other) noexcept {
@@ -50,23 +50,23 @@ struct Vector {
5050
dy -= other.dy;
5151
return *this;
5252
}
53-
inline cord_t operator*(Vector vector) const noexcept { return dx * vector.dx + dy * vector.dy; }
54-
inline Vector operator*(cord_t scalar) const noexcept { return Vector(dx * scalar, dy * scalar); }
55-
inline Vector& operator*=(cord_t scalar) noexcept {
53+
inline coordinate_t operator*(Vector vector) const noexcept { return dx * vector.dx + dy * vector.dy; }
54+
inline Vector operator*(coordinate_t scalar) const noexcept { return Vector(dx * scalar, dy * scalar); }
55+
inline Vector& operator*=(coordinate_t scalar) noexcept {
5656
dx *= scalar;
5757
dy *= scalar;
5858
return *this;
5959
}
60-
inline Vector operator/(cord_t scalar) const noexcept { return Vector(dx / scalar, dy / scalar); }
61-
inline Vector& operator/=(cord_t scalar) noexcept {
60+
inline Vector operator/(coordinate_t scalar) const noexcept { return Vector(dx / scalar, dy / scalar); }
61+
inline Vector& operator/=(coordinate_t scalar) noexcept {
6262
dx /= scalar;
6363
dy /= scalar;
6464
return *this;
6565
}
6666

6767
inline Iterator iter() const noexcept;
6868

69-
cord_t dx, dy;
69+
coordinate_t dx, dy;
7070
};
7171

7272
class Vector::Iterator {
@@ -126,8 +126,8 @@ Vector::Iterator Vector::iter() const noexcept { return Iterator(*this); }
126126
template <>
127127
struct std::hash<Vector> {
128128
inline std::size_t operator()(Vector vec) const noexcept {
129-
std::size_t x = std::hash<cord_t>{}(vec.dx);
130-
std::size_t y = std::hash<cord_t>{}(vec.dy);
129+
std::size_t x = std::hash<coordinate_t>{}(vec.dx);
130+
std::size_t y = std::hash<coordinate_t>{}(vec.dy);
131131
return (std::size_t)x ^ ((std::size_t)y << 32);
132132
}
133133
};
@@ -141,19 +141,19 @@ struct std::formatter<Vector> : std::formatter<std::string> {
141141

142142
struct FVector {
143143
inline FVector() noexcept : dx(0.0f), dy(0.0f) { }
144-
inline FVector(f_cord_t dx, f_cord_t dy) noexcept : dx(dx), dy(dy) { }
144+
inline FVector(f_coordinate_t dx, f_coordinate_t dy) noexcept : dx(dx), dy(dy) { }
145145
// allows the easy creation of fvectors that are all the same value
146-
inline FVector(f_cord_t d) noexcept : dx(d), dy(d) { }
146+
inline FVector(f_coordinate_t d) noexcept : dx(d), dy(d) { }
147147
inline Vector snap() const noexcept;
148148

149149
inline std::string toString() const noexcept { return "<" + std::to_string(dx) + ", " + std::to_string(dy) + ">"; }
150150

151151
inline bool operator==(FVector other) const noexcept { return approx_equals(dx, other.dx) && approx_equals(dy, other.dy); }
152152
inline bool operator!=(FVector other) const noexcept { return !operator==(other); }
153153

154-
inline f_cord_t manhattenlength() const noexcept { return fabs(dx) + fabs(dy); }
155-
inline f_cord_t lengthSquared() const noexcept { return FastPower<2>(dx) + FastPower<2>(dy); }
156-
inline f_cord_t length() const noexcept { return sqrt(FastPower<2>(dx) + FastPower<2>(dy)); }
154+
inline f_coordinate_t manhattenlength() const noexcept { return fabs(dx) + fabs(dy); }
155+
inline f_coordinate_t lengthSquared() const noexcept { return FastPower<2>(dx) + FastPower<2>(dy); }
156+
inline f_coordinate_t length() const noexcept { return sqrt(FastPower<2>(dx) + FastPower<2>(dy)); }
157157

158158
inline FVector operator+(FVector other) const noexcept { return FVector(dx + other.dx, dy + other.dy); }
159159
inline FVector& operator+=(FVector other) noexcept {
@@ -167,23 +167,23 @@ struct FVector {
167167
dy -= other.dy;
168168
return *this;
169169
}
170-
inline FVector operator*(f_cord_t scalar) const noexcept { return FVector(dx * scalar, dy * scalar); }
171-
inline FVector& operator*=(f_cord_t scalar) noexcept {
170+
inline FVector operator*(f_coordinate_t scalar) const noexcept { return FVector(dx * scalar, dy * scalar); }
171+
inline FVector& operator*=(f_coordinate_t scalar) noexcept {
172172
dx *= scalar, dy *= scalar;
173173
return *this;
174174
}
175-
inline f_cord_t operator*(FVector vector) const noexcept { return dx * vector.dx + dy * vector.dy; }
176-
inline FVector operator/(f_cord_t scalar) noexcept { return FVector(dx / scalar, dy / scalar); }
177-
inline FVector& operator/=(f_cord_t scalar) noexcept {
175+
inline f_coordinate_t operator*(FVector vector) const noexcept { return dx * vector.dx + dy * vector.dy; }
176+
inline FVector operator/(f_coordinate_t scalar) noexcept { return FVector(dx / scalar, dy / scalar); }
177+
inline FVector& operator/=(f_coordinate_t scalar) noexcept {
178178
dx /= scalar;
179179
dy /= scalar;
180180
return *this;
181181
}
182182

183-
inline f_cord_t lengthAlongProjectToVec(FVector vector) const noexcept { return (*this * vector) / vector.length(); }
183+
inline f_coordinate_t lengthAlongProjectToVec(FVector vector) const noexcept { return (*this * vector) / vector.length(); }
184184
inline FVector projectToVec(FVector vector) const noexcept { return vector * (*this * vector) / vector.lengthSquared(); }
185185

186-
f_cord_t dx, dy;
186+
f_coordinate_t dx, dy;
187187
};
188188

189189
template <>
@@ -197,9 +197,9 @@ struct Size {
197197
class Iterator;
198198

199199
inline Size() noexcept : w(0), h(0) { }
200-
inline Size(cord_t w, cord_t h) noexcept : w(w), h(h) { }
200+
inline Size(coordinate_t w, coordinate_t h) noexcept : w(w), h(h) { }
201201
// makes the size for hypercube with some edges length
202-
inline Size(cord_t sideLength) noexcept : w(sideLength), h(sideLength) { }
202+
inline Size(coordinate_t sideLength) noexcept : w(sideLength), h(sideLength) { }
203203
inline FSize free() const noexcept;
204204

205205
inline void extentToFit(Vector vector) noexcept {
@@ -214,14 +214,14 @@ struct Size {
214214
// w != 0 and h != 0
215215
inline bool isValid() const noexcept { return w > 0 && h > 0; }
216216

217-
inline cord_t area() const noexcept { return w * h; }
218-
inline cord_t perimeter() const noexcept { return w * 2 + h * 2; }
217+
inline coordinate_t area() const noexcept { return w * h; }
218+
inline coordinate_t perimeter() const noexcept { return w * 2 + h * 2; }
219219

220220
inline Iterator iter() const noexcept;
221221

222222
inline Vector getLargestVectorInArea() { return Vector(w - 1, h - 1); }
223223

224-
cord_t w, h;
224+
coordinate_t w, h;
225225
};
226226

227227
template <>
@@ -296,7 +296,7 @@ struct FSize {
296296
// class Iterator;
297297

298298
inline FSize() noexcept : w(0), h(0) { }
299-
inline FSize(f_cord_t w, f_cord_t h) noexcept : w(w), h(h) { }
299+
inline FSize(f_coordinate_t w, f_coordinate_t h) noexcept : w(w), h(h) { }
300300
inline Size snap() const noexcept;
301301

302302
inline void extentToFit(FVector vector) noexcept {
@@ -311,12 +311,12 @@ struct FSize {
311311
// w != 0 and h != 0
312312
inline bool isValid() const noexcept { return !(w && h); }
313313

314-
inline f_cord_t area() const noexcept { return w * h; }
315-
inline f_cord_t perimeter() const noexcept { return w * 2 + h * 2; }
314+
inline f_coordinate_t area() const noexcept { return w * h; }
315+
inline f_coordinate_t perimeter() const noexcept { return w * 2 + h * 2; }
316316

317317
// inline Iterator iter() const noexcept;
318318

319-
f_cord_t w, h;
319+
f_coordinate_t w, h;
320320
};
321321

322322
template <>
@@ -330,7 +330,7 @@ struct Position {
330330
class Iterator;
331331

332332
inline Position() noexcept : x(0), y(0) { }
333-
inline Position(cord_t x, cord_t y) noexcept : x(x), y(y) { }
333+
inline Position(coordinate_t x, coordinate_t y) noexcept : x(x), y(y) { }
334334
inline FPosition free() const noexcept;
335335

336336
inline std::string toString() const noexcept { return "(" + std::to_string(x) + ", " + std::to_string(y) + ")"; }
@@ -339,12 +339,12 @@ struct Position {
339339
inline bool operator!=(Position position) const noexcept { return !operator==(position); }
340340
inline bool withinArea(Position small, Position large) const noexcept { return small.x <= x && small.y <= y && large.x >= x && large.y >= y; }
341341

342-
inline cord_t manhattenDistanceTo(Position position) const noexcept { return Abs(x - position.x) + Abs(y - position.y); }
343-
inline cord_t manhattenDistanceToOrigin() const noexcept { return Abs(x) + Abs(y); }
344-
inline cord_t distanceToSquared(Position position) const noexcept { return FastPower<2>(x - position.x) + FastPower<2>(y - position.y); }
345-
inline cord_t distanceToOriginSquared() const noexcept { return FastPower<2>(x) + FastPower<2>(y); }
346-
inline f_cord_t distanceTo(Position position) const noexcept { return sqrt(FastPower<2>(x - position.x) + FastPower<2>(y - position.y)); }
347-
inline f_cord_t distanceToOrigin() const noexcept { return sqrt(FastPower<2>(x) + FastPower<2>(y)); }
342+
inline coordinate_t manhattenDistanceTo(Position position) const noexcept { return Abs(x - position.x) + Abs(y - position.y); }
343+
inline coordinate_t manhattenDistanceToOrigin() const noexcept { return Abs(x) + Abs(y); }
344+
inline coordinate_t distanceToSquared(Position position) const noexcept { return FastPower<2>(x - position.x) + FastPower<2>(y - position.y); }
345+
inline coordinate_t distanceToOriginSquared() const noexcept { return FastPower<2>(x) + FastPower<2>(y); }
346+
inline f_coordinate_t distanceTo(Position position) const noexcept { return sqrt(FastPower<2>(x - position.x) + FastPower<2>(y - position.y)); }
347+
inline f_coordinate_t distanceToOrigin() const noexcept { return sqrt(FastPower<2>(x) + FastPower<2>(y)); }
348348

349349
inline Position operator+(Vector vector) const noexcept { return Position(x + vector.dx, y + vector.dy); }
350350
inline Position& operator+=(Vector vector) noexcept {
@@ -362,7 +362,7 @@ struct Position {
362362

363363
inline Iterator iterTo(Position other) const noexcept;
364364

365-
cord_t x, y;
365+
coordinate_t x, y;
366366
};
367367

368368
class Position::Iterator {
@@ -440,8 +440,8 @@ inline bool areaWithinArea(Position area1Small, Position area1Large, Position ar
440440
template <>
441441
struct std::hash<Position> {
442442
inline std::size_t operator()(Position pos) const noexcept {
443-
std::size_t x = std::hash<cord_t>{}(pos.x);
444-
std::size_t y = std::hash<cord_t>{}(pos.y);
443+
std::size_t x = std::hash<coordinate_t>{}(pos.x);
444+
std::size_t y = std::hash<coordinate_t>{}(pos.y);
445445
return y + 0x9e3779b9 + (x << 6) + (x >> 2);
446446
}
447447
};
@@ -465,7 +465,7 @@ struct std::formatter<Position> : std::formatter<std::string> {
465465
struct FPosition {
466466
static FPosition getInvalid() { return FPosition(std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()); }
467467
inline FPosition() noexcept : x(0.0f), y(0.0f) { }
468-
inline FPosition(f_cord_t x, f_cord_t y) noexcept : x(x), y(y) { }
468+
inline FPosition(f_coordinate_t x, f_coordinate_t y) noexcept : x(x), y(y) { }
469469
inline Position snap() const noexcept;
470470

471471
inline std::string toString() const noexcept { return "(" + std::to_string(x) + ", " + std::to_string(y) + ")"; }
@@ -478,12 +478,12 @@ struct FPosition {
478478
inline bool operator!=(FPosition position) const noexcept { return !operator==(position); }
479479
inline bool withinArea(FPosition small, FPosition large) const noexcept { return small.x <= x && small.y <= y && large.x >= x && large.y >= y; }
480480

481-
inline f_cord_t manhattenDistanceTo(FPosition other) const noexcept { return fabs(x - other.x) + fabs(y - other.y); }
482-
inline f_cord_t manhattenDistanceToOrigin() const noexcept { return fabs(x) + fabs(y); }
483-
inline f_cord_t distanceToSquared(FPosition other) const noexcept { return FastPower<2>(x - other.x) + FastPower<2>(y - other.y); }
484-
inline f_cord_t distanceToOriginSquared() const noexcept { return FastPower<2>(x) + FastPower<2>(y); }
485-
inline f_cord_t distanceTo(FPosition other) const noexcept { return sqrt(FastPower<2>(x - other.x) + FastPower<2>(y - other.y)); }
486-
inline f_cord_t distanceToOrigin() const noexcept { return sqrt(FastPower<2>(x) + FastPower<2>(y)); }
481+
inline f_coordinate_t manhattenDistanceTo(FPosition other) const noexcept { return fabs(x - other.x) + fabs(y - other.y); }
482+
inline f_coordinate_t manhattenDistanceToOrigin() const noexcept { return fabs(x) + fabs(y); }
483+
inline f_coordinate_t distanceToSquared(FPosition other) const noexcept { return FastPower<2>(x - other.x) + FastPower<2>(y - other.y); }
484+
inline f_coordinate_t distanceToOriginSquared() const noexcept { return FastPower<2>(x) + FastPower<2>(y); }
485+
inline f_coordinate_t distanceTo(FPosition other) const noexcept { return sqrt(FastPower<2>(x - other.x) + FastPower<2>(y - other.y)); }
486+
inline f_coordinate_t distanceToOrigin() const noexcept { return sqrt(FastPower<2>(x) + FastPower<2>(y)); }
487487

488488
inline FPosition operator+(FVector vector) const noexcept { return FPosition(x + vector.dx, y + vector.dy); }
489489
inline FPosition& operator+=(FVector vector) noexcept {
@@ -498,11 +498,11 @@ struct FPosition {
498498
y -= vector.dy;
499499
return *this;
500500
}
501-
inline FPosition operator*(f_cord_t scalar) const noexcept { return FPosition(x * scalar, y * scalar); }
502-
inline f_cord_t lengthAlongProjectToVec(FPosition orginOfVec, FVector vector) const noexcept { return (*this - orginOfVec).lengthAlongProjectToVec(vector); }
501+
inline FPosition operator*(f_coordinate_t scalar) const noexcept { return FPosition(x * scalar, y * scalar); }
502+
inline f_coordinate_t lengthAlongProjectToVec(FPosition orginOfVec, FVector vector) const noexcept { return (*this - orginOfVec).lengthAlongProjectToVec(vector); }
503503
inline FPosition projectToVec(FPosition orginOfVec, FVector vector) const noexcept { return orginOfVec + (*this - orginOfVec).projectToVec(vector); }
504504

505-
f_cord_t x, y;
505+
f_coordinate_t x, y;
506506
};
507507

508508
inline bool areaWithinArea(FPosition area1Small, FPosition area1Large, FPosition area2Small, FPosition area2Large) noexcept {

‎src/backend/proceduralCircuits/generatedCircuitValidator.cpp

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -84,7 +84,7 @@ bool GeneratedCircuitValidator::handleInvalidConnections() {
8484

8585
bool GeneratedCircuitValidator::setOverlapsUnpositioned() {
8686
for (auto& [id, block] : generatedCircuit.blocks) {
87-
if (block.position.x == std::numeric_limits<cord_t>::max() || block.position.y == std::numeric_limits<cord_t>::max()) {
87+
if (block.position.x == std::numeric_limits<coordinate_t>::max() || block.position.y == std::numeric_limits<coordinate_t>::max()) {
8888
continue;
8989
}
9090

@@ -115,8 +115,8 @@ bool GeneratedCircuitValidator::setOverlapsUnpositioned() {
115115
block.position.toString(),
116116
intPos.toString()
117117
);
118-
block.position.x = std::numeric_limits<cord_t>::max();
119-
block.position.y = std::numeric_limits<cord_t>::max();
118+
block.position.x = std::numeric_limits<coordinate_t>::max();
119+
block.position.y = std::numeric_limits<coordinate_t>::max();
120120
} else {
121121
// mark all positions as occupied
122122
occupiedPositions.insert(takenPositions.begin(), takenPositions.end());
@@ -313,7 +313,7 @@ bool GeneratedCircuitValidator::handleUnpositionedBlocks() {
313313
auto iter = generatedCircuit.blocks.find(id);
314314
if (iter == generatedCircuit.blocks.end()) continue;
315315
GeneratedCircuit::GeneratedCircuitBlockData& block = iter->second;
316-
if (block.position.x != std::numeric_limits<cord_t>::max() && block.position.y != std::numeric_limits<cord_t>::max()) {
316+
if (block.position.x != std::numeric_limits<coordinate_t>::max() && block.position.y != std::numeric_limits<coordinate_t>::max()) {
317317
continue;
318318
}
319319

@@ -360,7 +360,7 @@ bool GeneratedCircuitValidator::handleUnpositionedBlocks() {
360360
block.position = Position(x, y);
361361
layerYcounter[x] = y + blockSize.h;
362362

363-
cord_t blockMaxY = y + blockSize.h - 1;
363+
coordinate_t blockMaxY = y + blockSize.h - 1;
364364

365365
maxYPlaced = std::max(maxYPlaced, blockMaxY);
366366
}

‎src/computerAPI/circuits/BLIFParser.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -19,8 +19,8 @@ class BLIFParser: public ParsedCircuitLoader {
1919
std::unordered_map<std::string, ConnectionEnd> nameToConnectionEnd;
2020
std::vector<std::pair<std::string, ConnectionEnd>> connectionsToMake;
2121
connection_end_id_t endId;
22-
cord_t inPortY;
23-
cord_t outPortY;
22+
coordinate_t inPortY;
23+
coordinate_t outPortY;
2424
block_id_t blockIdCounter;
2525
BlockType type = BlockType::NONE;
2626
};

‎src/computerAPI/circuits/connectionMachineParser.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -137,7 +137,7 @@ std::vector<circuit_id_t> ConnectionMachineParser::load(const std::string& path)
137137
inputFile >> cToken;
138138
connection_end_id_t endId;
139139
int blockId;
140-
cord_t vecX, vecY;
140+
coordinate_t vecX, vecY;
141141
std::string portName = "";
142142
inputFile >> token >> endId >> cToken >> blockId >> cToken >> cToken >> vecX >> cToken >> vecY >> cToken >> cToken >> std::quoted(portName) >> cToken;
143143
currentParsedCircuit->addConnectionPort(token == "IN,", endId, Vector(vecX, vecY), blockId, 0, portName);

‎src/gpu/renderer/viewport/logic/chunking/vulkanChunker.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@
99
#include "logging/logging.h"
1010

1111
const int CHUNK_SIZE = 64;
12-
cord_t getChunk(cord_t in) {
12+
coordinate_t getChunk(coordinate_t in) {
1313
return std::floor((float)in / (float)CHUNK_SIZE) * (int)CHUNK_SIZE;
1414
}
1515
Position getChunk(Position in) {
@@ -348,8 +348,8 @@ std::vector<std::shared_ptr<VulkanChunkAllocation>> VulkanChunker::getAllocation
348348

349349
// go through each chunk in view and collect it if it exists and has an allocation
350350
std::vector<std::shared_ptr<VulkanChunkAllocation>> seen;
351-
for (cord_t chunkX = min.x; chunkX <= max.x; chunkX += CHUNK_SIZE) {
352-
for (cord_t chunkY = min.y; chunkY <= max.y; chunkY += CHUNK_SIZE) {
351+
for (coordinate_t chunkX = min.x; chunkX <= max.x; chunkX += CHUNK_SIZE) {
352+
for (coordinate_t chunkY = min.y; chunkY <= max.y; chunkY += CHUNK_SIZE) {
353353
auto chunk = chunks.find({ chunkX, chunkY });
354354
if (chunk != chunks.end()) {
355355
auto allocation = chunk->second.getAllocation();

0 commit comments

Comments
 (0)