aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-11-25 00:26:17 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Separate count and size

Browse source
This commit is contained in:
kaetemi 2013-09-09 01:31:15 +02:00
parent b0079c38be
commit bb80d71b9b
3 changed files with 52 additions and 68 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
code/nel/include/nel/3d/driver.h
View file

@ -1124,9 +1124,6 @@ public:
virtual void setVertexProgram3f(uint index, const NLMISC::CVector& v) = 0; virtual void setVertexProgram3f(uint index, const NLMISC::CVector& v) = 0;
virtual void setVertexProgram4f(uint index, const NLMISC::CVector& v, float f3) = 0; virtual void setVertexProgram4f(uint index, const NLMISC::CVector& v, float f3) = 0;
virtual void setVertexProgram4x4f(uint index, const NLMISC::CMatrix& m) = 0; virtual void setVertexProgram4x4f(uint index, const NLMISC::CMatrix& m) = 0;
virtual void setVertexProgram1fv(uint index, size_t num, const float *src) = 0;
virtual void setVertexProgram2fv(uint index, size_t num, const float *src) = 0;
virtual void setVertexProgram3fv(uint index, size_t num, const float *src) = 0;
virtual void setVertexProgram4fv(uint index, size_t num, const float *src) = 0; virtual void setVertexProgram4fv(uint index, size_t num, const float *src) = 0;
// @} // @}
@ -1170,9 +1167,6 @@ public:
virtual void setPixelProgram3f(uint index, const NLMISC::CVector& v) = 0; virtual void setPixelProgram3f(uint index, const NLMISC::CVector& v) = 0;
virtual void setPixelProgram4f(uint index, const NLMISC::CVector& v, float f3) = 0; virtual void setPixelProgram4f(uint index, const NLMISC::CVector& v, float f3) = 0;
virtual void setPixelProgram4x4f(uint index, const NLMISC::CMatrix& m) = 0; virtual void setPixelProgram4x4f(uint index, const NLMISC::CMatrix& m) = 0;
virtual void setPixelProgram1fv(uint index, size_t num, const float *src) = 0;
virtual void setPixelProgram2fv(uint index, size_t num, const float *src) = 0;
virtual void setPixelProgram3fv(uint index, size_t num, const float *src) = 0;
virtual void setPixelProgram4fv(uint index, size_t num, const float *src) = 0; virtual void setPixelProgram4fv(uint index, size_t num, const float *src) = 0;
// @} // @}

39
code/nel/include/nel/3d/gpu_program_params.h
View file

