zdoom/zdray
0
0
Fork 0
mirror of https://github.com/ZDoom/ZDRay.git synced 2024-11-25 21:31:32 +00:00
Code Issues Projects Releases Packages Wiki Activity

- reformat files

Browse source
This commit is contained in:
Magnus Norddahl 2018-11-02 23:17:46 +01:00
parent 8eee053896
commit b588b809ea
25 changed files with 3375 additions and 3705 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

306
src/lightmap/kexlib/array.h
View file

@ -33,277 +33,231 @@ template<class type>
class kexArray
{
public:
kexArray();
~kexArray();
kexArray();
~kexArray();
typedef int compare_t(const type*, const type*);
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);
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]; }
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);
type &operator[](unsigned int index);
kexArray<type> &operator=(const kexArray<type> &arr);
protected:
type *data;
unsigned int length;
unsigned int aidx;
type *data;
unsigned int length;
unsigned int aidx;
};
//
// kexArray::kexArray
//
template<class type>
kexArray<type>::kexArray()
{
Init();
Init();
}
//
// kexArray::~kexArray
//
template<class type>
kexArray<type>::~kexArray()
{
Empty();
Empty();
}
//
// kexArray::Init
//
template<class type>
void kexArray<type>::Init()
{
data = NULL;
length = 0;
aidx = 0;
data = NULL;
length = 0;
aidx = 0;
}
//
// kexArray::Resize
//
template<class type>
void kexArray<type>::Resize(unsigned int size)
{
type *tmp;
type *tmp;
if(size == length)
{
return;
}
if (size == length)
{
return;
}
if(size <= 0 && length != 0)
{
delete[] data;
data = NULL;
length = 0;
return;
}
if (size <= 0 && length != 0)
{
delete[] data;
data = NULL;
length = 0;
return;
}
if(length == 0)
{
data = new type[size];
length = size;
return;
}
if (length == 0)
{
data = new type[size];
length = size;
return;
}
tmp = data;
data = new type[size];
tmp = data;
data = new type[size];
for(unsigned int i = 0; i < length; i++)
{
data[i] = tmp[i];
}
for (unsigned int i = 0; i < length; i++)
{
data[i] = tmp[i];
}
length = size;
delete[] tmp;
length = size;
delete[] tmp;
}
//
// kexArray::Push
//
template<class type>
void kexArray<type>::Push(type o)
{
Resize(length+1);
data[aidx++] = o;
Resize(length + 1);
data[aidx++] = o;
}
//
// kexArray::Pop
//
template<class type>
void kexArray<type>::Pop()
{
if(length == 0)
{
return;
}
if (length == 0)
{
return;
}
Resize(length-1);
aidx--;
Resize(length - 1);
aidx--;
}
//
// kexArray::Empty
//
template<class type>
void kexArray<type>::Empty()
{
if(data && length > 0)
{
delete[] data;
data = NULL;
length = 0;
aidx = 0;
}
if (data && length > 0)
{
delete[] data;
data = NULL;
length = 0;
aidx = 0;
}
}
//
// kexArray::IndexOf
//
template<class type>
type kexArray<type>::IndexOf(unsigned int index) const
{
if(index >= length)
{
index = length-1;
}
if (index >= length)
{
index = length - 1;
}
return data[index];
return data[index];
}
//
// kexArray::Contains
//
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;
}
}
for (unsigned int i = 0; i < length; ++i)
{
if (data[i] == check)
{
return true;
}
}
return false;
return false;
}
//
// kexArray::Splice
//
template<class type>
void kexArray<type>::Splice(const unsigned int start, unsigned int len)
{
if(length == 0 || len == 0)
{
return;
}
if (length == 0 || len == 0)
{
return;
}
if(len >= length)
{
len = length;
}
if (len >= length)
{
len = length;
}
type *tmp = new type[len];
type *tmp = new type[len];
for(unsigned int i = 0; i < len; i++)
{
tmp[i] = data[start+i];
}
for (unsigned int i = 0; i < len; i++)
{
tmp[i] = data[start + i];
}
delete[] data;
data = tmp;
length = length - len;
aidx = length-1;
delete[] data;
data = tmp;
length = length - len;
aidx = length - 1;
}
//
// kexArray::Sort
//
// Note that data will be shuffled around, so this could invalidate any
// pointers that relies on the array/data
//
// 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;
}
if (data == NULL)
{
return;
}
typedef int compareCast(const void*, const void*);
compareCast *cmpFunc = (compareCast*)function;
typedef int compareCast(const void*, const void*);
compareCast *cmpFunc = (compareCast*)function;
qsort((void*)data, length, sizeof(type), cmpFunc);
qsort((void*)data, length, sizeof(type), cmpFunc);
}
//
// kexArray::Sort
//
// Note that data will be shuffled around, so this could invalidate any
// pointers that relies on the array/data
//
// 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;
}
if (data == NULL)
{
return;
}
typedef int compareCast(const void*, const void*);
compareCast *cmpFunc = (compareCast*)function;
typedef int compareCast(const void*, const void*);
compareCast *cmpFunc = (compareCast*)function;
qsort((void*)data, count, sizeof(type), cmpFunc);
qsort((void*)data, count, sizeof(type), cmpFunc);
}
//
// kexArray::operator[]
//
template <class type>
type &kexArray<type>::operator[](unsigned int index)
{
assert(index < length);
return data[index];
assert(index < length);
return data[index];
}
//
// kexArray::operator=
//
template <class type>
kexArray<type> &kexArray<type>::operator=(const kexArray<type> &arr)
{
if(data)
{
delete[] data;
}
if (data)
{
delete[] data;
}
data = NULL;
length = arr.length;
aidx = arr.aidx;
data = NULL;
length = arr.length;
aidx = arr.aidx;
if(arr.length > 0)
{
data = new type[arr.length];
if (arr.length > 0)
{
data = new type[arr.length];
for(unsigned int i = 0; i < arr.length; i++)
{
data[i] = arr.data[i];
}
}
for (unsigned int i = 0; i < arr.length; i++)
{
data[i] = arr.data[i];
}
}
return *this;
return *this;
}

404
src/lightmap/kexlib/binfile.cpp
View file

@ -33,367 +33,279 @@
#include "lightmap/common.h"
#include "lightmap/kexlib/binfile.h"
//
// kexBinFile::kexBinFile
//
kexBinFile::kexBinFile()
{
this->handle = NULL;
this->buffer = NULL;
this->bufferOffset = 0;
this->bOpened = false;
this->handle = NULL;
this->buffer = NULL;
this->bufferOffset = 0;
this->bOpened = false;
}
//
// kexBinFile::~kexBinFile
//
kexBinFile::~kexBinFile()
{
Close();
Close();
}
//
// kexBinFile::Open
//
bool kexBinFile::Open(const char *file, kexHeapBlock &heapBlock)
{
if((handle = fopen(file, "rb")))
{
size_t length;
if ((handle = fopen(file, "rb")))
{
size_t length;
fseek(handle, 0, SEEK_END);
length = ftell(handle);
fseek(handle, 0, SEEK_SET);
fseek(handle, 0, SEEK_END);
length = ftell(handle);
fseek(handle, 0, SEEK_SET);
buffer = (byte*)Mem_Calloc(length+1, heapBlock);
buffer = (byte*)Mem_Calloc(length + 1, heapBlock);
if(fread(buffer, 1, length, handle) == length)
{
if(length > 0)
{
bOpened = true;
bufferOffset = 0;
return true;
}
}
if (fread(buffer, 1, length, handle) == length)
{
if (length > 0)
{
bOpened = true;
bufferOffset = 0;
return true;
}
}
Mem_Free(buffer);
buffer = NULL;
fclose(handle);
}
Mem_Free(buffer);
buffer = NULL;
fclose(handle);
}
return false;
return false;
}
//
// kexBinFile::Create
//
bool kexBinFile::Create(const char *file)
{
if((handle = fopen(file, "wb")))
{
bOpened = true;
bufferOffset = 0;
return true;
}
if ((handle = fopen(file, "wb")))
{
bOpened = true;
bufferOffset = 0;
return true;
}
return false;
return false;
}
//
// kexBinFile::Close
//
void kexBinFile::Close()
{
if(bOpened == false)
{
return;
}
if(handle)
{
fclose(handle);
handle = NULL;
if(buffer)
{
Mem_Free(buffer);
}
}
if (bOpened == false)
{
return;
}
if (handle)
{
fclose(handle);
handle = NULL;
if (buffer)
{
Mem_Free(buffer);
}
}
bOpened = false;
bOpened = false;
}
//
// kexBinFile::Exists
//
bool kexBinFile::Exists(const char *file)
{
FILE *fstream;
FILE *fstream;
fstream = fopen(file, "r");
fstream = fopen(file, "r");
if(fstream != NULL)
{
fclose(fstream);
return true;
}
if (fstream != NULL)
{
fclose(fstream);
return true;
}
#ifdef KEX_WIN32
else
{
// If we can't open because the file is a directory, the
// "file" exists at least!
if(errno == 21)
{
return true;
}
}
else
{
// If we can't open because the file is a directory, the
// "file" exists at least!
if (errno == 21)
{
return true;
}
}
#endif
return false;
return false;
}
//
// kexBinFile::Duplicate
//
void kexBinFile::Duplicate(const char *newFileName)
{
FILE *f;
FILE *f;
if(bOpened == false)
{
return;
}
if (bOpened == false)
{
return;
}
f = fopen(newFileName, "wb");
f = fopen(newFileName, "wb");
if(f == NULL)
{
return;
}
if (f == NULL)
{
return;
}
fwrite(buffer, Length(), 1, f);
fclose(f);
fwrite(buffer, Length(), 1, f);
fclose(f);
}
//
// kexBinFile::Length
//
int kexBinFile::Length()
{
long savedpos;
long length;
long savedpos;
long length;
if(bOpened == false)
{
return 0;
}
if (bOpened == false)
{
return 0;
}
// save the current position in the file
savedpos = ftell(handle);
// save the current position in the file
savedpos = ftell(handle);
// jump to the end and find the length
fseek(handle, 0, SEEK_END);
length = ftell(handle);
// jump to the end and find the length
fseek(handle, 0, SEEK_END);
length = ftell(handle);
// go back to the old location
fseek(handle, savedpos, SEEK_SET);
// go back to the old location
fseek(handle, savedpos, SEEK_SET);
return length;
return length;
}
//
// kexBinFile::Read8
//
byte kexBinFile::Read8()
{
byte result;
result = buffer[bufferOffset++];
return result;
byte result;
result = buffer[bufferOffset++];
return result;
}
//
// kexBinFile::Read16
//
short kexBinFile::Read16()
{
int result;
result = Read8();
result |= Read8() << 8;
return result;
int result;
result = Read8();
result |= Read8() << 8;
return result;
}
//
// kexBinFile::Read32
//
int kexBinFile::Read32()
{
int result;
result = Read8();
result |= Read8() << 8;
result |= Read8() << 16;
result |= Read8() << 24;
return result;
int result;
result = Read8();
result |= Read8() << 8;
result |= Read8() << 16;
result |= Read8() << 24;
return result;
}
//
// kexBinFile::ReadFloat
//
float kexBinFile::ReadFloat()
{
fint_t fi;
fi.i = Read32();
return fi.f;
fint_t fi;
fi.i = Read32();
return fi.f;
}
//
// kexBinFile::ReadVector
//
kexVec3 kexBinFile::ReadVector()
{
kexVec3 vec;
kexVec3 vec;
vec.x = ReadFloat();
vec.y = ReadFloat();
vec.z = ReadFloat();
vec.x = ReadFloat();
vec.y = ReadFloat();
vec.z = ReadFloat();
return vec;
return vec;
}
//
// kexBinFile::ReadString
//
kexStr kexBinFile::ReadString()
{
kexStr str;
char c = 0;
kexStr str;
char c = 0;
while(1)
{
if(!(c = Read8()))
{
break;
}
while (1)
{
if (!(c = Read8()))
{
break;
}
str += c;
}
str += c;
}
return str;
return str;
}
//
// kexBinFile::Write8
//
void kexBinFile::Write8(const byte val)
{
if(bOpened)
{
fwrite(&val, 1, 1, handle);
}
else
{
buffer[bufferOffset] = val;
}
bufferOffset++;
if (bOpened)
{
fwrite(&val, 1, 1, handle);
}
else
{
buffer[bufferOffset] = val;
}
bufferOffset++;
}
//
// kexBinFile::Write16
//
void kexBinFile::Write16(const short val)
{
Write8(val & 0xff);
Write8((val >> 8) & 0xff);
Write8(val & 0xff);
Write8((val >> 8) & 0xff);
}
//
// kexBinFile::Write32
//
void kexBinFile::Write32(const int val)
{
Write8(val & 0xff);
Write8((val >> 8) & 0xff);
Write8((val >> 16) & 0xff);
Write8((val >> 24) & 0xff);
Write8(val & 0xff);
Write8((val >> 8) & 0xff);
Write8((val >> 16) & 0xff);
Write8((val >> 24) & 0xff);
}
//
// kexBinFile::WriteFloat
//
void kexBinFile::WriteFloat(const float val)
{
fint_t fi;
fi.f = val;
Write32(fi.i);
fint_t fi;
fi.f = val;
Write32(fi.i);
}
//
// kexBinFile::WriteVector
//
void kexBinFile::WriteVector(const kexVec3 &val)
{
WriteFloat(val.x);
WriteFloat(val.y);
WriteFloat(val.z);
WriteFloat(val.x);
WriteFloat(val.y);
WriteFloat(val.z);
}
//
// kexBinFile::WriteString
//
void kexBinFile::WriteString(const kexStr &val)
{
const char *c = val.c_str();
const char *c = val.c_str();
for(int i = 0; i < val.Length(); i++)
{
Write8(c[i]);
}
for (int i = 0; i < val.Length(); i++)
{
Write8(c[i]);
}
Write8(0);
Write8(0);
}
//
// kexBinFile::GetOffsetValue
//
int kexBinFile::GetOffsetValue(int id)
{
return *(int*)(buffer + (id << 2));
return *(int*)(buffer + (id << 2));
}
//
// kexBinFile::GetOffset
//
byte *kexBinFile::GetOffset(int id, byte *subdata, int *count)
{
byte *data = (subdata == NULL) ? buffer : subdata;
byte *data = (subdata == NULL) ? buffer : subdata;
bufferOffset = GetOffsetValue(id);
byte *dataOffs = &data[bufferOffset];
bufferOffset = GetOffsetValue(id);
byte *dataOffs = &data[bufferOffset];
if(count)
{
*count = *(int*)(dataOffs);
}
if (count)
{
*count = *(int*)(dataOffs);
}
return dataOffs;
return dataOffs;
}

66
src/lightmap/kexlib/binfile.h
View file

@ -32,45 +32,43 @@
class kexBinFile
{
public:
kexBinFile();
~kexBinFile();
kexBinFile();
~kexBinFile();
bool Open(const char *file, kexHeapBlock &heapBlock = hb_static);
bool Create(const char *file);
void Close();
bool Exists(const char *file);
int Length();
void Duplicate(const char *newFileName);
bool Open(const char *file, kexHeapBlock &heapBlock = hb_static);
bool Create(const char *file);
void Close();
bool Exists(const char *file);
int Length();
void Duplicate(const char *newFileName);
byte Read8();
short Read16();
int Read32();
float ReadFloat();
kexVec3 ReadVector();
kexStr ReadString();
byte Read8();
short Read16();
int Read32();
float ReadFloat();
kexVec3 ReadVector();
kexStr ReadString();
void Write8(const byte val);
void Write16(const short val);
void Write32(const int val);
void WriteFloat(const float val);
void WriteVector(const kexVec3 &val);
void WriteString(const kexStr &val);
void Write8(const byte val);
void Write16(const short val);
void Write32(const int val);
void WriteFloat(const float val);
void WriteVector(const kexVec3 &val);
void WriteString(const kexStr &val);
int GetOffsetValue(int id);
byte *GetOffset(int id,
byte *subdata = NULL,
int *count = NULL);
int GetOffsetValue(int id);
byte *GetOffset(int id, byte *subdata = NULL, int *count = NULL);
FILE *Handle() const { return handle; }
byte *Buffer() const { return buffer; }
void SetBuffer(byte *ptr) { buffer = ptr; }
byte *BufferAt() const { return &buffer[bufferOffset]; }
bool Opened() const { return bOpened; }
void SetOffset(const int offset) { bufferOffset = offset; }
FILE *Handle() const { return handle; }
byte *Buffer() const { return buffer; }
void SetBuffer(byte *ptr) { buffer = ptr; }
byte *BufferAt() const { return &buffer[bufferOffset]; }
bool Opened() const { return bOpened; }
void SetOffset(const int offset) { bufferOffset = offset; }
private:
FILE *handle;
byte *buffer;
unsigned int bufferOffset;
bool bOpened;
FILE *handle;
byte *buffer;
unsigned int bufferOffset;
bool bOpened;
};

832
src/lightmap/kexlib/kstring.cpp
View file

File diff suppressed because it is too large Load diff

126
src/lightmap/kexlib/kstring.h
View file

@ -38,91 +38,91 @@ typedef kexArray<kexStr> kexStrList;
class kexStr
{
public:
kexStr();
kexStr(const char *string);
kexStr(const char *string, const int length);
kexStr(const kexStr &string);
~kexStr();
kexStr();
kexStr(const char *string);
kexStr(const char *string, const int length);
kexStr(const kexStr &string);
~kexStr();
void CheckSize(int size, bool bKeepString);
int IndexOf(const char *pattern) const;
int IndexOf(const kexStr &pattern) const;
kexStr &Concat(const char *string);
kexStr &Concat(const char *string, int len);
kexStr &Concat(const char c);
kexStr &NormalizeSlashes();
kexStr &StripPath();
kexStr &StripExtension();
kexStr &StripFile();
kexStr &Copy(const kexStr &src, int len);
kexStr &Copy(const kexStr &src);
kexStr &ToUpper();
kexStr &ToLower();
int Hash();
kexStr Substr(int start, int len) const;
void Split(kexStrList &list, const char seperator);
int Atoi();
float Atof();
void WriteToFile(const char *file);
void CheckSize(int size, bool bKeepString);
int IndexOf(const char *pattern) const;
int IndexOf(const kexStr &pattern) const;
kexStr &Concat(const char *string);
kexStr &Concat(const char *string, int len);
kexStr &Concat(const char c);
kexStr &NormalizeSlashes();
kexStr &StripPath();
kexStr &StripExtension();
kexStr &StripFile();
kexStr &Copy(const kexStr &src, int len);
kexStr &Copy(const kexStr &src);
kexStr &ToUpper();
kexStr &ToLower();
int Hash();
kexStr Substr(int start, int len) const;
void Split(kexStrList &list, const char seperator);
int Atoi();
float Atof();
void WriteToFile(const char *file);
int Length() const { return length; }
const char *c_str() const { return charPtr; }
int Length() const { return length; }
const char *c_str() const { return charPtr; }
kexStr &operator=(const kexStr &str);
kexStr &operator=(const char *str);
kexStr &operator=(const bool b);
kexStr operator+(const kexStr &str);
kexStr operator+(const char *str);
kexStr operator+(const bool b);
kexStr operator+(const int i);
kexStr operator+(const float f);
kexStr &operator+=(const kexStr &str);
kexStr &operator+=(const char *str);
kexStr &operator+=(const char c);
kexStr &operator+=(const bool b);
const char operator[](int index) const;
kexStr &operator=(const kexStr &str);
kexStr &operator=(const char *str);
kexStr &operator=(const bool b);
kexStr operator+(const kexStr &str);
kexStr operator+(const char *str);
kexStr operator+(const bool b);
kexStr operator+(const int i);
kexStr operator+(const float f);
kexStr &operator+=(const kexStr &str);
kexStr &operator+=(const char *str);
kexStr &operator+=(const char c);
kexStr &operator+=(const bool b);
const char operator[](int index) const;
friend bool operator==(const kexStr &a, const kexStr &b);
friend bool operator==(const char *a, const kexStr &b);
friend bool operator==(const kexStr &a, const char *b);
friend bool operator==(const kexStr &a, const kexStr &b);
friend bool operator==(const char *a, const kexStr &b);
friend bool operator==(const kexStr &a, const char *b);
operator const char *() const { return c_str(); }
operator const char *() { return c_str(); }
operator const char *() const { return c_str(); }
operator const char *() { return c_str(); }
static bool CompareCase(const char *s1, const char *s2);
static bool CompareCase(const kexStr &a, const kexStr &b);
static bool Compare(const char *s1, const char *s2);
static bool Compare(const kexStr &a, const kexStr &b);
static int IndexOf(const char *string, const char *pattern);
static int Hash(const char *s);
static char *Format(const char *str, ...);
static bool CompareCase(const char *s1, const char *s2);
static bool CompareCase(const kexStr &a, const kexStr &b);
static bool Compare(const char *s1, const char *s2);
static bool Compare(const kexStr &a, const kexStr &b);
static int IndexOf(const char *string, const char *pattern);
static int Hash(const char *s);
static char *Format(const char *str, ...);
private:
void Resize(int size, bool bKeepString);
void CopyNew(const char *string, int len);
void Resize(int size, bool bKeepString);
void CopyNew(const char *string, int len);
protected:
void Init();
void Init();
static const int STRING_DEFAULT_SIZE = 32;
static const int STRING_DEFAULT_SIZE = 32;
char *charPtr;
char defaultBuffer[STRING_DEFAULT_SIZE];
int length;
int bufferLength;
char *charPtr;
char defaultBuffer[STRING_DEFAULT_SIZE];
int length;
int bufferLength;
};
d_inline bool operator==(const kexStr &a, const kexStr &b)
{
return (!strcmp(a.charPtr, b.charPtr));
return (!strcmp(a.charPtr, b.charPtr));
}
d_inline bool operator==(const char *a, const kexStr &b)
{
return (!strcmp(a, b.charPtr));
return (!strcmp(a, b.charPtr));
}
d_inline bool operator==(const kexStr &a, const char *b)
{
return (!strcmp(a.charPtr, b));
return (!strcmp(a.charPtr, b));
}

224
src/lightmap/kexlib/math/angle.cpp
View file

@ -41,9 +41,9 @@
kexAngle::kexAngle()
{
this->yaw = 0;
this->pitch = 0;
this->roll = 0;
this->yaw = 0;
this->pitch = 0;
this->roll = 0;
}
//
@ -52,9 +52,9 @@ kexAngle::kexAngle()
kexAngle::kexAngle(const float yaw, const float pitch, const float roll)
{
this->yaw = yaw;
this->pitch = pitch;
this->roll = roll;
this->yaw = yaw;
this->pitch = pitch;
this->roll = roll;
}
//
@ -63,11 +63,11 @@ kexAngle::kexAngle(const float yaw, const float pitch, const float roll)
kexAngle::kexAngle(const kexVec3 &vector)
{
this->yaw = vector.x;
this->pitch = vector.y;
this->roll = vector.z;
this->yaw = vector.x;
this->pitch = vector.y;
this->roll = vector.z;
Clamp180();
Clamp180();
}
//
@ -76,9 +76,9 @@ kexAngle::kexAngle(const kexVec3 &vector)
kexAngle::kexAngle(const kexAngle &an)
{
this->yaw = an.yaw;
this->pitch = an.pitch;
this->roll = an.roll;
this->yaw = an.yaw;
this->pitch = an.pitch;
this->roll = an.roll;
}
//
@ -90,12 +90,12 @@ kexAngle &kexAngle::Clamp180()
#define CLAMP180(x) \
if(x < -M_PI) for(; x < -M_PI; x = x + FULLCIRCLE); \
if(x > M_PI) for(; x > M_PI; x = x - FULLCIRCLE)
CLAMP180(yaw);
CLAMP180(pitch);
CLAMP180(roll);
CLAMP180(yaw);
CLAMP180(pitch);
CLAMP180(roll);
#undef CLAMP180
return *this;
return *this;
}
//
@ -107,16 +107,16 @@ kexAngle &kexAngle::Clamp180Invert()
#define CLAMP180(x) \
for(; x < -M_PI; x = x + FULLCIRCLE); \
for(; x > M_PI; x = x - FULLCIRCLE)
CLAMP180(yaw);
CLAMP180(pitch);
CLAMP180(roll);
CLAMP180(yaw);
CLAMP180(pitch);
CLAMP180(roll);
#undef CLAMP180
yaw = -yaw;
pitch = -pitch;
roll = -roll;
yaw = -yaw;
pitch = -pitch;
roll = -roll;
return *this;
return *this;
}
//
@ -125,21 +125,21 @@ kexAngle &kexAngle::Clamp180Invert()
kexAngle &kexAngle::Clamp180InvertSum(const kexAngle &angle)
{
kexAngle an = angle;
kexAngle an = angle;
an.Clamp180Invert();
an.Clamp180Invert();
an.yaw += this->yaw;
an.pitch += this->pitch;
an.roll += this->roll;
an.yaw += this->yaw;
an.pitch += this->pitch;
an.roll += this->roll;
an.Clamp180Invert();
an.Clamp180Invert();
this->yaw = an.yaw;
this->pitch = an.pitch;
this->roll = an.roll;
this->yaw = an.yaw;
this->pitch = an.pitch;
this->roll = an.roll;
return *this;
return *this;
}
//
@ -151,12 +151,12 @@ kexAngle &kexAngle::Round()
#define ROUND(x) \
x = DEG2RAD((360.0f / 65536.0f) * \
((int)(RAD2DEG(x) * (65536.0f / 360.0f)) & 65535))
yaw = ROUND(yaw);
pitch = ROUND(pitch);
roll = ROUND(roll);
yaw = ROUND(yaw);
pitch = ROUND(pitch);
roll = ROUND(roll);
#undef ROUND
return Clamp180();
return Clamp180();
}
//
@ -165,11 +165,11 @@ kexAngle &kexAngle::Round()
kexAngle kexAngle::Diff(kexAngle &angle)
{
float an;
kexAngle out;
float an;
kexAngle out;
Clamp180();
angle.Clamp180();
Clamp180();
angle.Clamp180();
#define DIFF(x) \
if(x <= angle.x) { \
@ -190,12 +190,12 @@ kexAngle kexAngle::Diff(kexAngle &angle)
out.x = x - an; \
} \
}
DIFF(yaw);
DIFF(pitch);
DIFF(roll);
DIFF(yaw);
DIFF(pitch);
DIFF(roll);
#undef DIFF
return out;
return out;
}
//
@ -204,31 +204,31 @@ kexAngle kexAngle::Diff(kexAngle &angle)
void kexAngle::ToAxis(kexVec3 *forward, kexVec3 *up, kexVec3 *right)
{
float sy = kexMath::Sin(yaw);
float cy = kexMath::Cos(yaw);
float sp = kexMath::Sin(pitch);
float cp = kexMath::Cos(pitch);
float sr = kexMath::Sin(roll);
float cr = kexMath::Cos(roll);
float sy = kexMath::Sin(yaw);
float cy = kexMath::Cos(yaw);
float sp = kexMath::Sin(pitch);
float cp = kexMath::Cos(pitch);
float sr = kexMath::Sin(roll);
float cr = kexMath::Cos(roll);
if(forward)
{
forward->x = sy * cp;
forward->y = sp;
forward->z = cy * cp;
}
if(right)
{
right->x = sr * sp * sy + cr * cy;
right->y = sr * cp;
right->z = sr * sp * cy + cr * -sy;
}
if(up)
{
up->x = cr * sp * sy + -sr * cy;
up->y = cr * cp;
up->z = cr * sp * cy + -sr * -sy;
}
if (forward)
{
forward->x = sy * cp;
forward->y = sp;
forward->z = cy * cp;
}
if (right)
{
right->x = sr * sp * sy + cr * cy;
right->y = sr * cp;
right->z = sr * sp * cy + cr * -sy;
}
if (up)
{
up->x = cr * sp * sy + -sr * cy;
up->y = cr * cp;
up->z = cr * sp * cy + -sr * -sy;
}
}
//
@ -237,10 +237,10 @@ void kexAngle::ToAxis(kexVec3 *forward, kexVec3 *up, kexVec3 *right)
kexVec3 kexAngle::ToForwardAxis()
{
kexVec3 vec;
kexVec3 vec;
ToAxis(&vec, NULL, NULL);
return vec;
ToAxis(&vec, NULL, NULL);
return vec;
}
//
@ -249,10 +249,10 @@ kexVec3 kexAngle::ToForwardAxis()
kexVec3 kexAngle::ToUpAxis()
{
kexVec3 vec;
kexVec3 vec;
ToAxis(NULL, &vec, NULL);
return vec;
ToAxis(NULL, &vec, NULL);
return vec;
}
//
@ -261,10 +261,10 @@ kexVec3 kexAngle::ToUpAxis()
kexVec3 kexAngle::ToRightAxis()
{
kexVec3 vec;
kexVec3 vec;
ToAxis(NULL, NULL, &vec);
return vec;
ToAxis(NULL, NULL, &vec);
return vec;
}
//
@ -273,7 +273,7 @@ kexVec3 kexAngle::ToRightAxis()
const kexVec3 &kexAngle::ToVec3() const
{
return *reinterpret_cast<const kexVec3*>(&yaw);
return *reinterpret_cast<const kexVec3*>(&yaw);
}
//
@ -282,7 +282,7 @@ const kexVec3 &kexAngle::ToVec3() const
kexVec3 &kexAngle::ToVec3()
{
return *reinterpret_cast<kexVec3*>(&yaw);
return *reinterpret_cast<kexVec3*>(&yaw);
}
//
@ -291,10 +291,10 @@ kexVec3 &kexAngle::ToVec3()
kexQuat kexAngle::ToQuat()
{
return
(kexQuat(pitch, kexVec3::vecRight) *
(kexQuat(yaw, kexVec3::vecUp) *
kexQuat(roll, kexVec3::vecForward)));
return
(kexQuat(pitch, kexVec3::vecRight) *
(kexQuat(yaw, kexVec3::vecUp) *
kexQuat(roll, kexVec3::vecForward)));
}
//
@ -303,7 +303,7 @@ kexQuat kexAngle::ToQuat()
kexAngle kexAngle::operator+(const kexAngle &angle)
{
return kexAngle(yaw + angle.yaw, pitch + angle.pitch, roll + angle.roll);
return kexAngle(yaw + angle.yaw, pitch + angle.pitch, roll + angle.roll);
}
//
@ -312,7 +312,7 @@ kexAngle kexAngle::operator+(const kexAngle &angle)
kexAngle kexAngle::operator-(const kexAngle &angle)
{
return kexAngle(yaw - angle.yaw, pitch - angle.pitch, roll - angle.roll);
return kexAngle(yaw - angle.yaw, pitch - angle.pitch, roll - angle.roll);
}
//
@ -321,7 +321,7 @@ kexAngle kexAngle::operator-(const kexAngle &angle)
kexAngle kexAngle::operator-()
{
return kexAngle(-yaw, -pitch, -roll);
return kexAngle(-yaw, -pitch, -roll);
}
//
@ -330,10 +330,10 @@ kexAngle kexAngle::operator-()
kexAngle &kexAngle::operator+=(const kexAngle &angle)
{
yaw += angle.yaw;
pitch += angle.pitch;
roll += angle.roll;
return *this;
yaw += angle.yaw;
pitch += angle.pitch;
roll += angle.roll;
return *this;
}
//
@ -342,10 +342,10 @@ kexAngle &kexAngle::operator+=(const kexAngle &angle)
kexAngle &kexAngle::operator-=(const kexAngle &angle)
{
yaw -= angle.yaw;
pitch -= angle.pitch;
roll -= angle.roll;
return *this;
yaw -= angle.yaw;
pitch -= angle.pitch;
roll -= angle.roll;
return *this;
}
//
@ -354,10 +354,10 @@ kexAngle &kexAngle::operator-=(const kexAngle &angle)
kexAngle &kexAngle::operator=(const kexAngle &angle)
{
yaw = angle.yaw;
pitch = angle.pitch;
roll = angle.roll;
return *this;
yaw = angle.yaw;
pitch = angle.pitch;
roll = angle.roll;
return *this;
}
//
@ -366,10 +366,10 @@ kexAngle &kexAngle::operator=(const kexAngle &angle)
kexAngle &kexAngle::operator=(const kexVec3 &vector)
{
yaw = vector.x;
pitch = vector.y;
roll = vector.z;
return *this;
yaw = vector.x;
pitch = vector.y;
roll = vector.z;
return *this;
}
//
@ -378,10 +378,10 @@ kexAngle &kexAngle::operator=(const kexVec3 &vector)
kexAngle &kexAngle::operator=(const float *vecs)
{
yaw = vecs[0];
pitch = vecs[1];
roll = vecs[2];
return *this;
yaw = vecs[0];
pitch = vecs[1];
roll = vecs[2];
return *this;
}
//
@ -390,8 +390,8 @@ kexAngle &kexAngle::operator=(const float *vecs)
float kexAngle::operator[](int index) const
{
assert(index >= 0 && index < 3);
return (&yaw)[index];
assert(index >= 0 && index < 3);
return (&yaw)[index];
}
//
@ -400,6 +400,6 @@ float kexAngle::operator[](int index) const
float &kexAngle::operator[](int index)
{
assert(index >= 0 && index < 3);
return (&yaw)[index];
assert(index >= 0 && index < 3);
return (&yaw)[index];
}

