Removes bitarray.h from Code/Editor
Signed-off-by: Esteban Papp <81431996+amznestebanpapp@users.noreply.github.com>monroegm-disable-blank-issue-2
Esteban Papp
4 years ago
parent
ac4ce8983b
commit
0d94e5cb0d
@ -1,335 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) Contributors to the Open 3D Engine Project.
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
// Description : Array of m_bits.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_EDITOR_UTIL_BITARRAY_H
|
||||
#define CRYINCLUDE_EDITOR_UTIL_BITARRAY_H
|
||||
#pragma once
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// CBitArray is similar to std::vector but faster to clear.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
class CBitArray
|
||||
{
|
||||
public:
|
||||
struct BitReference
|
||||
{
|
||||
uint32* p;
|
||||
uint32 mask;
|
||||
BitReference(uint32* __x, uint32 __y)
|
||||
: p(__x)
|
||||
, mask(__y) {}
|
||||
|
||||
|
||||
public:
|
||||
BitReference()
|
||||
: p(0)
|
||||
, mask(0) {}
|
||||
|
||||
operator bool() const {
|
||||
return !(!(*p & mask));
|
||||
}
|
||||
BitReference& operator=(bool __x)
|
||||
{
|
||||
if (__x)
|
||||
{
|
||||
* p |= mask;
|
||||
}
|
||||
else
|
||||
{
|
||||
* p &= ~mask;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
BitReference& operator=(const BitReference& __x) { return *this = bool(__x); }
|
||||
bool operator==(const BitReference& __x) const { return bool(*this) == bool(__x); }
|
||||
bool operator<(const BitReference& __x) const { return !bool(*this) && bool(__x); }
|
||||
BitReference& operator |= (bool __x)
|
||||
{
|
||||
if (__x)
|
||||
{
|
||||
* p |= mask;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
BitReference& operator &= (bool __x)
|
||||
{
|
||||
if (!__x)
|
||||
{
|
||||
* p &= ~mask;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
void flip() {* p ^= mask; }
|
||||
};
|
||||
|
||||
CBitArray() { m_base = nullptr; m_bits = nullptr; m_size = 0; m_numBits = 0; };
|
||||
CBitArray(int numBits) { resize(numBits); };
|
||||
~CBitArray()
|
||||
{
|
||||
if (m_base)
|
||||
{
|
||||
free(m_base);
|
||||
}
|
||||
};
|
||||
|
||||
void resize(int c)
|
||||
{
|
||||
m_numBits = c;
|
||||
int newSize = ((c + 63) & (~63)) >> 5;
|
||||
if (newSize > m_size)
|
||||
{
|
||||
Alloc(newSize);
|
||||
}
|
||||
}
|
||||
int size() const { return m_numBits; };
|
||||
bool empty() const { return m_numBits == 0; };
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
void set()
|
||||
{
|
||||
memset(m_bits, 0xFFFFFFFF, m_size * sizeof(uint32)); // Set all bits.
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
void set(int numBits)
|
||||
{
|
||||
int num = (numBits >> 3) + 1;
|
||||
if (num > (m_size * sizeof(uint32)))
|
||||
{
|
||||
num = m_size * sizeof(uint32);
|
||||
}
|
||||
memset(m_bits, 0xFFFFFFFF, num); // Reset num bits.
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
void clear()
|
||||
{
|
||||
memset(m_bits, 0, m_size * sizeof(uint32)); // Reset all bits.
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
void clear(int numBits)
|
||||
{
|
||||
int num = (numBits >> 3) + 1;
|
||||
if (num > (m_size * sizeof(uint32)))
|
||||
{
|
||||
num = m_size * sizeof(uint32);
|
||||
}
|
||||
memset(m_bits, 0, num); // Reset num bits.
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// Check if all bits are 0.
|
||||
bool is_zero() const
|
||||
{
|
||||
for (int i = 0; i < m_size; i++)
|
||||
{
|
||||
if (m_bits[i] != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Count number of set bits.
|
||||
int count_bits() const
|
||||
{
|
||||
int c = 0;
|
||||
for (int i = 0; i < m_size; i++)
|
||||
{
|
||||
uint32 v = m_bits[i];
|
||||
for (int j = 0; j < 32; j++)
|
||||
{
|
||||
if (v & (1 << (j & 0x1F)))
|
||||
{
|
||||
c++; // if bit set increase bit count.
|
||||
}
|
||||
}
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
BitReference operator[](int pos) { return BitReference(&m_bits[index(pos)], shift(pos)); }
|
||||
const BitReference operator[](int pos) const { return BitReference(&m_bits[index(pos)], shift(pos)); }
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
void swap(CBitArray& bitarr)
|
||||
{
|
||||
std::swap(m_base, bitarr.m_base);
|
||||
std::swap(m_bits, bitarr.m_bits);
|
||||
std::swap(m_size, bitarr.m_size);
|
||||
}
|
||||
|
||||
CBitArray& operator =(const CBitArray& b)
|
||||
{
|
||||
if (m_size != b.m_size)
|
||||
{
|
||||
Alloc(b.m_size);
|
||||
}
|
||||
memcpy(m_bits, b.m_bits, m_size * sizeof(uint32));
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool checkByte(int pos) const { return reinterpret_cast<char*>(m_bits)[pos] != 0; };
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// Compresses this bit array into the specified one.
|
||||
// Uses run length encoding compression.
|
||||
void compress(CBitArray& b) const
|
||||
{
|
||||
int i, countz, compsize, bsize;
|
||||
char* out;
|
||||
char* in;
|
||||
|
||||
bsize = m_size * 4;
|
||||
compsize = 0;
|
||||
in = (char*)m_bits;
|
||||
for (i = 0; i < bsize; i++)
|
||||
{
|
||||
compsize++;
|
||||
if (in[i] == 0)
|
||||
{
|
||||
countz = 1;
|
||||
while (++i < bsize)
|
||||
{
|
||||
if (in[i] == 0 && countz != 255)
|
||||
{
|
||||
countz++;
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
i--;
|
||||
compsize++;
|
||||
}
|
||||
}
|
||||
b.resize((compsize + 1) << 3);
|
||||
out = (char*)b.m_bits;
|
||||
in = (char*)m_bits;
|
||||
*out++ = static_cast<char>(bsize);
|
||||
for (i = 0; i < bsize; i++)
|
||||
{
|
||||
*out++ = in[i];
|
||||
if (in[i] == 0)
|
||||
{
|
||||
countz = 1;
|
||||
while (++i < bsize)
|
||||
{
|
||||
if (in[i] == 0 && countz != 255)
|
||||
{
|
||||
countz++;
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
i--;
|
||||
*out++ = static_cast<char>(countz);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// Decompress specified bit array in to this one.
|
||||
// Uses run length encoding compression.
|
||||
void decompress(CBitArray& b)
|
||||
{
|
||||
int raw, decompressed, c;
|
||||
char* out, * in;
|
||||
|
||||
in = (char*)m_bits;
|
||||
out = (char*)b.m_bits;
|
||||
decompressed = 0;
|
||||
raw = *in++;
|
||||
while (decompressed < raw)
|
||||
{
|
||||
if (*in != 0)
|
||||
{
|
||||
*out++ = *in++;
|
||||
decompressed++;
|
||||
}
|
||||
else
|
||||
{
|
||||
in++;
|
||||
c = *in++;
|
||||
decompressed += c;
|
||||
while (c)
|
||||
{
|
||||
*out++ = 0;
|
||||
c--;
|
||||
}
|
||||
;
|
||||
}
|
||||
}
|
||||
m_numBits = decompressed;
|
||||
}
|
||||
|
||||
void CopyFromMem(const char* src, int size)
|
||||
{
|
||||
Alloc(size);
|
||||
memcpy(m_bits, src, size);
|
||||
}
|
||||
int CopyToMem(char* trg)
|
||||
{
|
||||
memcpy(trg, m_bits, m_size);
|
||||
return m_size;
|
||||
}
|
||||
|
||||
private:
|
||||
void* m_base;
|
||||
uint32* m_bits;
|
||||
int m_size;
|
||||
int m_numBits;
|
||||
|
||||
void Alloc(int s)
|
||||
{
|
||||
if (m_base)
|
||||
{
|
||||
free(m_base);
|
||||
}
|
||||
m_size = s;
|
||||
m_base = (char*)malloc(m_size * sizeof(uint32) + 32);
|
||||
m_bits = (uint32*)(((UINT_PTR)m_base + 31) & (~31)); // align by 32.
|
||||
memset(m_bits, 0, m_size * sizeof(uint32)); // Reset all bits.
|
||||
}
|
||||
uint32 shift(int pos) const
|
||||
{
|
||||
return (1 << (pos & 0x1F));
|
||||
}
|
||||
uint32 index(int pos) const
|
||||
{
|
||||
return pos >> 5;
|
||||
}
|
||||
|
||||
friend int concatBitarray(CBitArray& b1, CBitArray& b2, CBitArray& test, CBitArray& res);
|
||||
};
|
||||
|
||||
inline int concatBitarray(CBitArray& b1, CBitArray& b2, CBitArray& test, CBitArray& res)
|
||||
{
|
||||
unsigned int b, any;
|
||||
any = 0;
|
||||
for (int i = 0; i < b1.size(); i++)
|
||||
{
|
||||
b = b1.m_bits[i] & b2.m_bits[i];
|
||||
any |= (b & (~test.m_bits[i])); // test if any different from test(i) bit set.
|
||||
res.m_bits[i] = b;
|
||||
}
|
||||
return any;
|
||||
}
|
||||
|
||||
#endif // CRYINCLUDE_EDITOR_UTIL_BITARRAY_H
|
||||
Loading…
Reference in New Issue