js/Cube
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Convert remaining files to pure Objective-C

Browse source 
FossilOrigin-Name: 12cac9666ac09097e06d34da46bf50d15c8571dea22fd2a6d8a1fad076999689
This commit is contained in:
Jonathan Schleifer 2025-03-20 22:22:40 +00:00
parent 61bf59bbfc
commit fd09d38b8c
17 changed files with 182 additions and 182 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/entities.m
View file

@ -30,8 +30,8 @@ initEntities()
}
static void
renderent(Entity *e, OFString *mdlname, float z, float yaw, int frame /* = 0*/,
int numf /* = 1*/, int basetime /* = 0*/, float speed /* = 10.0f*/)
renderent(Entity *e, OFString *mdlname, float z, float yaw, int frame, int numf,
int basetime, float speed)
{
rendermodel(mdlname, frame, numf, 0, 1.1f,
OFMakeVector3D(e.x, z + S(e.x, e.y)->floor, e.y), yaw, 0, false,

24
src/init.m Normal file
View file

@ -0,0 +1,24 @@
#import "cube.h"
static void **queue;
static size_t queueCount;
void
enqueueInit(void (^init)(void))
{
queue = realloc(queue, (queueCount + 1) * sizeof(void *));
if (queue == NULL)
fatal(@"cannot allocate init queue");
queue[queueCount++] = (__bridge void *)init;
}
void
processInitQueue(void)
{
for (size_t i = 0; i < queueCount; i++)
((__bridge void (^)())queue[i])();
free(queue);
queueCount = 0;
}

24
src/init.mm
View file

@ -1,24 +0,0 @@
#include <vector>
#import "cube.h"
#import "protos.h"
static std::vector<void (^)(void)> *queue;
void
enqueueInit(void (^init)(void))
{
if (queue == NULL)
queue = new std::vector<void (^)(void)>();
queue->push_back(init);
}
void
processInitQueue(void)
{
for (auto &init : *queue)
init();
queue->clear();
}

26
src/meson.build
View file

@ -29,30 +29,30 @@ executable('client',
'console.m',
'editing.m',
'entities.m',
'init.mm',
'init.m',
'menus.m',
'monster.m',
'physics.m',
'rendercubes.m',
'renderextras.m',
'rendergl.mm',
'rendermd2.mm',
'renderparticles.mm',
'rendertext.mm',
'rndmap.mm',
'savegamedemo.mm',
'rendergl.m',
'rendermd2.m',
'renderparticles.m',
'rendertext.m',
'rndmap.m',
'savegamedemo.m',
'server.m',
'serverbrowser.mm',
'serverbrowser.m',
'serverms.m',
'serverutil.m',
'sound.m',
'tools.m',
'weapon.m',
'world.mm',
'worldio.mm',
'worldlight.mm',
'worldocull.mm',
'worldrender.mm',
'world.m',
'worldio.m',
'worldlight.m',
'worldocull.m',
'worldrender.m',
],
dependencies: [
objfw_dep,

15
src/rendergl.mm → src/rendergl.m
View file

@ -252,8 +252,8 @@ lookuptexture(int tex, int *xs, int *ys)
}
}
void
setupworld()
static void
gl_setupworld()
{
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
@ -281,7 +281,7 @@ renderstripssky()
{
glBindTexture(GL_TEXTURE_2D, skyoglid);
const strip *items = (const strip *)strips.items;
const struct strip *items = strips.items;
size_t count = strips.count;
for (size_t i = 0; i < count; i++)
if (items[i].tex == skyoglid)
@ -293,7 +293,7 @@ void
renderstrips()
{
int lasttex = -1;
const strip *items = (const strip *)strips.items;
const struct strip *items = strips.items;
size_t count = strips.count;
for (size_t i = 0; i < count; i++) {
if (items[i].tex == skyoglid)
@ -319,9 +319,10 @@ void
addstrip(int tex, int start, int n)
{
if (strips == nil)
strips = [[OFMutableData alloc] initWithItemSize:sizeof(strip)];
strips = [[OFMutableData alloc]
initWithItemSize:sizeof(struct strip)];
strip s = { .tex = tex, .start = start, .num = n };
struct strip s = { .tex = tex, .start = start, .num = n };
[strips addItem:&s];
}
@ -451,7 +452,7 @@ gl_drawframe(int w, int h, float curfps)
(int)player1.pitch, (float)fov, w, h);
finishstrips();
setupworld();
gl_setupworld();
renderstripssky();

2
src/rendermd2.mm → src/rendermd2.m
View file

@ -108,7 +108,7 @@ rendermodel(OFString *mdl, int frame, int range, int tex, float rad,
OFVector3D light = OFMakeVector3D(1, 1, 1);
if (!OUTBORD(ix, iy)) {
sqr *s = S(ix, iy);
struct sqr *s = S(ix, iy);
float ll = 256.0f; // 0.96f;
float of = 0.0f; // 0.1f;
light.x = s->r / ll + of;

10
src/renderparticles.mm → src/renderparticles.m
View file

@ -10,9 +10,9 @@ struct particle {
OFVector3D o, d;
int fade, type;
int millis;
particle *next;
struct particle *next;
};
particle particles[MAXPARTICLES], *parlist = NULL, *parempty = NULL;
struct particle particles[MAXPARTICLES], *parlist = NULL, *parempty = NULL;
bool parinit = false;
VARP(maxparticles, 100, 2000, MAXPARTICLES - 500);
@ -29,7 +29,7 @@ newparticle(const OFVector3D *o, const OFVector3D *d, int fade, int type)
parinit = true;
}
if (parempty) {
particle *p = parempty;
struct particle *p = parempty;
parempty = p->next;
p->o = *o;
p->d = *d;
@ -86,8 +86,8 @@ render_particles(int time)
int numrender = 0;
for (particle *p, **pp = &parlist; p = *pp;) {
parttype *pt = &parttypes[p->type];
for (struct particle *p, **pp = &parlist; (p = *pp) != NULL;) {
struct parttype *pt = &parttypes[p->type];
glBindTexture(GL_TEXTURE_2D, pt->tex);
glBegin(GL_QUADS);

0
src/rendertext.mm → src/rendertext.m
View file

4
src/rndmap.mm → src/rndmap.m
View file

@ -67,7 +67,7 @@ perlinnoise_2D(float x, float y, int seedstep, float pers)
}
void
perlinarea(const block *b, int scale, int seed, int psize)
perlinarea(const struct block *b, int scale, int seed, int psize)
{
srand(seed);
seed = rnd(10000);
@ -75,7 +75,7 @@ perlinarea(const block *b, int scale, int seed, int psize)
scale = 10;
for (int x = b->x; x <= b->x + b->xs; x++) {
for (int y = b->y; y <= b->y + b->ys; y++) {
sqr *s = S(x, y);
struct sqr *s = S(x, y);
if (!SOLID(s) && x != b->x + b->xs && y != b->y + b->ys)
s->type = FHF;
s->vdelta =

28
src/savegamedemo.mm → src/savegamedemo.m
View file

@ -19,41 +19,41 @@ bool demoloading = false;
static OFMutableArray<DynamicEntity *> *playerhistory;
int democlientnum = 0;
void startdemo();
extern void startdemo();
void
static void
gzput(int i)
{
gzputc(f, i);
}
void
static void
gzputi(int i)
{
gzwrite(f, &i, sizeof(int));
}
void
gzputv(OFVector3D &v)
static void
gzputv(const OFVector3D *v)
{
gzwrite(f, &v, sizeof(OFVector3D));
gzwrite(f, v, sizeof(OFVector3D));
}
void
static void
gzcheck(int a, int b)
{
if (a != b)
fatal(@"savegame file corrupt (short)");
}
int
static int
gzget()
{
char c = gzgetc(f);
return c;
}
int
static int
gzgeti()
{
int i;
@ -61,10 +61,10 @@ gzgeti()
return i;
}
void
gzgetv(OFVector3D &v)
static void
gzgetv(OFVector3D *v)
{
gzcheck(gzread(f, &v, sizeof(OFVector3D)), sizeof(OFVector3D));
gzcheck(gzread(f, v, sizeof(OFVector3D)), sizeof(OFVector3D));
}
void
@ -326,7 +326,7 @@ incomingdemodata(uchar *buf, int len, bool extras)
bdamage = 0;
gzputi(ddamage);
if (ddamage) {
gzputv(dorig);
gzputv(&dorig);
ddamage = 0;
}
// FIXME: add all other client state which is not send through
@ -453,7 +453,7 @@ demoplaybackstep()
if ((bdamage = gzgeti()))
damageblend(bdamage);
if ((ddamage = gzgeti())) {
gzgetv(dorig);
gzgetv(&dorig);
particle_splash(3, ddamage, 1000, &dorig);
}
// FIXME: set more client state here

2
src/serverbrowser.mm → src/serverbrowser.m
View file

@ -202,7 +202,7 @@ checkpings()
}
}
extern "C" void
void
refreshservers()
{
checkresolver();

37
src/world.mm → src/world.m
View file

@ -7,10 +7,10 @@
extern OFString *entnames[]; // lookup from map entities above to strings
sqr *world = NULL;
struct sqr *world = NULL;
int sfactor, ssize, cubicsize, mipsize;
header hdr;
struct header hdr;
// set all cubes with "tag" to space, if tag is 0 then reset ALL tagged cubes
// according to type
@ -20,7 +20,7 @@ settag(int tag, int type)
int maxx = 0, maxy = 0, minx = ssize, miny = ssize;
loop(x, ssize) loop(y, ssize)
{
sqr *s = S(x, y);
struct sqr *s = S(x, y);
if (s->tag) {
if (tag) {
if (tag == s->tag)
@ -40,7 +40,7 @@ settag(int tag, int type)
miny = y;
}
}
block b = { minx, miny, maxx - minx + 1, maxy - miny + 1 };
struct block b = { minx, miny, maxx - minx + 1, maxy - miny + 1 };
if (maxx)
remip(&b, 0); // remip minimal area of changed geometry
}
@ -90,17 +90,17 @@ COMMAND(trigger, ARG_2INT)
// rendering time if this is possible).
void
remip(const block *b, int level)
remip(const struct block *b, int level)
{
if (level >= SMALLEST_FACTOR)
return;
int lighterr = getvar(@"lighterror") * 3;
sqr *w = wmip[level];
sqr *v = wmip[level + 1];
struct sqr *w = wmip[level];
struct sqr *v = wmip[level + 1];
int ws = ssize >> level;
int vs = ssize >> (level + 1);
block s = *b;
struct block s = *b;
if (s.x & 1) {
s.x--;
s.xs++;
@ -113,13 +113,13 @@ remip(const block *b, int level)
s.ys = (s.ys + 1) & ~1;
for (int x = s.x; x < s.x + s.xs; x += 2)
for (int y = s.y; y < s.y + s.ys; y += 2) {
sqr *o[4];
struct sqr *o[4];
o[0] = SWS(w, x, y, ws); // the 4 constituent cubes
o[1] = SWS(w, x + 1, y, ws);
o[2] = SWS(w, x + 1, y + 1, ws);
o[3] = SWS(w, x, y + 1, ws);
// the target cube in the higher mip level
sqr *r = SWS(v, x / 2, y / 2, vs);
struct sqr *r = SWS(v, x / 2, y / 2, vs);
*r = *o[0];
uchar nums[MAXTYPE];
loopi(MAXTYPE) nums[i] = 0;
@ -242,9 +242,9 @@ remip(const block *b, int level)
}
void
remipmore(const block *b, int level)
remipmore(const struct block *b, int level)
{
block bb = *b;
struct block bb = *b;
if (bb.x > 1)
bb.x--;
@ -433,7 +433,7 @@ findentity(int type, int index)
return -1;
}
sqr *wmip[LARGEST_FACTOR * 2];
struct sqr *wmip[LARGEST_FACTOR * 2];
void
setupworld(int factor)
@ -441,7 +441,8 @@ setupworld(int factor)
ssize = 1 << (sfactor = factor);
cubicsize = ssize * ssize;
mipsize = cubicsize * 134 / 100;
sqr *w = world = (sqr *)OFAllocZeroedMemory(mipsize, sizeof(sqr));
struct sqr *w = world =
OFAllocZeroedMemory(mipsize, sizeof(struct sqr));
loopi(LARGEST_FACTOR * 2)
{
wmip[i] = w;
@ -458,7 +459,7 @@ empty_world(int factor, bool force)
return;
cleardlights();
pruneundos(0);
sqr *oldworld = world;
struct sqr *oldworld = world;
bool copy = false;
if (oldworld && factor < 0) {
factor = sfactor + 1;
@ -472,7 +473,7 @@ empty_world(int factor, bool force)
loop(x, ssize) loop(y, ssize)
{
sqr *s = S(x, y);
struct sqr *s = S(x, y);
s->r = s->g = s->b = 150;
s->ftex = DEFAULT_FLOOR;
s->ctex = DEFAULT_CEIL;
@ -486,7 +487,7 @@ empty_world(int factor, bool force)
strncpy(hdr.head, "CUBE", 4);
hdr.version = MAPVERSION;
hdr.headersize = sizeof(header);
hdr.headersize = sizeof(struct header);
hdr.sfactor = sfactor;
if (copy) {
@ -507,7 +508,7 @@ empty_world(int factor, bool force)
loopi(15) hdr.reserved[i] = 0;
loopk(3) loopi(256) hdr.texlists[k][i] = i;
[ents removeAllObjects];
block b = { 8, 8, ssize - 16, ssize - 16 };
struct block b = { 8, 8, ssize - 16, ssize - 16 };
edittypexy(SPACE, &b);
}

68
src/worldio.mm → src/worldio.m
View file

@ -53,7 +53,7 @@ setnames(OFString *name)
// to reduce the amount spend in the mipmapper (as that is done in realtime).
inline bool
nhf(sqr *s)
nhf(struct sqr *s)
{
return s->type != FHF && s->type != CHF;
}
@ -63,7 +63,7 @@ voptimize() // reset vdeltas on non-hf cubes
{
loop(x, ssize) loop(y, ssize)
{
sqr *s = S(x, y);
struct sqr *s = S(x, y);
if (x && y) {
if (nhf(s) && nhf(S(x - 1, y)) &&
nhf(S(x - 1, y - 1)) && nhf(S(x, y - 1)))
@ -73,34 +73,34 @@ voptimize() // reset vdeltas on non-hf cubes
}
}
void
topt(sqr *s, bool &wf, bool &uf, int &wt, int &ut)
static void
topt(struct sqr *s, bool *wf, bool *uf, int *wt, int *ut)
{
sqr *o[4];
struct sqr *o[4];
o[0] = SWS(s, 0, -1, ssize);
o[1] = SWS(s, 0, 1, ssize);
o[2] = SWS(s, 1, 0, ssize);
o[3] = SWS(s, -1, 0, ssize);
wf = true;
uf = true;
*wf = true;
*uf = true;
if (SOLID(s)) {
loopi(4) if (!SOLID(o[i]))
{
wf = false;
wt = s->wtex;
ut = s->utex;
*wf = false;
*wt = s->wtex;
*ut = s->utex;
return;
}
} else {
loopi(4) if (!SOLID(o[i]))
{
if (o[i]->floor < s->floor) {
wt = s->wtex;
wf = false;
*wt = s->wtex;
*wf = false;
}
if (o[i]->ceil > s->ceil) {
ut = s->utex;
uf = false;
*ut = s->utex;
*uf = false;
}
}
}
@ -110,18 +110,18 @@ void
toptimize() // FIXME: only does 2x2, make atleast for 4x4 also
{
bool wf[4], uf[4];
sqr *s[4];
struct sqr *s[4];
for (int x = 2; x < ssize - 4; x += 2) {
for (int y = 2; y < ssize - 4; y += 2) {
s[0] = S(x, y);
int wt = s[0]->wtex, ut = s[0]->utex;
topt(s[0], wf[0], uf[0], wt, ut);
topt(s[1] = SWS(s[0], 0, 1, ssize), wf[1], uf[1], wt,
ut);
topt(s[2] = SWS(s[0], 1, 1, ssize), wf[2], uf[2], wt,
ut);
topt(s[3] = SWS(s[0], 1, 0, ssize), wf[3], uf[3], wt,
ut);
topt(s[0], &wf[0], &uf[0], &wt, &ut);
topt(s[1] = SWS(s[0], 0, 1, ssize), &wf[1], &uf[1], &wt,
&ut);
topt(s[2] = SWS(s[0], 1, 1, ssize), &wf[2], &uf[2], &wt,
&ut);
topt(s[3] = SWS(s[0], 1, 0, ssize), &wf[3], &uf[3], &wt,
&ut);
loopi(4)
{
if (wf[i])
@ -185,19 +185,19 @@ save_world(OFString *mname)
for (Entity *e in ents)
if (e.type != NOTUSED)
hdr.numents++;
header tmp = hdr;
struct header tmp = hdr;
endianswap(&tmp.version, sizeof(int), 4);
endianswap(&tmp.waterlevel, sizeof(int), 16);
gzwrite(f, &tmp, sizeof(header));
gzwrite(f, &tmp, sizeof(struct header));
for (Entity *e in ents) {
if (e.type != NOTUSED) {
struct persistent_entity tmp = { e.x, e.y, e.z, e.attr1,
e.type, e.attr2, e.attr3, e.attr4 };
endianswap(&tmp, sizeof(short), 4);
gzwrite(f, &tmp, sizeof(persistent_entity));
gzwrite(f, &tmp, sizeof(struct persistent_entity));
}
}
sqr *t = NULL;
struct sqr *t = NULL;
int sc = 0;
#define spurge \
while (sc) { \
@ -212,7 +212,7 @@ save_world(OFString *mname)
}
loopk(cubicsize)
{
sqr *s = &world[k];
struct sqr *s = &world[k];
#define c(f) (s->f == t->f)
// 4 types of blocks, to compress a bit:
// 255 (2): same as previous block + count
@ -270,7 +270,7 @@ load_world(OFString *mname) // still supports all map formats that have existed
conoutf(@"could not read map %@", cgzname);
return;
}
gzread(f, &hdr, sizeof(header) - sizeof(int) * 16);
gzread(f, &hdr, sizeof(struct header) - sizeof(int) * 16);
endianswap(&hdr.version, sizeof(int), 4);
if (strncmp(hdr.head, "CUBE", 4) != 0)
fatal(@"while reading map: header malformatted");
@ -288,7 +288,7 @@ load_world(OFString *mname) // still supports all map formats that have existed
loopi(hdr.numents)
{
struct persistent_entity tmp;
gzread(f, &tmp, sizeof(persistent_entity));
gzread(f, &tmp, sizeof(struct persistent_entity));
endianswap(&tmp, sizeof(short), 4);
Entity *e = [Entity entity];
@ -313,22 +313,22 @@ load_world(OFString *mname) // still supports all map formats that have existed
setupworld(hdr.sfactor);
char texuse[256];
loopi(256) texuse[i] = 0;
sqr *t = NULL;
struct sqr *t = NULL;
loopk(cubicsize)
{
sqr *s = &world[k];
struct sqr *s = &world[k];
int type = gzgetc(f);
switch (type) {
case 255: {
int n = gzgetc(f);
for (int i = 0; i < n; i++, k++)
memcpy(&world[k], t, sizeof(sqr));
memcpy(&world[k], t, sizeof(struct sqr));
k--;
break;
}
case 254: // only in MAPVERSION<=2
{
memcpy(s, t, sizeof(sqr));
memcpy(s, t, sizeof(struct sqr));
s->r = s->g = s->b = gzgetc(f);
gzgetc(f);
break;
@ -382,7 +382,7 @@ load_world(OFString *mname) // still supports all map formats that have existed
calclight();
settagareas();
int xs, ys;
loopi(256) if (texuse) lookuptexture(i, &xs, &ys);
loopi(256) if (texuse[i]) lookuptexture(i, &xs, &ys);
conoutf(@"read map %@ (%d milliseconds)", cgzname,
SDL_GetTicks() - lastmillis);
conoutf(@"%s", hdr.maptitle);

50
src/worldlight.mm → src/worldlight.m
View file

@ -64,7 +64,7 @@ lightray(float bx, float by, PersistentEntity *light)
stepb /= lightscale;
loopi(steps)
{
sqr *s = S(x >> PRECBITS, y >> PRECBITS);
struct sqr *s = S(x >> PRECBITS, y >> PRECBITS);
int tl = (l >> PRECBITS) + s->r;
s->r = tl > 255 ? 255 : tl;
tl = (g >> PRECBITS) + s->g;
@ -93,7 +93,7 @@ lightray(float bx, float by, PersistentEntity *light)
loopi(steps)
{
sqr *s = S(x >> PRECBITS, y >> PRECBITS);
struct sqr *s = S(x >> PRECBITS, y >> PRECBITS);
int tl = (l >> PRECBITS) + s->r;
s->r = s->g = s->b = tl > 255 ? 255 : tl;
if (SOLID(s))
@ -109,7 +109,7 @@ lightray(float bx, float by, PersistentEntity *light)
{
loopi(steps)
{
sqr *s = S(x >> PRECBITS, y >> PRECBITS);
struct sqr *s = S(x >> PRECBITS, y >> PRECBITS);
int light = l >> PRECBITS;
if (light > s->r)
s->r = s->g = s->b = (uchar)light;
@ -147,13 +147,13 @@ calclightsource(PersistentEntity *l)
rndtime();
}
// median filter, smooths out random noise in light and makes it more mipable
void
postlightarea(block &a) // median filter, smooths out random noise in light and
// makes it more mipable
postlightarea(const struct block *a)
{
loop(x, a.xs) loop(y, a.ys) // assumes area not on edge of world
loop(x, a->xs) loop(y, a->ys) // assumes area not on edge of world
{
sqr *s = S(x + a.x, y + a.y);
struct sqr *s = S(x + a->x, y + a->y);
#define median(m) \
s->m = \
(s->m * 2 + SW(s, 1, 0)->m * 2 + SW(s, 0, 1)->m * 2 + \
@ -165,7 +165,7 @@ postlightarea(block &a) // median filter, smooths out random noise in light and
median(b);
}
remip(&a, 0);
remip(a, 0);
}
void
@ -173,7 +173,7 @@ calclight()
{
loop(x, ssize) loop(y, ssize)
{
sqr *s = S(x, y);
struct sqr *s = S(x, y);
s->r = s->g = s->b = 10;
}
@ -181,8 +181,8 @@ calclight()
if (e.type == LIGHT)
calclightsource(e);
block b = { 1, 1, ssize - 2, ssize - 2 };
postlightarea(b);
struct block b = { 1, 1, ssize - 2, ssize - 2 };
postlightarea(&b);
setvar(@"fullbright", 0);
}
@ -194,7 +194,7 @@ void
cleardlights()
{
while (dlights.count > 0) {
block *backup = *(block **)[dlights lastItem];
struct block *backup = *(struct block **)[dlights lastItem];
[dlights removeLastItem];
blockpaste(backup);
OFFreeMemory(backup);
@ -215,8 +215,8 @@ dodynlight(const OFVector3D *vold, const OFVector3D *v, int reach, int strength,
return;
int creach = reach + 16; // dependant on lightray random offsets!
block b = { (int)v->x - creach, (int)v->y - creach, creach * 2 + 1,
creach * 2 + 1 };
struct block b = { (int)v->x - creach, (int)v->y - creach,
creach * 2 + 1, creach * 2 + 1 };
if (b.x < 1)
b.x = 1;
@ -228,11 +228,11 @@ dodynlight(const OFVector3D *vold, const OFVector3D *v, int reach, int strength,
b.ys = ssize - 2 - b.y;
if (dlights == nil)
dlights =
[[OFMutableData alloc] initWithItemSize:sizeof(block *)];
dlights = [[OFMutableData alloc]
initWithItemSize:sizeof(struct block *)];
// backup area before rendering in dynlight
block *copy = blockcopy(&b);
struct block *copy = blockcopy(&b);
[dlights addItem:&copy];
PersistentEntity *l = [Entity entity];
@ -243,18 +243,18 @@ dodynlight(const OFVector3D *vold, const OFVector3D *v, int reach, int strength,
l.type = LIGHT;
l.attr2 = strength;
calclightsource(l);
postlightarea(b);
postlightarea(&b);
}
// utility functions also used by editing code
block *
blockcopy(const block *s)
struct block *
blockcopy(const struct block *s)
{
block *b = (block *)OFAllocZeroedMemory(
1, sizeof(block) + s->xs * s->ys * sizeof(sqr));
struct block *b = OFAllocZeroedMemory(
1, sizeof(struct block) + s->xs * s->ys * sizeof(struct sqr));
*b = *s;
sqr *q = (sqr *)(b + 1);
struct sqr *q = (struct sqr *)(b + 1);
for (int x = s->x; x < s->xs + s->x; x++)
for (int y = s->y; y < s->ys + s->y; y++)
*q++ = *S(x, y);
@ -262,9 +262,9 @@ blockcopy(const block *s)
}
void
blockpaste(const block *b)
blockpaste(const struct block *b)
{
sqr *q = (sqr *)(b + 1);
struct sqr *q = (struct sqr *)(b + 1);
for (int x = b->x; x < b->xs + b->x; x++)
for (int y = b->y; y < b->ys + b->y; y++)
*S(x, y) = *q++;

0
src/worldocull.mm → src/worldocull.m
View file

54
src/worldrender.mm → src/worldrender.m
View file

@ -7,8 +7,8 @@
#import "DynamicEntity.h"
void
render_wall(sqr *o, sqr *s, int x1, int y1, int x2, int y2, int mip, sqr *d1,
sqr *d2, bool topleft)
render_wall(struct sqr *o, struct sqr *s, int x1, int y1, int x2, int y2,
int mip, struct sqr *d1, struct sqr *d2, bool topleft)
{
if (SOLID(o) || o->type == SEMISOLID) {
float c1 = s->floor;
@ -83,7 +83,7 @@ issemi(int mip, int x, int y, int x1, int y1, int x2, int y2)
{
if (!(mip--))
return true;
sqr *w = wmip[mip];
struct sqr *w = wmip[mip];
int msize = ssize >> mip;
x *= 2;
y *= 2;
@ -121,7 +121,7 @@ void
render_seg_new(
float vx, float vy, float vh, int mip, int x, int y, int xs, int ys)
{
sqr *w = wmip[mip];
struct sqr *w = wmip[mip];
int sz = ssize >> mip;
int vxx = ((int)vx + (1 << mip) / 2) >> mip;
int vyy = ((int)vy + (1 << mip) / 2) >> mip;
@ -164,21 +164,21 @@ render_seg_new(
{ \
for (int xx = x; xx < xs; xx++) \
for (int yy = y; yy < ys; yy++) { \
sqr *s = SWS(w, xx, yy, sz); \
struct sqr *s = SWS(w, xx, yy, sz); \
if (s->occluded == 1) \
continue; \
if (s->defer && !s->occluded && mip && \
xx >= lx && xx < rx && yy >= ly && \
yy < ry)
#define LOOPD \
sqr *t = SWS(s, 1, 0, sz); \
sqr *u = SWS(s, 1, 1, sz); \
sqr *v = SWS(s, 0, 1, sz);
#define LOOPD \
struct sqr *t = SWS(s, 1, 0, sz); \
struct sqr *u = SWS(s, 1, 1, sz); \
struct sqr *v = SWS(s, 0, 1, sz);
LOOPH // ceils
{
int start = yy;
sqr *next;
struct sqr *next;
while (yy < ys - 1 && (next = SWS(w, xx, yy + 1, sz))->defer &&
!next->occluded)
yy++; // collect 2xN rect of lower mip
@ -221,15 +221,15 @@ LOOPD
// zSt
// vu
sqr *w = SWS(s, 0, -1, sz);
sqr *z = SWS(s, -1, 0, sz);
struct sqr *w = SWS(s, 0, -1, sz);
struct sqr *z = SWS(s, -1, 0, sz);
bool normalwall = true;
if (s->type == CORNER) {
// cull also
bool topleft = true;
sqr *h1 = NULL;
sqr *h2 = NULL;
struct sqr *h1 = NULL;
struct sqr *h2 = NULL;
if (SOLID(z)) {
if (SOLID(w)) {
render_wall(w, h2 = s, xx + 1, yy, xx, yy + 1, mip, t,
@ -299,16 +299,16 @@ if (normalwall) {
}
}
void
distlod(int &low, int &high, int angle, float widef)
static void
distlod(int *low, int *high, int angle, float widef)
{
float f = 90.0f / lod / widef;
low = (int)((90 - angle) / f);
high = (int)(angle / f);
if (low < min_lod)
low = min_lod;
if (high < min_lod)
high = min_lod;
*low = (int)((90 - angle) / f);
*high = (int)(angle / f);
if (*low < min_lod)
*low = min_lod;
if (*high < min_lod)
*high = min_lod;
}
// does some out of date view frustrum optimisation that doesn't contribute much
@ -334,17 +334,17 @@ render_world(
lodtop = lodbot = lodleft = lodright = min_lod;
if (yaw > 45 && yaw <= 135) {
lodleft = lod;
distlod(lodtop, lodbot, yaw - 45, widef);
distlod(&lodtop, &lodbot, yaw - 45, widef);
} else if (yaw > 135 && yaw <= 225) {
lodbot = lod;
distlod(lodleft, lodright, yaw - 135, widef);
distlod(&lodleft, &lodright, yaw - 135, widef);
} else if (yaw > 225 && yaw <= 315) {
lodright = lod;
distlod(lodbot, lodtop, yaw - 225, widef);
distlod(&lodbot, &lodtop, yaw - 225, widef);
} else {
lodtop = lod;
distlod(
lodright, lodleft, yaw <= 45 ? yaw + 45 : yaw - 315, widef);
distlod(&lodright, &lodleft, yaw <= 45 ? yaw + 45 : yaw - 315,
widef);
}
float hyfov = fov * h / w / 2;
render_floor = pitch < hyfov;