@ -56,11 +56,11 @@ namespace NL3D {
class CGPUProgramParams class CGPUProgramParams
{ {
public: public:
enum TType { Float, Int }; enum TType { Float, Int, UInt };
struct CMeta { uint Index, Count; TType Type; size_t Next, Prev; }; struct CMeta { uint Index, Size, Count; TType Type; size_t Next, Prev; }; // size is element size, count is nb of elements
private: private:
union CVec { float F[4]; sint32 I[4]; }; union CVec { float F[4]; sint32 I[4]; uint32 UI[4]; };
public: public:
CGPUProgramParams(); CGPUProgramParams();
@ -81,9 +81,6 @@ public:
void set3f(uint index, const NLMISC::CVector& v); void set3f(uint index, const NLMISC::CVector& v);
void set4f(uint index, const NLMISC::CVector& v, float f3); void set4f(uint index, const NLMISC::CVector& v, float f3);
void set4x4f(uint index, const NLMISC::CMatrix& m); void set4x4f(uint index, const NLMISC::CMatrix& m);
void set1fv(uint index, size_t num, const float *src);
void set2fv(uint index, size_t num, const float *src);
void set3fv(uint index, size_t num, const float *src);
void set4fv(uint index, size_t num, const float *src); void set4fv(uint index, size_t num, const float *src);
void unset(uint index); void unset(uint index);
@ -99,9 +96,6 @@ public:
void set3f(const std::string &name, const NLMISC::CVector& v); void set3f(const std::string &name, const NLMISC::CVector& v);
void set4f(const std::string &name, const NLMISC::CVector& v, float f3); void set4f(const std::string &name, const NLMISC::CVector& v, float f3);
void set4x4f(const std::string &name, const NLMISC::CMatrix& m); void set4x4f(const std::string &name, const NLMISC::CMatrix& m);
void set1fv(const std::string &name, size_t num, const float *src);
void set2fv(const std::string &name, size_t num, const float *src);
void set3fv(const std::string &name, size_t num, const float *src);
void set4fv(const std::string &name, size_t num, const float *src); void set4fv(const std::string &name, size_t num, const float *src);
void unset(const std::string &name); void unset(const std::string &name);
@ -110,8 +104,8 @@ public:
// Internal // Internal
/// Allocate specified number of components if necessary /// Allocate specified number of components if necessary
size_t allocOffset(uint index, uint count, TType type); size_t allocOffset(uint index, uint size, uint count, TType type);
size_t allocOffset(const std::string &name, uint count, TType type); size_t allocOffset(const std::string &name, uint size, uint count, TType type);
/// Return offset for specified index /// Return offset for specified index
size_t getOffset(uint index) const; size_t getOffset(uint index) const;
size_t getOffset(const std::string &name) const; size_t getOffset(const std::string &name) const;
@ -119,20 +113,23 @@ public:
void freeOffset(size_t offset); void freeOffset(size_t offset);
// Iteration (returns the offsets for access using getFooByOffset) // Iteration (returns the offsets for access using getFooByOffset)
size_t getBegin() const { return m_Meta.size() ? m_First : s_End; } inline size_t getBegin() const { return m_Meta.size() ? m_First : s_End; }
size_t getNext(size_t offset) const { return m_Meta[offset].Next; } inline size_t getNext(size_t offset) const { return m_Meta[offset].Next; }
size_t getEnd() const { return s_End; } inline size_t getEnd() const { return s_End; }
// Data access // Data access
uint getCountByOffset(size_t offset) { return m_Meta[offset].Count; } // component count (number of floats or ints) inline uint getSizeByOffset(size_t offset) const { return m_Meta[offset].Size; } // size of element (4 for float4)
float *getPtrFByOffset(size_t offset) { return m_Vec[offset].F; } inline uint getCountByOffset(size_t offset) const { return m_Meta[offset].Count; } // number of elements (usually 1)
int *getPtrIByOffset(size_t offset) { return m_Vec[offset].I; } inline uint getNbComponentsByOffset(size_t offset) const { return m_Meta[offset].Size * m_Meta[offset].Count; } // nb of components (size * count)
TType getTypeByOffset(size_t offset) { return m_Meta[offset].Type; } inline float *getPtrFByOffset(size_t offset) { return m_Vec[offset].F; }
uint getIndexByOffset(size_t offset) { return m_Meta[offset].Index; } inline sint32 *getPtrIByOffset(size_t offset) { return m_Vec[offset].I; }
const std::string *getNameByOffset(size_t offset); // non-optimized for dev tools only, may return NULL if name unknown inline uint32 *getPtrUIByOffset(size_t offset) { return m_Vec[offset].UI; }
inline TType getTypeByOffset(size_t offset) const { return m_Meta[offset].Type; }
inline uint getIndexByOffset(size_t offset) const { return m_Meta[offset].Index; }
const std::string *getNameByOffset(size_t offset) const; // non-optimized for dev tools only, may return NULL if name unknown
// Utility // Utility
static inline uint getNbRegistersByComponents(uint count) { return (count + 3) >> 2; } // vector register per 4 components static inline uint getNbRegistersByComponents(uint nbComponents) { return (nbComponents + 3) >> 2; } // vector register per 4 components
private: private:
std::vector<CVec> m_Vec; std::vector<CVec> m_Vec;

75
code/nel/src/3d/gpu_program_params.cpp
View file

@ -53,118 +53,110 @@ CGPUProgramParams::~CGPUProgramParams()
} }
void CGPUProgramParams::set(uint index, float f0) void CGPUProgramParams::set1f(uint index, float f0)
{ {
float *f = getPtrFByOffset(allocOffset(index, 1, Float)); float *f = getPtrFByOffset(allocOffset(index, 1, 1, Float));
f[0] = f0; f[0] = f0;
} }
void CGPUProgramParams::set(uint index, float f0, float f1) void CGPUProgramParams::set2f(uint index, float f0, float f1)
{ {
float *f = getPtrFByOffset(allocOffset(index, 2, Float)); float *f = getPtrFByOffset(allocOffset(index, 2, 1, Float));
f[0] = f0; f[0] = f0;
f[1] = f1; f[1] = f1;
} }
void CGPUProgramParams::set(uint index, float f0, float f1, float f2) void CGPUProgramParams::set3f(uint index, float f0, float f1, float f2)
{ {
float *f = getPtrFByOffset(allocOffset(index, 3, Float)); float *f = getPtrFByOffset(allocOffset(index, 3, 1, Float));
f[0] = f0; f[0] = f0;
f[1] = f1; f[1] = f1;
f[2] = f2; f[2] = f2;
} }
void CGPUProgramParams::set(uint index, float f0, float f1, float f2, float f3) void CGPUProgramParams::set4f(uint index, float f0, float f1, float f2, float f3)
{ {
float *f = getPtrFByOffset(allocOffset(index, 4, Float)); float *f = getPtrFByOffset(allocOffset(index, 4, 1, Float));
f[0] = f0; f[0] = f0;
f[1] = f1; f[1] = f1;
f[2] = f2; f[2] = f2;
f[3] = f3; f[3] = f3;
} }
void CGPUProgramParams::set(uint index, int i0) void CGPUProgramParams::set1i(uint index, int i0)
{ {
int *i = getPtrIByOffset(allocOffset(index, 1, Int)); int *i = getPtrIByOffset(allocOffset(index, 1, 1, Int));
i[0] = i0; i[0] = i0;
} }
void CGPUProgramParams::set(uint index, int i0, int i1) void CGPUProgramParams::set2i(uint index, int i0, int i1)
{ {
int *i = getPtrIByOffset(allocOffset(index, 2, Int)); int *i = getPtrIByOffset(allocOffset(index, 2, 1, Int));
i[0] = i0; i[0] = i0;
i[1] = i1; i[1] = i1;
} }
void CGPUProgramParams::set(uint index, int i0, int i1, int i2) void CGPUProgramParams::set3i(uint index, int i0, int i1, int i2)
{ {
int *i = getPtrIByOffset(allocOffset(index, 3, Int)); int *i = getPtrIByOffset(allocOffset(index, 3, 1, Int));
i[0] = i0; i[0] = i0;
i[1] = i1; i[1] = i1;
i[2] = i2; i[2] = i2;
} }
void CGPUProgramParams::set(uint index, int i0, int i1, int i2, int i3) void CGPUProgramParams::set4i(uint index, int i0, int i1, int i2, int i3)
{ {
int *i = getPtrIByOffset(allocOffset(index, 4, Int)); int *i = getPtrIByOffset(allocOffset(index, 4, 1, Int));
i[0] = i0; i[0] = i0;
i[1] = i1; i[1] = i1;
i[2] = i2; i[2] = i2;
i[3] = i3; i[3] = i3;
} }
void CGPUProgramParams::set(uint index, const NLMISC::CVector& v) void CGPUProgramParams::set3f(uint index, const NLMISC::CVector& v)
{ {
float *f = getPtrFByOffset(allocOffset(index, 3, Float)); float *f = getPtrFByOffset(allocOffset(index, 3, 1, Float));
f[0] = v.x; f[0] = v.x;
f[1] = v.y; f[1] = v.y;
f[2] = v.z; f[2] = v.z;
} }
void CGPUProgramParams::set(uint index, const NLMISC::CMatrix& m) void CGPUProgramParams::set4x4f(uint index, const NLMISC::CMatrix& m)
{ {
// TODO: Verify this! // TODO: Verify this!
float *f = getPtrFByOffset(allocOffset(index, 16, Float)); float *f = getPtrFByOffset(allocOffset(index, 4, 4, Float));
NLMISC::CMatrix mt = m; NLMISC::CMatrix mt = m;
mt.transpose(); mt.transpose();
mt.get(f); mt.get(f);
} }
void CGPUProgramParams::set(uint index, const float *arr, size_t sz) void CGPUProgramParams::set4fv(uint index, size_t num, const float *src)
{ {
float *f = getPtrFByOffset(allocOffset(index, sz, Float)); float *f = getPtrFByOffset(allocOffset(index, 4, num, Float));
for (uint c = 0; c < sz; ++c) size_t nb = 4 * num;
f[c] = arr[c]; for (uint c = 0; c < nb; ++c)
} f[c] = src[c];
void CGPUProgramParams::set(uint index, const sint32 *arr, size_t sz)
{
int *i = getPtrIByOffset(allocOffset(index, sz, Int));
for (uint c = 0; c < sz; ++c)
i[c] = arr[c];
} }
/// Allocate specified number of components if necessary /// Allocate specified number of components if necessary
size_t CGPUProgramParams::allocOffset(uint index, uint count, TType type) size_t CGPUProgramParams::allocOffset(uint index, uint size, uint count, TType type)
{ {
nlassert(count > 0); // this code will not properly handle 0 nlassert(count > 0); // this code will not properly handle 0
nlassert(size > 0); // this code will not properly handle 0
nlassert(index < 0xFFFF); // sanity check nlassert(index < 0xFFFF); // sanity check
uint nbComponents = size * count;
size_t offset = getOffset(index); size_t offset = getOffset(index);
if (offset != s_End) if (offset != s_End)
{ {
if (getCountByOffset(offset) == count) if (getCountByOffset(offset) >= nbComponents)
{ {
m_Meta[offset].Type = type; m_Meta[offset].Type = type;
m_Meta[offset].Size = size;
m_Meta[offset].Count = count;
return offset; return offset;
} }
if (getCountByOffset(offset) > count) if (getCountByOffset(offset) < nbComponents)
{
m_Meta[offset].Type = type;
m_Meta[offset].Count = count; // reduce count
return offset;
}
if (getCountByOffset(offset) < count)
{ {
freeOffset(offset); freeOffset(offset);
} }
@ -172,7 +164,7 @@ size_t CGPUProgramParams::allocOffset(uint index, uint count, TType type)
// Allocate space // Allocate space
offset = m_Meta.size(); offset = m_Meta.size();
uint blocks = getNbRegistersByComponents(count); // per 4 components uint blocks = getNbRegistersByComponents(nbComponents); // per 4 components
m_Meta.resize(offset + blocks); m_Meta.resize(offset + blocks);
m_Vec.resize(offset + blocks); m_Vec.resize(offset + blocks);
@ -183,6 +175,7 @@ size_t CGPUProgramParams::allocOffset(uint index, uint count, TType type)
// Fill // Fill
m_Meta[offset].Index = index; m_Meta[offset].Index = index;
m_Meta[offset].Size = size;
m_Meta[offset].Count = count; m_Meta[offset].Count = count;
m_Meta[offset].Type = type; m_Meta[offset].Type = type;
m_Meta[offset].Prev = m_Last; m_Meta[offset].Prev = m_Last;