X-Git-Url: http://deadsoftware.ru/gitweb?a=blobdiff_plain;f=src%2Fgame%2Fg_grid.pas;h=e45fede6f34b818d9a9f41191fc0d0c8bef8e32b;hb=747da9b7f35549ec88cec08069f6bfe725e508e2;hp=0ffc5bc6358208dfe83b292a0de5eb7445b9b890;hpb=dd0d8ac4cc2a0aa774f25c8a1a774f7358acfae7;p=d2df-sdl.git diff --git a/src/game/g_grid.pas b/src/game/g_grid.pas index 0ffc5bc..e45fede 100644 --- a/src/game/g_grid.pas +++ b/src/game/g_grid.pas @@ -13,149 +13,132 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . *) +// universal spatial grid {$INCLUDE ../shared/a_modes.inc} unit g_grid; interface -uses e_log; - -const - GridDefaultTileSize = 32; type - GridQueryCB = function (obj: TObject; tag: Integer): Boolean is nested; // return `true` to stop + TBodyProxyId = Integer; -type - TBodyGrid = class; + generic TBodyGridBase = class(TObject) + public + type TGridQueryCB = function (obj: ITP; tag: Integer): Boolean is nested; // return `true` to stop + type TGridRayQueryCB = function (obj: ITP; tag: Integer; x, y, prevx, prevy: Integer): Boolean is nested; // return `true` to stop - TBodyProxy = class(TObject) - private - mX, mY, mWidth, mHeight: Integer; // aabb - mQueryMark: DWord; // was this object visited at this query? - mObj: TObject; - mGrid: TBodyGrid; - mTag: Integer; - prevLink: TBodyProxy; // only for used - nextLink: TBodyProxy; // either used or free + const TagDisabled = $40000000; + const TagFullMask = $3fffffff; private - procedure setup (aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer); + const + GridDefaultTileSize = 32; + GridCellBucketSize = 8; // WARNING! can't be less than 2! - public - constructor Create (aGrid: TBodyGrid; aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer); - destructor Destroy (); override; + private + type + PBodyProxyRec = ^TBodyProxyRec; + TBodyProxyRec = record + private + mX, mY, mWidth, mHeight: Integer; // aabb + mQueryMark: LongWord; // was this object visited at this query? + mObj: ITP; + mTag: Integer; // `TagDisabled` set: disabled ;-) + nextLink: TBodyProxyId; // next free or nothing + + private + procedure setup (aX, aY, aWidth, aHeight: Integer; aObj: ITP; aTag: Integer); + end; - property x: Integer read mX; - property y: Integer read mY; - property width: Integer read mWidth; - property height: Integer read mHeight; - property obj: TObject read mObj; - property tag: Integer read mTag; - property grid: TBodyGrid read mGrid; - end; + PGridCell = ^TGridCell; + TGridCell = record + bodies: array [0..GridCellBucketSize-1] of Integer; // -1: end of list + next: Integer; // in this cell; index in mCells + end; - PGridCell = ^TGridCell; - TGridCell = record - body: TBodyProxy; - next: Integer; // in this cell; index in mCells - end; + TGridInternalCB = function (grida: Integer; bodyId: TBodyProxyId): Boolean of object; // return `true` to stop - GridInternalCB = function (grida: Integer): Boolean is nested; // return `true` to stop + private + //mTileSize: Integer; + const mTileSize = GridDefaultTileSize; - TBodyGrid = class(TObject) private - mTileSize: Integer; mMinX, mMinY: Integer; // so grids can start at any origin mWidth, mHeight: Integer; // in tiles mGrid: array of Integer; // mWidth*mHeight, index in mCells mCells: array of TGridCell; // cell pool mFreeCell: Integer; // first free cell index or -1 - mLastQuery: Integer; + mLastQuery: LongWord; mUsedCells: Integer; - mProxyFree: TBodyProxy; // free - mProxyList: TBodyProxy; // used - mProxyCount: Integer; // total allocated + mProxies: array of TBodyProxyRec; + mProxyFree: TBodyProxyId; // free + mProxyCount: Integer; // currently used + mProxyMaxCount: Integer; private function allocCell: Integer; procedure freeCell (idx: Integer); // `next` is simply overwritten - function allocProxy (aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer): TBodyProxy; - procedure freeProxy (body: TBodyProxy); - - procedure insert (body: TBodyProxy); - procedure remove (body: TBodyProxy); + function allocProxy (aX, aY, aWidth, aHeight: Integer; aObj: ITP; aTag: Integer): TBodyProxyId; + procedure freeProxy (body: TBodyProxyId); - function forGridRect (x, y, w, h: Integer; cb: GridInternalCB): Boolean; - - public - constructor Create (aMinPixX, aMinPixY, aPixWidth, aPixHeight: Integer; aTileSize: Integer=GridDefaultTileSize); - destructor Destroy (); override; + procedure insertInternal (body: TBodyProxyId); + procedure removeInternal (body: TBodyProxyId); - function insertBody (aObj: TObject; ax, ay, aWidth, aHeight: Integer; aTag: Integer=0): TBodyProxy; - procedure removeBody (aObj: TBodyProxy); // WARNING! this will NOT destroy proxy! + function forGridRect (x, y, w, h: Integer; cb: TGridInternalCB; bodyId: TBodyProxyId): Boolean; - procedure moveBody (body: TBodyProxy; dx, dy: Integer); - procedure resizeBody (body: TBodyProxy; sx, sy: Integer); - procedure moveResizeBody (body: TBodyProxy; dx, dy, sx, sy: Integer); + function inserter (grida: Integer; bodyId: TBodyProxyId): Boolean; + function remover (grida: Integer; bodyId: TBodyProxyId): Boolean; - function forEachInAABB (x, y, w, h: Integer; cb: GridQueryCB): Boolean; - - function getProxyForBody (aObj: TObject; x, y, w, h: Integer): TBodyProxy; - - procedure dumpStats (); - end; + function getProxyEnabled (pid: TBodyProxyId): Boolean; inline; + procedure setProxyEnabled (pid: TBodyProxyId; val: Boolean); inline; + public + constructor Create (aMinPixX, aMinPixY, aPixWidth, aPixHeight: Integer{; aTileSize: Integer=GridDefaultTileSize}); + destructor Destroy (); override; -type - TBinaryHeapLessFn = function (a, b: TObject): Boolean; + function insertBody (aObj: ITP; ax, ay, aWidth, aHeight: Integer; aTag: Integer=-1): TBodyProxyId; + procedure removeBody (aObj: TBodyProxyId); // WARNING! this WILL destroy proxy! - TBinaryHeapObj = class(TObject) - private - elem: array of TObject; - elemUsed: Integer; - lessfn: TBinaryHeapLessFn; + procedure moveBody (body: TBodyProxyId; dx, dy: Integer); + procedure resizeBody (body: TBodyProxyId; sx, sy: Integer); + procedure moveResizeBody (body: TBodyProxyId; dx, dy, sx, sy: Integer); - private - procedure heapify (root: Integer); + function insideGrid (x, y: Integer): Boolean; inline; - public - constructor Create (alessfn: TBinaryHeapLessFn); - destructor Destroy (); override; + //WARNING: don't modify grid while any query is in progress (no checks are made!) + // you can set enabled/disabled flag, tho (but iterator can still return objects disabled inside it) + // no callback: return `true` on the first hit + function forEachInAABB (x, y, w, h: Integer; cb: TGridQueryCB; tagmask: Integer=-1; allowDisabled: Boolean=false): ITP; - procedure clear (); + //WARNING: don't modify grid while any query is in progress (no checks are made!) + // you can set enabled/disabled flag, tho (but iterator can still return objects disabled inside it) + // no callback: return `true` on the first hit + function forEachAtPoint (x, y: Integer; cb: TGridQueryCB; tagmask: Integer=-1): ITP; - procedure insert (val: TObject); + //WARNING: don't modify grid while any query is in progress (no checks are made!) + // you can set enabled/disabled flag, tho (but iterator can still return objects disabled inside it) + // cb with `(nil)` will be called before processing new tile + // no callback: return `true` on the nearest hit + function traceRay (x0, y0, x1, y1: Integer; cb: TGridRayQueryCB; tagmask: Integer=-1): ITP; overload; + function traceRay (out ex, ey: Integer; x0, y0, x1, y1: Integer; cb: TGridRayQueryCB; tagmask: Integer=-1): ITP; - function front (): TObject; - procedure popFront (); + procedure dumpStats (); - property count: Integer read elemUsed; + //WARNING! no sanity checks! + property proxyEnabled[pid: TBodyProxyId]: Boolean read getProxyEnabled write setProxyEnabled; end; implementation uses - SysUtils; + SysUtils, e_log; // ////////////////////////////////////////////////////////////////////////// // -constructor TBodyProxy.Create (aGrid: TBodyGrid; aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer); -begin - mGrid := aGrid; - setup(aX, aY, aWidth, aHeight, aObj, aTag); -end; - - -destructor TBodyProxy.Destroy (); -begin - inherited; -end; - - -procedure TBodyProxy.setup (aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer); +procedure TBodyGridBase.TBodyProxyRec.setup (aX, aY, aWidth, aHeight: Integer; aObj: ITP; aTag: Integer); begin mX := aX; mY := aY; @@ -164,72 +147,61 @@ begin mQueryMark := 0; mObj := aObj; mTag := aTag; - prevLink := nil; - nextLink := nil; + nextLink := -1; end; // ////////////////////////////////////////////////////////////////////////// // -constructor TBodyGrid.Create (aMinPixX, aMinPixY, aPixWidth, aPixHeight: Integer; aTileSize: Integer=GridDefaultTileSize); +constructor TBodyGridBase.Create (aMinPixX, aMinPixY, aPixWidth, aPixHeight: Integer{; aTileSize: Integer=GridDefaultTileSize}); var idx: Integer; begin + { if aTileSize < 1 then aTileSize := 1; if aTileSize > 8192 then aTileSize := 8192; // arbitrary limit - if aPixWidth < aTileSize then aPixWidth := aTileSize; - if aPixHeight < aTileSize then aPixHeight := aTileSize; mTileSize := aTileSize; + } + if (aPixWidth < mTileSize) then aPixWidth := mTileSize; + if (aPixHeight < mTileSize) then aPixHeight := mTileSize; mMinX := aMinPixX; mMinY := aMinPixY; - mWidth := (aPixWidth+aTileSize-1) div aTileSize; - mHeight := (aPixHeight+aTileSize-1) div aTileSize; + mWidth := (aPixWidth+mTileSize-1) div mTileSize; + mHeight := (aPixHeight+mTileSize-1) div mTileSize; SetLength(mGrid, mWidth*mHeight); SetLength(mCells, mWidth*mHeight); + SetLength(mProxies, 8192); mFreeCell := 0; // init free list for idx := 0 to High(mCells) do begin - mCells[idx].body := nil; + mCells[idx].bodies[0] := -1; mCells[idx].next := idx+1; end; mCells[High(mCells)].next := -1; // last cell // init grid for idx := 0 to High(mGrid) do mGrid[idx] := -1; + // init proxies + for idx := 0 to High(mProxies) do mProxies[idx].nextLink := idx+1; + mProxies[High(mProxies)].nextLink := -1; mLastQuery := 0; mUsedCells := 0; - mProxyFree := nil; - mProxyList := nil; + mProxyFree := 0; mProxyCount := 0; + mProxyMaxCount := 0; e_WriteLog(Format('created grid with size: %dx%d (tile size: %d); pix: %dx%d', [mWidth, mHeight, mTileSize, mWidth*mTileSize, mHeight*mTileSize]), MSG_NOTIFY); end; -destructor TBodyGrid.Destroy (); -var - px: TBodyProxy; +destructor TBodyGridBase.Destroy (); begin - // free all owned proxies - while mProxyFree <> nil do - begin - px := mProxyFree; - mProxyFree := px.nextLink; - px.Free(); - end; - - while mProxyList <> nil do - begin - px := mProxyList; - mProxyList := px.nextLink; - px.Free(); - end; - mCells := nil; mGrid := nil; + mProxies := nil; inherited; end; -procedure TBodyGrid.dumpStats (); +procedure TBodyGridBase.dumpStats (); var idx, mcb, cidx, cnt: Integer; begin @@ -245,11 +217,42 @@ begin end; if (mcb < cnt) then mcb := cnt; end; - e_WriteLog(Format('grid size: %dx%d (tile size: %d); pix: %dx%d; used cells: %d; max bodies in cell: %d; proxies allocated: %d', [mWidth, mHeight, mTileSize, mWidth*mTileSize, mHeight*mTileSize, mUsedCells, mcb, mProxyCount]), MSG_NOTIFY); + e_WriteLog(Format('grid size: %dx%d (tile size: %d); pix: %dx%d; used cells: %d; max bodies in cell: %d; max proxies allocated: %d; proxies used: %d', [mWidth, mHeight, mTileSize, mWidth*mTileSize, mHeight*mTileSize, mUsedCells, mcb, mProxyMaxCount, mProxyCount]), MSG_NOTIFY); +end; + + +function TBodyGridBase.insideGrid (x, y: Integer): Boolean; inline; +begin + // fix coords + Dec(x, mMinX); + Dec(y, mMinY); + result := (x >= 0) and (y >= 0) and (x < mWidth*mTileSize) and (y < mHeight*mTileSize); +end; + + +function TBodyGridBase.getProxyEnabled (pid: TBodyProxyId): Boolean; inline; +begin + if (pid >= 0) then result := ((mProxies[pid].mTag and TagDisabled) = 0) else result := false; +end; + + +procedure TBodyGridBase.setProxyEnabled (pid: TBodyProxyId; val: Boolean); inline; +begin + if (pid >= 0) then + begin + if val then + begin + mProxies[pid].mTag := mProxies[pid].mTag and not TagDisabled; + end + else + begin + mProxies[pid].mTag := mProxies[pid].mTag or TagDisabled; + end; + end; end; -function TBodyGrid.allocCell: Integer; +function TBodyGridBase.allocCell: Integer; var idx: Integer; begin @@ -260,7 +263,7 @@ begin SetLength(mCells, mFreeCell+32768); // arbitrary number for idx := mFreeCell to High(mCells) do begin - mCells[idx].body := nil; + mCells[idx].bodies[0] := -1; mCells[idx].next := idx+1; end; mCells[High(mCells)].next := -1; // last cell @@ -268,17 +271,18 @@ begin result := mFreeCell; mFreeCell := mCells[result].next; mCells[result].next := -1; + mCells[result].bodies[0] := -1; Inc(mUsedCells); //e_WriteLog(Format('grid: allocated new cell #%d (total: %d)', [result, mUsedCells]), MSG_NOTIFY); end; -procedure TBodyGrid.freeCell (idx: Integer); +procedure TBodyGridBase.freeCell (idx: Integer); begin - if (idx >= 0) and (idx < High(mCells)) then + if (idx >= 0) and (idx < Length(mCells)) then begin - if mCells[idx].body = nil then exit; // the thing that should not be - mCells[idx].body := nil; + //if mCells[idx].body = -1 then exit; // the thing that should not be + mCells[idx].bodies[0] := -1; mCells[idx].next := mFreeCell; mFreeCell := idx; Dec(mUsedCells); @@ -286,53 +290,50 @@ begin end; -function TBodyGrid.allocProxy (aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer): TBodyProxy; +function TBodyGridBase.allocProxy (aX, aY, aWidth, aHeight: Integer; aObj: ITP; aTag: Integer): TBodyProxyId; +var + olen, idx: Integer; + px: PBodyProxyRec; begin - if (mProxyFree = nil) then + if (mProxyFree = -1) then begin - // no free proxies, create new - result := TBodyProxy.Create(self, aX, aY, aWidth, aHeight, aObj, aTag); - Inc(mProxyCount); - end - else - begin - // get one from list - result := mProxyFree; - mProxyFree := result.nextLink; - result.setup(aX, aY, aWidth, aHeight, aObj, aTag); + // no free proxies, resize list + olen := Length(mProxies); + SetLength(mProxies, olen+8192); // arbitrary number + for idx := olen to High(mProxies) do mProxies[idx].nextLink := idx+1; + mProxies[High(mProxies)].nextLink := -1; + mProxyFree := olen; end; + // get one from list + result := mProxyFree; + px := @mProxies[result]; + mProxyFree := px.nextLink; + px.setup(aX, aY, aWidth, aHeight, aObj, aTag); // add to used list - result.nextLink := mProxyList; - if (mProxyList <> nil) then mProxyList.prevLink := result; - mProxyList := result; + px.nextLink := -1; + // statistics + Inc(mProxyCount); + if (mProxyMaxCount < mProxyCount) then mProxyMaxCount := mProxyCount; end; -procedure TBodyGrid.freeProxy (body: TBodyProxy); +procedure TBodyGridBase.freeProxy (body: TBodyProxyId); begin - if body = nil then exit; // just in case - // remove from used list - if (body.prevLink = nil) then - begin - // this must be head - if (body <> mProxyList) then raise Exception.Create('wutafuuuuu in grid?'); - mProxyList := body.nextLink; - end - else - begin - body.prevLink.nextLink := body.nextLink; - end; - if (body.nextLink <> nil) then body.nextLink.prevLink := body.prevLink; + if (body < 0) or (body > High(mProxies)) then exit; // just in case + if (mProxyCount = 0) then raise Exception.Create('wutafuuuuu in grid (no allocated proxies, what i should free now?)'); // add to free list - //body.mObj := nil; //WARNING! DON'T DO THIS! `removeBody()` depends on valid mObj - body.prevLink := nil; - body.nextLink := mProxyFree; + mProxies[body].mObj := nil; + mProxies[body].nextLink := mProxyFree; mProxyFree := body; + Dec(mProxyCount); end; -function TBodyGrid.forGridRect (x, y, w, h: Integer; cb: GridInternalCB): Boolean; +function TBodyGridBase.forGridRect (x, y, w, h: Integer; cb: TGridInternalCB; bodyId: TBodyProxyId): Boolean; +const + tsize = mTileSize; var gx, gy: Integer; + gw, gh: Integer; begin result := false; if (w < 1) or (h < 1) or not assigned(cb) then exit; @@ -341,143 +342,268 @@ begin Dec(y, mMinY); // go on if (x+w <= 0) or (y+h <= 0) then exit; - if (x >= mWidth*mTileSize) or (y >= mHeight*mTileSize) then exit; - for gy := y div mTileSize to (y+h-1) div mTileSize do + gw := mWidth; + gh := mHeight; + //tsize := mTileSize; + if (x >= gw*tsize) or (y >= gh*tsize) then exit; + for gy := y div tsize to (y+h-1) div tsize do begin if (gy < 0) then continue; - if (gy >= mHeight) then break; - for gx := x div mTileSize to (x+w-1) div mTileSize do + if (gy >= gh) then break; + for gx := x div tsize to (x+w-1) div tsize do begin if (gx < 0) then continue; - if (gx >= mWidth) then break; - if (cb(gy*mWidth+gx)) then begin result := true; exit; end; + if (gx >= gw) then break; + result := cb(gy*gw+gx, bodyId); + if result then exit; end; end; end; -procedure TBodyGrid.insert (body: TBodyProxy); - - function inserter (grida: Integer): Boolean; - var - cidx: Integer; +function TBodyGridBase.inserter (grida: Integer; bodyId: TBodyProxyId): Boolean; +var + cidx: Integer; + pc: Integer; + pi: PGridCell; + f: Integer; +begin + result := false; // never stop + // add body to the given grid cell + pc := mGrid[grida]; + if (pc <> -1) then begin - result := false; // never stop - // add body to the given grid cell - cidx := allocCell(); - //e_WriteLog(Format(' 01: allocated cell for grid coords (%d,%d), body coords:(%d,%d): #%d', [gx, gy, dx, dy, cidx]), MSG_NOTIFY); - mCells[cidx].body := body; - mCells[cidx].next := mGrid[grida]; - mGrid[grida] := cidx; + pi := @mCells[pc]; + f := 0; + for f := 0 to High(TGridCell.bodies) do + begin + if (pi.bodies[f] = -1) then + begin + // can add here + pi.bodies[f] := bodyId; + if (f+1 < Length(TGridCell.bodies)) then pi.bodies[f+1] := -1; + exit; + end; + end; end; + // either no room, or no cell at all + cidx := allocCell(); + mCells[cidx].bodies[0] := bodyId; + mCells[cidx].bodies[1] := -1; + mCells[cidx].next := pc; + mGrid[grida] := cidx; +end; +procedure TBodyGridBase.insertInternal (body: TBodyProxyId); +var + px: PBodyProxyRec; begin - if body = nil then exit; - forGridRect(body.mX, body.mY, body.mWidth, body.mHeight, inserter); + if (body < 0) or (body > High(mProxies)) then exit; // just in case + px := @mProxies[body]; + forGridRect(px.mX, px.mY, px.mWidth, px.mHeight, inserter, body); end; // absolutely not tested -procedure TBodyGrid.remove (body: TBodyProxy); - - function remover (grida: Integer): Boolean; - var - pidx, idx, tmp: Integer; +function TBodyGridBase.remover (grida: Integer; bodyId: TBodyProxyId): Boolean; +var + f: Integer; + pidx, idx, tmp: Integer; + pc: PGridCell; +begin + result := false; // never stop + // find and remove cell + pidx := -1; + idx := mGrid[grida]; + while (idx >= 0) do begin - result := false; // never stop - // find and remove cell - pidx := -1; - idx := mGrid[grida]; - while idx >= 0 do + tmp := mCells[idx].next; + pc := @mCells[idx]; + f := 0; + while (f < High(TGridCell.bodies)) do begin - tmp := mCells[idx].next; - if (mCells[idx].body = body) then + if (pc.bodies[f] = bodyId) then begin - if (pidx = -1) then mGrid[grida] := tmp else mCells[pidx].next := tmp; - freeCell(idx); - break; // assume that we cannot have one object added to bucket twice - end - else - begin - pidx := idx; + // i found her! + if (f = 0) and (pc.bodies[1] = -1) then + begin + // this cell contains no elements, remove it + tmp := mCells[idx].next; + if (pidx = -1) then mGrid[grida] := tmp else mCells[pidx].next := tmp; + freeCell(idx); + end + else + begin + // remove element from bucket + Inc(f); + while (f < High(TGridCell.bodies)) do + begin + pc.bodies[f-1] := pc.bodies[f]; + if (pc.bodies[f] = -1) then break; + Inc(f); + end; + pc.bodies[High(TGridCell.bodies)] := -1; // just in case + end; + exit; // assume that we cannot have one object added to bucket twice end; - idx := tmp; + Inc(f); end; + pidx := idx; + idx := tmp; end; +end; +// absolutely not tested +procedure TBodyGridBase.removeInternal (body: TBodyProxyId); +var + px: PBodyProxyRec; begin - if body = nil then exit; - forGridRect(body.mX, body.mY, body.mWidth, body.mHeight, remover); + if (body < 0) or (body > High(mProxies)) then exit; // just in case + px := @mProxies[body]; + forGridRect(px.mX, px.mY, px.mWidth, px.mHeight, remover, body); end; -function TBodyGrid.insertBody (aObj: TObject; aX, aY, aWidth, aHeight: Integer; aTag: Integer=0): TBodyProxy; +function TBodyGridBase.insertBody (aObj: ITP; aX, aY, aWidth, aHeight: Integer; aTag: Integer=-1): TBodyProxyId; begin + aTag := aTag and TagFullMask; result := allocProxy(aX, aY, aWidth, aHeight, aObj, aTag); - insert(result); + insertInternal(result); end; -// WARNING! this will NOT destroy proxy! -procedure TBodyGrid.removeBody (aObj: TBodyProxy); +procedure TBodyGridBase.removeBody (aObj: TBodyProxyId); begin - if aObj = nil then exit; - if (aObj.mGrid <> self) then raise Exception.Create('trying to remove alien proxy from grid'); - removeBody(aObj); - //HACK! + if (aObj < 0) or (aObj > High(mProxies)) then exit; // just in case + removeInternal(aObj); freeProxy(aObj); - if (mProxyFree <> aObj) then raise Exception.Create('grid deletion invariant fucked'); - mProxyFree := aObj.nextLink; - aObj.nextLink := nil; end; -procedure TBodyGrid.moveResizeBody (body: TBodyProxy; dx, dy, sx, sy: Integer); +procedure TBodyGridBase.moveResizeBody (body: TBodyProxyId; dx, dy, sx, sy: Integer); +var + px: PBodyProxyRec; begin - if (body = nil) or ((dx = 0) and (dy = 0) and (sx = 0) and (sy = 0)) then exit; - remove(body); - Inc(body.mX, dx); - Inc(body.mY, dy); - Inc(body.mWidth, sx); - Inc(body.mHeight, sy); - insert(body); + if (body < 0) or (body > High(mProxies)) then exit; // just in case + if ((dx = 0) and (dy = 0) and (sx = 0) and (sy = 0)) then exit; + removeInternal(body); + px := @mProxies[body]; + Inc(px.mX, dx); + Inc(px.mY, dy); + Inc(px.mWidth, sx); + Inc(px.mHeight, sy); + insertInternal(body); end; -procedure TBodyGrid.moveBody (body: TBodyProxy; dx, dy: Integer); +procedure TBodyGridBase.moveBody (body: TBodyProxyId; dx, dy: Integer); begin moveResizeBody(body, dx, dy, 0, 0); end; -procedure TBodyGrid.resizeBody (body: TBodyProxy; sx, sy: Integer); +procedure TBodyGridBase.resizeBody (body: TBodyProxyId; sx, sy: Integer); begin moveResizeBody(body, 0, 0, sx, sy); end; -function TBodyGrid.forEachInAABB (x, y, w, h: Integer; cb: GridQueryCB): Boolean; - function iterator (grida: Integer): Boolean; - var - idx: Integer; +// ////////////////////////////////////////////////////////////////////////// // +// no callback: return `true` on the first hit +function TBodyGridBase.forEachAtPoint (x, y: Integer; cb: TGridQueryCB; tagmask: Integer=-1): ITP; +var + f: Integer; + idx, curci: Integer; + cc: PGridCell = nil; + px: PBodyProxyRec; + lq: LongWord; + ptag: Integer; +begin + result := Default(ITP); + tagmask := tagmask and TagFullMask; + if (tagmask = 0) then exit; + + // make coords (0,0)-based + Dec(x, mMinX); + Dec(y, mMinY); + if (x < 0) or (y < 0) or (x >= mWidth*mTileSize) or (y >= mHeight*mTileSize) then exit; + + curci := mGrid[(y div mTileSize)*mWidth+(x div mTileSize)]; + // restore coords + Inc(x, mMinX); + Inc(y, mMinY); + + // increase query counter + Inc(mLastQuery); + if (mLastQuery = 0) then begin - result := false; - idx := mGrid[grida]; - while idx >= 0 do + // just in case of overflow + mLastQuery := 1; + for idx := 0 to High(mProxies) do mProxies[idx].mQueryMark := 0; + end; + lq := mLastQuery; + + while (curci <> -1) do + begin + cc := @mCells[curci]; + for f := 0 to High(TGridCell.bodies) do begin - if (mCells[idx].body <> nil) and (mCells[idx].body.mQueryMark <> mLastQuery) then + if (cc.bodies[f] = -1) then break; + px := @mProxies[cc.bodies[f]]; + ptag := px.mTag; + if ((ptag and TagDisabled) = 0) and ((ptag and tagmask) <> 0) and (px.mQueryMark <> lq) then begin - //e_WriteLog(Format(' query #%d body hit: (%d,%d)-(%dx%d) tag:%d', [mLastQuery, mCells[idx].body.mX, mCells[idx].body.mY, mCells[idx].body.mWidth, mCells[idx].body.mHeight, mCells[idx].body.mTag]), MSG_NOTIFY); - mCells[idx].body.mQueryMark := mLastQuery; - if (cb(mCells[idx].body.mObj, mCells[idx].body.mTag)) then begin result := true; exit; end; + if (x >= px.mX) and (y >= px.mY) and (x < px.mX+px.mWidth) and (y < px.mY+px.mHeight) then + begin + px.mQueryMark := lq; + if assigned(cb) then + begin + if cb(px.mObj, ptag) then begin result := px.mObj; exit; end; + end + else + begin + result := px.mObj; + exit; + end; + end; end; - idx := mCells[idx].next; end; + curci := cc.next; end; +end; + +// no callback: return `true` on the first hit +function TBodyGridBase.forEachInAABB (x, y, w, h: Integer; cb: TGridQueryCB; tagmask: Integer=-1; allowDisabled: Boolean=false): ITP; +const + tsize = mTileSize; var idx: Integer; + gx, gy: Integer; + curci: Integer; + f: Integer; + cc: PGridCell = nil; + px: PBodyProxyRec; + lq: LongWord; + gw: Integer; + x0, y0: Integer; + ptag: Integer; begin - result := false; - if not assigned(cb) then exit; + result := Default(ITP); + if (w < 1) or (h < 1) then exit; + tagmask := tagmask and TagFullMask; + if (tagmask = 0) then exit; + + x0 := x; + y0 := y; + + // fix coords + Dec(x, mMinX); + Dec(y, mMinY); + + gw := mWidth; + //tsize := mTileSize; + + if (x+w <= 0) or (y+h <= 0) then exit; + if (x >= gw*tsize) or (y >= mHeight*tsize) then exit; // increase query counter Inc(mLastQuery); @@ -485,119 +611,292 @@ begin begin // just in case of overflow mLastQuery := 1; - for idx := 0 to High(mCells) do if (mCells[idx].body <> nil) then mCells[idx].body.mQueryMark := 0; + for idx := 0 to High(mProxies) do mProxies[idx].mQueryMark := 0; end; //e_WriteLog(Format('grid: query #%d: (%d,%d)-(%dx%d)', [mLastQuery, minx, miny, maxx, maxy]), MSG_NOTIFY); + lq := mLastQuery; - result := forGridRect(x, y, w, h, iterator); -end; - - -function TBodyGrid.getProxyForBody (aObj: TObject; x, y, w, h: Integer): TBodyProxy; -var - res: TBodyProxy = nil; - - function iterator (grida: Integer): Boolean; - var - idx: Integer; + // go on + for gy := y div tsize to (y+h-1) div tsize do begin - result := false; - idx := mGrid[grida]; - while idx >= 0 do + if (gy < 0) then continue; + if (gy >= mHeight) then break; + for gx := x div tsize to (x+w-1) div tsize do begin - if (mCells[idx].body <> nil) and (mCells[idx].body = aObj) then + if (gx < 0) then continue; + if (gx >= gw) then break; + // process cells + curci := mGrid[gy*gw+gx]; + while (curci <> -1) do begin - result := true; - res := mCells[idx].body; - exit; + cc := @mCells[curci]; + for f := 0 to High(TGridCell.bodies) do + begin + if (cc.bodies[f] = -1) then break; + px := @mProxies[cc.bodies[f]]; + ptag := px.mTag; + if (not allowDisabled) and ((ptag and TagDisabled) <> 0) then continue; + if ((ptag and tagmask) <> 0) and (px.mQueryMark <> lq) then + //if ((ptag and TagDisabled) = 0) and ((ptag and tagmask) <> 0) and (px.mQueryMark <> lq) then + //if ( ((ptag and TagDisabled) = 0) = ignoreDisabled) and ((ptag and tagmask) <> 0) and (px.mQueryMark <> lq) then + begin + if (x0 >= px.mX+px.mWidth) or (y0 >= px.mY+px.mHeight) then continue; + if (x0+w <= px.mX) or (y0+h <= px.mY) then continue; + px.mQueryMark := lq; + if assigned(cb) then + begin + if cb(px.mObj, ptag) then begin result := px.mObj; exit; end; + end + else + begin + result := px.mObj; + exit; + end; + end; + end; + curci := cc.next; end; - idx := mCells[idx].next; end; end; - -begin - result := nil; - if (aObj = nil) then exit; - forGridRect(x, y, w, h, iterator); - result := res; end; // ////////////////////////////////////////////////////////////////////////// // -constructor TBinaryHeapObj.Create (alessfn: TBinaryHeapLessFn); +// no callback: return `true` on the nearest hit +function TBodyGridBase.traceRay (x0, y0, x1, y1: Integer; cb: TGridRayQueryCB; tagmask: Integer=-1): ITP; +var + ex, ey: Integer; begin - if not assigned(alessfn) then raise Exception.Create('wutafuck?!'); - lessfn := alessfn; - SetLength(elem, 8192); // 'cause why not? - elemUsed := 0; + result := traceRay(ex, ey, x0, y0, x1, y1, cb, tagmask); end; -destructor TBinaryHeapObj.Destroy (); +// no callback: return `true` on the nearest hit +function TBodyGridBase.traceRay (out ex, ey: Integer; x0, y0, x1, y1: Integer; cb: TGridRayQueryCB; tagmask: Integer=-1): ITP; +const + tsize = mTileSize; +var + i: Integer; + dx, dy, d: Integer; + xerr, yerr: Integer; + incx, incy: Integer; + stepx, stepy: Integer; + x, y: Integer; + maxx, maxy: Integer; + gw, gh: Integer; + ccidx: Integer; + curci: Integer; + cc: PGridCell; + hasUntried: Boolean; + px: PBodyProxyRec; + lq: LongWord; + prevX, prevY: Integer; + minx, miny: Integer; + ptag: Integer; + lastDistSq, distSq: Integer; + wasHit: Boolean = false; + lastObj: ITP; + lastWasInGrid: Boolean; + tbcross: Boolean; + f: Integer; begin - inherited; -end; + result := Default(ITP); + lastObj := Default(ITP); + tagmask := tagmask and TagFullMask; + if (tagmask = 0) then begin ex := x0; ey := y0; exit; end; + minx := mMinX; + miny := mMinY; -procedure TBinaryHeapObj.clear (); -begin - elemUsed := 0; -end; + dx := x1-x0; + dy := y1-y0; + if (dx > 0) then incx := 1 else if (dx < 0) then incx := -1 else incx := 0; + if (dy > 0) then incy := 1 else if (dy < 0) then incy := -1 else incy := 0; -procedure TBinaryHeapObj.heapify (root: Integer); -var - smallest, right: Integer; - tmp: TObject; -begin - while true do - begin - smallest := 2*root+1; // left child - if (smallest >= elemUsed) then break; // anyway - right := smallest+1; // right child - if not lessfn(elem[smallest], elem[root]) then smallest := root; - if (right < elemUsed) and (lessfn(elem[right], elem[smallest])) then smallest := right; - if (smallest = root) then break; - // swap - tmp := elem[root]; - elem[root] := elem[smallest]; - elem[smallest] := tmp; - root := smallest; - end; -end; + dx := abs(dx); + dy := abs(dy); + if (dx > dy) then d := dx else d := dy; -procedure TBinaryHeapObj.insert (val: TObject); -var - i, par: Integer; -begin - if (val = nil) then exit; - i := elemUsed; - if (i = Length(elem)) then SetLength(elem, Length(elem)+16384); // arbitrary number - Inc(elemUsed); - while (i <> 0) do + // `x` and `y` will be in grid coords + x := x0-minx; + y := y0-miny; + + // increase query counter + Inc(mLastQuery); + if (mLastQuery = 0) then begin - par := (i-1) div 2; // parent - if not lessfn(val, elem[par]) then break; - elem[i] := elem[par]; - i := par; + // just in case of overflow + mLastQuery := 1; + for i := 0 to High(mProxies) do mProxies[i].mQueryMark := 0; end; - elem[i] := val; -end; + lq := mLastQuery; -function TBinaryHeapObj.front (): TObject; -begin - if elemUsed > 0 then result := elem[0] else result := nil; -end; + // cache various things + //tsize := mTileSize; + gw := mWidth; + gh := mHeight; + maxx := gw*tsize-1; + maxy := gh*tsize-1; + // setup distance and flags + lastDistSq := (x1-x0)*(x1-x0)+(y1-y0)*(y1-y0)+1; + lastWasInGrid := (x >= 0) and (y >= 0) and (x <= maxx) and (y <= maxy); -procedure TBinaryHeapObj.popFront (); -begin - if (elemUsed > 0) then + // setup starting tile ('cause we'll adjust tile vars only on tile edge crossing) + if lastWasInGrid then ccidx := mGrid[(y div tsize)*gw+(x div tsize)] else ccidx := -1; + + // it is slightly faster this way + xerr := -d; + yerr := -d; + + // now trace + for i := 1 to d do begin - Dec(elemUsed); - elem[0] := elem[elemUsed]; - heapify(0); + // prevs are always in map coords + prevX := x+minx; + prevY := y+miny; + // do one step + xerr += dx; + yerr += dy; + // invariant: one of those always changed + if (xerr < 0) and (yerr < 0) then raise Exception.Create('internal bug in grid raycaster (0)'); + if (xerr >= 0) then begin xerr -= d; x += incx; stepx := incx; end else stepx := 0; + if (yerr >= 0) then begin yerr -= d; y += incy; stepy := incy; end else stepy := 0; + // invariant: we always doing a step + if ((stepx or stepy) = 0) then raise Exception.Create('internal bug in grid raycaster (1)'); + begin + // check for crossing tile/grid boundary + if (x >= 0) and (y >= 0) and (x <= maxx) and (y <= maxy) then + begin + // we're still in grid + lastWasInGrid := true; + // check for tile edge crossing + if (stepx < 0) and ((x mod tsize) = tsize-1) then tbcross := true + else if (stepx > 0) and ((x mod tsize) = 0) then tbcross := true + else if (stepy < 0) and ((y mod tsize) = tsize-1) then tbcross := true + else if (stepy > 0) and ((y mod tsize) = 0) then tbcross := true + else tbcross := false; + // crossed tile edge? + if tbcross then + begin + // had something in the cell we're leaving? + if (ccidx <> -1) then + begin + // yes, signal cell completion + if assigned(cb) then + begin + if cb(nil, 0, x+minx, y+miny, prevX, prevY) then begin result := lastObj; exit; end; + end + else if wasHit then + begin + result := lastObj; + exit; + end; + end; + // setup new cell index + ccidx := mGrid[(y div tsize)*gw+(x div tsize)]; + end; + end + else + begin + // out of grid, had something in the last processed cell? + if (ccidx <> -1) then + begin + // yes, signal cell completion + ccidx := -1; + if assigned(cb) then + begin + if cb(nil, 0, x+minx, y+miny, prevX, prevY) then begin result := lastObj; exit; end; + end + else if wasHit then + begin + result := lastObj; + exit; + end; + end; + if lastWasInGrid then exit; // oops, stepped out of the grid -- there is no way to return + end; + end; + + // has something to process in the current cell? + if (ccidx <> -1) then + begin + // process cell + curci := ccidx; + hasUntried := false; // this will be set to `true` if we have some proxies we still want to process at the next step + // convert coords to map (to avoid ajdusting coords inside the loop) + Inc(x, minx); + Inc(y, miny); + // process cell list + while (curci <> -1) do + begin + cc := @mCells[curci]; + for f := 0 to High(TGridCell.bodies) do + begin + if (cc.bodies[f] = -1) then break; + px := @mProxies[cc.bodies[f]]; + ptag := px.mTag; + if ((ptag and TagDisabled) = 0) and ((ptag and tagmask) <> 0) and (px.mQueryMark <> lq) then + begin + // can we process this proxy? + if (x >= px.mX) and (y >= px.mY) and (x < px.mX+px.mWidth) and (y < px.mY+px.mHeight) then + begin + px.mQueryMark := lq; // mark as processed + if assigned(cb) then + begin + if cb(px.mObj, ptag, x, y, prevX, prevY) then + begin + result := lastObj; + ex := prevX; + ey := prevY; + exit; + end; + end + else + begin + // remember this hitpoint if it is nearer than an old one + distSq := (prevX-x0)*(prevX-x0)+(prevY-y0)*(prevY-y0); + if (distSq < lastDistSq) then + begin + wasHit := true; + lastDistSq := distSq; + ex := prevX; + ey := prevY; + lastObj := px.mObj; + end; + end; + end + else + begin + // this is possibly interesting proxy, set "has more to check" flag + hasUntried := true; + end; + end; + end; + // next cell + curci := cc.next; + end; + // still has something interesting in this cell? + if not hasUntried then + begin + // nope, don't process this cell anymore; signal cell completion + ccidx := -1; + if assigned(cb) then + begin + if cb(nil, 0, x, y, prevX, prevY) then begin result := lastObj; exit; end; + end + else if wasHit then + begin + result := lastObj; + exit; + end; + end; + // convert coords to grid + Dec(x, minx); + Dec(y, miny); + end; end; end;