- remove kexArray

This commit is contained in:
Magnus Norddahl 2018-11-03 16:43:58 +01:00
parent f86358daf5
commit dcb4f083a3
12 changed files with 64 additions and 329 deletions

View file

@ -194,7 +194,6 @@ set( HEADERS
src/lightmap/worker.h
src/lightmap/collision.h
src/lightmap/halffloat.h
src/lightmap/kexlib/array.h
src/lightmap/kexlib/binfile.h
src/lightmap/kexlib/kstring.h
src/lightmap/kexlib/memheap.h

View file

@ -34,6 +34,7 @@
#include <assert.h>
#include <ctype.h>
#include <cstdint>
#include <vector>
#ifdef _MSC_VER
#pragma warning(disable: 4267) // warning C4267: 'argument': conversion from 'size_t' to 'int', possible loss of data

View file

@ -1,263 +0,0 @@
//-----------------------------------------------------------------------------
// Note: this is a modified version of dlight. It is not the original software.
//-----------------------------------------------------------------------------
//
// Copyright (c) 2013-2014 Samuel Villarreal
// svkaiser@gmail.com
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would be
// appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not be
// misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
// distribution.
//
#pragma once
#include <assert.h>
template<class type>
class kexArray
{
public:
kexArray();
~kexArray();
typedef int compare_t(const type*, const type*);
void Push(type o);
void Pop();
void Empty();
void Init();
void Resize(unsigned int size);
type IndexOf(unsigned int index) const;
bool Contains(const type check) const;
void Splice(const unsigned int start, unsigned int len);
void Sort(compare_t *function);
void Sort(compare_t *function, unsigned int count);
const unsigned int Length() const { return length; }
type GetData(const int index) { return data[index]; }
type &operator[](unsigned int index);
kexArray<type> &operator=(const kexArray<type> &arr);
protected:
type *data;
unsigned int length;
unsigned int aidx;
};
template<class type>
kexArray<type>::kexArray()
{
Init();
}
template<class type>
kexArray<type>::~kexArray()
{
Empty();
}
template<class type>
void kexArray<type>::Init()
{
data = NULL;
length = 0;
aidx = 0;
}
template<class type>
void kexArray<type>::Resize(unsigned int size)
{
type *tmp;
if (size == length)
{
return;
}
if (size <= 0 && length != 0)
{
delete[] data;
data = NULL;
length = 0;
return;
}
if (length == 0)
{
data = new type[size];
length = size;
return;
}
tmp = data;
data = new type[size];
for (unsigned int i = 0; i < length; i++)
{
data[i] = tmp[i];
}
length = size;
delete[] tmp;
}
template<class type>
void kexArray<type>::Push(type o)
{
Resize(length + 1);
data[aidx++] = o;
}
template<class type>
void kexArray<type>::Pop()
{
if (length == 0)
{
return;
}
Resize(length - 1);
aidx--;
}
template<class type>
void kexArray<type>::Empty()
{
if (data && length > 0)
{
delete[] data;
data = NULL;
length = 0;
aidx = 0;
}
}
template<class type>
type kexArray<type>::IndexOf(unsigned int index) const
{
if (index >= length)
{
index = length - 1;
}
return data[index];
}
template<class type>
bool kexArray<type>::Contains(const type check) const
{
for (unsigned int i = 0; i < length; ++i)
{
if (data[i] == check)
{
return true;
}
}
return false;
}
template<class type>
void kexArray<type>::Splice(const unsigned int start, unsigned int len)
{
if (length == 0 || len == 0)
{
return;
}
if (len >= length)
{
len = length;
}
type *tmp = new type[len];
for (unsigned int i = 0; i < len; i++)
{
tmp[i] = data[start + i];
}
delete[] data;
data = tmp;
length = length - len;
aidx = length - 1;
}
// Note that data will be shuffled around, so this could invalidate any pointers that relies on the array/data
template<class type>
void kexArray<type>::Sort(compare_t *function)
{
if (data == NULL)
{
return;
}
typedef int compareCast(const void*, const void*);
compareCast *cmpFunc = (compareCast*)function;
qsort((void*)data, length, sizeof(type), cmpFunc);
}
// Note that data will be shuffled around, so this could invalidate any pointers that relies on the array/data
template<class type>
void kexArray<type>::Sort(compare_t *function, unsigned int count)
{
if (data == NULL)
{
return;
}
typedef int compareCast(const void*, const void*);
compareCast *cmpFunc = (compareCast*)function;
qsort((void*)data, count, sizeof(type), cmpFunc);
}
template <class type>
type &kexArray<type>::operator[](unsigned int index)
{
assert(index < length);
return data[index];
}
template <class type>
kexArray<type> &kexArray<type>::operator=(const kexArray<type> &arr)
{
if (data)
{
delete[] data;
}
data = NULL;
length = arr.length;
aidx = arr.aidx;
if (arr.length > 0)
{
data = new type[arr.length];
for (unsigned int i = 0; i < arr.length; i++)
{
data[i] = arr.data[i];
}
}
return *this;
}

View file

@ -481,7 +481,7 @@ kexStr kexStr::Substr(int start, int len) const
return str.Concat((const char*)&charPtr[start], len);
}
/*
void kexStr::Split(kexStrList &list, const char seperator)
{
int splitLen = 0;
@ -509,7 +509,7 @@ void kexStr::Split(kexStrList &list, const char seperator)
list.Push(kexStr(&charPtr[startOffs], splitLen));
}
}
*/
int kexStr::Atoi()
{
return atoi(charPtr);

View file

@ -29,11 +29,10 @@
#include <string.h>
#include "lightmap/common.h"
#include "array.h"
class kexStr;
typedef kexArray<kexStr> kexStrList;
//typedef kexArray<kexStr> kexStrList;
class kexStr
{
@ -60,7 +59,7 @@ public:
kexStr &ToLower();
int Hash();
kexStr Substr(int start, int len) const;
void Split(kexStrList &list, const char seperator);
//void Split(kexStrList &list, const char seperator);
int Atoi();
float Atof();
void WriteToFile(const char *file);

View file

@ -73,7 +73,7 @@ void kexLightmapBuilder::NewTexture()
memset(allocBlocks[numTextures - 1], 0, sizeof(int) * textureWidth);
uint16_t *texture = (uint16_t*)Mem_Calloc((textureWidth * textureHeight) * 3 * 2, hb_static);
textures.Push(texture);
textures.push_back(texture);
}
// Determines where to map a new block on to the lightmap texture
@ -547,10 +547,10 @@ void kexLightmapBuilder::TraceSurface(surface_t *surface)
void kexLightmapBuilder::LightSurface(const int surfid)
{
float remaining;
int numsurfs = surfaces.Length();
int numsurfs = surfaces.size();
// TODO: this should NOT happen, but apparently, it can randomly occur
if (surfaces.Length() == 0)
if (surfaces.size() == 0)
{
return;
}
@ -577,7 +577,7 @@ void kexLightmapBuilder::CreateLightmaps(FLevel &doomMap)
printf("------------- Tracing surfaces -------------\n");
processed = 0;
kexWorker::RunJob(surfaces.Length(), [=](int id) {
kexWorker::RunJob(surfaces.size(), [=](int id) {
LightSurface(id);
});
@ -589,7 +589,7 @@ void kexLightmapBuilder::AddLightmapLump(FWadWriter &wadFile)
// Calculate size of lump
int numTexCoords = 0;
int numSurfaces = 0;
for (unsigned int i = 0; i < surfaces.Length(); i++)
for (size_t i = 0; i < surfaces.size(); i++)
{
if (surfaces[i]->lightmapNum != -1)
{
@ -599,9 +599,9 @@ void kexLightmapBuilder::AddLightmapLump(FWadWriter &wadFile)
}
int version = 0;
int headerSize = 3 * sizeof(uint32_t) + 2 * sizeof(uint16_t);
int surfacesSize = surfaces.Length() * 5 * sizeof(uint32_t);
int surfacesSize = surfaces.size() * 5 * sizeof(uint32_t);
int texCoordsSize = numTexCoords * 2 * sizeof(float);
int texDataSize = textures.Length() * textureWidth * textureHeight * 3 * 2;
int texDataSize = textures.size() * textureWidth * textureHeight * 3 * 2;
int lumpSize = headerSize + surfacesSize + texCoordsSize + texDataSize;
// Setup buffer
@ -612,13 +612,13 @@ void kexLightmapBuilder::AddLightmapLump(FWadWriter &wadFile)
// Write header
lumpFile.Write32(version);
lumpFile.Write16(textureWidth);
lumpFile.Write16(textures.Length());
lumpFile.Write16(textures.size());
lumpFile.Write32(numSurfaces);
lumpFile.Write32(numTexCoords);
// Write surfaces
int coordOffsets = 0;
for (unsigned int i = 0; i < surfaces.Length(); i++)
for (size_t i = 0; i < surfaces.size(); i++)
{
if (surfaces[i]->lightmapNum == -1)
continue;
@ -632,7 +632,7 @@ void kexLightmapBuilder::AddLightmapLump(FWadWriter &wadFile)
}
// Write texture coordinates
for (unsigned int i = 0; i < surfaces.Length(); i++)
for (size_t i = 0; i < surfaces.size(); i++)
{
if (surfaces[i]->lightmapNum == -1)
continue;
@ -673,7 +673,7 @@ void kexLightmapBuilder::AddLightmapLump(FWadWriter &wadFile)
}
// Write lightmap textures
for (unsigned int i = 0; i < textures.Length(); i++)
for (size_t i = 0; i < textures.size(); i++)
{
unsigned int count = (textureWidth * textureHeight) * 3;
for (unsigned int j = 0; j < count; j++)
@ -701,7 +701,7 @@ void kexLightmapBuilder::WriteTexturesToTGA()
{
kexBinFile file;
for (unsigned int i = 0; i < textures.Length(); i++)
for (unsigned int i = 0; i < textures.size(); i++)
{
file.Create(Va("lightmap_%02d.tga", i));
file.Write16(0);
@ -730,7 +730,7 @@ void kexLightmapBuilder::WriteMeshToOBJ()
std::map<int, std::vector<surface_t*>> sortedSurfs;
for (unsigned int i = 0; i < surfaces.Length(); i++)
for (unsigned int i = 0; i < surfaces.size(); i++)
sortedSurfs[surfaces[i]->lightmapNum].push_back(surfaces[i]);
for (const auto &it : sortedSurfs)

View file

@ -64,7 +64,7 @@ private:
bool EmitFromCeiling(kexTrace &trace, const surface_t *surface, const kexVec3 &origin, const kexVec3 &normal, kexVec3 &color);
FLevel *map;
kexArray<uint16_t*> textures;
std::vector<uint16_t*> textures;
int **allocBlocks;
int numTextures;
int extraSamples;

View file

@ -66,11 +66,11 @@ void kexLightSurface::CreateCenterOrigin()
center += surface->verts[i];
}
origins.Push(center / (float)surface->numVerts);
origins.push_back(center / (float)surface->numVerts);
}
else
{
origins.Push(kexVec3((surface->verts[1].x + surface->verts[0].x) * 0.5f,
origins.push_back(kexVec3((surface->verts[1].x + surface->verts[0].x) * 0.5f,
(surface->verts[1].y + surface->verts[0].y) * 0.5f,
(surface->verts[2].z + surface->verts[0].z) * 0.5f));
}
@ -79,32 +79,32 @@ void kexLightSurface::CreateCenterOrigin()
// Splits surface vertices into two groups while adding new ones caused by the split
void kexLightSurface::Clip(vertexBatch_t &points, const kexVec3 &normal, float dist, vertexBatch_t *frontPoints, vertexBatch_t *backPoints)
{
kexArray<float> dists;
kexArray<char> sides;
std::vector<float> dists;
std::vector<char> sides;
// determines what sides the vertices lies on
for (unsigned int i = 0; i < points.Length(); ++i)
for (size_t i = 0; i < points.size(); ++i)
{
float d = points[i].Dot(normal) - dist;
dists.Push(d);
dists.push_back(d);
if (d > 0.1f)
{
sides.Push(1); // front
sides.push_back(1); // front
}
else if (d < -0.1f)
{
sides.Push(-1); // directly on the split plane
sides.push_back(-1); // directly on the split plane
}
else
{
sides.Push(0); // back
sides.push_back(0); // back
}
}
// add points
for (unsigned int i = 0; i < points.Length(); ++i)
for (unsigned int i = 0; i < points.size(); ++i)
{
int next;
float frac;
@ -113,16 +113,16 @@ void kexLightSurface::Clip(vertexBatch_t &points, const kexVec3 &normal, float d
switch (sides[i])
{
case -1:
backPoints->Push(points[i]);
backPoints->push_back(points[i]);
break;
case 1:
frontPoints->Push(points[i]);
frontPoints->push_back(points[i]);
break;
default:
frontPoints->Push(points[i]);
backPoints->Push(points[i]);
frontPoints->push_back(points[i]);
backPoints->push_back(points[i]);
// point is on the split plane so no new split vertex is needed
continue;
@ -130,7 +130,7 @@ void kexLightSurface::Clip(vertexBatch_t &points, const kexVec3 &normal, float d
}
// check if the edge crosses the split plane
next = (i + 1) % points.Length();
next = (i + 1) % points.size();
if (sides[next] == 0 || sides[next] == sides[i])
{
@ -145,13 +145,13 @@ void kexLightSurface::Clip(vertexBatch_t &points, const kexVec3 &normal, float d
frac = dists[i] / (dists[i] - dists[next]);
pt3 = pt1.Lerp(pt2, frac);
frontPoints->Push(pt3);
backPoints->Push(pt3);
frontPoints->push_back(pt3);
backPoints->push_back(pt3);
}
}
// Recursively divides the surface
bool kexLightSurface::SubdivideRecursion(vertexBatch_t &surfPoints, float divide, kexArray<vertexBatch_t*> &points)
bool kexLightSurface::SubdivideRecursion(vertexBatch_t &surfPoints, float divide, std::vector<vertexBatch_t*> &points)
{
kexBBox bounds;
kexVec3 splitNormal;
@ -160,7 +160,7 @@ bool kexLightSurface::SubdivideRecursion(vertexBatch_t &surfPoints, float divide
vertexBatch_t *backPoints;
// get bounds from current set of points
for (unsigned int i = 0; i < surfPoints.Length(); ++i)
for (unsigned int i = 0; i < surfPoints.size(); ++i)
{
bounds.AddPoint(surfPoints[i]);
}
@ -183,7 +183,7 @@ bool kexLightSurface::SubdivideRecursion(vertexBatch_t &surfPoints, float divide
if (!SubdivideRecursion(*frontPoints, divide, points))
{
points.Push(frontPoints);
points.push_back(frontPoints);
}
else
{
@ -192,7 +192,7 @@ bool kexLightSurface::SubdivideRecursion(vertexBatch_t &surfPoints, float divide
if (!SubdivideRecursion(*backPoints, divide, points))
{
points.Push(backPoints);
points.push_back(backPoints);
}
else
{
@ -208,36 +208,35 @@ bool kexLightSurface::SubdivideRecursion(vertexBatch_t &surfPoints, float divide
void kexLightSurface::Subdivide(const float divide)
{
kexArray<vertexBatch_t*> points;
std::vector<vertexBatch_t*> points;
vertexBatch_t surfPoints;
for (int i = 0; i < surface->numVerts; ++i)
{
surfPoints.Push(surface->verts[i]);
surfPoints.push_back(surface->verts[i]);
}
SubdivideRecursion(surfPoints, divide, points);
// from each group of vertices caused by the split, begin
// creating a origin point based on the center of that group
for (unsigned int i = 0; i < points.Length(); ++i)
for (size_t i = 0; i < points.size(); ++i)
{
vertexBatch_t *vb = points[i];
kexVec3 center;
for (unsigned int j = 0; j < vb->Length(); ++j)
for (unsigned int j = 0; j < vb->size(); ++j)
{
center += (*vb)[j];
}
origins.Push(center / (float)vb->Length());
origins.push_back(center / (float)vb->size());
}
for (unsigned int i = 0; i < points.Length(); ++i)
for (size_t i = 0; i < points.size(); ++i)
{
vertexBatch_t *vb = points[i];
vb->Empty();
delete vb;
}
}
@ -272,7 +271,7 @@ float kexLightSurface::TraceSurface(FLevel *doomMap, kexTrace &trace, const surf
float total = 0.0f;
float closestDistance = distance * gzdoomRadiusScale;
for (unsigned int i = 0; i < origins.Length(); ++i)
for (size_t i = 0; i < origins.size(); ++i)
{
kexVec3 center = origins[i];
@ -318,5 +317,5 @@ float kexLightSurface::TraceSurface(FLevel *doomMap, kexTrace &trace, const surf
}
float attenuation = 1.0f - closestDistance / (distance * gzdoomRadiusScale);
return attenuation * total / origins.Length();
return attenuation * total / origins.size();
}

View file

@ -52,7 +52,7 @@ public:
const vertexBatch_t Origins() const { return origins; }
private:
bool SubdivideRecursion(vertexBatch_t &surfPoints, float divide, kexArray<vertexBatch_t*> &points);
bool SubdivideRecursion(vertexBatch_t &surfPoints, float divide, std::vector<vertexBatch_t*> &points);
void Clip(vertexBatch_t &points, const kexVec3 &normal, float dist, vertexBatch_t *frontPoints, vertexBatch_t *backPoints);
float distance;

View file

@ -165,7 +165,7 @@ FloatVertex FLevel::GetSegVertex(int index)
void FLevel::CreateLights()
{
thingLight_t *thingLight;
unsigned int j;
size_t j;
int numSurfLights;
kexVec2 pt;
@ -239,7 +239,7 @@ void FLevel::CreateLights()
//
// add surface lights
//
for (j = 0; j < surfaces.Length(); ++j)
for (j = 0; j < surfaces.size(); ++j)
{
surface_t *surface = surfaces[j];

View file

@ -34,7 +34,7 @@
#include "mapdata.h"
#include "surfaces.h"
kexArray<surface_t*> surfaces;
std::vector<surface_t*> surfaces;
static void CreateSideSurfaces(FLevel &doomMap, IntSideDef *side)
{
@ -96,7 +96,7 @@ static void CreateSideSurfaces(FLevel &doomMap, IntSideDef *side)
surf->type = ST_LOWERSIDE;
surf->typeIndex = side - &doomMap.Sides[0];
surfaces.Push(surf);
surfaces.push_back(surf);
}
v1Bottom = v1BottomBack;
@ -139,7 +139,7 @@ static void CreateSideSurfaces(FLevel &doomMap, IntSideDef *side)
surf->typeIndex = side - &doomMap.Sides[0];
surf->bSky = bSky;
surfaces.Push(surf);
surfaces.push_back(surf);
}
v1Top = v1TopBack;
@ -168,7 +168,7 @@ static void CreateSideSurfaces(FLevel &doomMap, IntSideDef *side)
surf->type = ST_MIDDLESIDE;
surf->typeIndex = side - &doomMap.Sides[0];
surfaces.Push(surf);
surfaces.push_back(surf);
}
}
@ -224,7 +224,7 @@ static void CreateSubsectorSurfaces(FLevel &doomMap)
surf->type = ST_FLOOR;
surf->typeIndex = i;
surfaces.Push(surf);
surfaces.push_back(surf);
surf = (surface_t*)Mem_Calloc(sizeof(surface_t), hb_static);
surf->numVerts = sub->numlines;
@ -250,10 +250,10 @@ static void CreateSubsectorSurfaces(FLevel &doomMap)
surf->type = ST_CEILING;
surf->typeIndex = i;
surfaces.Push(surf);
surfaces.push_back(surf);
}
printf("\nLeaf surfaces: %i\n", surfaces.Length() - doomMap.NumGLSubsectors);
printf("\nLeaf surfaces: %i\n", (int)surfaces.size() - doomMap.NumGLSubsectors);
}
static bool IsDegenerate(const kexVec3 &v0, const kexVec3 &v1, const kexVec3 &v2)
@ -274,7 +274,7 @@ static bool IsDegenerate(const kexVec3 &v0, const kexVec3 &v1, const kexVec3 &v2
void CreateSurfaces(FLevel &doomMap)
{
for (unsigned int i = 0; i < surfaces.Length(); i++)
for (size_t i = 0; i < surfaces.size(); i++)
Mem_Free(surfaces[i]);
surfaces = {};
@ -321,15 +321,15 @@ void CreateSurfaces(FLevel &doomMap)
printf("sides: %i / %i\r", i + 1, doomMap.Sides.Size());
}
printf("\nSide surfaces: %i\n", surfaces.Length());
printf("\nSide surfaces: %i\n", (int)surfaces.size());
CreateSubsectorSurfaces(doomMap);
printf("Surfaces total: %i\n\n", surfaces.Length());
printf("Surfaces total: %i\n\n", (int)surfaces.size());
printf("Building collision mesh..\n\n");
for (unsigned int i = 0; i < surfaces.Length(); i++)
for (size_t i = 0; i < surfaces.size(); i++)
{
const auto &s = surfaces[i];
int numVerts = s->numVerts;

View file

@ -39,7 +39,7 @@ enum surfaceType_t
ST_FLOOR
};
typedef kexArray<kexVec3> vertexBatch_t;
typedef std::vector<kexVec3> vertexBatch_t;
// convert from fixed point(FRACUNIT) to floating point
#define F(x) (((float)(x))/65536.0f)
@ -62,7 +62,7 @@ struct surface_t
bool bSky;
};
extern kexArray<surface_t*> surfaces;
extern std::vector<surface_t*> surfaces;
struct FLevel;