466
src/lightmap/kexlib/math/bounds.cpp
View file

@ -39,7 +39,7 @@
kexBBox::kexBBox()
{
Clear();
Clear();
}
//
@ -48,8 +48,8 @@ kexBBox::kexBBox()
kexBBox::kexBBox(const kexVec3 &vMin, const kexVec3 &vMax)
{
this->min = vMin;
this->max = vMax;
this->min = vMin;
this->max = vMax;
}
//
@ -58,8 +58,8 @@ kexBBox::kexBBox(const kexVec3 &vMin, const kexVec3 &vMax)
void kexBBox::Clear()
{
min.Set(M_INFINITY, M_INFINITY, M_INFINITY);
max.Set(-M_INFINITY, -M_INFINITY, -M_INFINITY);
min.Set(M_INFINITY, M_INFINITY, M_INFINITY);
max.Set(-M_INFINITY, -M_INFINITY, -M_INFINITY);
}
//
@ -68,22 +68,22 @@ void kexBBox::Clear()
void kexBBox::AddPoint(const kexVec3 &vec)
{
float lowx = min.x;
float lowy = min.y;
float lowz = min.z;
float hix = max.x;
float hiy = max.y;
float hiz = max.z;
float lowx = min.x;
float lowy = min.y;
float lowz = min.z;
float hix = max.x;
float hiy = max.y;
float hiz = max.z;
if(vec.x < lowx) { lowx = vec.x; }
if(vec.y < lowy) { lowy = vec.y; }
if(vec.z < lowz) { lowz = vec.z; }
if(vec.x > hix) { hix = vec.x; }
if(vec.y > hiy) { hiy = vec.y; }
if(vec.z > hiz) { hiz = vec.z; }
if (vec.x < lowx) { lowx = vec.x; }
if (vec.y < lowy) { lowy = vec.y; }
if (vec.z < lowz) { lowz = vec.z; }
if (vec.x > hix) { hix = vec.x; }
if (vec.y > hiy) { hiy = vec.y; }
if (vec.z > hiz) { hiz = vec.z; }
min.Set(lowx, lowy, lowz);
max.Set(hix, hiy, hiz);
min.Set(lowx, lowy, lowz);
max.Set(hix, hiy, hiz);
}
//
@ -92,10 +92,10 @@ void kexBBox::AddPoint(const kexVec3 &vec)
kexVec3 kexBBox::Center() const
{
return kexVec3(
(max.x + min.x) * 0.5f,
(max.y + min.y) * 0.5f,
(max.z + min.z) * 0.5f);
return kexVec3(
(max.x + min.x) * 0.5f,
(max.y + min.y) * 0.5f,
(max.z + min.z) * 0.5f);
}
kexVec3 kexBBox::Extents() const
@ -112,27 +112,27 @@ kexVec3 kexBBox::Extents() const
float kexBBox::Radius() const
{
int i;
float r = 0;
float r1;
float r2;
int i;
float r = 0;
float r1;
float r2;
for(i = 0; i < 3; i++)
{
r1 = kexMath::Fabs(min[i]);
r2 = kexMath::Fabs(max[i]);
for (i = 0; i < 3; i++)
{
r1 = kexMath::Fabs(min[i]);
r2 = kexMath::Fabs(max[i]);
if(r1 > r2)
{
r += r1 * r1;
}
else
{
r += r2 * r2;
}
}
if (r1 > r2)
{
r += r1 * r1;
}
else
{
r += r2 * r2;
}
}
return kexMath::Sqrt(r);
return kexMath::Sqrt(r);
}
//
@ -141,8 +141,8 @@ float kexBBox::Radius() const
bool kexBBox::PointInside(const kexVec3 &vec) const
{
return !(vec[0] < min[0] || vec[1] < min[1] || vec[2] < min[2] ||
vec[0] > max[0] || vec[1] > max[1] || vec[2] > max[2]);
return !(vec[0] < min[0] || vec[1] < min[1] || vec[2] < min[2] ||
vec[0] > max[0] || vec[1] > max[1] || vec[2] > max[2]);
}
//
@ -151,8 +151,8 @@ bool kexBBox::PointInside(const kexVec3 &vec) const
bool kexBBox::IntersectingBox(const kexBBox &box) const
{
return !(box.max[0] < min[0] || box.max[1] < min[1] || box.max[2] < min[2] ||
box.min[0] > max[0] || box.min[1] > max[1] || box.min[2] > max[2]);
return !(box.max[0] < min[0] || box.max[1] < min[1] || box.max[2] < min[2] ||
box.min[0] > max[0] || box.min[1] > max[1] || box.min[2] > max[2]);
}
//
@ -161,8 +161,8 @@ bool kexBBox::IntersectingBox(const kexBBox &box) const
bool kexBBox::IntersectingBox2D(const kexBBox &box) const
{
return !(box.max[0] < min[0] || box.max[2] < min[2] ||
box.min[0] > max[0] || box.min[2] > max[2]);
return !(box.max[0] < min[0] || box.max[2] < min[2] ||
box.min[0] > max[0] || box.min[2] > max[2]);
}
//
@ -171,35 +171,35 @@ bool kexBBox::IntersectingBox2D(const kexBBox &box) const
float kexBBox::DistanceToPlane(kexPlane &plane)
{
kexVec3 c;
float distStart;
float distEnd;
float dist = 0;
kexVec3 c;
float distStart;
float distEnd;
float dist = 0;
c = Center();
c = Center();
distStart = plane.Distance(c);
distEnd = kexMath::Fabs((max.x - c.x) * plane.a) +
kexMath::Fabs((max.y - c.y) * plane.b) +
kexMath::Fabs((max.z - c.z) * plane.c);
distStart = plane.Distance(c);
distEnd = kexMath::Fabs((max.x - c.x) * plane.a) +
kexMath::Fabs((max.y - c.y) * plane.b) +
kexMath::Fabs((max.z - c.z) * plane.c);
dist = distStart - distEnd;
dist = distStart - distEnd;
if(dist > 0)
{
// in front
return dist;
}
if (dist > 0)
{
// in front
return dist;
}
dist = distStart + distEnd;
dist = distStart + distEnd;
if(dist < 0)
{
// behind
return dist;
}
if (dist < 0)
{
// behind
return dist;
}
return 0;
return 0;
}
//
@ -208,18 +208,18 @@ float kexBBox::DistanceToPlane(kexPlane &plane)
kexBBox kexBBox::operator+(const float radius) const
{
kexVec3 vmin = min;
kexVec3 vmax = max;
kexVec3 vmin = min;
kexVec3 vmax = max;
vmin.x -= radius;
vmin.y -= radius;
vmin.z -= radius;
vmin.x -= radius;
vmin.y -= radius;
vmin.z -= radius;
vmax.x += radius;
vmax.y += radius;
vmax.z += radius;
vmax.x += radius;
vmax.y += radius;
vmax.z += radius;
return kexBBox(vmin, vmax);
return kexBBox(vmin, vmax);
}
//
@ -228,13 +228,13 @@ kexBBox kexBBox::operator+(const float radius) const
kexBBox &kexBBox::operator+=(const float radius)
{
min.x -= radius;
min.y -= radius;
min.z -= radius;
max.x += radius;
max.y += radius;
max.z += radius;
return *this;
min.x -= radius;
min.y -= radius;
min.z -= radius;
max.x += radius;
max.y += radius;
max.z += radius;
return *this;
}
//
@ -243,18 +243,18 @@ kexBBox &kexBBox::operator+=(const float radius)
kexBBox kexBBox::operator+(const kexVec3 &vec) const
{
kexVec3 vmin = min;
kexVec3 vmax = max;
kexVec3 vmin = min;
kexVec3 vmax = max;
vmin.x += vec.x;
vmin.y += vec.y;
vmin.z += vec.z;
vmin.x += vec.x;
vmin.y += vec.y;
vmin.z += vec.z;
vmax.x += vec.x;
vmax.y += vec.y;
vmax.z += vec.z;
vmax.x += vec.x;
vmax.y += vec.y;
vmax.z += vec.z;
return kexBBox(vmin, vmax);
return kexBBox(vmin, vmax);
}
//
@ -263,18 +263,18 @@ kexBBox kexBBox::operator+(const kexVec3 &vec) const
kexBBox kexBBox::operator-(const float radius) const
{
kexVec3 vmin = min;
kexVec3 vmax = max;
kexVec3 vmin = min;
kexVec3 vmax = max;
vmin.x += radius;
vmin.y += radius;
vmin.z += radius;
vmin.x += radius;
vmin.y += radius;
vmin.z += radius;
vmax.x -= radius;
vmax.y -= radius;
vmax.z -= radius;
vmax.x -= radius;
vmax.y -= radius;
vmax.z -= radius;
return kexBBox(vmin, vmax);
return kexBBox(vmin, vmax);
}
//
@ -283,18 +283,18 @@ kexBBox kexBBox::operator-(const float radius) const
kexBBox kexBBox::operator-(const kexVec3 &vec) const
{
kexVec3 vmin = min;
kexVec3 vmax = max;
kexVec3 vmin = min;
kexVec3 vmax = max;
vmin.x -= vec.x;
vmin.y -= vec.y;
vmin.z -= vec.z;
vmin.x -= vec.x;
vmin.y -= vec.y;
vmin.z -= vec.z;
vmax.x -= vec.x;
vmax.y -= vec.y;
vmax.z -= vec.z;
vmax.x -= vec.x;
vmax.y -= vec.y;
vmax.z -= vec.z;
return kexBBox(vmin, vmax);
return kexBBox(vmin, vmax);
}
//
@ -303,13 +303,13 @@ kexBBox kexBBox::operator-(const kexVec3 &vec) const
kexBBox &kexBBox::operator-=(const float radius)
{
min.x += radius;
min.y += radius;
min.z += radius;
max.x -= radius;
max.y -= radius;
max.z -= radius;
return *this;
min.x += radius;
min.y += radius;
min.z += radius;
max.x -= radius;
max.y -= radius;
max.z -= radius;
return *this;
}
//
@ -318,24 +318,24 @@ kexBBox &kexBBox::operator-=(const float radius)
kexBBox kexBBox::operator*(const kexMatrix &matrix) const
{
kexVec3 c = Center();
kexVec3 ct = c * matrix;
kexBBox box(ct, ct);
kexVec3 c = Center();
kexVec3 ct = c * matrix;
kexBBox box(ct, ct);
kexMatrix mtx(matrix);
kexMatrix mtx(matrix);
for(int i = 0; i < 3; i++)
{
mtx.vectors[i].x = kexMath::Fabs(mtx.vectors[i].x);
mtx.vectors[i].y = kexMath::Fabs(mtx.vectors[i].y);
mtx.vectors[i].z = kexMath::Fabs(mtx.vectors[i].z);
}
for (int i = 0; i < 3; i++)
{
mtx.vectors[i].x = kexMath::Fabs(mtx.vectors[i].x);
mtx.vectors[i].y = kexMath::Fabs(mtx.vectors[i].y);
mtx.vectors[i].z = kexMath::Fabs(mtx.vectors[i].z);
}
kexVec3 ht = (max - c) * mtx;
box.min -= ht;
box.max += ht;
kexVec3 ht = (max - c) * mtx;
box.min -= ht;
box.max += ht;
return box;
return box;
}
//
@ -344,24 +344,24 @@ kexBBox kexBBox::operator*(const kexMatrix &matrix) const
kexBBox &kexBBox::operator*=(const kexMatrix &matrix)
{
kexVec3 c = Center();
kexVec3 ct = c * matrix;
kexVec3 c = Center();
kexVec3 ct = c * matrix;
kexMatrix mtx(matrix);
kexMatrix mtx(matrix);
for(int i = 0; i < 3; i++)
{
mtx.vectors[i].x = kexMath::Fabs(mtx.vectors[i].x);
mtx.vectors[i].y = kexMath::Fabs(mtx.vectors[i].y);
mtx.vectors[i].z = kexMath::Fabs(mtx.vectors[i].z);
}
for (int i = 0; i < 3; i++)
{
mtx.vectors[i].x = kexMath::Fabs(mtx.vectors[i].x);
mtx.vectors[i].y = kexMath::Fabs(mtx.vectors[i].y);
mtx.vectors[i].z = kexMath::Fabs(mtx.vectors[i].z);
}
kexVec3 ht = (max - c) * mtx;
kexVec3 ht = (max - c) * mtx;
min = (ct - ht);
max = (ct + ht);
min = (ct - ht);
max = (ct + ht);
return *this;
return *this;
}
//
@ -370,16 +370,16 @@ kexBBox &kexBBox::operator*=(const kexMatrix &matrix)
kexBBox kexBBox::operator*(const kexVec3 &vec) const
{
kexBBox box = *this;
kexBBox box = *this;
if(vec.x < 0) { box.min.x += (vec.x-1); }
else { box.max.x += (vec.x+1); }
if(vec.y < 0) { box.min.y += (vec.y-1); }
else { box.max.y += (vec.y+1); }
if(vec.z < 0) { box.min.z += (vec.z-1); }
else { box.max.z += (vec.z+1); }
if (vec.x < 0) { box.min.x += (vec.x - 1); }
else { box.max.x += (vec.x + 1); }
if (vec.y < 0) { box.min.y += (vec.y - 1); }
else { box.max.y += (vec.y + 1); }
if (vec.z < 0) { box.min.z += (vec.z - 1); }
else { box.max.z += (vec.z + 1); }
return box;
return box;
}
//
@ -388,14 +388,14 @@ kexBBox kexBBox::operator*(const kexVec3 &vec) const
kexBBox &kexBBox::operator*=(const kexVec3 &vec)
{
if(vec.x < 0) { min.x += (vec.x-1); }
else { max.x += (vec.x+1); }
if(vec.y < 0) { min.y += (vec.y-1); }
else { max.y += (vec.y+1); }
if(vec.z < 0) { min.z += (vec.z-1); }
else { max.z += (vec.z+1); }
if (vec.x < 0) { min.x += (vec.x - 1); }
else { max.x += (vec.x + 1); }
if (vec.y < 0) { min.y += (vec.y - 1); }
else { max.y += (vec.y + 1); }
if (vec.z < 0) { min.z += (vec.z - 1); }
else { max.z += (vec.z + 1); }
return *this;
return *this;
}
//
@ -404,10 +404,10 @@ kexBBox &kexBBox::operator*=(const kexVec3 &vec)
kexBBox &kexBBox::operator=(const kexBBox &bbox)
{
min = bbox.min;
max = bbox.max;
min = bbox.min;
max = bbox.max;
return *this;
return *this;
}
//
@ -416,8 +416,8 @@ kexBBox &kexBBox::operator=(const kexBBox &bbox)
kexVec3 kexBBox::operator[](int index) const
{
assert(index >= 0 && index < 2);
return index == 0 ? min : max;
assert(index >= 0 && index < 2);
return index == 0 ? min : max;
}
//
@ -426,8 +426,8 @@ kexVec3 kexBBox::operator[](int index) const
kexVec3 &kexBBox::operator[](int index)
{
assert(index >= 0 && index < 2);
return index == 0 ? min : max;
assert(index >= 0 && index < 2);
return index == 0 ? min : max;
}
//
@ -436,27 +436,27 @@ kexVec3 &kexBBox::operator[](int index)
bool kexBBox::LineIntersect(const kexVec3 &start, const kexVec3 &end)
{
float ld[3];
kexVec3 center = Center();
kexVec3 extents = max - center;
kexVec3 lineDir = (end - start) * 0.5f;
kexVec3 lineCenter = lineDir + start;
kexVec3 dir = lineCenter - center;
float ld[3];
kexVec3 center = Center();
kexVec3 extents = max - center;
kexVec3 lineDir = (end - start) * 0.5f;
kexVec3 lineCenter = lineDir + start;
kexVec3 dir = lineCenter - center;
ld[0] = kexMath::Fabs(lineDir.x);
if(kexMath::Fabs(dir.x) > extents.x + ld[0]) { return false; }
ld[1] = kexMath::Fabs(lineDir.y);
if(kexMath::Fabs(dir.y) > extents.y + ld[1]) { return false; }
ld[2] = kexMath::Fabs(lineDir.z);
if(kexMath::Fabs(dir.z) > extents.z + ld[2]) { return false; }
ld[0] = kexMath::Fabs(lineDir.x);
if (kexMath::Fabs(dir.x) > extents.x + ld[0]) { return false; }
ld[1] = kexMath::Fabs(lineDir.y);
if (kexMath::Fabs(dir.y) > extents.y + ld[1]) { return false; }
ld[2] = kexMath::Fabs(lineDir.z);
if (kexMath::Fabs(dir.z) > extents.z + ld[2]) { return false; }
kexVec3 cross = lineDir.Cross(dir);
kexVec3 cross = lineDir.Cross(dir);
if(kexMath::Fabs(cross.x) > extents.y * ld[2] + extents.z * ld[1]) { return false; }
if(kexMath::Fabs(cross.y) > extents.x * ld[2] + extents.z * ld[0]) { return false; }
if(kexMath::Fabs(cross.z) > extents.x * ld[1] + extents.y * ld[0]) { return false; }
if (kexMath::Fabs(cross.x) > extents.y * ld[2] + extents.z * ld[1]) { return false; }
if (kexMath::Fabs(cross.y) > extents.x * ld[2] + extents.z * ld[0]) { return false; }
if (kexMath::Fabs(cross.z) > extents.x * ld[1] + extents.y * ld[0]) { return false; }
return true;
return true;
}
//
@ -467,30 +467,30 @@ bool kexBBox::LineIntersect(const kexVec3 &start, const kexVec3 &end)
void kexBBox::ToPoints(float *points) const
{
points[0 * 3 + 0] = max[0];
points[0 * 3 + 1] = min[1];
points[0 * 3 + 2] = min[2];
points[1 * 3 + 0] = max[0];
points[1 * 3 + 1] = min[1];
points[1 * 3 + 2] = max[2];
points[2 * 3 + 0] = min[0];
points[2 * 3 + 1] = min[1];
points[2 * 3 + 2] = max[2];
points[3 * 3 + 0] = min[0];
points[3 * 3 + 1] = min[1];
points[3 * 3 + 2] = min[2];
points[4 * 3 + 0] = max[0];
points[4 * 3 + 1] = max[1];
points[4 * 3 + 2] = min[2];
points[5 * 3 + 0] = max[0];
points[5 * 3 + 1] = max[1];
points[5 * 3 + 2] = max[2];
points[6 * 3 + 0] = min[0];
points[6 * 3 + 1] = max[1];
points[6 * 3 + 2] = max[2];
points[7 * 3 + 0] = min[0];
points[7 * 3 + 1] = max[1];
points[7 * 3 + 2] = min[2];
points[0 * 3 + 0] = max[0];
points[0 * 3 + 1] = min[1];
points[0 * 3 + 2] = min[2];
points[1 * 3 + 0] = max[0];
points[1 * 3 + 1] = min[1];
points[1 * 3 + 2] = max[2];
points[2 * 3 + 0] = min[0];
points[2 * 3 + 1] = min[1];
points[2 * 3 + 2] = max[2];
points[3 * 3 + 0] = min[0];
points[3 * 3 + 1] = min[1];
points[3 * 3 + 2] = min[2];
points[4 * 3 + 0] = max[0];
points[4 * 3 + 1] = max[1];
points[4 * 3 + 2] = min[2];
points[5 * 3 + 0] = max[0];
points[5 * 3 + 1] = max[1];
points[5 * 3 + 2] = max[2];
points[6 * 3 + 0] = min[0];
points[6 * 3 + 1] = max[1];
points[6 * 3 + 2] = max[2];
points[7 * 3 + 0] = min[0];
points[7 * 3 + 1] = max[1];
points[7 * 3 + 2] = min[2];
}
//
@ -501,28 +501,28 @@ void kexBBox::ToPoints(float *points) const
void kexBBox::ToVectors(kexVec3 *vectors) const
{
vectors[0][0] = max[0];
vectors[0][1] = min[1];
vectors[0][2] = min[2];
vectors[1][0] = max[0];
vectors[1][1] = min[1];
vectors[1][2] = max[2];
vectors[2][0] = min[0];
vectors[2][1] = min[1];
vectors[2][2] = max[2];
vectors[3][0] = min[0];
vectors[3][1] = min[1];
vectors[3][2] = min[2];
vectors[4][0] = max[0];
vectors[4][1] = max[1];
vectors[4][2] = min[2];
vectors[5][0] = max[0];
vectors[5][1] = max[1];
vectors[5][2] = max[2];
vectors[6][0] = min[0];
vectors[6][1] = max[1];
vectors[6][2] = max[2];
vectors[7][0] = min[0];
vectors[7][1] = max[1];
vectors[7][2] = min[2];
vectors[0][0] = max[0];
vectors[0][1] = min[1];
vectors[0][2] = min[2];
vectors[1][0] = max[0];
vectors[1][1] = min[1];
vectors[1][2] = max[2];
vectors[2][0] = min[0];
vectors[2][1] = min[1];
vectors[2][2] = max[2];
vectors[3][0] = min[0];
vectors[3][1] = min[1];
vectors[3][2] = min[2];
vectors[4][0] = max[0];
vectors[4][1] = max[1];
vectors[4][2] = min[2];
vectors[5][0] = max[0];
vectors[5][1] = max[1];
vectors[5][2] = max[2];
vectors[6][0] = min[0];
vectors[6][1] = max[1];
vectors[6][2] = max[2];
vectors[7][0] = min[0];
vectors[7][1] = max[1];
vectors[7][2] = min[2];
}

66
src/lightmap/kexlib/math/mathlib.cpp
View file

