OpenClonk
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros
C4SolidMask.cpp
Go to the documentation of this file.
1 /*
2  * OpenClonk, http://www.openclonk.org
3  *
4  * Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
5  * Copyright (c) 2009-2016, The OpenClonk Team and contributors
6  *
7  * Distributed under the terms of the ISC license; see accompanying file
8  * "COPYING" for details.
9  *
10  * "Clonk" is a registered trademark of Matthes Bender, used with permission.
11  * See accompanying file "TRADEMARK" for details.
12  *
13  * To redistribute this file separately, substitute the full license texts
14  * for the above references.
15  */
16 
17 /* Solid areas of objects, put into the landscape */
18 
19 #include "C4Include.h"
20 #include "landscape/C4SolidMask.h"
21 
22 #include "object/C4Def.h"
23 #include "object/C4Object.h"
24 #include "landscape/C4Landscape.h"
25 #include "game/C4Game.h"
26 #include "object/C4GameObjects.h"
27 #include "graphics/C4DrawGL.h"
28 #include "graphics/StdPNG.h"
29 #include "graphics/CSurface8.h"
30 #include "landscape/C4Material.h"
31 
32 
33 void C4SolidMask::Put(bool fCauseInstability, C4TargetRect *pClipRect, bool fRestoreAttachment)
34 {
35  // If not put, put mask to background,
36  // storing background pixels in cSolidMask.
37 
38  // No mask
40  // Contained
41  if (pForObject->Contained) { iAttachingObjectsCount = 0; return; }
42  // Mask is put
43  if (fCauseInstability) CheckConsistency();
44 
45  bool RegularPut;
46  if (!pClipRect)
47  {
48  // Regular Put: Update MaskPutRect and MaskPutRotation
50  pClipRect = &MaskPutRect;
51  RegularPut = true;
52  }
53  else
54  {
55  // Reput by C4SolidMask::Remove
56  // Don't change MaskPutRotation or MaskPutRect
57  // Intersect ClipRect with the MaskPutRect
58  if (!pClipRect->ClipBy(MaskPutRect)) return;
59  RegularPut = false;
60  }
61  // Get mask surface
62  CSurface8 *pSolidMask = pForObject->Def->pSolidMask;
63  // Put mask pixels
64  int xcnt,ycnt,iTx,iTy;
65  BYTE byPixel;
66  // not rotated?
67  if (!MaskPutRotation)
68  {
69  // calc put rect
70  if (RegularPut)
71  {
72  int ox, oy;
75  MaskPutRect.x = ox;
76  if (MaskPutRect.x < 0) { MaskPutRect.tx = -MaskPutRect.x; MaskPutRect.x = 0; }
77  else MaskPutRect.tx = 0;
78  MaskPutRect.y = oy;
79  if (MaskPutRect.y < 0) { MaskPutRect.ty = -MaskPutRect.y; MaskPutRect.y = 0; }
80  else MaskPutRect.ty = 0;
81  MaskPutRect.Wdt = std::min<int32_t>(ox + pForObject->SolidMask.Wdt, ::Landscape.GetWidth()) - MaskPutRect.x;
82  MaskPutRect.Hgt = std::min<int32_t>(oy + pForObject->SolidMask.Hgt, ::Landscape.GetHeight()) - MaskPutRect.y;
83  }
84  // fill rect with mask
85  for (ycnt=0; ycnt<pClipRect->Hgt; ++ycnt)
86  {
87  BYTE *pPix=pSolidMask->Bits + (ycnt+pClipRect->ty+pForObject->SolidMask.y)*pSolidMask->Pitch + pClipRect->tx + pForObject->SolidMask.x;
88  for (xcnt=0; xcnt<pClipRect->Wdt; ++xcnt,++pPix)
89  {
90  if (*pPix)
91  {
92  // solid mask present here
93  // calc position in landscape
94  iTx=pClipRect->x+xcnt; iTy=pClipRect->y+ycnt;
95  // is background mat to be stored? always do this in the given rect
96  if (!MaskPut)
97  {
98  // get background pixel
99  byPixel=::Landscape.GetPix(iTx,iTy);
100  // store it. If MCVehic, also store in initial put, but won't be used in restore
101  // do not overwrite current value in re-put issued by SolidMask-remover
102  if (!IsSomeVehicle(byPixel) || RegularPut)
103  pSolidMaskMatBuff[(ycnt+pClipRect->ty)*MatBuffPitch+xcnt+pClipRect->tx]=byPixel;
104  }
105  // and set mask
107  }
108  else
109  // no SolidMask: mark buffer as unused here
110  if (!MaskPut)
111  pSolidMaskMatBuff[(ycnt+pClipRect->ty)*MatBuffPitch+xcnt+pClipRect->tx]=MCVehic;
112  }
113  }
114  }
115  else
116  {
117  // calc matrix for given rotation
119  Mb1 = Sin(itofix(-MaskPutRotation)), Mb2 = Cos(itofix(-MaskPutRotation));
120  // get upper-left corner of landscape copy rect
121  int centerx = pForObject->Def->Shape.x + pForObject->SolidMask.tx + pForObject->SolidMask.Wdt / 2;
122  int centery = pForObject->Def->Shape.y + pForObject->SolidMask.ty + pForObject->SolidMask.Hgt / 2;
123  int xstart = pForObject->GetX() + fixtoi(Ma1 * itofix(centerx) - Ma2 * itofix(centery)) - MatBuffPitch / 2;
124  int ystart = pForObject->GetY() + fixtoi(-Mb1 * itofix(centerx) + Mb2 * itofix(centery)) - MatBuffPitch / 2;
125  // store put rect
126  if (RegularPut)
127  {
128  MaskPutRect.x = xstart;
130  else { MaskPutRect.tx = 0; MaskPutRect.Wdt = 0; }
131  MaskPutRect.y = ystart;
133  else { MaskPutRect.ty = 0; MaskPutRect.Hgt = 0; }
134  MaskPutRect.Wdt = std::min<int32_t>(xstart + MatBuffPitch, ::Landscape.GetWidth()) - MaskPutRect.x;
135  MaskPutRect.Hgt = std::min<int32_t>(ystart + MatBuffPitch, ::Landscape.GetHeight()) - MaskPutRect.y;
136  }
137  // go through clipping rect
138  const C4Real y0 = itofix(pClipRect->ty - MatBuffPitch/2);
139  const C4Real x0 = itofix(pClipRect->tx - MatBuffPitch/2);
140  iTy=pClipRect->y;
141  int32_t w = pForObject->SolidMask.Wdt;
142  int32_t h = pForObject->SolidMask.Hgt;
143  int32_t mx0 = pForObject->SolidMask.x;
144  int32_t my0 = pForObject->SolidMask.y;
145  C4Real ya = y0 * Ma2;
146  C4Real yb = y0 * Mb2;
147  for (ycnt = 0; ycnt < pClipRect->Hgt; ycnt++)
148  {
149  iTx=pClipRect->x;
150  int i = (ycnt + pClipRect->ty) * MatBuffPitch + pClipRect->tx;
151  C4Real xa = x0 * Ma1;
152  C4Real xb = x0 * Mb1;
153  for (xcnt = 0; xcnt < pClipRect->Wdt; xcnt++)
154  {
155  // calc position in solidmask buffer
156  int32_t iMx = fixtoi(xa + ya) + w / 2;
157  int32_t iMy = fixtoi(xb + yb) + h / 2;
158  // in bounds? and solidmask?
159  if (iMx >= 0 && iMy >= 0 && iMx < w && iMy < h && pSolidMask->_GetPix(iMx+mx0, iMy+my0))
160  {
161  // is background mat to be stored?
162  if (!MaskPut)
163  {
164  // get background pixel
165  byPixel=::Landscape._GetPix(iTx,iTy);
166  // store it. If MCVehic, also store in initial put, but won't be used in restore
167  // do not overwrite current value in re-put issued by SolidMask-remover
168  if (!IsSomeVehicle(byPixel) || RegularPut)
169  pSolidMaskMatBuff[i + xcnt] = byPixel;
170  }
171  // set mask pix
173  }
174  else if (!MaskPut)
175  // mark pix as unused in buf
176  pSolidMaskMatBuff[i+xcnt] = MCVehic;
177  xa += Ma1; xb += Mb1;
178  ++iTx;
179  }
180  ya += Ma2; yb += Mb2;
181  ++iTy;
182  }
183  }
184  // Store mask put status
185  MaskPut=true;
186  // restore attached object positions if moved
187  if (fRestoreAttachment && iAttachingObjectsCount)
188  {
190  int32_t dy = pForObject->GetY() - MaskRemovalY;
191  if (dx != Fix0 || dy != 0)
192  for (int i = 0; i < iAttachingObjectsCount; ++i)
193  {
194  C4Object *pObj = ppAttachingObjects[i];
196  if (!pObj->Shape.ContactCheck(fixtoi(pObj->GetFixedX()+dx), fixtoi(pObj->GetFixedY()+dy)))
198  {
200  pObj->MovePosition(dx, itofix(dy));
201  }
202  }
203  iAttachingObjectsCount = 0;
204  }
205 
206  if (fCauseInstability) CheckConsistency();
207 }
208 
209 int32_t C4SolidMask::DensityProvider::GetDensity(int32_t x, int32_t y) const
210 {
211  // outside SolidMask: free
212  x -= rSolidMaskData.MaskPutRect.x;
213  y -= rSolidMaskData.MaskPutRect.y;
214  if (!Inside<int32_t>(x, 0, rSolidMaskData.MaskPutRect.Wdt-1)
215  || !Inside<int32_t>(y, 0, rSolidMaskData.MaskPutRect.Hgt-1))
216  return 0;
217  // check put mask. Easy for unrotated
218  BYTE pix;
219  if (!rSolidMaskData.MaskPutRotation)
220  {
221  CSurface8 *pSolidMask = rSolidMaskData.pForObject->Def->pSolidMask;
222  if (!pSolidMask) return 0; // can't really happen
223  pix=pSolidMask->_GetPix(x+rSolidMaskData.pForObject->SolidMask.x+rSolidMaskData.MaskPutRect.tx,
224  y+rSolidMaskData.pForObject->SolidMask.y+rSolidMaskData.MaskPutRect.ty);
225  if (pix == 0xff)
226  return C4M_Vehicle;
227  else
228  return 0;
229  }
230  else
231  {
232  // Using put-buffer for rotated masks
233  // for SolidMask-pixels not put because there was another SolidMask already, this will not return solid
234  pix=*(rSolidMaskData.pSolidMaskMatBuff+(y+rSolidMaskData.MaskPutRect.ty)*rSolidMaskData.MatBuffPitch+rSolidMaskData.MaskPutRect.tx+x);
235  if (IsSomeVehicle(pix))
236  return 0;
237  else
238  return C4M_Vehicle;
239  }
240 }
241 
242 void C4SolidMask::Remove(bool fBackupAttachment)
243 {
244  // If put, restore background pixels from buffer
245 
246  // Not put
247  if (!MaskPut || !pSolidMaskMatBuff) return;
248 
250 
251  // reput background pixels
252  for (int ycnt=0; ycnt<MaskPutRect.Hgt; ++ycnt)
253  {
255  for (int xcnt=0; xcnt<MaskPutRect.Wdt; ++xcnt,++pPix)
256  // only if mask was used here
257  if (*pPix != MCVehic)
258  {
259  // calc position in landscape
260  int iTx=MaskPutRect.x+xcnt; int iTy=MaskPutRect.y+ycnt;
261  // restore pixel here
262  // The pPix-check ensures that only pixels that hads been overwritten by this SolidMask are restored
263  // Non-SolidMask-pixels should not happen here, because all relevant landscape change routines should
264  // temp remove SolidMasks before
265  assert(IsSomeVehicle(::Landscape._GetPix(iTx,iTy)));
266  if (IsSomeVehicle(::Landscape._GetPix(iTx, iTy)))
267  ::Landscape._SetPix2(iTx, iTy, *pPix, ::Landscape.Transparent);
268  // Instability
270  }
271  }
272  // Mask not put flag
273  MaskPut=false;
274  // update surrounding masks in that range
275  C4TargetRect ClipRect;
276  for (C4SolidMask *pSolid = C4SolidMask::Last; pSolid; pSolid = pSolid->Prev)
277  if (pSolid->MaskPut) if (pSolid->MaskPutRect.Overlap(MaskPutRect))
278  {
279  // set clipping rect for all calls, since they may modify it
281  // doubled solidmask-pixels have just been removed in the clipped area!
282  pSolid->MaskPut = false;
283  // re-put the solidmask
284  pSolid->Put(false, &ClipRect, false);
285  }
286 
287  // backup attachment if desired: Backup old pos and all objects that attach to or lie on the SolidMask
288  if (fBackupAttachment)
289  {
293  // Search in area slightly larger than SolidMask because objects might have vertices slightly outside their shape
295  C4LSector *pSct;
296  for (C4ObjectList *pLst=SolidArea.FirstObjectShapes(&pSct); pLst; pLst=SolidArea.NextObjectShapes(pLst, &pSct))
297  for (C4Object *pObj : *pLst)
298  if (pObj && pObj != pForObject && pObj->IsMoveableBySolidMask(pForObject->GetSolidMaskPlane()) && !pObj->Shape.CheckContact(pObj->GetX(),pObj->GetY()))
299  {
300  // avoid duplicate that may be found due to sector overlaps
301  bool has_dup = false;
302  for (int32_t i_dup = 0; i_dup < iAttachingObjectsCount; ++i_dup)
303  if (ppAttachingObjects[i_dup] == pObj)
304  {
305  has_dup = true;
306  break;
307  }
308  if (has_dup) continue;
309  // check for any contact to own SolidMask - attach-directions, bottom - "stuck" (CNAT_Center) is ignored, because that causes problems with things being stuck in basements :(
310  int iVtx = 0;
311  for (; iVtx < pObj->Shape.VtxNum; ++iVtx)
312  if (pObj->Shape.GetVertexContact(iVtx, pObj->Action.t_attach | CNAT_Bottom, pObj->GetX(), pObj->GetY(), DensityProvider(pForObject, *this)))
313  break;
314  if (iVtx == pObj->Shape.VtxNum) continue; // no contact
315  // contact: Add object to list
316  if (iAttachingObjectsCapacity == iAttachingObjectsCount)
317  {
319  C4Object **ppNewAttachingObjects = new C4Object *[iAttachingObjectsCapacity];
320  if (iAttachingObjectsCount) memcpy(ppNewAttachingObjects, ppAttachingObjects, sizeof(C4Object *) * iAttachingObjectsCount);
321  delete [] ppAttachingObjects;
322  ppAttachingObjects = ppNewAttachingObjects;
323  }
324  ppAttachingObjects[iAttachingObjectsCount++] = pObj;
325  }
326  }
327 
329 }
330 
332 {
333  // only if put
334  if (!MaskPut) return;
335  // set topface facet
337  // draw it
338  if (MaskPutRotation)
340  else
342 }
343 
344 
346 {
347  if (!MaskPut || !pSolidMaskMatBuff) return;
348  where.Intersect(MaskPutRect);
349  // reput background pixels
350  for (int y = where.y; y < where.y + where.Hgt; ++y)
351  {
352  for (int x = where.x; x < where.x + where.Wdt; ++x)
353  {
355  // only if mask was used here
356  if (*pPix != MCVehic) //
357  {
358  // restore
359  assert(IsSomeVehicle(::Landscape.GetPix(x,y)));
361  }
362  }
363  }
364 }
365 
367 {
368  if (!MaskPut || !pSolidMaskMatBuff) return;
369  where.Intersect(MaskPutRect);
370  // reput vehicle pixels
371  for (int y = where.y; y < where.y + where.Hgt; ++y)
372  {
373  for (int x = where.x; x < where.x + where.Wdt; ++x)
374  {
376  // only if mask was used here
377  if (*pPix != MCVehic)
378  {
379  // put
380  assert(::Landscape.GetPix(x,y)==*pPix);
382  }
383  }
384  }
385 }
386 
388 {
389  if (!MaskPut || !pSolidMaskMatBuff) return;
390  where.Intersect(MaskPutRect);
391  // reput vehicle pixels
392  for (int y = where.y; y < where.y + where.Hgt; ++y)
393  {
394  for (int x = where.x; x < where.x + where.Wdt; ++x)
395  {
397  // only if mask was used here
398  if (*pPix != MCVehic)
399  {
400  // record changed landscape in MatBuff
401  *pPix = ::Landscape.GetPix(x,y);
402  // put
404  }
405  }
406  }
407 }
408 
409 C4SolidMask::C4SolidMask(C4Object *pForObject) : pForObject(pForObject)
410 {
411  // zero fields
412  MaskPut=false;
413  MaskPutRotation=0;
415  ppAttachingObjects=nullptr;
418  // Update linked list
419  Next = 0;
420  Prev = Last;
421  Last = this;
422  if (Prev) Prev->Next = this;
423  else First = this;
424  // create mat buff to store the material replaced by the solid mask
425  // the upper left corner is here the [objpos]+rot([shapexy]+[targetxy]+[realWH]/2)-maxWH/2
426  MatBuffPitch = (int) sqrt(double(pForObject->SolidMask.Wdt * pForObject->SolidMask.Wdt + pForObject->SolidMask.Hgt * pForObject->SolidMask.Hgt))+1;
427  if (!(pSolidMaskMatBuff= new BYTE [MatBuffPitch * MatBuffPitch] )) return;
428  memset(pSolidMaskMatBuff, 0, MatBuffPitch * MatBuffPitch);
429 }
430 
432 {
433  Remove(false);
434  // Update linked list
435  if (Next) Next->Prev = Prev;
436  if (Prev) Prev->Next = Next;
437  if (First == this) First = Next;
438  if (Last == this) Last = Prev;
439  delete [] pSolidMaskMatBuff;
440  delete [] ppAttachingObjects;
441 }
442 
444 {
445  C4Rect SolidMaskRect(0,0,::Landscape.GetWidth(),::Landscape.GetHeight());
446  C4SolidMask *pSolid;
447  for (pSolid = C4SolidMask::Last; pSolid; pSolid = pSolid->Prev)
448  {
449  pSolid->RemoveTemporary(SolidMaskRect);
450  }
451 }
452 
454 {
455  C4Rect SolidMaskRect(0,0,::Landscape.GetWidth(),::Landscape.GetHeight());
456  C4SolidMask *pSolid;
457  // Restore Solidmasks
458  for (pSolid = C4SolidMask::First; pSolid; pSolid = pSolid->Next)
459  {
460  pSolid->PutTemporary(SolidMaskRect);
461  }
462 }
463 
466 
467 
468 #ifdef SOLIDMASK_DEBUG
469 
471 {
472  assert(IsSomeVehicle(MaskMaterial));
473  C4Rect SolidMaskRect(0,0,::Landscape.GetWidth(),::Landscape.GetHeight());
474  C4SolidMask *pSolid;
475  for (pSolid = C4SolidMask::Last; pSolid; pSolid = pSolid->Prev)
476  {
477  pSolid->RemoveTemporary(SolidMaskRect);
478  }
479  assert(!::Landscape.MatCount[MVehic]);
480  // Restore Solidmasks
481  for (pSolid = C4SolidMask::First; pSolid; pSolid = pSolid->Next)
482  {
483  pSolid->PutTemporary(SolidMaskRect);
484  }
485  return true;
486 }
487 
488 #endif
489 
490 CSurface8 *C4SolidMask::LoadMaskFromFile(class C4Group &hGroup, const char *szFilename)
491 {
492  // Construct SolidMask surface from PNG bitmap:
493  // All pixels that are more than 50% transparent are not solid
494  CPNGFile png;
495  StdBuf png_buf;
496  if (!hGroup.LoadEntry(szFilename, &png_buf)) return nullptr; // error messages done by caller
497  if (!png.Load((BYTE*)png_buf.getMData(), png_buf.getSize())) return nullptr;
498  CSurface8 *result = new CSurface8(png.iWdt, png.iHgt);
499  for (size_t y=0u; y<png.iHgt; ++y)
500  for (size_t x=0u; x<png.iWdt; ++x)
501  result->SetPix(x,y,((png.GetPix(x,y)>>24)<128) ? 0x00 : 0xff);
502  return result;
503 }
504 
506 {
507  MaskMaterial = set ? MCHalfVehic : MCVehic;
508  // TODO: Redraw
509 }
void Put(bool fCauseInstability, C4TargetRect *pClipRect, bool fRestoreAttachment)
Definition: C4SolidMask.cpp:33
int32_t GetY() const
Definition: C4Object.h:287
BYTE _GetPix(int32_t x, int32_t y) const
C4Real GetFixedY() const
Definition: C4Object.h:290
int MaskPutRotation
Definition: C4SolidMask.h:29
const int32_t C4M_Vehicle
Definition: C4Constants.h:172
Definition: StdBuf.h:37
DWORD GetPix(int iX, int iY)
Definition: StdPNG.cpp:173
float Y
Definition: C4Facet.h:120
int MatBuffPitch
Definition: C4SolidMask.h:30
void MovePosition(int32_t dx, int32_t dy)
Definition: C4Movement.cpp:523
void SetHalfVehicle(bool set)
C4Game Game
Definition: C4Globals.cpp:52
static void RemoveSolidMasks()
CSurface8 * pSolidMask
Definition: C4Def.h:195
void Remove(bool fBackupAttachment)
int iAttachingObjectsCapacity
Definition: C4SolidMask.h:38
BYTE MCHalfVehic
Definition: C4Material.cpp:39
void PutTemporary(C4Rect where)
BYTE _GetPix(int x, int y) const
Definition: CSurface8.h:54
BYTE * Bits
Definition: CSurface8.h:30
int iAttachingObjectsCount
Definition: C4SolidMask.h:38
void _SetPix2Tmp(int32_t x, int32_t y, BYTE fgPix, BYTE bgPix)
C4Object * pForObject
Definition: C4SolidMask.h:46
Definition: C4Rect.h:29
bool LoadEntry(const char *szEntryName, char **lpbpBuf, size_t *ipSize=nullptr, int iAppendZeros=0)
Definition: C4Group.cpp:1893
uint8_t BYTE
C4TargetRect MaskPutRect
Definition: C4SolidMask.h:40
C4ObjectList * NextObjectShapes(C4ObjectList *pPrev, C4LSector **ppSct)
Definition: C4Sector.cpp:319
void Set(C4Surface &rSfc)
Definition: C4Facet.cpp:459
void Intersect(const C4Rect &r2)
Definition: C4Rect.cpp:100
size_t getSize() const
Definition: StdBuf.h:109
Definition: C4Real.h:58
friend class DensityProvider
Definition: C4SolidMask.h:68
int32_t Wdt
Definition: C4Rect.h:32
void RemoveTemporary(C4Rect where)
int32_t FrameCounter
Definition: C4Game.h:130
void Draw(C4TargetFacet &cgo)
C4Shape Shape
Definition: C4Def.h:106
unsigned long iHgt
Definition: StdPNG.h:44
C4Def * Def
Definition: C4Object.h:143
int32_t y
Definition: C4Rect.h:32
int Pitch
Definition: CSurface8.h:28
int32_t GetR() const
Definition: C4Object.h:288
void DrawX(C4Surface *sfcTarget, float iX, float iY, float iWdt, float iHgt, int32_t iPhaseX=0, int32_t iPhaseY=0) const
Definition: C4Facet.cpp:358
C4Landscape Landscape
void CheckInstabilityRange(int32_t tx, int32_t ty)
int32_t MVehic
Definition: C4Material.cpp:37
bool ClipBy(C4TargetRect &rClip)
Definition: C4Rect.cpp:51
BYTE MCVehic
Definition: C4Material.cpp:38
C4Surface * GetBitmap(DWORD dwClr=0)
C4DefGraphics * GetGraphics() const
Definition: C4Object.h:340
void Repair(C4Rect where)
virtual int32_t GetDensity(int32_t x, int32_t y) const
C4Real GetFixedX() const
Definition: C4Object.h:289
int32_t GetX() const
Definition: C4Object.h:286
int32_t tx
Definition: C4Rect.h:81
C4Fixed itofix(int32_t x)
Definition: C4Real.h:261
BYTE GetPix(int32_t x, int32_t y) const
int32_t ty
Definition: C4Rect.h:81
bool IsMoveableBySolidMask(int ComparisonPlane) const
Definition: C4Object.cpp:4809
class C4Object ** ppAttachingObjects
Definition: C4SolidMask.h:37
bool SetPix2(int32_t x, int32_t y, BYTE fgPix, BYTE bgPix)
static bool CheckConsistency()
Definition: C4SolidMask.h:88
C4ObjectList * FirstObjectShapes(C4LSector **ppSct)
Definition: C4Sector.h:122
C4LSectors Sectors
Definition: C4GameObjects.h:42
int32_t x
Definition: C4Rect.h:32
int32_t GetHeight() const
float TargetX
Definition: C4Facet.h:167
float Hgt
Definition: C4Facet.h:120
static C4SolidMask * First
Definition: C4SolidMask.h:72
unsigned long iWdt
Definition: StdPNG.h:44
void DrawXR(C4Surface *sfcTarget, int32_t iX, int32_t iY, int32_t iWdt, int32_t iHgt, int32_t iPhaseX=0, int32_t iPhaseY=0, int32_t r=0)
Definition: C4Facet.cpp:238
int32_t GetSolidMaskPlane() const
Definition: C4Object.cpp:4910
C4Real MaskRemovalX
Definition: C4SolidMask.h:34
int32_t iLastAttachMovementFrame
Definition: C4Object.h:127
C4ObjectPtr Contained
Definition: C4Object.h:144
int32_t Hgt
Definition: C4Rect.h:32
bool IsSomeVehicle(BYTE mat)
Definition: C4Material.h:228
C4Real Sin(const C4Real &fAngle)
Definition: C4Real.h:265
C4Shape Shape
Definition: C4Object.h:148
C4SolidMask(C4Object *pForObject)
void SetPix(int iX, int iY, BYTE byCol)
Definition: CSurface8.h:37
C4Surface * Surface
Definition: C4Facet.h:119
bool MaskPut
Definition: C4SolidMask.h:28
void Set(int32_t iX, int32_t iY, int32_t iWdt, int32_t iHgt, int32_t iTX, int32_t iTY)
Definition: C4Rect.cpp:45
float TargetY
Definition: C4Facet.h:167
BYTE * pSolidMaskMatBuff
Definition: C4SolidMask.h:42
C4SolidMask * Prev
Definition: C4SolidMask.h:74
static CSurface8 * LoadMaskFromFile(class C4Group &hGroup, const char *szFilename)
C4TargetRect SolidMask
Definition: C4Object.h:150
static const uint8_t Transparent
Definition: C4Landscape.h:51
int fixtoi(const C4Fixed &x)
Definition: C4Real.h:259
bool Load(BYTE *pFile, int iSize)
Definition: StdPNG.cpp:153
float Wdt
Definition: C4Facet.h:120
static void PutSolidMasks()
float X
Definition: C4Facet.h:120
static C4SolidMask * Last
Definition: C4SolidMask.h:73
const BYTE CNAT_Bottom
Definition: C4Constants.h:113
C4Real Cos(const C4Real &fAngle)
Definition: C4Real.h:266
BYTE MaskMaterial
Definition: C4SolidMask.h:44
void * getMData()
Definition: StdBuf.h:108
int32_t GetWidth() const
C4SolidMask * Next
Definition: C4SolidMask.h:75
C4GameObjects Objects
Definition: C4Globals.cpp:48
const C4Real Fix0
Definition: C4Real.h:312
bool _SetPix2(int32_t x, int32_t y, BYTE fgPix, BYTE bgPix)
int32_t MaskRemovalY
Definition: C4SolidMask.h:35
bool ContactCheck(int32_t cx, int32_t cy, uint32_t *border_hack_contacts=0, bool collide_halfvehic=false)
Definition: C4Shape.cpp:352