public static void FillUvs(TpSpriteMeta *self, float *uvs)
{
#if FDB
Should.NotNull("self", self);
Should.NotNull("uvs", uvs);
Should.TypeEqual("self", self->type, Type);
Should.NotNull("self->atlas", self->atlas);
Should.TypeEqual("self->atlas->type", self->atlas->type, TpAtlasMeta.Type);
#endif
float *size = self->atlas->size;
float invSizeX = 1 / size[0], invSizeY = 1 / size[1];
float *uv = self->uv;
float uvX = uv[0], uvY = uv[1], uvW = uv[2], uvH = uv[3];
if (self->rotated)
{
Vec2.Set(uvs, (uvX + uvW) * invSizeX, -uvY * invSizeY);
Vec2.Set(uvs + 2, (uvX + uvW) * invSizeX, (-uvY - uvH) * invSizeY);
Vec2.Set(uvs + 4, uvX * invSizeX, (-uvY - uvH) * invSizeY);
Vec2.Set(uvs + 6, uvX * invSizeX, -uvY * invSizeY);
}
else
{
Vec2.Set(uvs, uvX * invSizeX, -uvY * invSizeY);
Vec2.Set(uvs + 2, (uvX + uvW) * invSizeX, -uvY * invSizeY);
Vec2.Set(uvs + 4, (uvX + uvW) * invSizeX, (-uvY - uvH) * invSizeY);
Vec2.Set(uvs + 6, uvX * invSizeX, (-uvY - uvH) * invSizeY);
}
}
public static void Remove(PtrLst *self, void *ptr)
{
#if FDB
Should.NotNull("self", self);
Should.TypeEqual("self", self->type, Type);
int oldCount = self->count;
#endif
void **arr = self->arr;
int i = 0, len = self->count;
while (i < len && arr[i] != ptr)
{
i += 1;
}
if (i < len) // arr[i] == p
// for (len = self->count -= 1; i < len; i += 1) arr[i] = arr[i + 1];
{
byte *src = (byte *)(arr + i);
int size = self->size;
int count = self->count -= 1;
Mem.Memmove(src, src + size, (count - i) * size);
}
#if FDB
else
{
Fdb.Error("{0:X} does not exist in PtrLst {1:X}", (ulong)ptr, (ulong)self);
}
Should.Equal("self->count", self->count, oldCount - 1);
#endif
}
public static void SetTint(TpSprite *self, float r, float g, float b)
{
#if FDB
Should.NotNull("self", self);
Should.TypeEqual("self", self->type, Type);
#endif
Vec3.Set(self->color, r, g, b);
}
public static void SetAlpha(TpSprite *self, float a)
{
#if FDB
Should.NotNull("self", self);
Should.TypeEqual("self", self->type, Type);
#endif
self->color[3] = a;
}
public static void Clear(PtrLst *self)
{
#if FDB
Should.NotNull("self", self);
Should.TypeEqual("self", self->type, Type);
#endif
self->count = 0;
}
public static void SetScale(TpSprite *self, float x, float y)
{
#if FDB
Should.NotNull("self", self);
Should.TypeEqual("self", self->type, Type);
#endif
Vec2.Set(self->scl, x, y);
self->isTransformDirty = true;
}
public static void SetRotation(TpSprite *self, float rotation)
{
#if FDB
Should.NotNull("self", self);
Should.TypeEqual("self", self->type, Type);
#endif
self->rot = rotation;
self->isTransformDirty = true;
}
public static void SetPosition(TpSprite *self, float x, float y, float z)
{
#if FDB
Should.NotNull("self", self);
Should.TypeEqual("self", self->type, Type);
#endif
Vec3.Set(self->pos, x, y, z);
self->isTransformDirty = true;
}
public static void Verify(PtrLst *self)
{
Should.NotNull("self", self);
Should.TypeEqual("self", self->type, Type);
int len = Mem.Verify(self->arr) / sizeof(void *);
Should.Equal("self->len", self->len, len);
Should.InRange("self->count", self->count, 0, self->len);
Should.Equal("self->size", self->size, sizeof(void *));
}
public static void Draw(TpSprite *self, float *parentMat, bool isParentTransformDirty)
{
#if FDB
Should.NotNull("self", self);
Should.TypeEqual("self", self->type, Type);
Should.NotNull("self->spriteMeta", self->spriteMeta);
#endif
var bat = DrawCtx.GetBatch(self->spriteMeta->atlas->name);
int vertIdx = bat.vertCount, triIdx = bat.triCount;
bat.RequestQuota(4, 6);
float *verts = self->verts;
float *uvs = self->uvs;
if (self->isTransformDirty)
{
float *mat = stackalloc float[6];
Mat2D.FromScalingRotationTranslation(mat, self->pos, self->scl, self->rot);
TpSpriteMeta.FillQuad(self->spriteMeta, mat, self->verts);
}
var bVerts = bat.verts; var bUvs = bat.uvs;
float z = self->pos[2];
bVerts[vertIdx].Set(verts[0], verts[1], z);
bVerts[vertIdx + 1].Set(verts[2], verts[3], z);
bVerts[vertIdx + 2].Set(verts[4], verts[5], z);
bVerts[vertIdx + 3].Set(verts[6], verts[7], z);
bUvs[vertIdx].Set(uvs[0], uvs[1]);
bUvs[vertIdx + 1].Set(uvs[2], uvs[3]);
bUvs[vertIdx + 2].Set(uvs[4], uvs[5]);
bUvs[vertIdx + 3].Set(uvs[6], uvs[7]);
float *color = self->color;
var bColor = Vec4.Color(color, 0.5f);
var bColors = bat.colors;
bColors[vertIdx] = bColor;
bColors[vertIdx + 1] = bColor;
bColors[vertIdx + 2] = bColor;
bColors[vertIdx + 3] = bColor;
var bTris = bat.tris;
bTris[triIdx] = vertIdx;
bTris[triIdx + 1] = vertIdx + 1;
bTris[triIdx + 2] = vertIdx + 2;
bTris[triIdx + 3] = vertIdx;
bTris[triIdx + 4] = vertIdx + 2;
bTris[triIdx + 5] = vertIdx + 3;
}
public static void Decon(TpAtlasMeta *self)
{
#if FDB
Should.NotNull("self", self);
Should.TypeEqual("self", self->type, Type);
Should.NotNull("self->sprites", self->sprites);
self->type = Fdb.NullType;
for (int j = 0, end = self->spriteCount; j < end; j += 1)
{
var sprite = self->sprites + j;
Should.TypeEqual("sprite->type", sprite->type, TpSpriteMeta.Type);
sprite->type = Fdb.NullType;
}
#endif
self->name = -1;
Mem.Free(self->sprites); self->sprites = null;
}
// v0 - v1
// | \ |
// v3 - v2
public static void FillQuad(TpSpriteMeta *self, float *mat, float *verts)
{
#if FDB
Should.NotNull("self", self);
Should.NotNull("verts", verts);
Should.NotNull("mat", mat);
Should.TypeEqual("self", self->type, Type);
Should.NotNull("self->atlas", self->atlas);
Should.TypeEqual("self->atlas->type", self->atlas->type, TpAtlasMeta.Type);
#endif
float *pivot = self->pivot;
float pivotX = pivot[0], pivotY = pivot[1];
float *quad = self->quad;
float quadX = quad[0], quadY = quad[1], quadW = quad[2], quadH = quad[3];
Vec2.TransformMat2D(verts, mat, -pivotX + quadX, pivotY - quadY);
Vec2.TransformMat2D(verts + 2, mat, -pivotX + quadX + quadW, pivotY - quadY);
Vec2.TransformMat2D(verts + 4, mat, -pivotX + quadX + quadW, pivotY - quadY - quadH);
Vec2.TransformMat2D(verts + 6, mat, -pivotX + quadX, pivotY - quadY - quadH);
}
public static void Verify(Pool *self)
{
Should.NotNull("self", self);
Should.TypeEqual("self", self->type, Type);
Should.GreaterThanZero("self->len", self->len);
Should.Equal("self->HeadSize", HeadSize, 3 * sizeof(int));
Should.Equal("self->TailSize", TailSize, sizeof(int));
int len = Mem.Verify(self->arr);
Should.Equal("self->len", self->len, len);
// Fdb.Dump(self->arr, len);
byte *arr = self->arr;
int * head;
head = (int *)(arr + self->len - HeadSize);
Should.Equal("endHead->prev", head[0], -1); // head.prev = -1
Should.Equal("endHead->next", head[1], -1); // head.next = -1
Should.Equal("endHead->size", head[2], 0); // head.size = 0
head = (int *)arr;
Should.Equal("firstHead->prev", head[0], -1); // head.prev = -1
Should.Equal("firstHead->size", head[2], 0); // head.size = 0
Should.Equal("firstTail->size", head[3], -1); // tail.size = -1
int curFree = head[1], lastFree = 0;
var dict = new System.Collections.Generic.Dictionary <int, int>();
while (curFree != -1)
{
head = (int *)(arr + curFree);
Should.Equal("head" + curFree + "->prev", head[0], lastFree);
Should.Equal("tail->size", *(int *)((byte *)head + HeadSize + head[2]), head[2]);
dict.Add(curFree, head[2]);
lastFree = curFree;
curFree = head[1];
}
head = (int *)(arr + HeadSize + TailSize);
int *end = (int *)(arr + self->len);
while (head < end)
{
int pos = (int)((byte *)head - self->arr);
int prev = head[0], next = head[1], size = head[2];
int *tail = (int *)((byte *)head + HeadSize + size);
if (tail < end)
{
int tailVal = tail[0];
if (tailVal == -1) // in use
{
Should.False("dict.ContainsKey(pos)", dict.ContainsKey(pos));
Should.Equal("prev", prev, -1);
Should.Equal("next", next, -1);
Should.GreaterThanZero("size", size);
}
else // free
{
Should.True("dict.ContainsKey(pos)" + pos, dict.ContainsKey(pos));
Should.GreaterThanOrEqualTo("prev", prev, 0);
Should.GreaterThanOrEqualTo("next", next, -1);
Should.Equal("size", size, dict[pos]);
dict.Remove(pos);
}
}
else // head is end sentinel, no tail
{
Should.Equal("head", head, (int *)(arr + len - HeadSize));
Should.Equal("endHead->prev", head[0], -1); // head.prev = -1
Should.Equal("endHead->next", head[1], -1); // head.next = -1
Should.Equal("endHead->size", head[2], 0); // head.size = 0
}
head = (int *)((byte *)head + HeadSize + size + TailSize);
}
Should.Zero("dict.Count", dict.Count);
}