@ -39,19 +39,19 @@
int kexMath::RoundPowerOfTwo(int x)
{
int mask = 1;
int mask = 1;
while(mask < 0x40000000)
{
if(x == mask || (x & (mask-1)) == x)
{
return mask;
}
while (mask < 0x40000000)
{
if (x == mask || (x & (mask - 1)) == x)
{
return mask;
}
mask <<= 1;
}
mask <<= 1;
}
return x;
return x;
}
//
@ -59,20 +59,20 @@ int kexMath::RoundPowerOfTwo(int x)
//
void kexMath::CubicCurve(const kexVec3 &start, const kexVec3 &end, const float time,
const kexVec3 &point, kexVec3 *vec)
const kexVec3 &point, kexVec3 *vec)
{
int i;
float xyz[3];
int i;
float xyz[3];
for(i = 0; i < 3; i++)
{
xyz[i] = kexMath::Pow(1-time, 2) * start[i] +
(2 * (1-time)) * time * point[i] + kexMath::Pow(time, 2) * end[i];
}
for (i = 0; i < 3; i++)
{
xyz[i] = kexMath::Pow(1 - time, 2) * start[i] +
(2 * (1 - time)) * time * point[i] + kexMath::Pow(time, 2) * end[i];
}
vec->x = xyz[0];
vec->y = xyz[1];
vec->z = xyz[2];
vec->x = xyz[0];
vec->y = xyz[1];
vec->z = xyz[2];
}
//
@ -80,20 +80,20 @@ void kexMath::CubicCurve(const kexVec3 &start, const kexVec3 &end, const float t
//
void kexMath::QuadraticCurve(const kexVec3 &start, const kexVec3 &end, const float time,
const kexVec3 &pt1, const kexVec3 &pt2, kexVec3 *vec)
const kexVec3 &pt1, const kexVec3 &pt2, kexVec3 *vec)
{
int i;
float xyz[3];
int i;
float xyz[3];
for(i = 0; i < 3; i++)
{
xyz[i] = kexMath::Pow(1-time, 3) * start[i] + (3 * kexMath::Pow(1-time, 2)) *
time * pt1[i] + (3 * (1-time)) * kexMath::Pow(time, 2) * pt2[i] +
kexMath::Pow(time, 3) * end[i];
}
for (i = 0; i < 3; i++)
{
xyz[i] = kexMath::Pow(1 - time, 3) * start[i] + (3 * kexMath::Pow(1 - time, 2)) *
time * pt1[i] + (3 * (1 - time)) * kexMath::Pow(time, 2) * pt2[i] +
kexMath::Pow(time, 3) * end[i];
}
vec->x = xyz[0];
vec->y = xyz[1];
vec->z = xyz[2];
vec->x = xyz[0];
vec->y = xyz[1];
vec->z = xyz[2];
}

704
src/lightmap/kexlib/math/mathlib.h
View file

@ -54,248 +54,248 @@ class kexStr;
class kexMath
{
public:
static float Sin(float x);
static float Cos(float x);
static float Tan(float x);
static float ATan2(float x, float y);
static float ACos(float x);
static float Sqrt(float x);
static float Pow(float x, float y);
static float Log(float x);
static float Floor(float x);
static float Ceil(float x);
static float Deg2Rad(float x);
static float Rad2Deg(float x);
static float Sin(float x);
static float Cos(float x);
static float Tan(float x);
static float ATan2(float x, float y);
static float ACos(float x);
static float Sqrt(float x);
static float Pow(float x, float y);
static float Log(float x);
static float Floor(float x);
static float Ceil(float x);
static float Deg2Rad(float x);
static float Rad2Deg(float x);
static int Abs(int x);
static float Fabs(float x);
static int RoundPowerOfTwo(int x);
static float InvSqrt(float x);
static void Clamp(float &f, const float min, const float max);
static void Clamp(int &i, const int min, const int max);
static void Clamp(byte &b, const byte min, const byte max);
static void Clamp(kexVec3 &f, const float min, const float max);
static int Abs(int x);
static float Fabs(float x);
static int RoundPowerOfTwo(int x);
static float InvSqrt(float x);
static void Clamp(float &f, const float min, const float max);
static void Clamp(int &i, const int min, const int max);
static void Clamp(byte &b, const byte min, const byte max);
static void Clamp(kexVec3 &f, const float min, const float max);
static void CubicCurve(const kexVec3 &start, const kexVec3 &end, const float time,
const kexVec3 &point, kexVec3 *vec);
static void QuadraticCurve(const kexVec3 &start, const kexVec3 &end, const float time,
const kexVec3 &pt1, const kexVec3 &pt2, kexVec3 *vec);
static void CubicCurve(const kexVec3 &start, const kexVec3 &end, const float time,
const kexVec3 &point, kexVec3 *vec);
static void QuadraticCurve(const kexVec3 &start, const kexVec3 &end, const float time,
const kexVec3 &pt1, const kexVec3 &pt2, kexVec3 *vec);
};
class kexRand
{
public:
static void SetSeed(const int randSeed);
static int SysRand();
static int Int();
static int Max(const int max);
static float Float();
static float CFloat();
static void SetSeed(const int randSeed);
static int SysRand();
static int Int();
static int Max(const int max);
static float Float();
static float CFloat();
private:
static int seed;
static int seed;
};
class kexQuat
{
public:
kexQuat();
kexQuat();
explicit kexQuat(const float angle, const float x, const float y, const float z);
explicit kexQuat(const float angle, kexVec3 &vector);
explicit kexQuat(const float angle, const kexVec3 &vector);
explicit kexQuat(const float angle, const float x, const float y, const float z);
explicit kexQuat(const float angle, kexVec3 &vector);
explicit kexQuat(const float angle, const kexVec3 &vector);
void Set(const float x, const float y, const float z, const float w);
void Clear();
float Dot(const kexQuat &quat) const;
float UnitSq() const;
float Unit() const;
kexQuat &Normalize();
kexQuat Slerp(const kexQuat &quat, float movement) const;
kexQuat RotateFrom(const kexVec3 &location, const kexVec3 &target, float maxAngle);
kexQuat Inverse() const;
void Set(const float x, const float y, const float z, const float w);
void Clear();
float Dot(const kexQuat &quat) const;
float UnitSq() const;
float Unit() const;
kexQuat &Normalize();
kexQuat Slerp(const kexQuat &quat, float movement) const;
kexQuat RotateFrom(const kexVec3 &location, const kexVec3 &target, float maxAngle);
kexQuat Inverse() const;
kexQuat operator+(const kexQuat &quat);
kexQuat &operator+=(const kexQuat &quat);
kexQuat operator-(const kexQuat &quat);
kexQuat &operator-=(const kexQuat &quat);
kexQuat operator*(const kexQuat &quat);
kexQuat operator*(const float val) const;
kexQuat &operator*=(const kexQuat &quat);
kexQuat &operator*=(const float val);
kexQuat &operator=(const kexQuat &quat);
kexQuat &operator=(const kexVec4 &vec);
kexQuat &operator=(const float *vecs);
kexVec3 operator|(const kexVec3 &vector);
kexQuat operator+(const kexQuat &quat);
kexQuat &operator+=(const kexQuat &quat);
kexQuat operator-(const kexQuat &quat);
kexQuat &operator-=(const kexQuat &quat);
kexQuat operator*(const kexQuat &quat);
kexQuat operator*(const float val) const;
kexQuat &operator*=(const kexQuat &quat);
kexQuat &operator*=(const float val);
kexQuat &operator=(const kexQuat &quat);
kexQuat &operator=(const kexVec4 &vec);
kexQuat &operator=(const float *vecs);
kexVec3 operator|(const kexVec3 &vector);
const kexVec3 &ToVec3() const;
kexVec3 &ToVec3();
const kexVec3 &ToVec3() const;
kexVec3 &ToVec3();
float x;
float y;
float z;
float w;
float x;
float y;
float z;
float w;
};
class kexVec2
{
public:
kexVec2();
explicit kexVec2(const float x, const float y);
kexVec2();
explicit kexVec2(const float x, const float y);
void Set(const float x, const float y);
void Clear();
float Dot(const kexVec2 &vec) const;
static float Dot(const kexVec2 &vec1, const kexVec2 &vec2);
float CrossScalar(const kexVec2 &vec) const;
kexVec2 Cross(const kexVec2 &vec) const;
kexVec2 &Cross(const kexVec2 &vec1, const kexVec2 &vec2);
float Dot(const kexVec3 &vec) const;
static float Dot(const kexVec3 &vec1, const kexVec3 &vec2);
kexVec2 Cross(const kexVec3 &vec) const;
kexVec2 &Cross(const kexVec3 &vec1, const kexVec3 &vec2);
float UnitSq() const;
float Unit() const;
float DistanceSq(const kexVec2 &vec) const;
float Distance(const kexVec2 &vec) const;
kexVec2 &Normalize();
kexVec2 Lerp(const kexVec2 &next, float movement) const;
kexVec2 &Lerp(const kexVec2 &next, const float movement);
kexVec2 &Lerp(const kexVec2 &start, const kexVec2 &next, float movement);
kexStr ToString() const;
float ToYaw() const;
float *ToFloatPtr();
kexVec3 ToVec3();
void Set(const float x, const float y);
void Clear();
float Dot(const kexVec2 &vec) const;
static float Dot(const kexVec2 &vec1, const kexVec2 &vec2);
float CrossScalar(const kexVec2 &vec) const;
kexVec2 Cross(const kexVec2 &vec) const;
kexVec2 &Cross(const kexVec2 &vec1, const kexVec2 &vec2);
float Dot(const kexVec3 &vec) const;
static float Dot(const kexVec3 &vec1, const kexVec3 &vec2);
kexVec2 Cross(const kexVec3 &vec) const;
kexVec2 &Cross(const kexVec3 &vec1, const kexVec3 &vec2);
float UnitSq() const;
float Unit() const;
float DistanceSq(const kexVec2 &vec) const;
float Distance(const kexVec2 &vec) const;
kexVec2 &Normalize();
kexVec2 Lerp(const kexVec2 &next, float movement) const;
kexVec2 &Lerp(const kexVec2 &next, const float movement);
kexVec2 &Lerp(const kexVec2 &start, const kexVec2 &next, float movement);
kexStr ToString() const;
float ToYaw() const;
float *ToFloatPtr();
kexVec3 ToVec3();
kexVec2 operator+(const kexVec2 &vec);
kexVec2 operator+(const kexVec2 &vec) const;
kexVec2 operator+(kexVec2 &vec);
kexVec2 operator-() const;
kexVec2 operator-(const kexVec2 &vec) const;
kexVec2 operator*(const kexVec2 &vec);
kexVec2 operator*(const float val);
kexVec2 operator*(const float val) const;
kexVec2 operator/(const kexVec2 &vec);
kexVec2 operator/(const float val);
kexVec2 &operator=(kexVec3 &vec);
kexVec2 &operator=(const kexVec2 &vec);
kexVec2 &operator=(const kexVec3 &vec);
kexVec2 &operator=(const float *vecs);
kexVec2 &operator+=(const kexVec2 &vec);
kexVec2 &operator-=(const kexVec2 &vec);
kexVec2 &operator*=(const kexVec2 &vec);
kexVec2 &operator*=(const float val);
kexVec2 &operator/=(const kexVec2 &vec);
kexVec2 &operator/=(const float val);
kexVec2 operator*(const kexMatrix &mtx);
kexVec2 operator*(const kexMatrix &mtx) const;
kexVec2 &operator*=(const kexMatrix &mtx);
float operator[](int index) const;
float &operator[](int index);
bool operator==(const kexVec2 &vec);
kexVec2 operator+(const kexVec2 &vec);
kexVec2 operator+(const kexVec2 &vec) const;
kexVec2 operator+(kexVec2 &vec);
kexVec2 operator-() const;
kexVec2 operator-(const kexVec2 &vec) const;
kexVec2 operator*(const kexVec2 &vec);
kexVec2 operator*(const float val);
kexVec2 operator*(const float val) const;
kexVec2 operator/(const kexVec2 &vec);
kexVec2 operator/(const float val);
kexVec2 &operator=(kexVec3 &vec);
kexVec2 &operator=(const kexVec2 &vec);
kexVec2 &operator=(const kexVec3 &vec);
kexVec2 &operator=(const float *vecs);
kexVec2 &operator+=(const kexVec2 &vec);
kexVec2 &operator-=(const kexVec2 &vec);
kexVec2 &operator*=(const kexVec2 &vec);
kexVec2 &operator*=(const float val);
kexVec2 &operator/=(const kexVec2 &vec);
kexVec2 &operator/=(const float val);
kexVec2 operator*(const kexMatrix &mtx);
kexVec2 operator*(const kexMatrix &mtx) const;
kexVec2 &operator*=(const kexMatrix &mtx);
float operator[](int index) const;
float &operator[](int index);
bool operator==(const kexVec2 &vec);
operator float *() { return reinterpret_cast<float*>(&x); }
operator float *() { return reinterpret_cast<float*>(&x); }
static kexVec2 vecZero;
static const kexVec2 vecRight;
static const kexVec2 vecUp;
static kexVec2 vecZero;
static const kexVec2 vecRight;
static const kexVec2 vecUp;
float x;
float y;
float x;
float y;
};
class kexVec3
{
public:
kexVec3();
explicit kexVec3(const float x, const float y, const float z);
kexVec3();
explicit kexVec3(const float x, const float y, const float z);
void Set(const float x, const float y, const float z);
void Clear();
float Dot(const kexVec3 &vec) const;
static float Dot(const kexVec3 &vec1, const kexVec3 &vec2);
kexVec3 Cross(const kexVec3 &vec) const;
static kexVec3 Cross(const kexVec3 &vec1, const kexVec3 &vec2);
float UnitSq() const;
float Unit() const;
void Set(const float x, const float y, const float z);
void Clear();
float Dot(const kexVec3 &vec) const;
static float Dot(const kexVec3 &vec1, const kexVec3 &vec2);
kexVec3 Cross(const kexVec3 &vec) const;
static kexVec3 Cross(const kexVec3 &vec1, const kexVec3 &vec2);
float UnitSq() const;
float Unit() const;
float LengthSq() const { return UnitSq(); }
float Length() const { return Unit(); }
float DistanceSq(const kexVec3 &vec) const;
float Distance(const kexVec3 &vec) const;
kexVec3 &Normalize();
float Distance(const kexVec3 &vec) const;
kexVec3 &Normalize();
static kexVec3 Normalize(kexVec3 a);
kexAngle PointAt(kexVec3 &location) const;
kexVec3 Lerp(const kexVec3 &next, float movement) const;
kexVec3 &Lerp(const kexVec3 &start, const kexVec3 &next, float movement);
kexQuat ToQuat();
float ToYaw() const;
float ToPitch() const;
kexStr ToString() const;
float *ToFloatPtr();
kexVec2 ToVec2();
kexVec2 ToVec2() const;
kexVec3 ScreenProject(kexMatrix &proj, kexMatrix &model,
const int width, const int height,
const int wx, const int wy);
kexAngle PointAt(kexVec3 &location) const;
kexVec3 Lerp(const kexVec3 &next, float movement) const;
kexVec3 &Lerp(const kexVec3 &start, const kexVec3 &next, float movement);
kexQuat ToQuat();
float ToYaw() const;
float ToPitch() const;
kexStr ToString() const;
float *ToFloatPtr();
kexVec2 ToVec2();
kexVec2 ToVec2() const;
kexVec3 ScreenProject(kexMatrix &proj, kexMatrix &model,
const int width, const int height,
const int wx, const int wy);
kexVec3 operator+(const kexVec3 &vec);
kexVec3 operator+(const kexVec3 &vec) const;
kexVec3 operator+(kexVec3 &vec);
kexVec3 operator+(const kexVec3 &vec);
kexVec3 operator+(const kexVec3 &vec) const;
kexVec3 operator+(kexVec3 &vec);
kexVec3 operator+(const float val) const;
kexVec3 operator-() const;
kexVec3 operator-(const float val) const;
kexVec3 operator-(const kexVec3 &vec) const;
kexVec3 operator*(const kexVec3 &vec);
kexVec3 operator*(const float val);
kexVec3 operator*(const float val) const;
kexVec3 operator/(const kexVec3 &vec);
kexVec3 operator/(const float val);
kexVec3 operator*(const kexQuat &quat);
kexVec3 operator*(const kexMatrix &mtx);
kexVec3 operator*(const kexMatrix &mtx) const;
kexVec3 &operator=(const kexVec3 &vec);
kexVec3 &operator=(const float *vecs);
kexVec3 &operator+=(const kexVec3 &vec);
kexVec3 operator*(const kexVec3 &vec);
kexVec3 operator*(const float val);
kexVec3 operator*(const float val) const;
kexVec3 operator/(const kexVec3 &vec);
kexVec3 operator/(const float val);
kexVec3 operator*(const kexQuat &quat);
kexVec3 operator*(const kexMatrix &mtx);
kexVec3 operator*(const kexMatrix &mtx) const;
kexVec3 &operator=(const kexVec3 &vec);
kexVec3 &operator=(const float *vecs);
kexVec3 &operator+=(const kexVec3 &vec);
kexVec3 &operator+=(const float val);
kexVec3 &operator-=(const kexVec3 &vec);
kexVec3 &operator-=(const float val);
kexVec3 &operator*=(const kexVec3 &vec);
kexVec3 &operator*=(const float val);
kexVec3 &operator/=(const kexVec3 &vec);
kexVec3 &operator/=(const float val);
kexVec3 &operator*=(const kexQuat &quat);
kexVec3 &operator*=(const kexMatrix &mtx);
float operator[](int index) const;
float &operator[](int index);
kexVec3 &operator*=(const float val);
kexVec3 &operator/=(const kexVec3 &vec);
kexVec3 &operator/=(const float val);
kexVec3 &operator*=(const kexQuat &quat);
kexVec3 &operator*=(const kexMatrix &mtx);
float operator[](int index) const;
float &operator[](int index);
operator float *() { return reinterpret_cast<float*>(&x); }
operator float *() { return reinterpret_cast<float*>(&x); }
static const kexVec3 vecForward;
static const kexVec3 vecUp;
static const kexVec3 vecRight;
static const kexVec3 vecForward;
static const kexVec3 vecUp;
static const kexVec3 vecRight;
float x;
float y;
float z;
float x;
float y;
float z;
};
class kexVec4
{
public:
kexVec4();
explicit kexVec4(const float x, const float y, const float z, const float w);
kexVec4();
explicit kexVec4(const float x, const float y, const float z, const float w);
explicit kexVec4(const kexVec3 &v, const float w);
void Set(const float x, const float y, const float z, const float w);
void Clear();
float *ToFloatPtr();
void Set(const float x, const float y, const float z, const float w);
void Clear();
float *ToFloatPtr();
static float Dot(const kexVec4 &a, const kexVec4 &b) { return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; }
const kexVec3 &ToVec3() const;
kexVec3 &ToVec3();
kexVec4 operator|(const kexMatrix &mtx);
kexVec4 &operator|=(const kexMatrix &mtx);
const kexVec3 &ToVec3() const;
kexVec3 &ToVec3();
kexVec4 operator|(const kexMatrix &mtx);
kexVec4 &operator|=(const kexMatrix &mtx);
kexVec4 operator+(const kexVec4 &vec) const;
kexVec4 operator+(const float val) const;
kexVec4 operator-(const kexVec4 &vec) const;
@ -313,187 +313,187 @@ public:
kexVec4 &operator/=(const kexVec4 &vec);
kexVec4 &operator/=(const float val);
float operator[](int index) const;
float &operator[](int index);
float &operator[](int index);
float x;
float y;
float z;
float w;
float x;
float y;
float z;
float w;
};
class kexMatrix
{
public:
kexMatrix();
kexMatrix(const kexMatrix &mtx);
kexMatrix(const float x, const float y, const float z);
kexMatrix(const kexQuat &quat);
kexMatrix(const float angle, const int axis);
kexMatrix();
kexMatrix(const kexMatrix &mtx);
kexMatrix(const float x, const float y, const float z);
kexMatrix(const kexQuat &quat);
kexMatrix(const float angle, const int axis);
kexMatrix &Identity();
kexMatrix &Identity(const float x, const float y, const float z);
kexMatrix &SetTranslation(const float x, const float y, const float z);
kexMatrix &SetTranslation(const kexVec3 &vector);
kexMatrix &AddTranslation(const float x, const float y, const float z);
kexMatrix &AddTranslation(const kexVec3 &vector);
kexMatrix &Scale(const float x, const float y, const float z);
kexMatrix &Scale(const kexVec3 &vector);
static kexMatrix Scale(const kexMatrix &mtx, const float x, const float y, const float z);
kexMatrix &Transpose();
static kexMatrix Transpose(const kexMatrix &mtx);
static kexMatrix Invert(kexMatrix &mtx);
kexQuat ToQuat();
float *ToFloatPtr();
void SetViewProjection(float aspect, float fov, float zNear, float zFar);
void SetOrtho(float left, float right,
float bottom, float top,
float zNear, float zFar);
kexMatrix &Identity();
kexMatrix &Identity(const float x, const float y, const float z);
kexMatrix &SetTranslation(const float x, const float y, const float z);
kexMatrix &SetTranslation(const kexVec3 &vector);
kexMatrix &AddTranslation(const float x, const float y, const float z);
kexMatrix &AddTranslation(const kexVec3 &vector);
kexMatrix &Scale(const float x, const float y, const float z);
kexMatrix &Scale(const kexVec3 &vector);
static kexMatrix Scale(const kexMatrix &mtx, const float x, const float y, const float z);
kexMatrix &Transpose();
static kexMatrix Transpose(const kexMatrix &mtx);
static kexMatrix Invert(kexMatrix &mtx);
kexQuat ToQuat();
float *ToFloatPtr();
void SetViewProjection(float aspect, float fov, float zNear, float zFar);
void SetOrtho(float left, float right,
float bottom, float top,
float zNear, float zFar);
kexMatrix operator*(const kexVec3 &vector);
kexMatrix &operator*=(const kexVec3 &vector);
kexMatrix operator*(const kexMatrix &matrix);
kexMatrix &operator*=(const kexMatrix &matrix);
friend kexMatrix operator*(const kexMatrix &m1, const kexMatrix &m2);
kexMatrix &operator=(const kexMatrix &matrix);
kexMatrix &operator=(const float *m);
kexMatrix operator|(const kexMatrix &matrix);
kexMatrix operator*(const kexVec3 &vector);
kexMatrix &operator*=(const kexVec3 &vector);
kexMatrix operator*(const kexMatrix &matrix);
kexMatrix &operator*=(const kexMatrix &matrix);
friend kexMatrix operator*(const kexMatrix &m1, const kexMatrix &m2);
kexMatrix &operator=(const kexMatrix &matrix);
kexMatrix &operator=(const float *m);
kexMatrix operator|(const kexMatrix &matrix);
float operator[](size_t i) const { return vectors[i >> 2][i & 3]; }
float &operator[](size_t i) { return vectors[i >> 2][i & 3]; }
kexVec4 vectors[4];
kexVec4 vectors[4];
};
class kexPluecker
{
public:
kexPluecker();
kexPluecker(const kexVec3 &start, const kexVec3 &end, bool bRay = false);
kexPluecker();
kexPluecker(const kexVec3 &start, const kexVec3 &end, bool bRay = false);
void Clear();
void SetLine(const kexVec3 &start, const kexVec3 &end);
void SetRay(const kexVec3 &start, const kexVec3 &dir);
float InnerProduct(const kexPluecker &pluecker) const;
void Clear();
void SetLine(const kexVec3 &start, const kexVec3 &end);
void SetRay(const kexVec3 &start, const kexVec3 &dir);
float InnerProduct(const kexPluecker &pluecker) const;
float p[6];
float p[6];
};
class kexPlane
{
public:
kexPlane();
kexPlane(const float a, const float b, const float c, const float d);
kexPlane(const kexVec3 &pt1, const kexVec3 &pt2, const kexVec3 &pt3);
kexPlane(const kexVec3 &normal, const kexVec3 &point);
kexPlane(const kexPlane &plane);
kexPlane();
kexPlane(const float a, const float b, const float c, const float d);
kexPlane(const kexVec3 &pt1, const kexVec3 &pt2, const kexVec3 &pt3);
kexPlane(const kexVec3 &normal, const kexVec3 &point);
kexPlane(const kexPlane &plane);
enum planeAxis_t
{
AXIS_YZ = 0,
AXIS_XZ,
AXIS_XY
};
enum planeAxis_t
{
AXIS_YZ = 0,
AXIS_XZ,
AXIS_XY
};
const kexVec3 &Normal() const;
kexVec3 &Normal();
kexPlane &SetNormal(const kexVec3 &normal);
kexPlane &SetNormal(const kexVec3 &pt1, const kexVec3 &pt2, const kexVec3 &pt3);
float Distance(const kexVec3 &point);
kexPlane &SetDistance(const kexVec3 &point);
bool IsFacing(const float yaw);
float ToYaw();
float ToPitch();
kexQuat ToQuat();
const kexVec4 &ToVec4() const;
kexVec4 &ToVec4();
const planeAxis_t BestAxis() const;
kexVec3 GetInclination();
const kexVec3 &Normal() const;
kexVec3 &Normal();
kexPlane &SetNormal(const kexVec3 &normal);
kexPlane &SetNormal(const kexVec3 &pt1, const kexVec3 &pt2, const kexVec3 &pt3);
float Distance(const kexVec3 &point);
kexPlane &SetDistance(const kexVec3 &point);
bool IsFacing(const float yaw);
float ToYaw();
float ToPitch();
kexQuat ToQuat();
const kexVec4 &ToVec4() const;
kexVec4 &ToVec4();
const planeAxis_t BestAxis() const;
kexVec3 GetInclination();
float zAt(float x, float y) const { return (d - a * x - b * y) / c; }
kexPlane &operator|(const kexQuat &quat);
kexPlane &operator|=(const kexQuat &quat);
kexPlane &operator|(const kexMatrix &mtx);
kexPlane &operator|=(const kexMatrix &mtx);
kexPlane &operator|(const kexQuat &quat);
kexPlane &operator|=(const kexQuat &quat);
kexPlane &operator|(const kexMatrix &mtx);
kexPlane &operator|=(const kexMatrix &mtx);
float a;
float b;
float c;
float d;
float a;
float b;
float c;
float d;
};
class kexAngle
{
public:
kexAngle();
kexAngle(const float yaw, const float pitch, const float roll);
kexAngle(const kexVec3 &vector);
kexAngle(const kexAngle &an);
kexAngle();
kexAngle(const float yaw, const float pitch, const float roll);
kexAngle(const kexVec3 &vector);
kexAngle(const kexAngle &an);
kexAngle &Round();
kexAngle &Clamp180();
kexAngle &Clamp180Invert();
kexAngle &Clamp180InvertSum(const kexAngle &angle);
kexAngle Diff(kexAngle &angle);
void ToAxis(kexVec3 *forward, kexVec3 *up, kexVec3 *right);
kexVec3 ToForwardAxis();
kexVec3 ToUpAxis();
kexVec3 ToRightAxis();
const kexVec3 &ToVec3() const;
kexVec3 &ToVec3();
kexQuat ToQuat();
kexAngle &Round();
kexAngle &Clamp180();
kexAngle &Clamp180Invert();
kexAngle &Clamp180InvertSum(const kexAngle &angle);
kexAngle Diff(kexAngle &angle);
void ToAxis(kexVec3 *forward, kexVec3 *up, kexVec3 *right);
kexVec3 ToForwardAxis();
kexVec3 ToUpAxis();
kexVec3 ToRightAxis();
const kexVec3 &ToVec3() const;
kexVec3 &ToVec3();
kexQuat ToQuat();
kexAngle operator+(const kexAngle &angle);
kexAngle operator-(const kexAngle &angle);
kexAngle &operator+=(const kexAngle &angle);
kexAngle &operator-=(const kexAngle &angle);
kexAngle &operator=(const kexAngle &angle);
kexAngle &operator=(const kexVec3 &vector);
kexAngle &operator=(const float *vecs);
kexAngle operator-();
float operator[](int index) const;
float &operator[](int index);
kexAngle operator+(const kexAngle &angle);
kexAngle operator-(const kexAngle &angle);
kexAngle &operator+=(const kexAngle &angle);
kexAngle &operator-=(const kexAngle &angle);
kexAngle &operator=(const kexAngle &angle);
kexAngle &operator=(const kexVec3 &vector);
kexAngle &operator=(const float *vecs);
kexAngle operator-();
float operator[](int index) const;
float &operator[](int index);
float yaw;
float pitch;
float roll;
float yaw;
float pitch;
float roll;
};
class kexBBox
{
public:
kexBBox();
explicit kexBBox(const kexVec3 &vMin, const kexVec3 &vMax);
kexBBox();
explicit kexBBox(const kexVec3 &vMin, const kexVec3 &vMax);
void Clear();
kexVec3 Center() const;
void Clear();
kexVec3 Center() const;
kexVec3 Extents() const;
float Radius() const;
void AddPoint(const kexVec3 &vec);
bool PointInside(const kexVec3 &vec) const;
bool IntersectingBox(const kexBBox &box) const;
bool IntersectingBox2D(const kexBBox &box) const;
float DistanceToPlane(kexPlane &plane);
bool LineIntersect(const kexVec3 &start, const kexVec3 &end);
void ToPoints(float *points) const;
void ToVectors(kexVec3 *vectors) const;
void AddPoint(const kexVec3 &vec);
bool PointInside(const kexVec3 &vec) const;
bool IntersectingBox(const kexBBox &box) const;
bool IntersectingBox2D(const kexBBox &box) const;
float DistanceToPlane(kexPlane &plane);
bool LineIntersect(const kexVec3 &start, const kexVec3 &end);
void ToPoints(float *points) const;
void ToVectors(kexVec3 *vectors) const;
kexBBox operator+(const float radius) const;
kexBBox &operator+=(const float radius);
kexBBox operator+(const kexVec3 &vec) const;
kexBBox operator-(const float radius) const;
kexBBox operator-(const kexVec3 &vec) const;
kexBBox &operator-=(const float radius);
kexBBox operator*(const kexMatrix &matrix) const;
kexBBox &operator*=(const kexMatrix &matrix);
kexBBox operator*(const kexVec3 &vec) const;
kexBBox &operator*=(const kexVec3 &vec);
kexBBox &operator=(const kexBBox &bbox);
kexVec3 operator[](int index) const;
kexVec3 &operator[](int index);
kexBBox operator+(const float radius) const;
kexBBox &operator+=(const float radius);
kexBBox operator+(const kexVec3 &vec) const;
kexBBox operator-(const float radius) const;
kexBBox operator-(const kexVec3 &vec) const;
kexBBox &operator-=(const float radius);
kexBBox operator*(const kexMatrix &matrix) const;
kexBBox &operator*=(const kexMatrix &matrix);
kexBBox operator*(const kexVec3 &vec) const;
kexBBox &operator*=(const kexVec3 &vec);
kexBBox &operator=(const kexBBox &bbox);
kexVec3 operator[](int index) const;
kexVec3 &operator[](int index);
kexVec3 min;
kexVec3 max;
kexVec3 min;
kexVec3 max;
};
//
@ -502,7 +502,7 @@ public:
d_inline float kexMath::Sin(float x)
{
return sinf(x);
return sinf(x);
}
//
@ -511,7 +511,7 @@ d_inline float kexMath::Sin(float x)
d_inline float kexMath::Cos(float x)
{
return cosf(x);
return cosf(x);
}
//
@ -520,7 +520,7 @@ d_inline float kexMath::Cos(float x)
d_inline float kexMath::Tan(float x)
{
return tanf(x);
return tanf(x);
}
//
@ -529,7 +529,7 @@ d_inline float kexMath::Tan(float x)
d_inline float kexMath::ATan2(float x, float y)
{
return atan2f(x, y);
return atan2f(x, y);
}
//
@ -538,7 +538,7 @@ d_inline float kexMath::ATan2(float x, float y)
d_inline float kexMath::ACos(float x)
{
return acosf(x);
return acosf(x);
}
//
@ -547,7 +547,7 @@ d_inline float kexMath::ACos(float x)
d_inline float kexMath::Sqrt(float x)
{
return x * InvSqrt(x);
return x * InvSqrt(x);
}
//
@ -556,7 +556,7 @@ d_inline float kexMath::Sqrt(float x)
d_inline float kexMath::Pow(float x, float y)
{
return powf(x, y);
return powf(x, y);
}
//
@ -565,7 +565,7 @@ d_inline float kexMath::Pow(float x, float y)
d_inline float kexMath::Log(float x)
{
return logf(x);
return logf(x);
}
//
@ -574,7 +574,7 @@ d_inline float kexMath::Log(float x)
d_inline float kexMath::Floor(float x)
{
return floorf(x);
return floorf(x);
}
//
@ -583,7 +583,7 @@ d_inline float kexMath::Floor(float x)
d_inline float kexMath::Ceil(float x)
{
return ceilf(x);
return ceilf(x);
}
//
@ -592,7 +592,7 @@ d_inline float kexMath::Ceil(float x)
d_inline float kexMath::Deg2Rad(float x)
{
return DEG2RAD(x);
return DEG2RAD(x);
}
//
@ -601,7 +601,7 @@ d_inline float kexMath::Deg2Rad(float x)
d_inline float kexMath::Rad2Deg(float x)
{
return RAD2DEG(x);
return RAD2DEG(x);
}
//
@ -610,8 +610,8 @@ d_inline float kexMath::Rad2Deg(float x)
d_inline int kexMath::Abs(int x)
{
int y = x >> 31;
return ((x ^ y) - y);
int y = x >> 31;
return ((x ^ y) - y);
}
//
@ -620,9 +620,9 @@ d_inline int kexMath::Abs(int x)
d_inline float kexMath::Fabs(float x)
{
int tmp = *reinterpret_cast<int*>(&x);
tmp &= 0x7FFFFFFF;
return *reinterpret_cast<float*>(&tmp);
int tmp = *reinterpret_cast<int*>(&x);
tmp &= 0x7FFFFFFF;
return *reinterpret_cast<float*>(&tmp);
}
//
@ -631,17 +631,17 @@ d_inline float kexMath::Fabs(float x)
d_inline float kexMath::InvSqrt(float x)
{
unsigned int i;
float r;
float y;
unsigned int i;
float r;
float y;
y = x * 0.5f;
i = *reinterpret_cast<unsigned int*>(&x);
i = 0x5f3759df - (i >> 1);
r = *reinterpret_cast<float*>(&i);
r = r * (1.5f - r * r * y);
y = x * 0.5f;
i = *reinterpret_cast<unsigned int*>(&x);
i = 0x5f3759df - (i >> 1);
r = *reinterpret_cast<float*>(&i);
r = r * (1.5f - r * r * y);
return r;
return r;
}
//
@ -650,8 +650,8 @@ d_inline float kexMath::InvSqrt(float x)
d_inline void kexMath::Clamp(float &f, const float min, const float max)
{
if(f < min) { f = min; }
if(f > max) { f = max; }
if (f < min) { f = min; }
if (f > max) { f = max; }
}
//
@ -660,8 +660,8 @@ d_inline void kexMath::Clamp(float &f, const float min, const float max)
d_inline void kexMath::Clamp(byte &b, const byte min, const byte max)
{
if(b < min) { b = min; }
if(b > max) { b = max; }
if (b < min) { b = min; }
if (b > max) { b = max; }
}
//
@ -670,8 +670,8 @@ d_inline void kexMath::Clamp(byte &b, const byte min, const byte max)
d_inline void kexMath::Clamp(int &i, const int min, const int max)
{
if(i < min) { i = min; }
if(i > max) { i = max; }
if (i < min) { i = min; }
if (i > max) { i = max; }
}
//
@ -680,10 +680,10 @@ d_inline void kexMath::Clamp(int &i, const int min, const int max)
d_inline void kexMath::Clamp(kexVec3 &v, const float min, const float max)
{
if(v.x < min) { v.x = min; }
if(v.x > max) { v.x = max; }
if(v.y < min) { v.y = min; }
if(v.y > max) { v.y = max; }
if(v.z < min) { v.z = min; }
if(v.z > max) { v.z = max; }
if (v.x < min) { v.x = min; }
if (v.x > max) { v.x = max; }
if (v.y < min) { v.y = min; }
if (v.y > max) { v.y = max; }
if (v.z < min) { v.z = min; }
if (v.z > max) { v.z = max; }
}

