mirror of
https://github.com/ZDoom/ZDRay.git
synced 2024-11-12 23:54:27 +00:00
- remove kexArray
This commit is contained in:
parent
f86358daf5
commit
dcb4f083a3
12 changed files with 64 additions and 329 deletions
|
@ -194,7 +194,6 @@ set( HEADERS
|
||||||
src/lightmap/worker.h
|
src/lightmap/worker.h
|
||||||
src/lightmap/collision.h
|
src/lightmap/collision.h
|
||||||
src/lightmap/halffloat.h
|
src/lightmap/halffloat.h
|
||||||
src/lightmap/kexlib/array.h
|
|
||||||
src/lightmap/kexlib/binfile.h
|
src/lightmap/kexlib/binfile.h
|
||||||
src/lightmap/kexlib/kstring.h
|
src/lightmap/kexlib/kstring.h
|
||||||
src/lightmap/kexlib/memheap.h
|
src/lightmap/kexlib/memheap.h
|
||||||
|
|
|
@ -34,6 +34,7 @@
|
||||||
#include <assert.h>
|
#include <assert.h>
|
||||||
#include <ctype.h>
|
#include <ctype.h>
|
||||||
#include <cstdint>
|
#include <cstdint>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
#ifdef _MSC_VER
|
#ifdef _MSC_VER
|
||||||
#pragma warning(disable: 4267) // warning C4267: 'argument': conversion from 'size_t' to 'int', possible loss of data
|
#pragma warning(disable: 4267) // warning C4267: 'argument': conversion from 'size_t' to 'int', possible loss of data
|
||||||
|
|
|
@ -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;
|
|
||||||
}
|
|
|
@ -481,7 +481,7 @@ kexStr kexStr::Substr(int start, int len) const
|
||||||
|
|
||||||
return str.Concat((const char*)&charPtr[start], len);
|
return str.Concat((const char*)&charPtr[start], len);
|
||||||
}
|
}
|
||||||
|
/*
|
||||||
void kexStr::Split(kexStrList &list, const char seperator)
|
void kexStr::Split(kexStrList &list, const char seperator)
|
||||||
{
|
{
|
||||||
int splitLen = 0;
|
int splitLen = 0;
|
||||||
|
@ -509,7 +509,7 @@ void kexStr::Split(kexStrList &list, const char seperator)
|
||||||
list.Push(kexStr(&charPtr[startOffs], splitLen));
|
list.Push(kexStr(&charPtr[startOffs], splitLen));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
*/
|
||||||
int kexStr::Atoi()
|
int kexStr::Atoi()
|
||||||
{
|
{
|
||||||
return atoi(charPtr);
|
return atoi(charPtr);
|
||||||
|
|
|
@ -29,11 +29,10 @@
|
||||||
|
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
#include "lightmap/common.h"
|
#include "lightmap/common.h"
|
||||||
#include "array.h"
|
|
||||||
|
|
||||||
class kexStr;
|
class kexStr;
|
||||||
|
|
||||||
typedef kexArray<kexStr> kexStrList;
|
//typedef kexArray<kexStr> kexStrList;
|
||||||
|
|
||||||
class kexStr
|
class kexStr
|
||||||
{
|
{
|
||||||
|
@ -60,7 +59,7 @@ public:
|
||||||
kexStr &ToLower();
|
kexStr &ToLower();
|
||||||
int Hash();
|
int Hash();
|
||||||
kexStr Substr(int start, int len) const;
|
kexStr Substr(int start, int len) const;
|
||||||
void Split(kexStrList &list, const char seperator);
|
//void Split(kexStrList &list, const char seperator);
|
||||||
int Atoi();
|
int Atoi();
|
||||||
float Atof();
|
float Atof();
|
||||||
void WriteToFile(const char *file);
|
void WriteToFile(const char *file);
|
||||||
|
|
|
@ -73,7 +73,7 @@ void kexLightmapBuilder::NewTexture()
|
||||||
memset(allocBlocks[numTextures - 1], 0, sizeof(int) * textureWidth);
|
memset(allocBlocks[numTextures - 1], 0, sizeof(int) * textureWidth);
|
||||||
|
|
||||||
uint16_t *texture = (uint16_t*)Mem_Calloc((textureWidth * textureHeight) * 3 * 2, hb_static);
|
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
|
// 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)
|
void kexLightmapBuilder::LightSurface(const int surfid)
|
||||||
{
|
{
|
||||||
float remaining;
|
float remaining;
|
||||||
int numsurfs = surfaces.Length();
|
int numsurfs = surfaces.size();
|
||||||
|
|
||||||
// TODO: this should NOT happen, but apparently, it can randomly occur
|
// TODO: this should NOT happen, but apparently, it can randomly occur
|
||||||
if (surfaces.Length() == 0)
|
if (surfaces.size() == 0)
|
||||||
{
|
{
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
@ -577,7 +577,7 @@ void kexLightmapBuilder::CreateLightmaps(FLevel &doomMap)
|
||||||
printf("------------- Tracing surfaces -------------\n");
|
printf("------------- Tracing surfaces -------------\n");
|
||||||
|
|
||||||
processed = 0;
|
processed = 0;
|
||||||
kexWorker::RunJob(surfaces.Length(), [=](int id) {
|
kexWorker::RunJob(surfaces.size(), [=](int id) {
|
||||||
LightSurface(id);
|
LightSurface(id);
|
||||||
});
|
});
|
||||||
|
|
||||||
|
@ -589,7 +589,7 @@ void kexLightmapBuilder::AddLightmapLump(FWadWriter &wadFile)
|
||||||
// Calculate size of lump
|
// Calculate size of lump
|
||||||
int numTexCoords = 0;
|
int numTexCoords = 0;
|
||||||
int numSurfaces = 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)
|
if (surfaces[i]->lightmapNum != -1)
|
||||||
{
|
{
|
||||||
|
@ -599,9 +599,9 @@ void kexLightmapBuilder::AddLightmapLump(FWadWriter &wadFile)
|
||||||
}
|
}
|
||||||
int version = 0;
|
int version = 0;
|
||||||
int headerSize = 3 * sizeof(uint32_t) + 2 * sizeof(uint16_t);
|
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 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;
|
int lumpSize = headerSize + surfacesSize + texCoordsSize + texDataSize;
|
||||||
|
|
||||||
// Setup buffer
|
// Setup buffer
|
||||||
|
@ -612,13 +612,13 @@ void kexLightmapBuilder::AddLightmapLump(FWadWriter &wadFile)
|
||||||
// Write header
|
// Write header
|
||||||
lumpFile.Write32(version);
|
lumpFile.Write32(version);
|
||||||
lumpFile.Write16(textureWidth);
|
lumpFile.Write16(textureWidth);
|
||||||
lumpFile.Write16(textures.Length());
|
lumpFile.Write16(textures.size());
|
||||||
lumpFile.Write32(numSurfaces);
|
lumpFile.Write32(numSurfaces);
|
||||||
lumpFile.Write32(numTexCoords);
|
lumpFile.Write32(numTexCoords);
|
||||||
|
|
||||||
// Write surfaces
|
// Write surfaces
|
||||||
int coordOffsets = 0;
|
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)
|
if (surfaces[i]->lightmapNum == -1)
|
||||||
continue;
|
continue;
|
||||||
|
@ -632,7 +632,7 @@ void kexLightmapBuilder::AddLightmapLump(FWadWriter &wadFile)
|
||||||
}
|
}
|
||||||
|
|
||||||
// Write texture coordinates
|
// 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)
|
if (surfaces[i]->lightmapNum == -1)
|
||||||
continue;
|
continue;
|
||||||
|
@ -673,7 +673,7 @@ void kexLightmapBuilder::AddLightmapLump(FWadWriter &wadFile)
|
||||||
}
|
}
|
||||||
|
|
||||||
// Write lightmap textures
|
// 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;
|
unsigned int count = (textureWidth * textureHeight) * 3;
|
||||||
for (unsigned int j = 0; j < count; j++)
|
for (unsigned int j = 0; j < count; j++)
|
||||||
|
@ -701,7 +701,7 @@ void kexLightmapBuilder::WriteTexturesToTGA()
|
||||||
{
|
{
|
||||||
kexBinFile file;
|
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.Create(Va("lightmap_%02d.tga", i));
|
||||||
file.Write16(0);
|
file.Write16(0);
|
||||||
|
@ -730,7 +730,7 @@ void kexLightmapBuilder::WriteMeshToOBJ()
|
||||||
|
|
||||||
std::map<int, std::vector<surface_t*>> sortedSurfs;
|
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]);
|
sortedSurfs[surfaces[i]->lightmapNum].push_back(surfaces[i]);
|
||||||
|
|
||||||
for (const auto &it : sortedSurfs)
|
for (const auto &it : sortedSurfs)
|
||||||
|
|
|
@ -64,7 +64,7 @@ private:
|
||||||
bool EmitFromCeiling(kexTrace &trace, const surface_t *surface, const kexVec3 &origin, const kexVec3 &normal, kexVec3 &color);
|
bool EmitFromCeiling(kexTrace &trace, const surface_t *surface, const kexVec3 &origin, const kexVec3 &normal, kexVec3 &color);
|
||||||
|
|
||||||
FLevel *map;
|
FLevel *map;
|
||||||
kexArray<uint16_t*> textures;
|
std::vector<uint16_t*> textures;
|
||||||
int **allocBlocks;
|
int **allocBlocks;
|
||||||
int numTextures;
|
int numTextures;
|
||||||
int extraSamples;
|
int extraSamples;
|
||||||
|
|
|
@ -66,11 +66,11 @@ void kexLightSurface::CreateCenterOrigin()
|
||||||
center += surface->verts[i];
|
center += surface->verts[i];
|
||||||
}
|
}
|
||||||
|
|
||||||
origins.Push(center / (float)surface->numVerts);
|
origins.push_back(center / (float)surface->numVerts);
|
||||||
}
|
}
|
||||||
else
|
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[1].y + surface->verts[0].y) * 0.5f,
|
||||||
(surface->verts[2].z + surface->verts[0].z) * 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
|
// 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)
|
void kexLightSurface::Clip(vertexBatch_t &points, const kexVec3 &normal, float dist, vertexBatch_t *frontPoints, vertexBatch_t *backPoints)
|
||||||
{
|
{
|
||||||
kexArray<float> dists;
|
std::vector<float> dists;
|
||||||
kexArray<char> sides;
|
std::vector<char> sides;
|
||||||
|
|
||||||
// determines what sides the vertices lies on
|
// 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;
|
float d = points[i].Dot(normal) - dist;
|
||||||
|
|
||||||
dists.Push(d);
|
dists.push_back(d);
|
||||||
|
|
||||||
if (d > 0.1f)
|
if (d > 0.1f)
|
||||||
{
|
{
|
||||||
sides.Push(1); // front
|
sides.push_back(1); // front
|
||||||
}
|
}
|
||||||
else if (d < -0.1f)
|
else if (d < -0.1f)
|
||||||
{
|
{
|
||||||
sides.Push(-1); // directly on the split plane
|
sides.push_back(-1); // directly on the split plane
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
sides.Push(0); // back
|
sides.push_back(0); // back
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// add points
|
// add points
|
||||||
for (unsigned int i = 0; i < points.Length(); ++i)
|
for (unsigned int i = 0; i < points.size(); ++i)
|
||||||
{
|
{
|
||||||
int next;
|
int next;
|
||||||
float frac;
|
float frac;
|
||||||
|
@ -113,16 +113,16 @@ void kexLightSurface::Clip(vertexBatch_t &points, const kexVec3 &normal, float d
|
||||||
switch (sides[i])
|
switch (sides[i])
|
||||||
{
|
{
|
||||||
case -1:
|
case -1:
|
||||||
backPoints->Push(points[i]);
|
backPoints->push_back(points[i]);
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case 1:
|
case 1:
|
||||||
frontPoints->Push(points[i]);
|
frontPoints->push_back(points[i]);
|
||||||
break;
|
break;
|
||||||
|
|
||||||
default:
|
default:
|
||||||
frontPoints->Push(points[i]);
|
frontPoints->push_back(points[i]);
|
||||||
backPoints->Push(points[i]);
|
backPoints->push_back(points[i]);
|
||||||
|
|
||||||
// point is on the split plane so no new split vertex is needed
|
// point is on the split plane so no new split vertex is needed
|
||||||
continue;
|
continue;
|
||||||
|
@ -130,7 +130,7 @@ void kexLightSurface::Clip(vertexBatch_t &points, const kexVec3 &normal, float d
|
||||||
}
|
}
|
||||||
|
|
||||||
// check if the edge crosses the split plane
|
// 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])
|
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]);
|
frac = dists[i] / (dists[i] - dists[next]);
|
||||||
pt3 = pt1.Lerp(pt2, frac);
|
pt3 = pt1.Lerp(pt2, frac);
|
||||||
|
|
||||||
frontPoints->Push(pt3);
|
frontPoints->push_back(pt3);
|
||||||
backPoints->Push(pt3);
|
backPoints->push_back(pt3);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// Recursively divides the surface
|
// 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;
|
kexBBox bounds;
|
||||||
kexVec3 splitNormal;
|
kexVec3 splitNormal;
|
||||||
|
@ -160,7 +160,7 @@ bool kexLightSurface::SubdivideRecursion(vertexBatch_t &surfPoints, float divide
|
||||||
vertexBatch_t *backPoints;
|
vertexBatch_t *backPoints;
|
||||||
|
|
||||||
// get bounds from current set of points
|
// 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]);
|
bounds.AddPoint(surfPoints[i]);
|
||||||
}
|
}
|
||||||
|
@ -183,7 +183,7 @@ bool kexLightSurface::SubdivideRecursion(vertexBatch_t &surfPoints, float divide
|
||||||
|
|
||||||
if (!SubdivideRecursion(*frontPoints, divide, points))
|
if (!SubdivideRecursion(*frontPoints, divide, points))
|
||||||
{
|
{
|
||||||
points.Push(frontPoints);
|
points.push_back(frontPoints);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -192,7 +192,7 @@ bool kexLightSurface::SubdivideRecursion(vertexBatch_t &surfPoints, float divide
|
||||||
|
|
||||||
if (!SubdivideRecursion(*backPoints, divide, points))
|
if (!SubdivideRecursion(*backPoints, divide, points))
|
||||||
{
|
{
|
||||||
points.Push(backPoints);
|
points.push_back(backPoints);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -208,36 +208,35 @@ bool kexLightSurface::SubdivideRecursion(vertexBatch_t &surfPoints, float divide
|
||||||
|
|
||||||
void kexLightSurface::Subdivide(const float divide)
|
void kexLightSurface::Subdivide(const float divide)
|
||||||
{
|
{
|
||||||
kexArray<vertexBatch_t*> points;
|
std::vector<vertexBatch_t*> points;
|
||||||
vertexBatch_t surfPoints;
|
vertexBatch_t surfPoints;
|
||||||
|
|
||||||
for (int i = 0; i < surface->numVerts; ++i)
|
for (int i = 0; i < surface->numVerts; ++i)
|
||||||
{
|
{
|
||||||
surfPoints.Push(surface->verts[i]);
|
surfPoints.push_back(surface->verts[i]);
|
||||||
}
|
}
|
||||||
|
|
||||||
SubdivideRecursion(surfPoints, divide, points);
|
SubdivideRecursion(surfPoints, divide, points);
|
||||||
|
|
||||||
// from each group of vertices caused by the split, begin
|
// from each group of vertices caused by the split, begin
|
||||||
// creating a origin point based on the center of that group
|
// 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];
|
vertexBatch_t *vb = points[i];
|
||||||
kexVec3 center;
|
kexVec3 center;
|
||||||
|
|
||||||
for (unsigned int j = 0; j < vb->Length(); ++j)
|
for (unsigned int j = 0; j < vb->size(); ++j)
|
||||||
{
|
{
|
||||||
center += (*vb)[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];
|
vertexBatch_t *vb = points[i];
|
||||||
|
|
||||||
vb->Empty();
|
|
||||||
delete vb;
|
delete vb;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -272,7 +271,7 @@ float kexLightSurface::TraceSurface(FLevel *doomMap, kexTrace &trace, const surf
|
||||||
|
|
||||||
float total = 0.0f;
|
float total = 0.0f;
|
||||||
float closestDistance = distance * gzdoomRadiusScale;
|
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];
|
kexVec3 center = origins[i];
|
||||||
|
|
||||||
|
@ -318,5 +317,5 @@ float kexLightSurface::TraceSurface(FLevel *doomMap, kexTrace &trace, const surf
|
||||||
}
|
}
|
||||||
|
|
||||||
float attenuation = 1.0f - closestDistance / (distance * gzdoomRadiusScale);
|
float attenuation = 1.0f - closestDistance / (distance * gzdoomRadiusScale);
|
||||||
return attenuation * total / origins.Length();
|
return attenuation * total / origins.size();
|
||||||
}
|
}
|
||||||
|
|
|
@ -52,7 +52,7 @@ public:
|
||||||
const vertexBatch_t Origins() const { return origins; }
|
const vertexBatch_t Origins() const { return origins; }
|
||||||
|
|
||||||
private:
|
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);
|
void Clip(vertexBatch_t &points, const kexVec3 &normal, float dist, vertexBatch_t *frontPoints, vertexBatch_t *backPoints);
|
||||||
|
|
||||||
float distance;
|
float distance;
|
||||||
|
|
|
@ -165,7 +165,7 @@ FloatVertex FLevel::GetSegVertex(int index)
|
||||||
void FLevel::CreateLights()
|
void FLevel::CreateLights()
|
||||||
{
|
{
|
||||||
thingLight_t *thingLight;
|
thingLight_t *thingLight;
|
||||||
unsigned int j;
|
size_t j;
|
||||||
int numSurfLights;
|
int numSurfLights;
|
||||||
kexVec2 pt;
|
kexVec2 pt;
|
||||||
|
|
||||||
|
@ -239,7 +239,7 @@ void FLevel::CreateLights()
|
||||||
//
|
//
|
||||||
// add surface lights
|
// add surface lights
|
||||||
//
|
//
|
||||||
for (j = 0; j < surfaces.Length(); ++j)
|
for (j = 0; j < surfaces.size(); ++j)
|
||||||
{
|
{
|
||||||
surface_t *surface = surfaces[j];
|
surface_t *surface = surfaces[j];
|
||||||
|
|
||||||
|
|
|
@ -34,7 +34,7 @@
|
||||||
#include "mapdata.h"
|
#include "mapdata.h"
|
||||||
#include "surfaces.h"
|
#include "surfaces.h"
|
||||||
|
|
||||||
kexArray<surface_t*> surfaces;
|
std::vector<surface_t*> surfaces;
|
||||||
|
|
||||||
static void CreateSideSurfaces(FLevel &doomMap, IntSideDef *side)
|
static void CreateSideSurfaces(FLevel &doomMap, IntSideDef *side)
|
||||||
{
|
{
|
||||||
|
@ -96,7 +96,7 @@ static void CreateSideSurfaces(FLevel &doomMap, IntSideDef *side)
|
||||||
surf->type = ST_LOWERSIDE;
|
surf->type = ST_LOWERSIDE;
|
||||||
surf->typeIndex = side - &doomMap.Sides[0];
|
surf->typeIndex = side - &doomMap.Sides[0];
|
||||||
|
|
||||||
surfaces.Push(surf);
|
surfaces.push_back(surf);
|
||||||
}
|
}
|
||||||
|
|
||||||
v1Bottom = v1BottomBack;
|
v1Bottom = v1BottomBack;
|
||||||
|
@ -139,7 +139,7 @@ static void CreateSideSurfaces(FLevel &doomMap, IntSideDef *side)
|
||||||
surf->typeIndex = side - &doomMap.Sides[0];
|
surf->typeIndex = side - &doomMap.Sides[0];
|
||||||
surf->bSky = bSky;
|
surf->bSky = bSky;
|
||||||
|
|
||||||
surfaces.Push(surf);
|
surfaces.push_back(surf);
|
||||||
}
|
}
|
||||||
|
|
||||||
v1Top = v1TopBack;
|
v1Top = v1TopBack;
|
||||||
|
@ -168,7 +168,7 @@ static void CreateSideSurfaces(FLevel &doomMap, IntSideDef *side)
|
||||||
surf->type = ST_MIDDLESIDE;
|
surf->type = ST_MIDDLESIDE;
|
||||||
surf->typeIndex = side - &doomMap.Sides[0];
|
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->type = ST_FLOOR;
|
||||||
surf->typeIndex = i;
|
surf->typeIndex = i;
|
||||||
|
|
||||||
surfaces.Push(surf);
|
surfaces.push_back(surf);
|
||||||
|
|
||||||
surf = (surface_t*)Mem_Calloc(sizeof(surface_t), hb_static);
|
surf = (surface_t*)Mem_Calloc(sizeof(surface_t), hb_static);
|
||||||
surf->numVerts = sub->numlines;
|
surf->numVerts = sub->numlines;
|
||||||
|
@ -250,10 +250,10 @@ static void CreateSubsectorSurfaces(FLevel &doomMap)
|
||||||
surf->type = ST_CEILING;
|
surf->type = ST_CEILING;
|
||||||
surf->typeIndex = i;
|
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)
|
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)
|
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]);
|
Mem_Free(surfaces[i]);
|
||||||
surfaces = {};
|
surfaces = {};
|
||||||
|
|
||||||
|
@ -321,15 +321,15 @@ void CreateSurfaces(FLevel &doomMap)
|
||||||
printf("sides: %i / %i\r", i + 1, doomMap.Sides.Size());
|
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);
|
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");
|
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];
|
const auto &s = surfaces[i];
|
||||||
int numVerts = s->numVerts;
|
int numVerts = s->numVerts;
|
||||||
|
|
|
@ -39,7 +39,7 @@ enum surfaceType_t
|
||||||
ST_FLOOR
|
ST_FLOOR
|
||||||
};
|
};
|
||||||
|
|
||||||
typedef kexArray<kexVec3> vertexBatch_t;
|
typedef std::vector<kexVec3> vertexBatch_t;
|
||||||
|
|
||||||
// convert from fixed point(FRACUNIT) to floating point
|
// convert from fixed point(FRACUNIT) to floating point
|
||||||
#define F(x) (((float)(x))/65536.0f)
|
#define F(x) (((float)(x))/65536.0f)
|
||||||
|
@ -62,7 +62,7 @@ struct surface_t
|
||||||
bool bSky;
|
bool bSky;
|
||||||
};
|
};
|
||||||
|
|
||||||
extern kexArray<surface_t*> surfaces;
|
extern std::vector<surface_t*> surfaces;
|
||||||
|
|
||||||
struct FLevel;
|
struct FLevel;
|
||||||
|
|
||||||
|
|
Loading…
Reference in a new issue