740
src/lightmap/kexlib/math/matrix.cpp
View file

@ -79,7 +79,7 @@
kexMatrix::kexMatrix()
{
Identity();
Identity();
}
//
@ -88,13 +88,13 @@ kexMatrix::kexMatrix()
kexMatrix::kexMatrix(const kexMatrix &mtx)
{
for(int i = 0; i < 4; i++)
{
vectors[i].x = mtx.vectors[i].x;
vectors[i].y = mtx.vectors[i].y;
vectors[i].z = mtx.vectors[i].z;
vectors[i].w = mtx.vectors[i].w;
}
for (int i = 0; i < 4; i++)
{
vectors[i].x = mtx.vectors[i].x;
vectors[i].y = mtx.vectors[i].y;
vectors[i].z = mtx.vectors[i].z;
vectors[i].w = mtx.vectors[i].w;
}
}
//
@ -103,7 +103,7 @@ kexMatrix::kexMatrix(const kexMatrix &mtx)
kexMatrix::kexMatrix(const float x, const float y, const float z)
{
Identity(x, y, z);
Identity(x, y, z);
}
//
@ -112,33 +112,33 @@ kexMatrix::kexMatrix(const float x, const float y, const float z)
kexMatrix::kexMatrix(const kexQuat &quat)
{
float xx = quat.x * quat.x;
float yx = quat.y * quat.x;
float zx = quat.z * quat.x;
float wx = quat.w * quat.x;
float yy = quat.y * quat.y;
float zy = quat.z * quat.y;
float wy = quat.w * quat.y;
float zz = quat.z * quat.z;
float wz = quat.w * quat.z;
float ww = quat.w * quat.w;
float xx = quat.x * quat.x;
float yx = quat.y * quat.x;
float zx = quat.z * quat.x;
float wx = quat.w * quat.x;
float yy = quat.y * quat.y;
float zy = quat.z * quat.y;
float wy = quat.w * quat.y;
float zz = quat.z * quat.z;
float wz = quat.w * quat.z;
float ww = quat.w * quat.w;
vectors[0].Set(
((ww + xx) - yy) - zz,
(wz + wz) + (yx + yx),
(zx + zx) - (wy + wy),
0);
vectors[1].Set(
(yx + yx) - (wz + wz),
(yy + (ww - xx)) - zz,
(wx + wx) + (zy + zy),
0);
vectors[2].Set(
(wy + wy + zx + zx),
(zy + zy) - (wx + wx),
((ww - xx) - yy) + zz,
0);
vectors[3].Set(0, 0, 0, 1);
vectors[0].Set(
((ww + xx) - yy) - zz,
(wz + wz) + (yx + yx),
(zx + zx) - (wy + wy),
0);
vectors[1].Set(
(yx + yx) - (wz + wz),
(yy + (ww - xx)) - zz,
(wx + wx) + (zy + zy),
0);
vectors[2].Set(
(wy + wy + zx + zx),
(zy + zy) - (wx + wx),
((ww - xx) - yy) + zz,
0);
vectors[3].Set(0, 0, 0, 1);
}
//
@ -147,35 +147,35 @@ kexMatrix::kexMatrix(const kexQuat &quat)
kexMatrix::kexMatrix(const float angle, const int axis)
{
float s;
float c;
float s;
float c;
s = kexMath::Sin(angle);
c = kexMath::Cos(angle);
s = kexMath::Sin(angle);
c = kexMath::Cos(angle);
Identity();
Identity();
switch(axis)
{
case 0:
this->vectors[0].x = c;
this->vectors[0].z = -s;
this->vectors[3].x = s;
this->vectors[3].z = c;
break;
case 1:
this->vectors[1].y = c;
this->vectors[1].z = s;
this->vectors[2].y = -s;
this->vectors[2].z = c;
break;
case 2:
this->vectors[0].x = c;
this->vectors[0].y = s;
this->vectors[1].x = -s;
this->vectors[1].y = c;
break;
}
switch (axis)
{
case 0:
this->vectors[0].x = c;
this->vectors[0].z = -s;
this->vectors[3].x = s;
this->vectors[3].z = c;
break;
case 1:
this->vectors[1].y = c;
this->vectors[1].z = s;
this->vectors[2].y = -s;
this->vectors[2].z = c;
break;
case 2:
this->vectors[0].x = c;
this->vectors[0].y = s;
this->vectors[1].x = -s;
this->vectors[1].y = c;
break;
}
}
//
@ -184,12 +184,12 @@ kexMatrix::kexMatrix(const float angle, const int axis)
kexMatrix &kexMatrix::Identity()
{
vectors[0].Set(1, 0, 0, 0);
vectors[1].Set(0, 1, 0, 0);
vectors[2].Set(0, 0, 1, 0);
vectors[3].Set(0, 0, 0, 1);
vectors[0].Set(1, 0, 0, 0);
vectors[1].Set(0, 1, 0, 0);
vectors[2].Set(0, 0, 1, 0);
vectors[3].Set(0, 0, 0, 1);
return *this;
return *this;
}
//
@ -198,12 +198,12 @@ kexMatrix &kexMatrix::Identity()
kexMatrix &kexMatrix::Identity(const float x, const float y, const float z)
{
vectors[0].Set(x, 0, 0, 0);
vectors[1].Set(0, y, 0, 0);
vectors[2].Set(0, 0, z, 0);
vectors[3].Set(0, 0, 0, 1);
vectors[0].Set(x, 0, 0, 0);
vectors[1].Set(0, y, 0, 0);
vectors[2].Set(0, 0, z, 0);
vectors[3].Set(0, 0, 0, 1);
return *this;
return *this;
}
//
@ -212,8 +212,8 @@ kexMatrix &kexMatrix::Identity(const float x, const float y, const float z)
kexMatrix &kexMatrix::SetTranslation(const float x, const float y, const float z)
{
vectors[3].ToVec3().Set(x, y, z);
return *this;
vectors[3].ToVec3().Set(x, y, z);
return *this;
}
//
@ -222,8 +222,8 @@ kexMatrix &kexMatrix::SetTranslation(const float x, const float y, const float z
kexMatrix &kexMatrix::SetTranslation(const kexVec3 &vector)
{
vectors[3].ToVec3() = vector;
return *this;
vectors[3].ToVec3() = vector;
return *this;
}
//
@ -232,10 +232,10 @@ kexMatrix &kexMatrix::SetTranslation(const kexVec3 &vector)
kexMatrix &kexMatrix::AddTranslation(const float x, const float y, const float z)
{
vectors[3].x += x;
vectors[3].y += y;
vectors[3].z += z;
return *this;
vectors[3].x += x;
vectors[3].y += y;
vectors[3].z += z;
return *this;
}
//
@ -244,8 +244,8 @@ kexMatrix &kexMatrix::AddTranslation(const float x, const float y, const float z
kexMatrix &kexMatrix::AddTranslation(const kexVec3 &vector)
{
vectors[3].ToVec3() += vector;
return *this;
vectors[3].ToVec3() += vector;
return *this;
}
//
@ -254,11 +254,11 @@ kexMatrix &kexMatrix::AddTranslation(const kexVec3 &vector)
kexMatrix &kexMatrix::Scale(const float x, const float y, const float z)
{
vectors[0].ToVec3() *= x;
vectors[1].ToVec3() *= y;
vectors[2].ToVec3() *= z;
vectors[0].ToVec3() *= x;
vectors[1].ToVec3() *= y;
vectors[2].ToVec3() *= z;
return *this;
return *this;
}
//
@ -267,11 +267,11 @@ kexMatrix &kexMatrix::Scale(const float x, const float y, const float z)
kexMatrix &kexMatrix::Scale(const kexVec3 &vector)
{
vectors[0].ToVec3() *= vector.x;
vectors[1].ToVec3() *= vector.y;
vectors[2].ToVec3() *= vector.z;
vectors[0].ToVec3() *= vector.x;
vectors[1].ToVec3() *= vector.y;
vectors[2].ToVec3() *= vector.z;
return *this;
return *this;
}
//
@ -280,13 +280,13 @@ kexMatrix &kexMatrix::Scale(const kexVec3 &vector)
kexMatrix kexMatrix::Scale(const kexMatrix &mtx, const float x, const float y, const float z)
{
kexMatrix out;
kexMatrix out;
out.vectors[0].ToVec3() = mtx.vectors[0].ToVec3() * x;
out.vectors[1].ToVec3() = mtx.vectors[1].ToVec3() * y;
out.vectors[2].ToVec3() = mtx.vectors[2].ToVec3() * z;
out.vectors[0].ToVec3() = mtx.vectors[0].ToVec3() * x;
out.vectors[1].ToVec3() = mtx.vectors[1].ToVec3() * y;
out.vectors[2].ToVec3() = mtx.vectors[2].ToVec3() * z;
return out;
return out;
}
//
@ -295,12 +295,12 @@ kexMatrix kexMatrix::Scale(const kexMatrix &mtx, const float x, const float y, c
kexMatrix &kexMatrix::Transpose()
{
kexVec3 v1 = vectors[1].ToVec3();
kexVec3 v2 = vectors[2].ToVec3();
kexVec3 v1 = vectors[1].ToVec3();
kexVec3 v2 = vectors[2].ToVec3();
vectors[1].ToVec3() = v2;
vectors[2].ToVec3() = v1;
return *this;
vectors[1].ToVec3() = v2;
vectors[2].ToVec3() = v1;
return *this;
}
//
@ -309,14 +309,14 @@ kexMatrix &kexMatrix::Transpose()
kexMatrix kexMatrix::Transpose(const kexMatrix &mtx)
{
kexMatrix out;
kexMatrix out;
out.vectors[0].ToVec3() = mtx.vectors[0].ToVec3();
out.vectors[1].ToVec3() = mtx.vectors[2].ToVec3();
out.vectors[2].ToVec3() = mtx.vectors[1].ToVec3();
out.vectors[3].ToVec3() = mtx.vectors[3].ToVec3();
out.vectors[0].ToVec3() = mtx.vectors[0].ToVec3();
out.vectors[1].ToVec3() = mtx.vectors[2].ToVec3();
out.vectors[2].ToVec3() = mtx.vectors[1].ToVec3();
out.vectors[3].ToVec3() = mtx.vectors[3].ToVec3();
return out;
return out;
}
//
@ -325,62 +325,62 @@ kexMatrix kexMatrix::Transpose(const kexMatrix &mtx)
kexMatrix kexMatrix::Invert(kexMatrix &mtx)
{
float d;
float *m;
float d;
float *m;
m = mtx.ToFloatPtr();
m = mtx.ToFloatPtr();
d = m[ 0] * m[10] * m[ 5] -
m[ 0] * m[ 9] * m[ 6] -
m[ 1] * m[ 4] * m[10] +
m[ 2] * m[ 4] * m[ 9] +
m[ 1] * m[ 6] * m[ 8] -
m[ 2] * m[ 5] * m[ 8];
d = m[0] * m[10] * m[5] -
m[0] * m[9] * m[6] -
m[1] * m[4] * m[10] +
m[2] * m[4] * m[9] +
m[1] * m[6] * m[8] -
m[2] * m[5] * m[8];
if(d != 0.0f)
{
kexMatrix inv;
if (d != 0.0f)
{
kexMatrix inv;
d = (1.0f / d);
d = (1.0f / d);
inv.vectors[0].x = ( m[10] * m[ 5] - m[ 9] * m[ 6]) * d;
inv.vectors[0].y = -((m[ 1] * m[10] - m[ 2] * m[ 9]) * d);
inv.vectors[0].z = ( m[ 1] * m[ 6] - m[ 2] * m[ 5]) * d;
inv.vectors[0].w = 0;
inv.vectors[1].x = ( m[ 6] * m[ 8] - m[ 4] * m[10]) * d;
inv.vectors[1].y = ( m[ 0] * m[10] - m[ 2] * m[ 8]) * d;
inv.vectors[1].z = -((m[ 0] * m[ 6] - m[ 2] * m[ 4]) * d);
inv.vectors[1].w = 0;
inv.vectors[2].x = -((m[ 5] * m[ 8] - m[ 4] * m[ 9]) * d);
inv.vectors[2].y = ( m[ 1] * m[ 8] - m[ 0] * m[ 9]) * d;
inv.vectors[2].z = -((m[ 1] * m[ 4] - m[ 0] * m[ 5]) * d);
inv.vectors[2].w = 0;
inv.vectors[3].x = (
( m[13] * m[10] - m[14] * m[ 9]) * m[ 4]
+ m[14] * m[ 5] * m[ 8]
- m[13] * m[ 6] * m[ 8]
- m[12] * m[10] * m[ 5]
+ m[12] * m[ 9] * m[ 6]) * d;
inv.vectors[3].y = (
m[ 0] * m[14] * m[ 9]
- m[ 0] * m[13] * m[10]
- m[14] * m[ 1] * m[ 8]
+ m[13] * m[ 2] * m[ 8]
+ m[12] * m[ 1] * m[10]
- m[12] * m[ 2] * m[ 9]) * d;
inv.vectors[3].z = -(
( m[ 0] * m[14] * m[ 5]
- m[ 0] * m[13] * m[ 6]
- m[14] * m[ 1] * m[ 4]
+ m[13] * m[ 2] * m[ 4]
+ m[12] * m[ 1] * m[ 6]
- m[12] * m[ 2] * m[ 5]) * d);
inv.vectors[3].w = 1.0f;
inv.vectors[0].x = (m[10] * m[5] - m[9] * m[6]) * d;
inv.vectors[0].y = -((m[1] * m[10] - m[2] * m[9]) * d);
inv.vectors[0].z = (m[1] * m[6] - m[2] * m[5]) * d;
inv.vectors[0].w = 0;
inv.vectors[1].x = (m[6] * m[8] - m[4] * m[10]) * d;
inv.vectors[1].y = (m[0] * m[10] - m[2] * m[8]) * d;
inv.vectors[1].z = -((m[0] * m[6] - m[2] * m[4]) * d);
inv.vectors[1].w = 0;
inv.vectors[2].x = -((m[5] * m[8] - m[4] * m[9]) * d);
inv.vectors[2].y = (m[1] * m[8] - m[0] * m[9]) * d;
inv.vectors[2].z = -((m[1] * m[4] - m[0] * m[5]) * d);
inv.vectors[2].w = 0;
inv.vectors[3].x = (
(m[13] * m[10] - m[14] * m[9]) * m[4]
+ m[14] * m[5] * m[8]
- m[13] * m[6] * m[8]
- m[12] * m[10] * m[5]
+ m[12] * m[9] * m[6]) * d;
inv.vectors[3].y = (
m[0] * m[14] * m[9]
- m[0] * m[13] * m[10]
- m[14] * m[1] * m[8]
+ m[13] * m[2] * m[8]
+ m[12] * m[1] * m[10]
- m[12] * m[2] * m[9]) * d;
inv.vectors[3].z = -(
(m[0] * m[14] * m[5]
- m[0] * m[13] * m[6]
- m[14] * m[1] * m[4]
+ m[13] * m[2] * m[4]
+ m[12] * m[1] * m[6]
- m[12] * m[2] * m[5]) * d);
inv.vectors[3].w = 1.0f;
return inv;
}
return inv;
}
return mtx;
return mtx;
}
//
@ -389,29 +389,29 @@ kexMatrix kexMatrix::Invert(kexMatrix &mtx)
void kexMatrix::SetViewProjection(float aspect, float fov, float zNear, float zFar)
{
float top = zNear * kexMath::Tan(fov * M_PI / 360.0f);
float bottom = -top;
float left = bottom * aspect;
float right = top * aspect;
float top = zNear * kexMath::Tan(fov * M_PI / 360.0f);
float bottom = -top;
float left = bottom * aspect;
float right = top * aspect;
vectors[0].x = (2 * zNear) / (right - left);
vectors[1].y = (2 * zNear) / (top - bottom);
vectors[3].z = -(2 * zFar * zNear) / (zFar - zNear);
vectors[0].x = (2 * zNear) / (right - left);
vectors[1].y = (2 * zNear) / (top - bottom);
vectors[3].z = -(2 * zFar * zNear) / (zFar - zNear);
vectors[2].x = (right + left) / (right - left);
vectors[2].y = (top + bottom) / (top - bottom);
vectors[2].z = -(zFar + zNear) / (zFar - zNear);
vectors[2].x = (right + left) / (right - left);
vectors[2].y = (top + bottom) / (top - bottom);
vectors[2].z = -(zFar + zNear) / (zFar - zNear);
vectors[0].y = 0;
vectors[0].z = 0;
vectors[0].w = 0;
vectors[1].x = 0;
vectors[1].w = 0;
vectors[1].z = 0;
vectors[2].w = -1;
vectors[3].x = 0;
vectors[3].y = 0;
vectors[3].w = 0;
vectors[0].y = 0;
vectors[0].z = 0;
vectors[0].w = 0;
vectors[1].x = 0;
vectors[1].w = 0;
vectors[1].z = 0;
vectors[2].w = -1;
vectors[3].x = 0;
vectors[3].y = 0;
vectors[3].w = 0;
}
//
@ -419,27 +419,27 @@ void kexMatrix::SetViewProjection(float aspect, float fov, float zNear, float zF
//
void kexMatrix::SetOrtho(float left, float right,
float bottom, float top,
float zNear, float zFar)
float bottom, float top,
float zNear, float zFar)
{
vectors[0].x = 2 / (right - left);
vectors[1].y = 2 / (top - bottom);
vectors[2].z = -2 / (zFar - zNear);
vectors[0].x = 2 / (right - left);
vectors[1].y = 2 / (top - bottom);
vectors[2].z = -2 / (zFar - zNear);
vectors[3].x = -(right + left) / (right - left);
vectors[3].y = -(top + bottom) / (top - bottom);
vectors[3].z = -(zFar + zNear) / (zFar - zNear);
vectors[3].w = 1;
vectors[3].x = -(right + left) / (right - left);
vectors[3].y = -(top + bottom) / (top - bottom);
vectors[3].z = -(zFar + zNear) / (zFar - zNear);
vectors[3].w = 1;
vectors[0].y = 0;
vectors[0].z = 0;
vectors[0].w = 0;
vectors[1].x = 0;
vectors[1].z = 0;
vectors[1].w = 0;
vectors[2].x = 0;
vectors[2].y = 0;
vectors[2].w = 0;
vectors[0].y = 0;
vectors[0].z = 0;
vectors[0].w = 0;
vectors[1].x = 0;
vectors[1].z = 0;
vectors[1].w = 0;
vectors[2].x = 0;
vectors[2].y = 0;
vectors[2].w = 0;
}
//
@ -448,61 +448,61 @@ void kexMatrix::SetOrtho(float left, float right,
kexQuat kexMatrix::ToQuat()
{
float t;
float d;
float mx;
float my;
float mz;
float m21;
float m20;
float m10;
kexQuat q;
float t;
float d;
float mx;
float my;
float mz;
float m21;
float m20;
float m10;
kexQuat q;
mx = vectors[0][0];
my = vectors[1][1];
mz = vectors[2][2];
mx = vectors[0][0];
my = vectors[1][1];
mz = vectors[2][2];
m21 = (vectors[2][1] - vectors[1][2]);
m20 = (vectors[2][0] - vectors[0][2]);
m10 = (vectors[1][0] - vectors[0][1]);
m21 = (vectors[2][1] - vectors[1][2]);
m20 = (vectors[2][0] - vectors[0][2]);
m10 = (vectors[1][0] - vectors[0][1]);
t = 1.0f + mx + my + mz;
t = 1.0f + mx + my + mz;
if(t > 0)
{
d = 0.5f / kexMath::Sqrt(t);
q.x = m21 * d;
q.y = m20 * d;
q.z = m10 * d;
q.w = 0.25f / d;
}
else if(mx > my && mx > mz)
{
d = kexMath::Sqrt(1.0f + mx - my - mz) * 2;
q.x = 0.5f / d;
q.y = m10 / d;
q.z = m20 / d;
q.w = m21 / d;
}
else if(my > mz)
{
d = kexMath::Sqrt(1.0f + my - mx - mz) * 2;
q.x = m10 / d;
q.y = 0.5f / d;
q.z = m21 / d;
q.w = m20 / d;
}
else
{
d = kexMath::Sqrt(1.0f + mz - mx - my) * 2;
q.x = m20 / d;
q.y = m21 / d;
q.z = 0.5f / d;
q.w = m10 / d;
}
if (t > 0)
{
d = 0.5f / kexMath::Sqrt(t);
q.x = m21 * d;
q.y = m20 * d;
q.z = m10 * d;
q.w = 0.25f / d;
}
else if (mx > my && mx > mz)
{
d = kexMath::Sqrt(1.0f + mx - my - mz) * 2;
q.x = 0.5f / d;
q.y = m10 / d;
q.z = m20 / d;
q.w = m21 / d;
}
else if (my > mz)
{
d = kexMath::Sqrt(1.0f + my - mx - mz) * 2;
q.x = m10 / d;
q.y = 0.5f / d;
q.z = m21 / d;
q.w = m20 / d;
}
else
{
d = kexMath::Sqrt(1.0f + mz - mx - my) * 2;
q.x = m20 / d;
q.y = m21 / d;
q.z = 0.5f / d;
q.w = m10 / d;
}
q.Normalize();
return q;
q.Normalize();
return q;
}
//
@ -511,13 +511,13 @@ kexQuat kexMatrix::ToQuat()
kexMatrix kexMatrix::operator*(const kexVec3 &vector)
{
kexMatrix out(*this);
kexMatrix out(*this);
out.vectors[3].ToVec3() +=
vectors[0].ToVec3() * vector.x +
vectors[1].ToVec3() * vector.y +
vectors[2].ToVec3() * vector.z;
return out;
out.vectors[3].ToVec3() +=
vectors[0].ToVec3() * vector.x +
vectors[1].ToVec3() * vector.y +
vectors[2].ToVec3() * vector.z;
return out;
}
//
@ -526,11 +526,11 @@ kexMatrix kexMatrix::operator*(const kexVec3 &vector)
kexMatrix &kexMatrix::operator*=(const kexVec3 &vector)
{
vectors[3].ToVec3() +=
vectors[0].ToVec3() * vector.x +
vectors[1].ToVec3() * vector.y +
vectors[2].ToVec3() * vector.z;
return *this;
vectors[3].ToVec3() +=
vectors[0].ToVec3() * vector.x +
vectors[1].ToVec3() * vector.y +
vectors[2].ToVec3() * vector.z;
return *this;
}
//
@ -539,7 +539,7 @@ kexMatrix &kexMatrix::operator*=(const kexVec3 &vector)
float *kexMatrix::ToFloatPtr()
{
return reinterpret_cast<float*>(vectors);
return reinterpret_cast<float*>(vectors);
}
//
@ -548,33 +548,33 @@ float *kexMatrix::ToFloatPtr()
kexMatrix kexMatrix::operator*(const kexMatrix &matrix)
{
kexMatrix out;
kexMatrix out;
for(int i = 0; i < 4; i++)
{
out.vectors[i].x =
vectors[i].x * matrix.vectors[0].x +
vectors[i].y * matrix.vectors[1].x +
vectors[i].z * matrix.vectors[2].x +
vectors[i].w * matrix.vectors[3].x;
out.vectors[i].y =
vectors[i].x * matrix.vectors[0].y +
vectors[i].y * matrix.vectors[1].y +
vectors[i].z * matrix.vectors[2].y +
vectors[i].w * matrix.vectors[3].y;
out.vectors[i].z =
vectors[i].x * matrix.vectors[0].z +
vectors[i].y * matrix.vectors[1].z +
vectors[i].z * matrix.vectors[2].z +
vectors[i].w * matrix.vectors[3].z;
out.vectors[i].w =
vectors[i].x * matrix.vectors[0].w +
vectors[i].y * matrix.vectors[1].w +
vectors[i].z * matrix.vectors[2].w +
vectors[i].w * matrix.vectors[3].w;
}
for (int i = 0; i < 4; i++)
{
out.vectors[i].x =
vectors[i].x * matrix.vectors[0].x +
vectors[i].y * matrix.vectors[1].x +
vectors[i].z * matrix.vectors[2].x +
vectors[i].w * matrix.vectors[3].x;
out.vectors[i].y =
vectors[i].x * matrix.vectors[0].y +
vectors[i].y * matrix.vectors[1].y +
vectors[i].z * matrix.vectors[2].y +
vectors[i].w * matrix.vectors[3].y;
out.vectors[i].z =
vectors[i].x * matrix.vectors[0].z +
vectors[i].y * matrix.vectors[1].z +
vectors[i].z * matrix.vectors[2].z +
vectors[i].w * matrix.vectors[3].z;
out.vectors[i].w =
vectors[i].x * matrix.vectors[0].w +
vectors[i].y * matrix.vectors[1].w +
vectors[i].z * matrix.vectors[2].w +
vectors[i].w * matrix.vectors[3].w;
}
return out;
return out;
}
//
@ -583,31 +583,31 @@ kexMatrix kexMatrix::operator*(const kexMatrix &matrix)
kexMatrix &kexMatrix::operator*=(const kexMatrix &matrix)
{
for(int i = 0; i < 4; i++)
{
vectors[i].x =
vectors[i].x * matrix.vectors[0].x +
vectors[i].y * matrix.vectors[1].x +
vectors[i].z * matrix.vectors[2].x +
vectors[i].w * matrix.vectors[3].x;
vectors[i].y =
vectors[i].x * matrix.vectors[0].y +
vectors[i].y * matrix.vectors[1].y +
vectors[i].z * matrix.vectors[2].y +
vectors[i].w * matrix.vectors[3].y;
vectors[i].z =
vectors[i].x * matrix.vectors[0].z +
vectors[i].y * matrix.vectors[1].z +
vectors[i].z * matrix.vectors[2].z +
vectors[i].w * matrix.vectors[3].z;
vectors[i].w =
vectors[i].x * matrix.vectors[0].w +
vectors[i].y * matrix.vectors[1].w +
vectors[i].z * matrix.vectors[2].w +
vectors[i].w * matrix.vectors[3].w;
}
for (int i = 0; i < 4; i++)
{
vectors[i].x =
vectors[i].x * matrix.vectors[0].x +
vectors[i].y * matrix.vectors[1].x +
vectors[i].z * matrix.vectors[2].x +
vectors[i].w * matrix.vectors[3].x;
vectors[i].y =
vectors[i].x * matrix.vectors[0].y +
vectors[i].y * matrix.vectors[1].y +
vectors[i].z * matrix.vectors[2].y +
vectors[i].w * matrix.vectors[3].y;
vectors[i].z =
vectors[i].x * matrix.vectors[0].z +
vectors[i].y * matrix.vectors[1].z +
vectors[i].z * matrix.vectors[2].z +
vectors[i].w * matrix.vectors[3].z;
vectors[i].w =
vectors[i].x * matrix.vectors[0].w +
vectors[i].y * matrix.vectors[1].w +
vectors[i].z * matrix.vectors[2].w +
vectors[i].w * matrix.vectors[3].w;
}
return *this;
return *this;
}
//
@ -616,33 +616,33 @@ kexMatrix &kexMatrix::operator*=(const kexMatrix &matrix)
kexMatrix operator*(const kexMatrix &m1, const kexMatrix &m2)
{
kexMatrix out;
kexMatrix out;
for(int i = 0; i < 4; i++)
{
out.vectors[i].x =
m1.vectors[i].x * m2.vectors[0].x +
m1.vectors[i].y * m2.vectors[1].x +
m1.vectors[i].z * m2.vectors[2].x +
m1.vectors[i].w * m2.vectors[3].x;
out.vectors[i].y =
m1.vectors[i].x * m2.vectors[0].y +
m1.vectors[i].y * m2.vectors[1].y +
m1.vectors[i].z * m2.vectors[2].y +
m1.vectors[i].w * m2.vectors[3].y;
out.vectors[i].z =
m1.vectors[i].x * m2.vectors[0].z +
m1.vectors[i].y * m2.vectors[1].z +
m1.vectors[i].z * m2.vectors[2].z +
m1.vectors[i].w * m2.vectors[3].z;
out.vectors[i].w =
m1.vectors[i].x * m2.vectors[0].w +
m1.vectors[i].y * m2.vectors[1].w +
m1.vectors[i].z * m2.vectors[2].w +
m1.vectors[i].w * m2.vectors[3].w;
}
for (int i = 0; i < 4; i++)
{
out.vectors[i].x =
m1.vectors[i].x * m2.vectors[0].x +
m1.vectors[i].y * m2.vectors[1].x +
m1.vectors[i].z * m2.vectors[2].x +
m1.vectors[i].w * m2.vectors[3].x;
out.vectors[i].y =
m1.vectors[i].x * m2.vectors[0].y +
m1.vectors[i].y * m2.vectors[1].y +
m1.vectors[i].z * m2.vectors[2].y +
m1.vectors[i].w * m2.vectors[3].y;
out.vectors[i].z =
m1.vectors[i].x * m2.vectors[0].z +
m1.vectors[i].y * m2.vectors[1].z +
m1.vectors[i].z * m2.vectors[2].z +
m1.vectors[i].w * m2.vectors[3].z;
out.vectors[i].w =
m1.vectors[i].x * m2.vectors[0].w +
m1.vectors[i].y * m2.vectors[1].w +
m1.vectors[i].z * m2.vectors[2].w +
m1.vectors[i].w * m2.vectors[3].w;
}
return out;
return out;
}
//
@ -651,38 +651,38 @@ kexMatrix operator*(const kexMatrix &m1, const kexMatrix &m2)
kexMatrix kexMatrix::operator|(const kexMatrix &matrix)
{
kexMatrix out;
kexMatrix out;
for(int i = 0; i < 3; i++)
{
out.vectors[i].x =
vectors[i].x * matrix.vectors[0].x +
vectors[i].y * matrix.vectors[1].x +
vectors[i].z * matrix.vectors[2].x;
out.vectors[i].y =
vectors[i].x * matrix.vectors[0].y +
vectors[i].y * matrix.vectors[1].y +
vectors[i].z * matrix.vectors[2].y;
out.vectors[i].z =
vectors[i].x * matrix.vectors[0].z +
vectors[i].y * matrix.vectors[1].z +
vectors[i].z * matrix.vectors[2].z;
}
for (int i = 0; i < 3; i++)
{
out.vectors[i].x =
vectors[i].x * matrix.vectors[0].x +
vectors[i].y * matrix.vectors[1].x +
vectors[i].z * matrix.vectors[2].x;
out.vectors[i].y =
vectors[i].x * matrix.vectors[0].y +
vectors[i].y * matrix.vectors[1].y +
vectors[i].z * matrix.vectors[2].y;
out.vectors[i].z =
vectors[i].x * matrix.vectors[0].z +
vectors[i].y * matrix.vectors[1].z +
vectors[i].z * matrix.vectors[2].z;
}
out.vectors[3].x =
vectors[3].x * matrix.vectors[0].x +
vectors[3].y * matrix.vectors[1].x +
vectors[3].z * matrix.vectors[2].x + matrix.vectors[3].x;
out.vectors[3].y =
vectors[3].x * matrix.vectors[0].y +
vectors[3].y * matrix.vectors[1].y +
vectors[3].z * matrix.vectors[2].y + matrix.vectors[3].y;
out.vectors[3].z =
vectors[3].x * matrix.vectors[0].z +
vectors[3].y * matrix.vectors[1].z +
vectors[3].z * matrix.vectors[2].z + matrix.vectors[3].z;
out.vectors[3].x =
vectors[3].x * matrix.vectors[0].x +
vectors[3].y * matrix.vectors[1].x +
vectors[3].z * matrix.vectors[2].x + matrix.vectors[3].x;
out.vectors[3].y =
vectors[3].x * matrix.vectors[0].y +
vectors[3].y * matrix.vectors[1].y +
vectors[3].z * matrix.vectors[2].y + matrix.vectors[3].y;
out.vectors[3].z =
vectors[3].x * matrix.vectors[0].z +
vectors[3].y * matrix.vectors[1].z +
vectors[3].z * matrix.vectors[2].z + matrix.vectors[3].z;
return out;
return out;
}
//
@ -691,12 +691,12 @@ kexMatrix kexMatrix::operator|(const kexMatrix &matrix)
kexMatrix &kexMatrix::operator=(const kexMatrix &matrix)
{
vectors[0] = matrix.vectors[0];
vectors[1] = matrix.vectors[1];
vectors[2] = matrix.vectors[2];
vectors[3] = matrix.vectors[3];
vectors[0] = matrix.vectors[0];
vectors[1] = matrix.vectors[1];
vectors[2] = matrix.vectors[2];
vectors[3] = matrix.vectors[3];
return *this;
return *this;
}
//
@ -705,13 +705,13 @@ kexMatrix &kexMatrix::operator=(const kexMatrix &matrix)
kexMatrix &kexMatrix::operator=(const float *m)
{
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 4; j++)
{
vectors[i][j] = m[i * 4 + j];
}
}
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
vectors[i][j] = m[i * 4 + j];
}
}
return *this;
return *this;
}

120
src/lightmap/kexlib/math/plane.cpp
View file

@ -39,10 +39,10 @@
kexPlane::kexPlane()
{
this->a = 0;
this->b = 0;
this->c = 0;
this->d = 0;
this->a = 0;
this->b = 0;
this->c = 0;
this->d = 0;
}
//
@ -51,10 +51,10 @@ kexPlane::kexPlane()
kexPlane::kexPlane(const float a, const float b, const float c, const float d)
{
this->a = a;
this->b = b;
this->c = c;
this->d = d;
this->a = a;
this->b = b;
this->c = c;
this->d = d;
}
//
@ -63,8 +63,8 @@ kexPlane::kexPlane(const float a, const float b, const float c, const float d)
kexPlane::kexPlane(const kexVec3 &pt1, const kexVec3 &pt2, const kexVec3 &pt3)
{
SetNormal(pt1, pt2, pt3);
this->d = kexVec3::Dot(pt1, Normal());
SetNormal(pt1, pt2, pt3);
this->d = kexVec3::Dot(pt1, Normal());
}
//
@ -73,10 +73,10 @@ kexPlane::kexPlane(const kexVec3 &pt1, const kexVec3 &pt2, const kexVec3 &pt3)
kexPlane::kexPlane(const kexVec3 &normal, const kexVec3 &point)
{
this->a = normal.x;
this->b = normal.y;
this->c = normal.z;
this->d = point.Dot(normal);
this->a = normal.x;
this->b = normal.y;
this->c = normal.z;
this->d = point.Dot(normal);
}
//
@ -85,10 +85,10 @@ kexPlane::kexPlane(const kexVec3 &normal, const kexVec3 &point)
kexPlane::kexPlane(const kexPlane &plane)
{
this->a = plane.a;
this->b = plane.b;
this->c = plane.c;
this->d = plane.d;
this->a = plane.a;
this->b = plane.b;
this->c = plane.c;
this->d = plane.d;
}
//
@ -97,8 +97,8 @@ kexPlane::kexPlane(const kexPlane &plane)
kexPlane &kexPlane::SetNormal(const kexVec3 &normal)
{
Normal() = normal;
return *this;
Normal() = normal;
return *this;
}
//
@ -107,8 +107,8 @@ kexPlane &kexPlane::SetNormal(const kexVec3 &normal)
kexPlane &kexPlane::SetNormal(const kexVec3 &pt1, const kexVec3 &pt2, const kexVec3 &pt3)
{
Normal() = (pt2 - pt1).Cross(pt3 - pt2).Normalize();
return *this;
Normal() = (pt2 - pt1).Cross(pt3 - pt2).Normalize();
return *this;
}
//
@ -117,7 +117,7 @@ kexPlane &kexPlane::SetNormal(const kexVec3 &pt1, const kexVec3 &pt2, const kexV
kexVec3 const &kexPlane::Normal() const
{
return *reinterpret_cast<const kexVec3*>(&a);
return *reinterpret_cast<const kexVec3*>(&a);
}
//
@ -126,7 +126,7 @@ kexVec3 const &kexPlane::Normal() const
kexVec3 &kexPlane::Normal()
{
return *reinterpret_cast<kexVec3*>(&a);
return *reinterpret_cast<kexVec3*>(&a);
}
//
@ -135,7 +135,7 @@ kexVec3 &kexPlane::Normal()
float kexPlane::Distance(const kexVec3 &point)
{
return point.Dot(Normal());
return point.Dot(Normal());
}
//
@ -144,8 +144,8 @@ float kexPlane::Distance(const kexVec3 &point)
kexPlane &kexPlane::SetDistance(const kexVec3 &point)
{
this->d = point.Dot(Normal());
return *this;
this->d = point.Dot(Normal());
return *this;
}
//
@ -154,7 +154,7 @@ kexPlane &kexPlane::SetDistance(const kexVec3 &point)
bool kexPlane::IsFacing(const float yaw)
{
return -kexMath::Sin(yaw) * a + -kexMath::Cos(yaw) * b < 0;
return -kexMath::Sin(yaw) * a + -kexMath::Cos(yaw) * b < 0;
}
//
@ -163,21 +163,21 @@ bool kexPlane::IsFacing(const float yaw)
float kexPlane::ToYaw()
{
float d = Normal().Unit();
float d = Normal().Unit();
if(d != 0)
{
float phi;
phi = kexMath::ACos(b / d);
if(a <= 0)
{
phi = -phi;
}
if (d != 0)
{
float phi;
phi = kexMath::ACos(b / d);
if (a <= 0)
{
phi = -phi;
}
return phi;
}
return phi;
}
return 0;
return 0;
}
//
@ -186,7 +186,7 @@ float kexPlane::ToYaw()
float kexPlane::ToPitch()
{
return kexMath::ACos(kexVec3::vecUp.Dot(Normal()));
return kexMath::ACos(kexVec3::vecUp.Dot(Normal()));
}
//
@ -195,8 +195,8 @@ float kexPlane::ToPitch()
kexQuat kexPlane::ToQuat()
{
kexVec3 cross = kexVec3::vecUp.Cross(Normal()).Normalize();
return kexQuat(kexMath::ACos(kexVec3::vecUp.Dot(Normal())), cross);
kexVec3 cross = kexVec3::vecUp.Cross(Normal()).Normalize();
return kexQuat(kexMath::ACos(kexVec3::vecUp.Dot(Normal())), cross);
}
//
@ -205,7 +205,7 @@ kexQuat kexPlane::ToQuat()
kexVec4 const &kexPlane::ToVec4() const
{
return *reinterpret_cast<const kexVec4*>(&a);
return *reinterpret_cast<const kexVec4*>(&a);
}
//
@ -214,7 +214,7 @@ kexVec4 const &kexPlane::ToVec4() const
kexVec4 &kexPlane::ToVec4()
{
return *reinterpret_cast<kexVec4*>(&a);
return *reinterpret_cast<kexVec4*>(&a);
}
//
@ -223,21 +223,21 @@ kexVec4 &kexPlane::ToVec4()
const kexPlane::planeAxis_t kexPlane::BestAxis() const
{
float na = kexMath::Fabs(a);
float nb = kexMath::Fabs(b);
float nc = kexMath::Fabs(c);
float na = kexMath::Fabs(a);
float nb = kexMath::Fabs(b);
float nc = kexMath::Fabs(c);
// figure out what axis the plane lies on
if(na >= nb && na >= nc)
{
return AXIS_YZ;
}
else if(nb >= na && nb >= nc)
{
return AXIS_XZ;
}
// figure out what axis the plane lies on
if (na >= nb && na >= nc)
{
return AXIS_YZ;
}
else if (nb >= na && nb >= nc)
{
return AXIS_XZ;
}
return AXIS_XY;
return AXIS_XY;
}
//
@ -246,6 +246,6 @@ const kexPlane::planeAxis_t kexPlane::BestAxis() const
kexVec3 kexPlane::GetInclination()
{
kexVec3 dir = Normal() * kexVec3::vecUp.Dot(Normal());
return (kexVec3::vecUp - dir).Normalize();
kexVec3 dir = Normal() * kexVec3::vecUp.Dot(Normal());
return (kexVec3::vecUp - dir).Normalize();
}

44
src/lightmap/kexlib/math/pluecker.cpp
View file

@ -40,7 +40,7 @@
kexPluecker::kexPluecker()
{
Clear();
Clear();
}
//
@ -49,7 +49,7 @@ kexPluecker::kexPluecker()
kexPluecker::kexPluecker(const kexVec3 &start, const kexVec3 &end, bool bRay)
{
bRay ? SetRay(start, end) : SetLine(start, end);
bRay ? SetRay(start, end) : SetLine(start, end);
}
//
@ -58,7 +58,7 @@ kexPluecker::kexPluecker(const kexVec3 &start, const kexVec3 &end, bool bRay)
void kexPluecker::Clear()
{
p[0] = p[1] = p[2] = p[3] = p[4] = p[5] = 0;
p[0] = p[1] = p[2] = p[3] = p[4] = p[5] = 0;
}
//
@ -67,13 +67,13 @@ void kexPluecker::Clear()
void kexPluecker::SetLine(const kexVec3 &start, const kexVec3 &end)
{
p[0] = start.x * end.y - end.x * start.y;
p[1] = start.x * end.z - end.x * start.z;
p[3] = start.y * end.z - end.y * start.z;
p[0] = start.x * end.y - end.x * start.y;
p[1] = start.x * end.z - end.x * start.z;
p[3] = start.y * end.z - end.y * start.z;
p[2] = start.x - end.x;
p[5] = end.y - start.y;
p[4] = start.z - end.z;
p[2] = start.x - end.x;
p[5] = end.y - start.y;
p[4] = start.z - end.z;
}
//
@ -82,13 +82,13 @@ void kexPluecker::SetLine(const kexVec3 &start, const kexVec3 &end)
void kexPluecker::SetRay(const kexVec3 &start, const kexVec3 &dir)
{
p[0] = start.x * dir.y - dir.x * start.y;
p[1] = start.x * dir.z - dir.x * start.z;
p[3] = start.y * dir.z - dir.y * start.z;
p[0] = start.x * dir.y - dir.x * start.y;
p[1] = start.x * dir.z - dir.x * start.z;
p[3] = start.y * dir.z - dir.y * start.z;
p[2] = -dir.x;
p[5] = dir.y;
p[4] = -dir.z;
p[2] = -dir.x;
p[5] = dir.y;
p[4] = -dir.z;
}
//
@ -97,11 +97,11 @@ void kexPluecker::SetRay(const kexVec3 &start, const kexVec3 &dir)
float kexPluecker::InnerProduct(const kexPluecker &pluecker) const
{
return
p[0] * pluecker.p[4] +
p[1] * pluecker.p[5] +
p[2] * pluecker.p[3] +
p[4] * pluecker.p[0] +
p[5] * pluecker.p[1] +
p[3] * pluecker.p[2];
return
p[0] * pluecker.p[4] +
p[1] * pluecker.p[5] +
p[2] * pluecker.p[3] +
p[4] * pluecker.p[0] +
p[5] * pluecker.p[1] +
p[3] * pluecker.p[2];
}

354
src/lightmap/kexlib/math/quaternion.cpp
View file

@ -39,7 +39,7 @@
kexQuat::kexQuat()
{
Clear();
Clear();
}
//
@ -48,13 +48,13 @@ kexQuat::kexQuat()
kexQuat::kexQuat(const float angle, const float x, const float y, const float z)
{
float s = kexMath::Sin(angle * 0.5f);
float c = kexMath::Cos(angle * 0.5f);
float s = kexMath::Sin(angle * 0.5f);
float c = kexMath::Cos(angle * 0.5f);
this->x = x * s;
this->y = y * s;
this->z = z * s;
this->w = c;
this->x = x * s;
this->y = y * s;
this->z = z * s;
this->w = c;
}
//
@ -63,13 +63,13 @@ kexQuat::kexQuat(const float angle, const float x, const float y, const float z)
kexQuat::kexQuat(const float angle, kexVec3 &vector)
{
float s = kexMath::Sin(angle * 0.5f);
float c = kexMath::Cos(angle * 0.5f);
float s = kexMath::Sin(angle * 0.5f);
float c = kexMath::Cos(angle * 0.5f);
this->x = vector.x * s;
this->y = vector.y * s;
this->z = vector.z * s;
this->w = c;
this->x = vector.x * s;
this->y = vector.y * s;
this->z = vector.z * s;
this->w = c;
}
//
@ -78,13 +78,13 @@ kexQuat::kexQuat(const float angle, kexVec3 &vector)
kexQuat::kexQuat(const float angle, const kexVec3 &vector)
{
float s = kexMath::Sin(angle * 0.5f);
float c = kexMath::Cos(angle * 0.5f);
float s = kexMath::Sin(angle * 0.5f);
float c = kexMath::Cos(angle * 0.5f);
this->x = vector.x * s;
this->y = vector.y * s;
this->z = vector.z * s;
this->w = c;
this->x = vector.x * s;
this->y = vector.y * s;
this->z = vector.z * s;
this->w = c;
}
//
@ -93,10 +93,10 @@ kexQuat::kexQuat(const float angle, const kexVec3 &vector)
void kexQuat::Set(const float x, const float y, const float z, const float w)
{
this->x = x;
this->y = y;
this->z = z;
this->w = w;
this->x = x;
this->y = y;
this->z = z;
this->w = w;
}
//
@ -105,8 +105,8 @@ void kexQuat::Set(const float x, const float y, const float z, const float w)
void kexQuat::Clear()
{
x = y = z = 0.0f;
w = 1.0f;
x = y = z = 0.0f;
w = 1.0f;
}
//
@ -115,7 +115,7 @@ void kexQuat::Clear()
float kexQuat::UnitSq() const
{
return x * x + y * y + z * z + w * w;
return x * x + y * y + z * z + w * w;
}
//
@ -124,7 +124,7 @@ float kexQuat::UnitSq() const
float kexQuat::Unit() const
{
return kexMath::Sqrt(UnitSq());
return kexMath::Sqrt(UnitSq());
}
//
@ -133,13 +133,13 @@ float kexQuat::Unit() const
kexQuat &kexQuat::Normalize()
{
float d = Unit();
if(d != 0.0f)
{
d = 1.0f / d;
*this *= d;
}
return *this;
float d = Unit();
if (d != 0.0f)
{
d = 1.0f / d;
*this *= d;
}
return *this;
}
//
@ -148,9 +148,9 @@ kexQuat &kexQuat::Normalize()
kexQuat kexQuat::Inverse() const
{
kexQuat out;
out.Set(-x, -y, -z, -w);
return out;
kexQuat out;
out.Set(-x, -y, -z, -w);
return out;
}
//
@ -159,12 +159,12 @@ kexQuat kexQuat::Inverse() const
kexQuat kexQuat::operator+(const kexQuat &quat)
{
kexQuat out;
out.x = x + quat.x;
out.y = y + quat.y;
out.z = z + quat.z;
out.w = w + quat.w;
return out;
kexQuat out;
out.x = x + quat.x;
out.y = y + quat.y;
out.z = z + quat.z;
out.w = w + quat.w;
return out;
}
//
@ -173,11 +173,11 @@ kexQuat kexQuat::operator+(const kexQuat &quat)
kexQuat &kexQuat::operator+=(const kexQuat &quat)
{
x += quat.x;
y += quat.y;
z += quat.z;
w += quat.w;
return *this;
x += quat.x;
y += quat.y;
z += quat.z;
w += quat.w;
return *this;
}
//
@ -186,12 +186,12 @@ kexQuat &kexQuat::operator+=(const kexQuat &quat)
kexQuat kexQuat::operator-(const kexQuat &quat)
{
kexQuat out;
out.x = x - quat.x;
out.y = y - quat.y;
out.z = z - quat.z;
out.w = w - quat.w;
return out;
kexQuat out;
out.x = x - quat.x;
out.y = y - quat.y;
out.z = z - quat.z;
out.w = w - quat.w;
return out;
}
//
@ -200,11 +200,11 @@ kexQuat kexQuat::operator-(const kexQuat &quat)
kexQuat &kexQuat::operator-=(const kexQuat &quat)
{
x -= quat.x;
y -= quat.y;
z -= quat.z;
w -= quat.w;
return *this;
x -= quat.x;
y -= quat.y;
z -= quat.z;
w -= quat.w;
return *this;
}
//
@ -213,14 +213,14 @@ kexQuat &kexQuat::operator-=(const kexQuat &quat)
kexQuat kexQuat::operator*(const kexQuat &quat)
{
kexQuat out;
kexQuat out;
out.x = x * quat.w - y * quat.z + quat.x * w + quat.y * z;
out.y = x * quat.z + y * quat.w - quat.x * z + w * quat.y;
out.z = quat.x * y + w * quat.z + z * quat.w - x * quat.y;
out.w = w * quat.w - quat.y * y + z * quat.z + quat.x * x;
out.x = x * quat.w - y * quat.z + quat.x * w + quat.y * z;
out.y = x * quat.z + y * quat.w - quat.x * z + w * quat.y;
out.z = quat.x * y + w * quat.z + z * quat.w - x * quat.y;
out.w = w * quat.w - quat.y * y + z * quat.z + quat.x * x;
return out;
return out;
}
//
@ -229,17 +229,17 @@ kexQuat kexQuat::operator*(const kexQuat &quat)
kexQuat &kexQuat::operator*=(const kexQuat &quat)
{
float tx = x;
float ty = y;
float tz = z;
float tw = w;
float tx = x;
float ty = y;
float tz = z;
float tw = w;
x = tx * quat.w - ty * quat.z + quat.x * tw + quat.y * z;
y = tx * quat.z + ty * quat.w - quat.x * tz + tw * quat.y;
z = quat.x * ty + tw * quat.z + tz * quat.w - tx * quat.y;
w = tw * quat.w - quat.y * ty + tz * quat.z + quat.x * x;
x = tx * quat.w - ty * quat.z + quat.x * tw + quat.y * z;
y = tx * quat.z + ty * quat.w - quat.x * tz + tw * quat.y;
z = quat.x * ty + tw * quat.z + tz * quat.w - tx * quat.y;
w = tw * quat.w - quat.y * ty + tz * quat.z + quat.x * x;
return *this;
return *this;
}
//
@ -248,12 +248,12 @@ kexQuat &kexQuat::operator*=(const kexQuat &quat)
kexQuat kexQuat::operator*(const float val) const
{
kexQuat out;
out.x = x * val;
out.y = y * val;
out.z = z * val;
out.w = w * val;
return out;
kexQuat out;
out.x = x * val;
out.y = y * val;
out.z = z * val;
out.w = w * val;
return out;
}
//
@ -262,12 +262,12 @@ kexQuat kexQuat::operator*(const float val) const
kexQuat &kexQuat::operator*=(const float val)
{
x *= val;
y *= val;
z *= val;
w *= val;
x *= val;
y *= val;
z *= val;
w *= val;
return *this;
return *this;
}
//
@ -276,28 +276,28 @@ kexQuat &kexQuat::operator*=(const float val)
kexVec3 kexQuat::operator|(const kexVec3 &vector)
{
float xx = x * x;
float yx = y * x;
float zx = z * x;
float wx = w * x;
float yy = y * y;
float zy = z * y;
float wy = w * y;
float zz = z * z;
float wz = w * z;
float ww = w * w;
float xx = x * x;
float yx = y * x;
float zx = z * x;
float wx = w * x;
float yy = y * y;
float zy = z * y;
float wy = w * y;
float zz = z * z;
float wz = w * z;
float ww = w * w;
return kexVec3(
((yx + yx) - (wz + wz)) * vector.y +
((wy + wy + zx + zx)) * vector.z +
(((ww + xx) - yy) - zz) * vector.x,
((yy + (ww - xx)) - zz) * vector.y +
((zy + zy) - (wx + wx)) * vector.z +
((wz + wz) + (yx + yx)) * vector.x,
((wx + wx) + (zy + zy)) * vector.y +
(((ww - xx) - yy) + zz) * vector.z +
((zx + zx) - (wy + wy)) * vector.x
);
return kexVec3(
((yx + yx) - (wz + wz)) * vector.y +
((wy + wy + zx + zx)) * vector.z +
(((ww + xx) - yy) - zz) * vector.x,
((yy + (ww - xx)) - zz) * vector.y +
((zy + zy) - (wx + wx)) * vector.z +
((wz + wz) + (yx + yx)) * vector.x,
((wx + wx) + (zy + zy)) * vector.y +
(((ww - xx) - yy) + zz) * vector.z +
((zx + zx) - (wy + wy)) * vector.x
);
}
//
@ -306,7 +306,7 @@ kexVec3 kexQuat::operator|(const kexVec3 &vector)
float kexQuat::Dot(const kexQuat &quat) const
{
return (x * quat.x + y * quat.y + z * quat.z + w * quat.w);
return (x * quat.x + y * quat.y + z * quat.z + w * quat.w);
}
//
@ -315,51 +315,51 @@ float kexQuat::Dot(const kexQuat &quat) const
kexQuat kexQuat::Slerp(const kexQuat &quat, float movement) const
{
kexQuat rdest = quat;
float d1 = Dot(quat);
float d2 = Dot(quat.Inverse());
kexQuat rdest = quat;
float d1 = Dot(quat);
float d2 = Dot(quat.Inverse());
if(d1 < d2)
{
rdest = quat.Inverse();
d1 = d2;
}
if (d1 < d2)
{
rdest = quat.Inverse();
d1 = d2;
}
if(d1 <= 0.7071067811865001f)
{
float halfcos = kexMath::ACos(d1);
float halfsin = kexMath::Sin(halfcos);
if (d1 <= 0.7071067811865001f)
{
float halfcos = kexMath::ACos(d1);
float halfsin = kexMath::Sin(halfcos);
if(halfsin == 0)
{
kexQuat out;
out.Set(x, y, z, w);
return out;
}
else
{
float d;
float ms1;
float ms2;
if (halfsin == 0)
{
kexQuat out;
out.Set(x, y, z, w);
return out;
}
else
{
float d;
float ms1;
float ms2;
d = 1.0f / halfsin;
ms1 = kexMath::Sin((1.0f - movement) * halfcos) * d;
ms2 = kexMath::Sin(halfcos * movement) * d;
d = 1.0f / halfsin;
ms1 = kexMath::Sin((1.0f - movement) * halfcos) * d;
ms2 = kexMath::Sin(halfcos * movement) * d;
if(ms2 < 0)
{
rdest = quat.Inverse();
}
if (ms2 < 0)
{
rdest = quat.Inverse();
}
return *this * ms1 + rdest * ms2;
}
}
else
{
kexQuat out = (rdest - *this) * movement + *this;
out.Normalize();
return out;
}
return *this * ms1 + rdest * ms2;
}
}
else
{
kexQuat out = (rdest - *this) * movement + *this;
out.Normalize();
return out;
}
}
//
@ -368,24 +368,24 @@ kexQuat kexQuat::Slerp(const kexQuat &quat, float movement) const
kexQuat kexQuat::RotateFrom(const kexVec3 &location, const kexVec3 &target, float maxAngle)
{
kexVec3 axis;
kexVec3 dir;
kexVec3 cp;
kexQuat prot;
float an;
kexVec3 axis;
kexVec3 dir;
kexVec3 cp;
kexQuat prot;
float an;
dir = (*this | kexVec3::vecForward);
axis = (target - location).Normalize();
cp = dir.Cross(axis).Normalize();
dir = (*this | kexVec3::vecForward);
axis = (target - location).Normalize();
cp = dir.Cross(axis).Normalize();
an = kexMath::ACos(axis.Dot(dir));
an = kexMath::ACos(axis.Dot(dir));
if(maxAngle != 0 && an >= maxAngle)
{
an = maxAngle;
}
if (maxAngle != 0 && an >= maxAngle)
{
an = maxAngle;
}
return (*this * kexQuat(an, cp));
return (*this * kexQuat(an, cp));
}
//
@ -394,11 +394,11 @@ kexQuat kexQuat::RotateFrom(const kexVec3 &location, const kexVec3 &target, floa
kexQuat &kexQuat::operator=(const kexQuat &quat)
{
x = quat.x;
y = quat.y;
z = quat.z;
w = quat.w;
return *this;
x = quat.x;
y = quat.y;
z = quat.z;
w = quat.w;
return *this;
}
//
@ -407,11 +407,11 @@ kexQuat &kexQuat::operator=(const kexQuat &quat)
kexQuat &kexQuat::operator=(const kexVec4 &vec)
{
x = vec.x;
y = vec.y;
z = vec.z;
w = vec.w;
return *this;
x = vec.x;
y = vec.y;
z = vec.z;
w = vec.w;
return *this;
}
//
@ -420,11 +420,11 @@ kexQuat &kexQuat::operator=(const kexVec4 &vec)
kexQuat &kexQuat::operator=(const float *vecs)
{
x = vecs[0];
y = vecs[1];
z = vecs[2];
w = vecs[3];
return *this;
x = vecs[0];
y = vecs[1];
z = vecs[2];
w = vecs[3];
return *this;
}
//
@ -433,7 +433,7 @@ kexQuat &kexQuat::operator=(const float *vecs)
kexVec3 const &kexQuat::ToVec3() const
{
return *reinterpret_cast<const kexVec3*>(this);
return *reinterpret_cast<const kexVec3*>(this);
}
//
@ -442,5 +442,5 @@ kexVec3 const &kexQuat::ToVec3() const
kexVec3 &kexQuat::ToVec3()
{
return *reinterpret_cast<kexVec3*>(this);
return *reinterpret_cast<kexVec3*>(this);
}

22
src/lightmap/kexlib/math/random.cpp
View file

@ -43,7 +43,7 @@ int kexRand::seed = 0;
void kexRand::SetSeed(const int randSeed)
{
seed = randSeed;
seed = randSeed;
}
//
@ -52,7 +52,7 @@ void kexRand::SetSeed(const int randSeed)
int kexRand::SysRand()
{
return rand();
return rand();
}
//
@ -61,8 +61,8 @@ int kexRand::SysRand()
int kexRand::Int()
{
seed = 1479838765 - 1471521965 * seed;
return seed & RANDOM_MAX;
seed = 1479838765 - 1471521965 * seed;
return seed & RANDOM_MAX;
}
//
@ -71,12 +71,12 @@ int kexRand::Int()
int kexRand::Max(const int max)
{
if(max == 0)
{
return 0;
}
if (max == 0)
{
return 0;
}
return Int() % max;
return Int() % max;
}
//
@ -85,7 +85,7 @@ int kexRand::Max(const int max)
float kexRand::Float()
{
return (float)Max(RANDOM_MAX+1) / ((float)RANDOM_MAX+1);
return (float)Max(RANDOM_MAX + 1) / ((float)RANDOM_MAX + 1);
}
//
@ -94,6 +94,6 @@ float kexRand::Float()
float kexRand::CFloat()
{
return (float)(Max(20000) - 10000) * 0.0001f;
return (float)(Max(20000) - 10000) * 0.0001f;
}

620
src/lightmap/kexlib/math/vector.cpp
View file

File diff suppressed because it is too large Load diff

350
src/lightmap/kexlib/memheap.cpp
View file

@ -51,40 +51,40 @@ kexHeapBlock hb_object("object", false, NULL, NULL);
//
kexHeapBlock::kexHeapBlock(const char *name, bool bGarbageCollect,
blockFunc_t funcFree, blockFunc_t funcGC)
blockFunc_t funcFree, blockFunc_t funcGC)
{
this->name = (char*)name;
this->freeFunc = funcFree;
this->gcFunc = funcGC;
this->blocks = NULL;
this->bGC = bGarbageCollect;
this->purgeID = kexHeap::numHeapBlocks++;
this->name = (char*)name;
this->freeFunc = funcFree;
this->gcFunc = funcGC;
this->blocks = NULL;
this->bGC = bGarbageCollect;
this->purgeID = kexHeap::numHeapBlocks++;
// add heap block to main block list
if(kexHeap::blockList)
{
if(kexHeap::blockList->prev)
{
kexHeap::blockList->prev->next = this;
this->prev = kexHeap::blockList->prev;
this->next = NULL;
kexHeap::blockList->prev = this;
}
else
{
kexHeap::blockList->prev = this;
kexHeap::blockList->next = this;
this->prev = kexHeap::blockList;
this->next = NULL;
}
// add heap block to main block list
if (kexHeap::blockList)
{
if (kexHeap::blockList->prev)
{
kexHeap::blockList->prev->next = this;
this->prev = kexHeap::blockList->prev;
this->next = NULL;
kexHeap::blockList->prev = this;
}
else
{
kexHeap::blockList->prev = this;
kexHeap::blockList->next = this;
this->prev = kexHeap::blockList;
this->next = NULL;
}
}
else
{
kexHeap::blockList = this;
this->prev = NULL;
this->next = NULL;
}
}
else
{
kexHeap::blockList = this;
this->prev = NULL;
this->next = NULL;
}
}
//
@ -103,26 +103,26 @@ kexHeapBlock::~kexHeapBlock()
kexHeapBlock *kexHeapBlock::operator[](int index)
{
if(kexHeap::currentHeapBlockID == index)
{
return kexHeap::currentHeapBlock;
}
if (kexHeap::currentHeapBlockID == index)
{
return kexHeap::currentHeapBlock;
}
kexHeapBlock *heapBlock = this;
kexHeapBlock *heapBlock = this;
for(int i = 0; i < index; i++)
{
heapBlock = heapBlock->next;
if(heapBlock == NULL)
{
return NULL;
}
}
for (int i = 0; i < index; i++)
{
heapBlock = heapBlock->next;
if (heapBlock == NULL)
{
return NULL;
}
}
kexHeap::currentHeapBlockID = index;
kexHeap::currentHeapBlock = heapBlock;
kexHeap::currentHeapBlockID = index;
kexHeap::currentHeapBlock = heapBlock;
return heapBlock;
return heapBlock;
}
//
@ -131,16 +131,16 @@ kexHeapBlock *kexHeapBlock::operator[](int index)
void kexHeap::AddBlock(memBlock *block, kexHeapBlock *heapBlock)
{
block->prev = NULL;
block->next = heapBlock->blocks;
heapBlock->blocks = block;
block->prev = NULL;
block->next = heapBlock->blocks;
heapBlock->blocks = block;
block->heapBlock = heapBlock;
block->heapBlock = heapBlock;
if(block->next != NULL)
{
block->next->prev = block;
}
if (block->next != NULL)
{
block->next->prev = block;
}
}
//
@ -149,21 +149,21 @@ void kexHeap::AddBlock(memBlock *block, kexHeapBlock *heapBlock)
void kexHeap::RemoveBlock(memBlock *block)
{
if(block->prev == NULL)
{
block->heapBlock->blocks = block->next;
}
else
{
block->prev->next = block->next;
}
if (block->prev == NULL)
{
block->heapBlock->blocks = block->next;
}
else
{
block->prev->next = block->next;
}
if(block->next != NULL)
{
block->next->prev = block->prev;
}
if (block->next != NULL)
{
block->next->prev = block->prev;
}
block->heapBlock = NULL;
block->heapBlock = NULL;
}
//
@ -172,16 +172,16 @@ void kexHeap::RemoveBlock(memBlock *block)
memBlock *kexHeap::GetBlock(void *ptr, const char *file, int line)
{
memBlock* block;
memBlock* block;
block = (memBlock*)((byte*)ptr - sizeof(memBlock));
block = (memBlock*)((byte*)ptr - sizeof(memBlock));
if(block->heapTag != kexHeap::HeapTag)
{
Error("kexHeap::GetBlock: found a pointer without heap tag (%s:%d)", file, line);
}
if (block->heapTag != kexHeap::HeapTag)
{
Error("kexHeap::GetBlock: found a pointer without heap tag (%s:%d)", file, line);
}
return block;
return block;
}
//
@ -190,25 +190,25 @@ memBlock *kexHeap::GetBlock(void *ptr, const char *file, int line)
void *kexHeap::Malloc(int size, kexHeapBlock &heapBlock, const char *file, int line)
{
memBlock *newblock;
memBlock *newblock;
assert(size > 0);
assert(size > 0);
newblock = NULL;
newblock = NULL;
if(!(newblock = (memBlock*)malloc(sizeof(memBlock) + size)))
{
Error("kexHeap::Malloc: failed on allocation of %u bytes (%s:%d)", size, file, line);
}
if (!(newblock = (memBlock*)malloc(sizeof(memBlock) + size)))
{
Error("kexHeap::Malloc: failed on allocation of %u bytes (%s:%d)", size, file, line);
}
newblock->purgeID = heapBlock.purgeID;
newblock->heapTag = kexHeap::HeapTag;
newblock->size = size;
newblock->ptrRef = NULL;
newblock->purgeID = heapBlock.purgeID;
newblock->heapTag = kexHeap::HeapTag;
newblock->size = size;
newblock->ptrRef = NULL;
kexHeap::AddBlock(newblock, &heapBlock);
kexHeap::AddBlock(newblock, &heapBlock);
return ((byte*)newblock) + sizeof(memBlock);
return ((byte*)newblock) + sizeof(memBlock);
}
//
@ -217,7 +217,7 @@ void *kexHeap::Malloc(int size, kexHeapBlock &heapBlock, const char *file, int l
void *kexHeap::Calloc(int size, kexHeapBlock &heapBlock, const char *file, int line)
{
return memset(kexHeap::Malloc(size, heapBlock, file, line), 0, size);
return memset(kexHeap::Malloc(size, heapBlock, file, line), 0, size);
}
//
@ -226,48 +226,48 @@ void *kexHeap::Calloc(int size, kexHeapBlock &heapBlock, const char *file, int l
void *kexHeap::Realloc(void *ptr, int size, kexHeapBlock &heapBlock, const char *file, int line)
{
memBlock *block;
memBlock *newblock;
memBlock *block;
memBlock *newblock;
if(!ptr)
{
return kexHeap::Malloc(size, heapBlock, file, line);
}
if (!ptr)
{
return kexHeap::Malloc(size, heapBlock, file, line);
}
assert(size >= 0);
assert(size >= 0);
if(size == 0)
{
kexHeap::Free(ptr, file, line);
return NULL;
}
if (size == 0)
{
kexHeap::Free(ptr, file, line);
return NULL;
}
block = kexHeap::GetBlock(ptr, file, line);
newblock = NULL;
block = kexHeap::GetBlock(ptr, file, line);
newblock = NULL;
kexHeap::RemoveBlock(block);
kexHeap::RemoveBlock(block);
block->next = NULL;
block->prev = NULL;
block->next = NULL;
block->prev = NULL;
if(block->ptrRef)
{
*block->ptrRef = NULL;
}
if (block->ptrRef)
{
*block->ptrRef = NULL;
}
if(!(newblock = (memBlock*)realloc(block, sizeof(memBlock) + size)))
{
Error("kexHeap::Realloc: failed on allocation of %u bytes (%s:%d)", size, file, line);
}
if (!(newblock = (memBlock*)realloc(block, sizeof(memBlock) + size)))
{
Error("kexHeap::Realloc: failed on allocation of %u bytes (%s:%d)", size, file, line);
}
newblock->purgeID = heapBlock.purgeID;
newblock->heapTag = kexHeap::HeapTag;
newblock->size = size;
newblock->ptrRef = NULL;
newblock->purgeID = heapBlock.purgeID;
newblock->heapTag = kexHeap::HeapTag;
newblock->size = size;
newblock->ptrRef = NULL;
kexHeap::AddBlock(newblock, &heapBlock);
kexHeap::AddBlock(newblock, &heapBlock);
return ((byte*)newblock) + sizeof(memBlock);
return ((byte*)newblock) + sizeof(memBlock);
}
//
@ -276,7 +276,7 @@ void *kexHeap::Realloc(void *ptr, int size, kexHeapBlock &heapBlock, const char
void *kexHeap::Alloca(int size, const char *file, int line)
{
return size == 0 ? NULL : kexHeap::Calloc(size, hb_auto, file, line);
return size == 0 ? NULL : kexHeap::Calloc(size, hb_auto, file, line);
}
//
@ -285,18 +285,18 @@ void *kexHeap::Alloca(int size, const char *file, int line)
void kexHeap::Free(void *ptr, const char *file, int line)
{
memBlock* block;
memBlock* block;
block = kexHeap::GetBlock(ptr, file, line);
if(block->ptrRef)
{
*block->ptrRef = NULL;
}
block = kexHeap::GetBlock(ptr, file, line);
if (block->ptrRef)
{
*block->ptrRef = NULL;
}
kexHeap::RemoveBlock(block);
kexHeap::RemoveBlock(block);
// free back to system
free(block);
// free back to system
free(block);
}
//
@ -305,28 +305,28 @@ void kexHeap::Free(void *ptr, const char *file, int line)
void kexHeap::Purge(kexHeapBlock &heapBlock, const char *file, int line)
{
memBlock *block;
memBlock *next;
memBlock *block;
memBlock *next;
for(block = heapBlock.blocks; block != NULL;)
{
next = block->next;
for (block = heapBlock.blocks; block != NULL;)
{
next = block->next;
if(block->heapTag != kexHeap::HeapTag)
{
Error("kexHeap::Purge: Purging without heap tag (%s:%d)", file, line);
}
if (block->heapTag != kexHeap::HeapTag)
{
Error("kexHeap::Purge: Purging without heap tag (%s:%d)", file, line);
}
if(block->ptrRef)
{
*block->ptrRef = NULL;
}
if (block->ptrRef)
{
*block->ptrRef = NULL;
}
free(block);
block = next;
}
free(block);
block = next;
}
heapBlock.blocks = NULL;
heapBlock.blocks = NULL;
}
//
@ -335,7 +335,7 @@ void kexHeap::Purge(kexHeapBlock &heapBlock, const char *file, int line)
void kexHeap::SetCacheRef(void **ptr, const char *file, int line)
{
kexHeap::GetBlock(*ptr, file, line)->ptrRef = ptr;
kexHeap::GetBlock(*ptr, file, line)->ptrRef = ptr;
}
//
@ -344,7 +344,7 @@ void kexHeap::SetCacheRef(void **ptr, const char *file, int line)
void kexHeap::GarbageCollect(const char *file, int line)
{
kexHeap::Purge(hb_auto, file, line);
kexHeap::Purge(hb_auto, file, line);
}
//
@ -353,28 +353,28 @@ void kexHeap::GarbageCollect(const char *file, int line)
void kexHeap::CheckBlocks(const char *file, int line)
{
memBlock *block;
memBlock *prev;
kexHeapBlock *heapBlock;
memBlock *block;
memBlock *prev;
kexHeapBlock *heapBlock;
for(heapBlock = kexHeap::blockList; heapBlock; heapBlock = heapBlock->next)
{
prev = NULL;
for (heapBlock = kexHeap::blockList; heapBlock; heapBlock = heapBlock->next)
{
prev = NULL;
for(block = heapBlock->blocks; block != NULL; block = block->next)
{
if(block->heapTag != kexHeap::HeapTag)
{
Error("kexHeap::CheckBlocks: found block without heap tag (%s:%d)", file, line);
}
if(block->prev != prev)
{
Error("kexHeap::CheckBlocks: bad link list found (%s:%d)", file, line);
}
for (block = heapBlock->blocks; block != NULL; block = block->next)
{
if (block->heapTag != kexHeap::HeapTag)
{
Error("kexHeap::CheckBlocks: found block without heap tag (%s:%d)", file, line);
}
if (block->prev != prev)
{
Error("kexHeap::CheckBlocks: bad link list found (%s:%d)", file, line);
}
prev = block;
}
}
prev = block;
}
}
}
//
@ -391,13 +391,13 @@ void kexHeap::Touch(void *ptr, const char *file, int line)
int kexHeap::Usage(const kexHeapBlock &heapBlock)
{
int bytes = 0;
memBlock *block;
int bytes = 0;
memBlock *block;
for(block = heapBlock.blocks; block != NULL; block = block->next)
{
bytes += block->size;
}
for (block = heapBlock.blocks; block != NULL; block = block->next)
{
bytes += block->size;
}
return bytes;
return bytes;
}

78
src/lightmap/kexlib/memheap.h
View file

@ -27,66 +27,66 @@
#pragma once
typedef void (*blockFunc_t)(void*);
typedef void(*blockFunc_t)(void*);
class kexHeapBlock;
struct memBlock
{
int heapTag;
int purgeID;
int size;
kexHeapBlock *heapBlock;
void **ptrRef;
memBlock *prev;
memBlock *next;
int heapTag;
int purgeID;
int size;
kexHeapBlock *heapBlock;
void **ptrRef;
memBlock *prev;
memBlock *next;
};
class kexHeapBlock
{
public:
kexHeapBlock(const char *name, bool bGarbageCollect,
blockFunc_t funcFree, blockFunc_t funcGC);
~kexHeapBlock();
kexHeapBlock(const char *name, bool bGarbageCollect,
blockFunc_t funcFree, blockFunc_t funcGC);
~kexHeapBlock();
kexHeapBlock *operator[](int index);
kexHeapBlock *operator[](int index);
char *name;
memBlock *blocks;
bool bGC;
blockFunc_t freeFunc;
blockFunc_t gcFunc;
int purgeID;
kexHeapBlock *prev;
kexHeapBlock *next;
char *name;
memBlock *blocks;
bool bGC;
blockFunc_t freeFunc;
blockFunc_t gcFunc;
int purgeID;
kexHeapBlock *prev;
kexHeapBlock *next;
};
class kexHeap
{
public:
static void *Malloc(int size, kexHeapBlock &heapBlock, const char *file, int line);
static void *Calloc(int size, kexHeapBlock &heapBlock, const char *file, int line);
static void *Realloc(void *ptr, int size, kexHeapBlock &heapBlock, const char *file, int line);
static void *Alloca(int size, const char *file, int line);
static void Free(void *ptr, const char *file, int line);
static void Purge(kexHeapBlock &heapBlock, const char *file, int line);
static void GarbageCollect(const char *file, int line);
static void CheckBlocks(const char *file, int line);
static void Touch(void *ptr, const char *file, int line);
static int Usage(const kexHeapBlock &heapBlock);
static void SetCacheRef(void **ptr, const char *file, int line);
static void *Malloc(int size, kexHeapBlock &heapBlock, const char *file, int line);
static void *Calloc(int size, kexHeapBlock &heapBlock, const char *file, int line);
static void *Realloc(void *ptr, int size, kexHeapBlock &heapBlock, const char *file, int line);
static void *Alloca(int size, const char *file, int line);
static void Free(void *ptr, const char *file, int line);
static void Purge(kexHeapBlock &heapBlock, const char *file, int line);
static void GarbageCollect(const char *file, int line);
static void CheckBlocks(const char *file, int line);
static void Touch(void *ptr, const char *file, int line);
static int Usage(const kexHeapBlock &heapBlock);
static void SetCacheRef(void **ptr, const char *file, int line);
static int numHeapBlocks;
static kexHeapBlock *currentHeapBlock;
static int currentHeapBlockID;
static kexHeapBlock *blockList;
static int numHeapBlocks;
static kexHeapBlock *currentHeapBlock;
static int currentHeapBlockID;
static kexHeapBlock *blockList;
private:
static void AddBlock(memBlock *block, kexHeapBlock *heapBlock);
static void RemoveBlock(memBlock *block);
static memBlock *GetBlock(void *ptr, const char *file, int line);
static void AddBlock(memBlock *block, kexHeapBlock *heapBlock);
static void RemoveBlock(memBlock *block);
static memBlock *GetBlock(void *ptr, const char *file, int line);
static const int HeapTag = 0x03151983;
static const int HeapTag = 0x03151983;
};
extern kexHeapBlock hb_static;

664
src/lightmap/lightmap.cpp
View file

@ -48,14 +48,14 @@ const kexVec3 kexLightmapBuilder::gridSize(64, 64, 128);
kexLightmapBuilder::kexLightmapBuilder()
{
this->textureWidth = 128;
this->textureHeight = 128;
this->allocBlocks = NULL;
this->numTextures = 0;
this->samples = 16;
this->extraSamples = 2;
this->ambience = 0.0f;
this->tracedTexels = 0;
this->textureWidth = 128;
this->textureHeight = 128;
this->allocBlocks = NULL;
this->numTextures = 0;
this->samples = 16;
this->extraSamples = 2;
this->ambience = 0.0f;
this->tracedTexels = 0;
}
kexLightmapBuilder::~kexLightmapBuilder()
@ -64,142 +64,142 @@ kexLightmapBuilder::~kexLightmapBuilder()
void kexLightmapBuilder::NewTexture()
{
numTextures++;
numTextures++;
allocBlocks = (int**)Mem_Realloc(allocBlocks, sizeof(int*) * numTextures, hb_static);
allocBlocks[numTextures-1] = (int*)Mem_Calloc(sizeof(int) * textureWidth, hb_static);
allocBlocks = (int**)Mem_Realloc(allocBlocks, sizeof(int*) * numTextures, hb_static);
allocBlocks[numTextures - 1] = (int*)Mem_Calloc(sizeof(int) * textureWidth, hb_static);
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);
textures.Push(texture);
uint16_t *texture = (uint16_t*)Mem_Calloc((textureWidth * textureHeight) * 3 * 2, hb_static);
textures.Push(texture);
}
// Determines where to map a new block on to the lightmap texture
bool kexLightmapBuilder::MakeRoomForBlock(const int width, const int height, int *x, int *y, int *num)
{
int i;
int j;
int k;
int bestRow1;
int bestRow2;
int i;
int j;
int k;
int bestRow1;
int bestRow2;
*num = -1;
*num = -1;
if(allocBlocks == NULL)
{
return false;
}
if (allocBlocks == NULL)
{
return false;
}
for(k = 0; k < numTextures; ++k)
{
bestRow1 = textureHeight;
for (k = 0; k < numTextures; ++k)
{
bestRow1 = textureHeight;
for(i = 0; i <= textureWidth - width; i++)
{
bestRow2 = 0;
for (i = 0; i <= textureWidth - width; i++)
{
bestRow2 = 0;
for(j = 0; j < width; j++)
{
if(allocBlocks[k][i + j] >= bestRow1)
{
break;
}
for (j = 0; j < width; j++)
{
if (allocBlocks[k][i + j] >= bestRow1)
{
break;
}
if(allocBlocks[k][i + j] > bestRow2)
{
bestRow2 = allocBlocks[k][i + j];
}
}
if (allocBlocks[k][i + j] > bestRow2)
{
bestRow2 = allocBlocks[k][i + j];
}
}
// found a free block
if(j == width)
{
*x = i;
*y = bestRow1 = bestRow2;
}
}
// found a free block
if (j == width)
{
*x = i;
*y = bestRow1 = bestRow2;
}
}
if(bestRow1 + height > textureHeight)
{
// no room
continue;
}
if (bestRow1 + height > textureHeight)
{
// no room
continue;
}
for(i = 0; i < width; i++)
{
// store row offset
allocBlocks[k][*x + i] = bestRow1 + height;
}
for (i = 0; i < width; i++)
{
// store row offset
allocBlocks[k][*x + i] = bestRow1 + height;
}
*num = k;
return true;
}
*num = k;
return true;
}
return false;
return false;
}
kexBBox kexLightmapBuilder::GetBoundsFromSurface(const surface_t *surface)
{
kexVec3 low(M_INFINITY, M_INFINITY, M_INFINITY);
kexVec3 hi(-M_INFINITY, -M_INFINITY, -M_INFINITY);
kexVec3 low(M_INFINITY, M_INFINITY, M_INFINITY);
kexVec3 hi(-M_INFINITY, -M_INFINITY, -M_INFINITY);
kexBBox bounds;
bounds.Clear();
kexBBox bounds;
bounds.Clear();
for(int i = 0; i < surface->numVerts; i++)
{
for(int j = 0; j < 3; j++)
{
if(surface->verts[i][j] < low[j])
{
low[j] = surface->verts[i][j];
}
if(surface->verts[i][j] > hi[j])
{
hi[j] = surface->verts[i][j];
}
}
}
for (int i = 0; i < surface->numVerts; i++)
{
for (int j = 0; j < 3; j++)
{
if (surface->verts[i][j] < low[j])
{
low[j] = surface->verts[i][j];
}
if (surface->verts[i][j] > hi[j])
{
hi[j] = surface->verts[i][j];
}
}
}
bounds.min = low;
bounds.max = hi;
bounds.min = low;
bounds.max = hi;
return bounds;
return bounds;
}
// Traces to the ceiling surface. Will emit light if the surface that was traced is a sky
bool kexLightmapBuilder::EmitFromCeiling(kexTrace &trace, const surface_t *surface, const kexVec3 &origin, const kexVec3 &normal, kexVec3 &color)
{
float attenuation = normal.Dot(map->GetSunDirection());
float attenuation = normal.Dot(map->GetSunDirection());
if(attenuation <= 0)
{
// plane is not even facing the sunlight
return false;
}
if (attenuation <= 0)
{
// plane is not even facing the sunlight
return false;
}
trace.Trace(origin, origin + (map->GetSunDirection() * 32768.0f));
trace.Trace(origin, origin + (map->GetSunDirection() * 32768.0f));
if(trace.fraction == 1.0f)
{
// nothing was hit
if (trace.fraction == 1.0f)
{
// nothing was hit
//color.x += 1.0f;
return false;
}
return false;
}
if(trace.hitSurface->bSky == false)
{
if (trace.hitSurface->bSky == false)
{
if (trace.hitSurface->type == ST_CEILING)
return false;
// not a ceiling/sky surface
return false;
}
// not a ceiling/sky surface
return false;
}
color += map->GetSunColor() * attenuation;
return true;
return true;
}
template<class T>
@ -217,13 +217,13 @@ static float radians(float degrees)
// Traces a line from the texel's origin to the sunlight direction and against all nearby thing lights
kexVec3 kexLightmapBuilder::LightTexelSample(kexTrace &trace, const kexVec3 &origin, surface_t *surface)
{
kexPlane plane = surface->plane;
kexPlane plane = surface->plane;
kexVec3 color(0.0f, 0.0f, 0.0f);
// check all thing lights
for(unsigned int i = 0; i < map->thingLights.Size(); i++)
{
thingLight_t *tl = map->thingLights[i];
// check all thing lights
for (unsigned int i = 0; i < map->thingLights.Size(); i++)
{
thingLight_t *tl = map->thingLights[i];
float originZ;
if (!tl->bCeiling)
@ -233,20 +233,20 @@ kexVec3 kexLightmapBuilder::LightTexelSample(kexTrace &trace, const kexVec3 &ori
kexVec3 lightOrigin(tl->origin.x, tl->origin.y, originZ);
if(plane.Distance(lightOrigin) - plane.d < 0)
{
// completely behind the plane
continue;
}
if (plane.Distance(lightOrigin) - plane.d < 0)
{
// completely behind the plane
continue;
}
float radius = tl->radius * 2.0f; // 2.0 because gzdoom's dynlights do this and we want them to match
float intensity = tl->intensity;
float radius = tl->radius * 2.0f; // 2.0 because gzdoom's dynlights do this and we want them to match
float intensity = tl->intensity;
if(origin.DistanceSq(lightOrigin) > (radius*radius))
{
// not within range
continue;
}
if (origin.DistanceSq(lightOrigin) > (radius*radius))
{
// not within range
continue;
}
kexVec3 dir = (lightOrigin - origin);
float dist = dir.Unit();
@ -270,177 +270,177 @@ kexVec3 kexLightmapBuilder::LightTexelSample(kexTrace &trace, const kexVec3 &ori
}
}
trace.Trace(lightOrigin, origin);
trace.Trace(lightOrigin, origin);
if(trace.fraction != 1)
{
// this light is occluded by something
continue;
}
if (trace.fraction != 1)
{
// this light is occluded by something
continue;
}
float attenuation = 1.0f - (dist / radius);
attenuation *= spotAttenuation;
attenuation *= plane.Normal().Dot(dir);
attenuation *= intensity;
// accumulate results
color += tl->rgb * attenuation;
// accumulate results
color += tl->rgb * attenuation;
tracedTexels++;
}
tracedTexels++;
}
if(surface->type != ST_CEILING)
{
// see if it's exposed to sunlight
if(EmitFromCeiling(trace, surface, origin, plane.Normal(), color))
tracedTexels++;
}
if (surface->type != ST_CEILING)
{
// see if it's exposed to sunlight
if (EmitFromCeiling(trace, surface, origin, plane.Normal(), color))
tracedTexels++;
}
// trace against surface lights
for(unsigned int i = 0; i < map->lightSurfaces.Size(); ++i)
{
kexLightSurface *surfaceLight = map->lightSurfaces[i];
// trace against surface lights
for (unsigned int i = 0; i < map->lightSurfaces.Size(); ++i)
{
kexLightSurface *surfaceLight = map->lightSurfaces[i];
float attenuation;
if(surfaceLight->TraceSurface(map, trace, surface, origin, &attenuation))
{
color += surfaceLight->GetRGB() * attenuation;
if (surfaceLight->TraceSurface(map, trace, surface, origin, &attenuation))
{
color += surfaceLight->GetRGB() * attenuation;
tracedTexels++;
}
}
tracedTexels++;
}
}
return color;
return color;
}
// Determines a lightmap block in which to map to the lightmap texture.
// Width and height of the block is calcuated and steps are computed to determine where each texel will be positioned on the surface
void kexLightmapBuilder::BuildSurfaceParams(surface_t *surface)
{
kexPlane *plane;
kexBBox bounds;
kexVec3 roundedSize;
int i;
kexPlane::planeAxis_t axis;
kexVec3 tCoords[2];
kexVec3 tOrigin;
int width;
int height;
float d;
kexPlane *plane;
kexBBox bounds;
kexVec3 roundedSize;
int i;
kexPlane::planeAxis_t axis;
kexVec3 tCoords[2];
kexVec3 tOrigin;
int width;
int height;
float d;
plane = &surface->plane;
bounds = GetBoundsFromSurface(surface);
plane = &surface->plane;
bounds = GetBoundsFromSurface(surface);
// round off dimentions
for(i = 0; i < 3; i++)
{
bounds.min[i] = samples * kexMath::Floor(bounds.min[i] / samples);
bounds.max[i] = samples * kexMath::Ceil(bounds.max[i] / samples);
// round off dimentions
for (i = 0; i < 3; i++)
{
bounds.min[i] = samples * kexMath::Floor(bounds.min[i] / samples);
bounds.max[i] = samples * kexMath::Ceil(bounds.max[i] / samples);
roundedSize[i] = (bounds.max[i] - bounds.min[i]) / samples + 1;
}
roundedSize[i] = (bounds.max[i] - bounds.min[i]) / samples + 1;
}
tCoords[0].Clear();
tCoords[1].Clear();
tCoords[0].Clear();
tCoords[1].Clear();
axis = plane->BestAxis();
axis = plane->BestAxis();
switch(axis)
{
case kexPlane::AXIS_YZ:
width = (int)roundedSize.y;
height = (int)roundedSize.z;
tCoords[0].y = 1.0f / samples;
tCoords[1].z = 1.0f / samples;
break;
switch (axis)
{
case kexPlane::AXIS_YZ:
width = (int)roundedSize.y;
height = (int)roundedSize.z;
tCoords[0].y = 1.0f / samples;
tCoords[1].z = 1.0f / samples;
break;
case kexPlane::AXIS_XZ:
width = (int)roundedSize.x;
height = (int)roundedSize.z;
tCoords[0].x = 1.0f / samples;
tCoords[1].z = 1.0f / samples;
break;
case kexPlane::AXIS_XZ:
width = (int)roundedSize.x;
height = (int)roundedSize.z;
tCoords[0].x = 1.0f / samples;
tCoords[1].z = 1.0f / samples;
break;
case kexPlane::AXIS_XY:
width = (int)roundedSize.x;
height = (int)roundedSize.y;
tCoords[0].x = 1.0f / samples;
tCoords[1].y = 1.0f / samples;
break;
}
case kexPlane::AXIS_XY:
width = (int)roundedSize.x;
height = (int)roundedSize.y;
tCoords[0].x = 1.0f / samples;
tCoords[1].y = 1.0f / samples;
break;
}
// clamp width
if(width > textureWidth)
{
tCoords[0] *= ((float)textureWidth / (float)width);
width = textureWidth;
}
// clamp width
if (width > textureWidth)
{
tCoords[0] *= ((float)textureWidth / (float)width);
width = textureWidth;
}
// clamp height
if(height > textureHeight)
{
tCoords[1] *= ((float)textureHeight / (float)height);
height = textureHeight;
}
// clamp height
if (height > textureHeight)
{
tCoords[1] *= ((float)textureHeight / (float)height);
height = textureHeight;
}
surface->lightmapCoords = (float*)Mem_Calloc(sizeof(float) *
surface->numVerts * 2, hb_static);
surface->lightmapCoords = (float*)Mem_Calloc(sizeof(float) *
surface->numVerts * 2, hb_static);
surface->textureCoords[0] = tCoords[0];
surface->textureCoords[1] = tCoords[1];
surface->textureCoords[0] = tCoords[0];
surface->textureCoords[1] = tCoords[1];
tOrigin = bounds.min;
tOrigin = bounds.min;
// project tOrigin and tCoords so they lie on the plane
d = (plane->Distance(bounds.min) - plane->d) / plane->Normal()[axis];
tOrigin[axis] -= d;
// project tOrigin and tCoords so they lie on the plane
d = (plane->Distance(bounds.min) - plane->d) / plane->Normal()[axis];
tOrigin[axis] -= d;
for(i = 0; i < 2; i++)
{
tCoords[i].Normalize();
d = plane->Distance(tCoords[i]) / plane->Normal()[axis];
tCoords[i][axis] -= d;
}
for (i = 0; i < 2; i++)
{
tCoords[i].Normalize();
d = plane->Distance(tCoords[i]) / plane->Normal()[axis];
tCoords[i][axis] -= d;
}
surface->bounds = bounds;
surface->lightmapDims[0] = width;
surface->lightmapDims[1] = height;
surface->lightmapOrigin = tOrigin;
surface->lightmapSteps[0] = tCoords[0] * (float)samples;
surface->lightmapSteps[1] = tCoords[1] * (float)samples;
surface->bounds = bounds;
surface->lightmapDims[0] = width;
surface->lightmapDims[1] = height;
surface->lightmapOrigin = tOrigin;
surface->lightmapSteps[0] = tCoords[0] * (float)samples;
surface->lightmapSteps[1] = tCoords[1] * (float)samples;
}
// Steps through each texel and traces a line to the world.
// For each non-occluded trace, color is accumulated and saved off into the lightmap texture based on what block is mapped to
void kexLightmapBuilder::TraceSurface(surface_t *surface)
{
static thread_local kexVec3 colorSamples[1024 * 1024];
static thread_local kexVec3 colorSamples[1024 * 1024];
int sampleWidth;
int sampleHeight;
kexVec3 normal;
kexVec3 pos;
kexVec3 tDelta;
int i;
int j;
kexTrace trace;
uint16_t *currentTexture;
bool bShouldLookupTexture = false;
int sampleWidth;
int sampleHeight;
kexVec3 normal;
kexVec3 pos;
kexVec3 tDelta;
int i;
int j;
kexTrace trace;
uint16_t *currentTexture;
bool bShouldLookupTexture = false;
trace.Init(*map);
trace.Init(*map);
sampleWidth = surface->lightmapDims[0];
sampleHeight = surface->lightmapDims[1];
sampleWidth = surface->lightmapDims[0];
sampleHeight = surface->lightmapDims[1];
normal = surface->plane.Normal();
normal = surface->plane.Normal();
int multisampleCount = Multisample;
// start walking through each texel
for(i = 0; i < sampleHeight; i++)
{
for(j = 0; j < sampleWidth; j++)
{
// start walking through each texel
for (i = 0; i < sampleHeight; i++)
{
for (j = 0; j < sampleWidth; j++)
{
kexVec3 c(0.0f, 0.0f, 0.0f);
for (int k = 0; k < multisampleCount; k++)
@ -467,103 +467,103 @@ void kexLightmapBuilder::TraceSurface(surface_t *surface)
c /= multisampleCount;
// if nothing at all was traced and color is completely black
// then this surface will not go through the extra rendering
// step in rendering the lightmap
if (c.x > 0.0f || c.y > 0.0f || c.z > 0.0f)
{
bShouldLookupTexture = true;
}
// if nothing at all was traced and color is completely black
// then this surface will not go through the extra rendering
// step in rendering the lightmap
if (c.x > 0.0f || c.y > 0.0f || c.z > 0.0f)
{
bShouldLookupTexture = true;
}
kexMath::Clamp(c, 0, 1);
colorSamples[i * 1024 + j] = c;
}
}
}
// SVE redraws the scene for lightmaps, so for optimizations,
// tell the engine to ignore this surface if completely black
if(bShouldLookupTexture == false)
{
surface->lightmapNum = -1;
return;
}
else
{
int x = 0, y = 0;
int width = surface->lightmapDims[0];
int height = surface->lightmapDims[1];
// SVE redraws the scene for lightmaps, so for optimizations,
// tell the engine to ignore this surface if completely black
if (bShouldLookupTexture == false)
{
surface->lightmapNum = -1;
return;
}
else
{
int x = 0, y = 0;
int width = surface->lightmapDims[0];
int height = surface->lightmapDims[1];
std::unique_lock<std::mutex> lock(mutex);
// now that we know the width and height of this block, see if we got
// room for it in the light map texture. if not, then we must allocate
// a new texture
if(!MakeRoomForBlock(width, height, &x, &y, &surface->lightmapNum))
{
// allocate a new texture for this block
NewTexture();
// now that we know the width and height of this block, see if we got
// room for it in the light map texture. if not, then we must allocate
// a new texture
if (!MakeRoomForBlock(width, height, &x, &y, &surface->lightmapNum))
{
// allocate a new texture for this block
NewTexture();
if(!MakeRoomForBlock(width, height, &x, &y, &surface->lightmapNum))
{
if (!MakeRoomForBlock(width, height, &x, &y, &surface->lightmapNum))
{
Error("Lightmap allocation failed\n");
return;
}
}
return;
}
}
lock.unlock();
// calculate texture coordinates
for(i = 0; i < surface->numVerts; i++)
{
tDelta = surface->verts[i] - surface->bounds.min;
surface->lightmapCoords[i * 2 + 0] =
(tDelta.Dot(surface->textureCoords[0]) + x + 0.5f) / (float)textureWidth;
surface->lightmapCoords[i * 2 + 1] =
(tDelta.Dot(surface->textureCoords[1]) + y + 0.5f) / (float)textureHeight;
}
// calculate texture coordinates
for (i = 0; i < surface->numVerts; i++)
{
tDelta = surface->verts[i] - surface->bounds.min;
surface->lightmapCoords[i * 2 + 0] =
(tDelta.Dot(surface->textureCoords[0]) + x + 0.5f) / (float)textureWidth;
surface->lightmapCoords[i * 2 + 1] =
(tDelta.Dot(surface->textureCoords[1]) + y + 0.5f) / (float)textureHeight;
}
surface->lightmapOffs[0] = x;
surface->lightmapOffs[1] = y;
}
surface->lightmapOffs[0] = x;
surface->lightmapOffs[1] = y;
}
std::unique_lock<std::mutex> lock(mutex);
currentTexture = textures[surface->lightmapNum];
currentTexture = textures[surface->lightmapNum];
lock.unlock();
// store results to lightmap texture
for(i = 0; i < sampleHeight; i++)
{
for(j = 0; j < sampleWidth; j++)
{
// get texture offset
int offs = (((textureWidth * (i + surface->lightmapOffs[1])) + surface->lightmapOffs[0]) * 3);
// store results to lightmap texture
for (i = 0; i < sampleHeight; i++)
{
for (j = 0; j < sampleWidth; j++)
{
// get texture offset
int offs = (((textureWidth * (i + surface->lightmapOffs[1])) + surface->lightmapOffs[0]) * 3);
// convert RGB to bytes
currentTexture[offs + j * 3 + 0] = floatToHalf(colorSamples[i * 1024 + j].x);
currentTexture[offs + j * 3 + 1] = floatToHalf(colorSamples[i * 1024 + j].y);
currentTexture[offs + j * 3 + 2] = floatToHalf(colorSamples[i * 1024 + j].z);
}
}
// convert RGB to bytes
currentTexture[offs + j * 3 + 0] = floatToHalf(colorSamples[i * 1024 + j].x);
currentTexture[offs + j * 3 + 1] = floatToHalf(colorSamples[i * 1024 + j].y);
currentTexture[offs + j * 3 + 2] = floatToHalf(colorSamples[i * 1024 + j].z);
}
}
}
void kexLightmapBuilder::LightSurface(const int surfid)
{
float remaining;
int numsurfs = surfaces.Length();
float remaining;
int numsurfs = surfaces.Length();
// TODO: this should NOT happen, but apparently, it can randomly occur
if(surfaces.Length() == 0)
{
return;
}
// TODO: this should NOT happen, but apparently, it can randomly occur
if (surfaces.Length() == 0)
{
return;
}
BuildSurfaceParams(surfaces[surfid]);
TraceSurface(surfaces[surfid]);
BuildSurfaceParams(surfaces[surfid]);
TraceSurface(surfaces[surfid]);
std::unique_lock<std::mutex> lock(mutex);
int lastproc = processed * 100 / numsurfs;
processed++;
processed++;
int curproc = processed * 100 / numsurfs;
if (lastproc != curproc || processed == 1)
{
@ -574,16 +574,16 @@ void kexLightmapBuilder::LightSurface(const int surfid)
void kexLightmapBuilder::CreateLightmaps(FLevel &doomMap)
{
map = &doomMap;
map = &doomMap;
printf("------------- Tracing surfaces -------------\n");
printf("------------- Tracing surfaces -------------\n");
processed = 0;
kexWorker::RunJob(surfaces.Length(), [=](int id) {
LightSurface(id);
});
printf("Texels traced: %i \n\n", tracedTexels);
printf("Texels traced: %i \n\n", tracedTexels);
}
void kexLightmapBuilder::AddLightmapLump(FWadWriter &wadFile)
@ -701,29 +701,29 @@ void kexLightmapBuilder::AddLightmapLump(FWadWriter &wadFile)
void kexLightmapBuilder::WriteTexturesToTGA()
{
kexBinFile file;
kexBinFile file;
for(unsigned int i = 0; i < textures.Length(); i++)
{
file.Create(Va("lightmap_%02d.tga", i));
file.Write16(0);
file.Write16(2);
file.Write16(0);
file.Write16(0);
file.Write16(0);
file.Write16(0);
file.Write16(textureWidth);
file.Write16(textureHeight);
file.Write16(24);
for (unsigned int i = 0; i < textures.Length(); i++)
{
file.Create(Va("lightmap_%02d.tga", i));
file.Write16(0);
file.Write16(2);
file.Write16(0);
file.Write16(0);
file.Write16(0);
file.Write16(0);
file.Write16(textureWidth);
file.Write16(textureHeight);
file.Write16(24);
for(int j = 0; j < (textureWidth * textureHeight) * 3; j += 3)
{
file.Write8(textures[i][j+2]);
file.Write8(textures[i][j+1]);
file.Write8(textures[i][j+0]);
}
file.Close();
}
for (int j = 0; j < (textureWidth * textureHeight) * 3; j += 3)
{
file.Write8(textures[i][j + 2]);
file.Write8(textures[i][j + 1]);
file.Write8(textures[i][j + 0]);
}
file.Close();
}
}
void kexLightmapBuilder::WriteMeshToOBJ()

52
src/lightmap/lightmap.h
View file

@ -38,39 +38,37 @@ class FWadWriter;
class kexLightmapBuilder
{
public:
kexLightmapBuilder();
~kexLightmapBuilder();
kexLightmapBuilder();
~kexLightmapBuilder();
void BuildSurfaceParams(surface_t *surface);
void TraceSurface(surface_t *surface);
void CreateLightmaps(FLevel &doomMap);
void LightSurface(const int surfid);
void WriteTexturesToTGA();
void WriteMeshToOBJ();
void AddLightmapLump(FWadWriter &wadFile);
void BuildSurfaceParams(surface_t *surface);
void TraceSurface(surface_t *surface);
void CreateLightmaps(FLevel &doomMap);
void LightSurface(const int surfid);
void WriteTexturesToTGA();
void WriteMeshToOBJ();
void AddLightmapLump(FWadWriter &wadFile);
int samples;
float ambience;
int textureWidth;
int textureHeight;
int samples;
float ambience;
int textureWidth;
int textureHeight;
static const kexVec3 gridSize;
static const kexVec3 gridSize;
private:
void NewTexture();
bool MakeRoomForBlock(const int width, const int height, int *x, int *y, int *num);
kexBBox GetBoundsFromSurface(const surface_t *surface);
kexVec3 LightTexelSample(kexTrace &trace, const kexVec3 &origin, surface_t *surface);
bool EmitFromCeiling(kexTrace &trace, const surface_t *surface, const kexVec3 &origin, const kexVec3 &normal, kexVec3 &color);
void ExportTexelsToObjFile(FILE *f, const kexVec3 &org, int indices);
void WriteBlock(FILE *f, const int i, const kexVec3 &org, int indices, kexBBox &box);
void NewTexture();
bool MakeRoomForBlock(const int width, const int height, int *x, int *y, int *num);
kexBBox GetBoundsFromSurface(const surface_t *surface);
kexVec3 LightTexelSample(kexTrace &trace, const kexVec3 &origin, surface_t *surface);
bool EmitFromCeiling(kexTrace &trace, const surface_t *surface, const kexVec3 &origin, const kexVec3 &normal, kexVec3 &color);
FLevel *map;
kexArray<uint16_t*> textures;
int **allocBlocks;
int numTextures;
int extraSamples;
int tracedTexels;
FLevel *map;
kexArray<uint16_t*> textures;
int **allocBlocks;
int numTextures;
int extraSamples;
int tracedTexels;
std::mutex mutex;
int processed = 0;

460
src/lightmap/lightsurface.cpp
View file

@ -47,313 +47,313 @@ kexLightSurface::~kexLightSurface()
void kexLightSurface::Init(const surfaceLightDef &lightSurfaceDef, surface_t *surface, const bool bWall, const bool bNoCenterPoint)
{
this->intensity = lightSurfaceDef.intensity;
this->distance = lightSurfaceDef.distance;
this->rgb = lightSurfaceDef.rgb;
this->surface = surface;
this->bWall = bWall;
this->bNoCenterPoint = bNoCenterPoint;
this->intensity = lightSurfaceDef.intensity;
this->distance = lightSurfaceDef.distance;
this->rgb = lightSurfaceDef.rgb;
this->surface = surface;
this->bWall = bWall;
this->bNoCenterPoint = bNoCenterPoint;
}
// Creates a single origin point if we're not intending on subdividing this light surface
void kexLightSurface::CreateCenterOrigin()
{
if(!bWall)
{
kexVec3 center;
if (!bWall)
{
kexVec3 center;
for(int i = 0; i < surface->numVerts; ++i)
{
center += surface->verts[i];
}
for (int i = 0; i < surface->numVerts; ++i)
{
center += surface->verts[i];
}
origins.Push(center / (float)surface->numVerts);
}
else
{
origins.Push(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));
}
origins.Push(center / (float)surface->numVerts);
}
else
{
origins.Push(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));
}
}
// 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;
kexArray<float> dists;
kexArray<char> sides;
// determines what sides the vertices lies on
for(unsigned int i = 0; i < points.Length(); ++i)
{
float d = points[i].Dot(normal) - dist;
// determines what sides the vertices lies on
for (unsigned int i = 0; i < points.Length(); ++i)
{
float d = points[i].Dot(normal) - dist;
dists.Push(d);
dists.Push(d);
if(d > 0.1f)
{
sides.Push(1); // front
}
else if(d < -0.1f)
{
sides.Push(-1); // directly on the split plane
}
else
{
sides.Push(0); // back
}
}
if (d > 0.1f)
{
sides.Push(1); // front
}
else if (d < -0.1f)
{
sides.Push(-1); // directly on the split plane
}
else
{
sides.Push(0); // back
}
}
// add points
for(unsigned int i = 0; i < points.Length(); ++i)
{
int next;
float frac;
kexVec3 pt1, pt2, pt3;
// add points
for (unsigned int i = 0; i < points.Length(); ++i)
{
int next;
float frac;
kexVec3 pt1, pt2, pt3;
switch(sides[i])
{
case -1:
backPoints->Push(points[i]);
break;
switch (sides[i])
{
case -1:
backPoints->Push(points[i]);
break;
case 1:
frontPoints->Push(points[i]);
break;
case 1:
frontPoints->Push(points[i]);
break;
default:
frontPoints->Push(points[i]);
backPoints->Push(points[i]);
default:
frontPoints->Push(points[i]);
backPoints->Push(points[i]);
// point is on the split plane so no new split vertex is needed
continue;
// point is on the split plane so no new split vertex is needed
continue;
}
}
// check if the edge crosses the split plane
next = (i + 1) % points.Length();
// check if the edge crosses the split plane
next = (i + 1) % points.Length();
if(sides[next] == 0 || sides[next] == sides[i])
{
// didn't cross
continue;
}
if (sides[next] == 0 || sides[next] == sides[i])
{
// didn't cross
continue;
}
pt1 = points[i];
pt2 = points[next];
pt1 = points[i];
pt2 = points[next];
// insert a new point caused by the split
frac = dists[i] / (dists[i] - dists[next]);
pt3 = pt1.Lerp(pt2, frac);
// insert a new point caused by the split
frac = dists[i] / (dists[i] - dists[next]);
pt3 = pt1.Lerp(pt2, frac);
frontPoints->Push(pt3);
backPoints->Push(pt3);
}
frontPoints->Push(pt3);
backPoints->Push(pt3);
}
}
// Recursively divides the surface
bool kexLightSurface::SubdivideRecursion(vertexBatch_t &surfPoints, float divide, kexArray<vertexBatch_t*> &points)
{
kexBBox bounds;
kexVec3 splitNormal;
float dist;
vertexBatch_t *frontPoints;
vertexBatch_t *backPoints;
kexBBox bounds;
kexVec3 splitNormal;
float dist;
vertexBatch_t *frontPoints;
vertexBatch_t *backPoints;
// get bounds from current set of points
for(unsigned int i = 0; i < surfPoints.Length(); ++i)
{
bounds.AddPoint(surfPoints[i]);
}
// get bounds from current set of points
for (unsigned int i = 0; i < surfPoints.Length(); ++i)
{
bounds.AddPoint(surfPoints[i]);
}
for(int i = 0; i < 3; ++i)
{
// check if its large enough to be divided
if((bounds.max[i] - bounds.min[i]) > divide)
{
splitNormal.Clear();
splitNormal[i] = 1;
for (int i = 0; i < 3; ++i)
{
// check if its large enough to be divided
if ((bounds.max[i] - bounds.min[i]) > divide)
{
splitNormal.Clear();
splitNormal[i] = 1;
dist = (bounds.max[i] + bounds.min[i]) * 0.5f;
dist = (bounds.max[i] + bounds.min[i]) * 0.5f;
frontPoints = new vertexBatch_t;
backPoints = new vertexBatch_t;
frontPoints = new vertexBatch_t;
backPoints = new vertexBatch_t;
// start clipping
Clip(surfPoints, splitNormal, dist, frontPoints, backPoints);
// start clipping
Clip(surfPoints, splitNormal, dist, frontPoints, backPoints);
if(!SubdivideRecursion(*frontPoints, divide, points))
{
points.Push(frontPoints);
}
else
{
delete frontPoints;
}
if (!SubdivideRecursion(*frontPoints, divide, points))
{
points.Push(frontPoints);
}
else
{
delete frontPoints;
}
if(!SubdivideRecursion(*backPoints, divide, points))
{
points.Push(backPoints);
}
else
{
delete backPoints;
}
if (!SubdivideRecursion(*backPoints, divide, points))
{
points.Push(backPoints);
}
else
{
delete backPoints;
}
return true;
}
}
return true;
}
}
return false;
return false;
}
void kexLightSurface::Subdivide(const float divide)
{
kexArray<vertexBatch_t*> points;
vertexBatch_t surfPoints;
kexArray<vertexBatch_t*> points;
vertexBatch_t surfPoints;
for(int i = 0; i < surface->numVerts; ++i)
{
surfPoints.Push(surface->verts[i]);
}
for (int i = 0; i < surface->numVerts; ++i)
{
surfPoints.Push(surface->verts[i]);
}
SubdivideRecursion(surfPoints, divide, points);
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)
{
vertexBatch_t *vb = points[i];
kexVec3 center;
// 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)
{
vertexBatch_t *vb = points[i];
kexVec3 center;
for(unsigned int j = 0; j < vb->Length(); ++j)
{
center += (*vb)[j];
}
for (unsigned int j = 0; j < vb->Length(); ++j)
{
center += (*vb)[j];
}
origins.Push(center / (float)vb->Length());
}
origins.Push(center / (float)vb->Length());
}
for(unsigned int i = 0; i < points.Length(); ++i)
{
vertexBatch_t *vb = points[i];
for (unsigned int i = 0; i < points.Length(); ++i)
{
vertexBatch_t *vb = points[i];
vb->Empty();
delete vb;
}
vb->Empty();
delete vb;
}
}
bool kexLightSurface::TraceSurface(FLevel *doomMap, kexTrace &trace, const surface_t *surf, const kexVec3 &origin, float *dist)
{
kexVec3 normal;
kexVec3 lnormal;
float curDist;
kexVec3 normal;
kexVec3 lnormal;
float curDist;
*dist = -M_INFINITY;
*dist = -M_INFINITY;
// light surface will always be fullbright
if(surf == surface)
{
*dist = Intensity();
return true;
}
// light surface will always be fullbright
if (surf == surface)
{
*dist = Intensity();
return true;
}
lnormal = surface->plane.Normal();
lnormal = surface->plane.Normal();
if(surf)
{
normal = surf->plane.Normal();
if (surf)
{
normal = surf->plane.Normal();
if(normal.Dot(lnormal) > 0)
{
// not facing the light surface
return false;
}
}
else
{
normal = kexVec3::vecUp;
}
if (normal.Dot(lnormal) > 0)
{
// not facing the light surface
return false;
}
}
else
{
normal = kexVec3::vecUp;
}
// we need to pick the closest sample point on the light surface. what really sucks is
// that we have to trace each one... which could really blow up the compile time
for(unsigned int i = 0; i < origins.Length(); ++i)
{
// we need to pick the closest sample point on the light surface. what really sucks is
// that we have to trace each one... which could really blow up the compile time
for (unsigned int i = 0; i < origins.Length(); ++i)
{
kexVec3 center = origins[i];
if(!bWall && origin.z > center.z)
{
// origin is not going to seen or traced by the light surface
// so don't even bother. this also fixes some bizzare light
// bleeding issues
continue;
}
if (!bWall && origin.z > center.z)
{
// origin is not going to seen or traced by the light surface
// so don't even bother. this also fixes some bizzare light
// bleeding issues
continue;
}
/*if(bWall)
{
angle = (origin - center).ToVec2().Normalize().Dot(lnormal.ToVec2());
}
else
{
kexVec3 dir = (origin - center).Normalize();
/*if(bWall)
{
angle = (origin - center).ToVec2().Normalize().Dot(lnormal.ToVec2());
}
else
{
kexVec3 dir = (origin - center).Normalize();
if(surf)
{
if(normal.Dot(dir) >= 0)
{
// not even facing the light surface
continue;
}
}
if(surf)
{
if(normal.Dot(dir) >= 0)
{
// not even facing the light surface
continue;
}
}
angle = dir.Dot(lnormal);
}*/
angle = dir.Dot(lnormal);
}*/
if(bWall)
{
if(origin.z >= surface->verts[0].z && origin.z <= surface->verts[2].z)
{
// since walls are always vertically straight, we can cheat a little by adjusting
// the sampling point height. this also allows us to do accurate light emitting
// while just using one sample point
center.z = origin.z;
}
}
if (bWall)
{
if (origin.z >= surface->verts[0].z && origin.z <= surface->verts[2].z)
{
// since walls are always vertically straight, we can cheat a little by adjusting
// the sampling point height. this also allows us to do accurate light emitting
// while just using one sample point
center.z = origin.z;
}
}
// trace the origin to the center of the light surface. nudge by the normals in
// case the start/end points are directly on or inside the surface
trace.Trace(center + lnormal, origin + normal);
// trace the origin to the center of the light surface. nudge by the normals in
// case the start/end points are directly on or inside the surface
trace.Trace(center + lnormal, origin + normal);
if(trace.fraction != 1)
{
// something is obstructing it
continue;
}
if (trace.fraction != 1)
{
// something is obstructing it
continue;
}
float d = origin.Distance(center);
float d = origin.Distance(center);
curDist = 1.0f - d / (distance * 2.0f); // 2.0 because gzdoom's dynlights do this and we want them to match
if (curDist < 0.0f) curDist = 0.0f;
if(curDist >= 1)
{
curDist = 1;
if (curDist >= 1)
{
curDist = 1;
// might get large unlit gaps near the surface. this looks a lot worse for
// non-wall light surfaces so just clamp to full bright and exit out.
if(!bWall)
{
*dist = 1;
// might get large unlit gaps near the surface. this looks a lot worse for
// non-wall light surfaces so just clamp to full bright and exit out.
if (!bWall)
{
*dist = 1;
break;
}
}
}
}
if(curDist > *dist)
{
*dist = curDist;
}
}
if (curDist > *dist)
{
*dist = curDist;
}
}
*dist *= Intensity();
return *dist > 0;
return *dist > 0;
}

44
src/lightmap/lightsurface.h
View file

@ -36,31 +36,31 @@ class kexTrace;
class kexLightSurface
{
public:
kexLightSurface();
~kexLightSurface();
kexLightSurface();
~kexLightSurface();
void Init(const surfaceLightDef &lightSurfaceDef, surface_t *surface, const bool bWall, const bool bNoCenterPoint);
void Subdivide(const float divide);
void CreateCenterOrigin();
bool TraceSurface(FLevel *doomMap, kexTrace &trace, const surface_t *surface, const kexVec3 &origin, float *dist);
void Init(const surfaceLightDef &lightSurfaceDef, surface_t *surface, const bool bWall, const bool bNoCenterPoint);
void Subdivide(const float divide);
void CreateCenterOrigin();
bool TraceSurface(FLevel *doomMap, kexTrace &trace, const surface_t *surface, const kexVec3 &origin, float *dist);
const float Distance() const { return distance; }
const float Intensity() const { return intensity; }
const kexVec3 GetRGB() const { return rgb; }
const bool IsAWall() const { return bWall; }
const bool NoCenterPoint() const { return bNoCenterPoint; }
const surface_t *Surface() const { return surface; }
const vertexBatch_t Origins() const { return origins; }
const float Distance() const { return distance; }
const float Intensity() const { return intensity; }
const kexVec3 GetRGB() const { return rgb; }
const bool IsAWall() const { return bWall; }
const bool NoCenterPoint() const { return bNoCenterPoint; }
const surface_t *Surface() const { return surface; }
const vertexBatch_t Origins() const { return origins; }
private:
bool SubdivideRecursion(vertexBatch_t &surfPoints, float divide, kexArray<vertexBatch_t*> &points);
void Clip(vertexBatch_t &points, const kexVec3 &normal, float dist, vertexBatch_t *frontPoints, vertexBatch_t *backPoints);
bool SubdivideRecursion(vertexBatch_t &surfPoints, float divide, kexArray<vertexBatch_t*> &points);
void Clip(vertexBatch_t &points, const kexVec3 &normal, float dist, vertexBatch_t *frontPoints, vertexBatch_t *backPoints);
float distance;
float intensity;
kexVec3 rgb;
bool bWall;
bool bNoCenterPoint;
vertexBatch_t origins;
surface_t *surface;
float distance;
float intensity;
kexVec3 rgb;
bool bWall;
bool bNoCenterPoint;
vertexBatch_t origins;
surface_t *surface;
};

278
src/lightmap/surfaces.cpp
View file

@ -38,17 +38,17 @@ kexArray<surface_t*> surfaces;
static void CreateSideSurfaces(FLevel &doomMap, IntSideDef *side)
{
surface_t *surf;
IntSector *front;
IntSector *back;
surface_t *surf;
IntSector *front;
IntSector *back;
front = doomMap.GetFrontSector(side);
back = doomMap.GetBackSector(side);
front = doomMap.GetFrontSector(side);
back = doomMap.GetBackSector(side);
if (front->controlsector)
return;
FloatVertex v1 = doomMap.GetSegVertex(side->line->v1);
FloatVertex v1 = doomMap.GetSegVertex(side->line->v1);
FloatVertex v2 = doomMap.GetSegVertex(side->line->v2);
if (side->line->sidenum[0] != (ptrdiff_t)(side - &doomMap.Sides[0]))
@ -61,199 +61,199 @@ static void CreateSideSurfaces(FLevel &doomMap, IntSideDef *side)
float v2Top = front->ceilingplane.zAt(v2.x, v2.y);
float v2Bottom = front->floorplane.zAt(v2.x, v2.y);
if(back)
{
if (back)
{
float v1TopBack = back->ceilingplane.zAt(v1.x, v1.y);
float v1BottomBack = back->floorplane.zAt(v1.x, v1.y);
float v2TopBack = back->ceilingplane.zAt(v2.x, v2.y);
float v2BottomBack = back->floorplane.zAt(v2.x, v2.y);
if (v1Top == v1TopBack && v1Bottom == v1BottomBack && v2Top == v2TopBack && v2Bottom == v2BottomBack)
{
return;
}
if (v1Top == v1TopBack && v1Bottom == v1BottomBack && v2Top == v2TopBack && v2Bottom == v2BottomBack)
{
return;
}
// bottom seg
if(v1Bottom < v1BottomBack || v2Bottom < v2BottomBack)
{
if(side->bottomtexture[0] != '-')
{
surf = (surface_t*)Mem_Calloc(sizeof(surface_t), hb_static);
surf->numVerts = 4;
surf->verts = (kexVec3*)Mem_Calloc(sizeof(kexVec3) * 4, hb_static);
// bottom seg
if (v1Bottom < v1BottomBack || v2Bottom < v2BottomBack)
{
if (side->bottomtexture[0] != '-')
{
surf = (surface_t*)Mem_Calloc(sizeof(surface_t), hb_static);
surf->numVerts = 4;
surf->verts = (kexVec3*)Mem_Calloc(sizeof(kexVec3) * 4, hb_static);
surf->verts[0].x = surf->verts[2].x = v1.x;
surf->verts[0].y = surf->verts[2].y = v1.y;
surf->verts[1].x = surf->verts[3].x = v2.x;
surf->verts[1].y = surf->verts[3].y = v2.y;
surf->verts[0].x = surf->verts[2].x = v1.x;
surf->verts[0].y = surf->verts[2].y = v1.y;
surf->verts[1].x = surf->verts[3].x = v2.x;
surf->verts[1].y = surf->verts[3].y = v2.y;
surf->verts[0].z = v1Bottom;
surf->verts[1].z = v2Bottom;
surf->verts[2].z = v1BottomBack;
surf->verts[3].z = v2BottomBack;
surf->plane.SetNormal(surf->verts[0], surf->verts[1], surf->verts[2]);
surf->plane.SetDistance(surf->verts[0]);
surf->type = ST_LOWERSIDE;
surf->typeIndex = side - &doomMap.Sides[0];
surf->plane.SetNormal(surf->verts[0], surf->verts[1], surf->verts[2]);
surf->plane.SetDistance(surf->verts[0]);
surf->type = ST_LOWERSIDE;
surf->typeIndex = side - &doomMap.Sides[0];
surfaces.Push(surf);
}
surfaces.Push(surf);
}
v1Bottom = v1BottomBack;
v2Bottom = v2BottomBack;
}
}
// top seg
if(v1Top > v1TopBack || v2Top > v2TopBack)
{
bool bSky = false;
int frontidx = front - &doomMap.Sectors[0];
int backidx = back - &doomMap.Sectors[0];
// top seg
if (v1Top > v1TopBack || v2Top > v2TopBack)
{
bool bSky = false;
int frontidx = front - &doomMap.Sectors[0];
int backidx = back - &doomMap.Sectors[0];
if(doomMap.bSkySectors[frontidx] && doomMap.bSkySectors[backidx])
{
if(front->data.ceilingheight != back->data.ceilingheight && side->toptexture[0] == '-')
{
bSky = true;
}
}
if (doomMap.bSkySectors[frontidx] && doomMap.bSkySectors[backidx])
{
if (front->data.ceilingheight != back->data.ceilingheight && side->toptexture[0] == '-')
{
bSky = true;
}
}
if(side->toptexture[0] != '-' || bSky)
{
surf = (surface_t*)Mem_Calloc(sizeof(surface_t), hb_static);
surf->numVerts = 4;
surf->verts = (kexVec3*)Mem_Calloc(sizeof(kexVec3) * 4, hb_static);
if (side->toptexture[0] != '-' || bSky)
{
surf = (surface_t*)Mem_Calloc(sizeof(surface_t), hb_static);
surf->numVerts = 4;
surf->verts = (kexVec3*)Mem_Calloc(sizeof(kexVec3) * 4, hb_static);
surf->verts[0].x = surf->verts[2].x = v1.x;
surf->verts[0].y = surf->verts[2].y = v1.y;
surf->verts[1].x = surf->verts[3].x = v2.x;
surf->verts[1].y = surf->verts[3].y = v2.y;
surf->verts[0].x = surf->verts[2].x = v1.x;
surf->verts[0].y = surf->verts[2].y = v1.y;
surf->verts[1].x = surf->verts[3].x = v2.x;
surf->verts[1].y = surf->verts[3].y = v2.y;
surf->verts[0].z = v1TopBack;
surf->verts[1].z = v2TopBack;
surf->verts[2].z = v1Top;
surf->verts[3].z = v2Top;
surf->plane.SetNormal(surf->verts[0], surf->verts[1], surf->verts[2]);
surf->plane.SetDistance(surf->verts[0]);
surf->type = ST_UPPERSIDE;
surf->plane.SetNormal(surf->verts[0], surf->verts[1], surf->verts[2]);
surf->plane.SetDistance(surf->verts[0]);
surf->type = ST_UPPERSIDE;
surf->typeIndex = side - &doomMap.Sides[0];
surf->bSky = bSky;
surf->bSky = bSky;
surfaces.Push(surf);
}
surfaces.Push(surf);
}
v1Top = v1TopBack;
v2Top = v2TopBack;
}
}
}
}
// middle seg
if(back == NULL)
{
surf = (surface_t*)Mem_Calloc(sizeof(surface_t), hb_static);
surf->numVerts = 4;
surf->verts = (kexVec3*)Mem_Calloc(sizeof(kexVec3) * 4, hb_static);
// middle seg
if (back == NULL)
{
surf = (surface_t*)Mem_Calloc(sizeof(surface_t), hb_static);
surf->numVerts = 4;
surf->verts = (kexVec3*)Mem_Calloc(sizeof(kexVec3) * 4, hb_static);
surf->verts[0].x = surf->verts[2].x = v1.x;
surf->verts[0].y = surf->verts[2].y = v1.y;
surf->verts[1].x = surf->verts[3].x = v2.x;
surf->verts[1].y = surf->verts[3].y = v2.y;
surf->verts[0].x = surf->verts[2].x = v1.x;
surf->verts[0].y = surf->verts[2].y = v1.y;
surf->verts[1].x = surf->verts[3].x = v2.x;
surf->verts[1].y = surf->verts[3].y = v2.y;
surf->verts[0].z = v1Bottom;
surf->verts[1].z = v2Bottom;
surf->verts[2].z = v1Top;
surf->verts[3].z = v2Top;
surf->plane.SetNormal(surf->verts[0], surf->verts[1], surf->verts[2]);
surf->plane.SetDistance(surf->verts[0]);
surf->type = ST_MIDDLESIDE;
surf->plane.SetNormal(surf->verts[0], surf->verts[1], surf->verts[2]);
surf->plane.SetDistance(surf->verts[0]);
surf->type = ST_MIDDLESIDE;
surf->typeIndex = side - &doomMap.Sides[0];
surfaces.Push(surf);
}
surfaces.Push(surf);
}
}
static void CreateSubsectorSurfaces(FLevel &doomMap)
{
surface_t *surf;
IntSector *sector = NULL;
int i;
int j;
surface_t *surf;
IntSector *sector = NULL;
int i;
int j;
printf("------------- Building subsector surfaces -------------\n");
printf("------------- Building subsector surfaces -------------\n");
for(i = 0; i < doomMap.NumGLSubsectors; i++)
{
printf("subsectors: %i / %i\r", i+1, doomMap.NumGLSubsectors);
for (i = 0; i < doomMap.NumGLSubsectors; i++)
{
printf("subsectors: %i / %i\r", i + 1, doomMap.NumGLSubsectors);
MapSubsectorEx *sub = &doomMap.GLSubsectors[i];
if(sub->numlines < 3)
{
continue;
}
if (sub->numlines < 3)
{
continue;
}
sector = doomMap.GetSectorFromSubSector(sub);
sector = doomMap.GetSectorFromSubSector(sub);
// I will be NOT surprised if some users tries to do something stupid with
// sector hacks
if(sector == NULL)
{
Error("CreateSubsectorSurfaces: subsector %i has no sector\n", i);
return;
}
// I will be NOT surprised if some users tries to do something stupid with
// sector hacks
if (sector == NULL)
{
Error("CreateSubsectorSurfaces: subsector %i has no sector\n", i);
return;
}
if (sector->controlsector)
continue;
surf = (surface_t*)Mem_Calloc(sizeof(surface_t), hb_static);
surf->numVerts = sub->numlines;
surf->verts = (kexVec3*)Mem_Calloc(sizeof(kexVec3) * surf->numVerts, hb_static);
surf = (surface_t*)Mem_Calloc(sizeof(surface_t), hb_static);
surf->numVerts = sub->numlines;
surf->verts = (kexVec3*)Mem_Calloc(sizeof(kexVec3) * surf->numVerts, hb_static);
// floor verts
for(j = 0; j < surf->numVerts; j++)
{
MapSegGLEx *seg = &doomMap.GLSegs[sub->firstline + (surf->numVerts - 1) - j];
// floor verts
for (j = 0; j < surf->numVerts; j++)
{
MapSegGLEx *seg = &doomMap.GLSegs[sub->firstline + (surf->numVerts - 1) - j];
FloatVertex v1 = doomMap.GetSegVertex(seg->v1);
surf->verts[j].x = v1.x;
surf->verts[j].y = v1.y;
surf->verts[j].z = sector->floorplane.zAt(surf->verts[j].x, surf->verts[j].y);
}
surf->verts[j].x = v1.x;
surf->verts[j].y = v1.y;
surf->verts[j].z = sector->floorplane.zAt(surf->verts[j].x, surf->verts[j].y);
}
surf->plane = sector->floorplane;
surf->type = ST_FLOOR;
surf->typeIndex = i;
surf->plane = sector->floorplane;
surf->type = ST_FLOOR;
surf->typeIndex = i;
surfaces.Push(surf);
surfaces.Push(surf);
surf = (surface_t*)Mem_Calloc(sizeof(surface_t), hb_static);
surf->numVerts = sub->numlines;
surf->verts = (kexVec3*)Mem_Calloc(sizeof(kexVec3) * surf->numVerts, hb_static);
surf = (surface_t*)Mem_Calloc(sizeof(surface_t), hb_static);
surf->numVerts = sub->numlines;
surf->verts = (kexVec3*)Mem_Calloc(sizeof(kexVec3) * surf->numVerts, hb_static);
if(doomMap.bSkySectors[sector-&doomMap.Sectors[0]])
{
surf->bSky = true;
}
if (doomMap.bSkySectors[sector - &doomMap.Sectors[0]])
{
surf->bSky = true;
}
// ceiling verts
for(j = 0; j < surf->numVerts; j++)
{
// ceiling verts
for (j = 0; j < surf->numVerts; j++)
{
MapSegGLEx *seg = &doomMap.GLSegs[sub->firstline + j];
FloatVertex v1 = doomMap.GetSegVertex(seg->v1);
surf->verts[j].x = v1.x;
surf->verts[j].y = v1.y;
surf->verts[j].z = sector->ceilingplane.zAt(surf->verts[j].x, surf->verts[j].y);
}
surf->verts[j].x = v1.x;
surf->verts[j].y = v1.y;
surf->verts[j].z = sector->ceilingplane.zAt(surf->verts[j].x, surf->verts[j].y);
}
surf->plane = sector->ceilingplane;
surf->type = ST_CEILING;
surf->typeIndex = i;
surf->plane = sector->ceilingplane;
surf->type = ST_CEILING;
surf->typeIndex = i;
surfaces.Push(surf);
}
surfaces.Push(surf);
}
printf("\nLeaf surfaces: %i\n", surfaces.Length() - doomMap.NumGLSubsectors);
printf("\nLeaf surfaces: %i\n", surfaces.Length() - doomMap.NumGLSubsectors);
}
static bool IsDegenerate(const kexVec3 &v0, const kexVec3 &v1, const kexVec3 &v2)
@ -313,19 +313,19 @@ void CreateSurfaces(FLevel &doomMap)
}
}
printf("------------- Building side surfaces -------------\n");
printf("------------- Building side surfaces -------------\n");
for(unsigned int i = 0; i < doomMap.Sides.Size(); i++)
{
for (unsigned int i = 0; i < doomMap.Sides.Size(); i++)
{
CreateSideSurfaces(doomMap, &doomMap.Sides[i]);
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", surfaces.Length());
CreateSubsectorSurfaces(doomMap);
CreateSubsectorSurfaces(doomMap);
printf("Surfaces total: %i\n\n", surfaces.Length());
printf("Surfaces total: %i\n\n", surfaces.Length());
printf("Building collision mesh..\n\n");

40
src/lightmap/surfaces.h
View file

@ -31,12 +31,12 @@ struct MapSubsectorEx;
enum surfaceType_t
{
ST_UNKNOWN = 0,
ST_MIDDLESIDE,
ST_UPPERSIDE,
ST_LOWERSIDE,
ST_CEILING,
ST_FLOOR
ST_UNKNOWN,
ST_MIDDLESIDE,
ST_UPPERSIDE,
ST_LOWERSIDE,
ST_CEILING,
ST_FLOOR
};
typedef kexArray<kexVec3> vertexBatch_t;
@ -46,20 +46,20 @@ typedef kexArray<kexVec3> vertexBatch_t;
struct surface_t
{
kexPlane plane;
int lightmapNum;
int lightmapOffs[2];
int lightmapDims[2];
kexVec3 lightmapOrigin;
kexVec3 lightmapSteps[2];
kexVec3 textureCoords[2];
kexBBox bounds;
int numVerts;
kexVec3 *verts;
float *lightmapCoords;
surfaceType_t type;
int typeIndex;
bool bSky;
kexPlane plane;
int lightmapNum;
int lightmapOffs[2];
int lightmapDims[2];
kexVec3 lightmapOrigin;
kexVec3 lightmapSteps[2];
kexVec3 textureCoords[2];
kexBBox bounds;
int numVerts;
kexVec3 *verts;
float *lightmapCoords;
surfaceType_t type;
int typeIndex;
bool bSky;
};
extern kexArray<surface_t*> surfaces;

6
src/lightmap/trace.cpp
View file

@ -37,13 +37,13 @@
void kexTrace::Init(FLevel &doomMap)
{
map = &doomMap;
map = &doomMap;
}
void kexTrace::Trace(const kexVec3 &startVec, const kexVec3 &endVec)
{
start = startVec;
end = endVec;
start = startVec;
end = endVec;
TraceHit hit = TriangleMeshShape::find_first_hit(map->CollisionMesh.get(), start, end);
fraction = hit.fraction;

14
src/lightmap/trace.h
View file

@ -32,14 +32,14 @@ struct FLevel;
class kexTrace
{
public:
void Init(FLevel &doomMap);
void Trace(const kexVec3 &startVec, const kexVec3 &endVec);
void Init(FLevel &doomMap);
void Trace(const kexVec3 &startVec, const kexVec3 &endVec);
kexVec3 start;
kexVec3 end;
surface_t *hitSurface;
float fraction;
kexVec3 start;
kexVec3 end;
surface_t *hitSurface;
float fraction;
private:
FLevel *map = nullptr;
FLevel *map = nullptr;
};