Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Sync llcommon with Alchemy a bit.

Browse Source 
llmath::llround->ll_round
LL_ICC->LL_INTELC
Add llpredicate
Add LL_CPP11 macro
Remove llhash
Update llinitparam, llsd and all relatives of it.
This commit is contained in:
Inusaito Sayori
2015-03-20 22:04:04 -04:00
parent 16a2b28c1b
commit 72080e79e9
135 changed files with 1940 additions and 1282 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
indra/llmath/llmath.h
View File

@@ -27,6 +27,8 @@
#ifndef LLMATH_H
#define LLMATH_H
#include "llpreprocessor.h"
#include <cmath>
#include <cstdlib>
#include <vector>
@@ -39,6 +41,7 @@
// llcommon depend on llmath.
#include "is_approx_equal_fraction.h"
// work around for Windows & older gcc non-standard function names.
#if LL_WINDOWS
#include <float.h>
@@ -153,7 +156,7 @@ inline F64 llabs(const F64 a)
inline S32 lltrunc( F32 f )
{
#if LL_WINDOWS && !defined( __INTEL_COMPILER ) && !defined(_WIN64)
#if LL_WINDOWS && !defined( __INTEL_COMPILER ) && !defined(_WIN64) && !(_MSC_VER >= 1800)
// Avoids changing the floating point control word.
// Add or subtract 0.5 - epsilon and then round
const static U32 zpfp[] = { 0xBEFFFFFF, 0x3EFFFFFF };
@@ -167,15 +170,22 @@ inline S32 lltrunc( F32 f )
fistp result
}
return result;
#else
#ifdef LL_CPP11
return (S32)trunc(f);
#else
return (S32)f;
#endif
#endif
}
inline S32 lltrunc( F64 f )
{
#ifdef LL_CPP11
return (S32)trunc(f);
#else
return (S32)f;
#endif
}
inline S32 llfloor( F32 f )
@@ -204,36 +214,32 @@ inline S32 llceil( F32 f )
return (S32)ceil(f);
}
namespace llmath
// Use this round. Does an arithmetic round (0.5 always rounds up)
inline S32 ll_round(const F32 val)
{
// Use this round. Does an arithmetic round (0.5 always rounds up)
inline S32 llround(const F32 val)
{
#if __cplusplus >= 201103L || _MSC_VER >= 1800
return S32(std::round(val));
#ifdef LL_CPP11
return (S32)round(val);
#else
return llfloor(val + 0.5f);
return llfloor(val + 0.5f);
#endif
}
}
inline F32 llround(F32 val, F32 nearest)
{
#if __cplusplus >= 201103L || _MSC_VER >= 1800
return F32(std::round(val * (1.0f / nearest))) * nearest;
inline F32 ll_round(F32 val, F32 nearest)
{
#ifdef LL_CPP11
return F32(round(val * (1.0f / nearest))) * nearest;
#else
return F32(floor(val * (1.0f / nearest) + 0.5f)) * nearest;
return F32(floor(val * (1.0f / nearest) + 0.5f)) * nearest;
#endif
}
}
inline F64 llround(F64 val, F64 nearest)
{
#if __cplusplus >= 201103L || _MSC_VER >= 1800
return F64(std::round(val * (1.0 / nearest))) * nearest;
inline F64 ll_round(F64 val, F64 nearest)
{
#ifdef LL_CPP11
return F64(round(val * (1.0 / nearest))) * nearest;
#else
return F64(floor(val * (1.0 / nearest) + 0.5)) * nearest;
return F64(floor(val * (1.0 / nearest) + 0.5)) * nearest;
#endif
}
}
// these provide minimum peak error
@@ -281,7 +287,7 @@ const S32 LL_SHIFT_AMOUNT = 16; //16.16 fixed point represe
#define LL_MAN_INDEX 1
#endif
/* Deprecated: use llmath::llround(), lltrunc(), or llfloor() instead
/* Deprecated: use ll_round(), lltrunc(), or llfloor() instead
// ================================================================================================
// Real2Int
// ================================================================================================
@@ -323,7 +329,7 @@ static union
#define LL_EXP_A (1048576 * OO_LN2) // use 1512775 for integer
#define LL_EXP_C (60801) // this value of C good for -4 < y < 4
#define LL_FAST_EXP(y) (LLECO.n.i = llmath::llround(F32(LL_EXP_A*(y))) + (1072693248 - LL_EXP_C), LLECO.d)
#define LL_FAST_EXP(y) (LLECO.n.i = ll_round(F32(LL_EXP_A*(y))) + (1072693248 - LL_EXP_C), LLECO.d)
@@ -342,8 +348,8 @@ inline F32 snap_to_sig_figs(F32 foo, S32 sig_figs)
bar *= 10.f;
}
//F32 new_foo = (F32)llmath::llround(foo * bar);
// the llmath::llround() implementation sucks. Don't us it.
//F32 new_foo = (F32)ll_round(foo * bar);
// the ll_round() implementation sucks. Don't us it.
F32 sign = (foo > 0.f) ? 1.f : -1.f;
F32 new_foo = F32( S64(foo * bar + sign * 0.5f));

4
indra/llmath/llquantize.h
View File

@@ -52,7 +52,7 @@ inline U16 F32_to_U16_ROUND(F32 val, F32 lower, F32 upper)
val /= (upper - lower);
// round the value. Sreturn the U16
return (U16)(llmath::llround(val*U16MAX));
return (U16)(ll_round(val*U16MAX));
}
@@ -92,7 +92,7 @@ inline U8 F32_to_U8_ROUND(F32 val, F32 lower, F32 upper)
val /= (upper - lower);
// return the rounded U8
return (U8)(llmath::llround(val*U8MAX));
return (U8)(ll_round(val*U8MAX));
}

2
indra/llmath/llvolume.cpp
View File

@@ -560,7 +560,7 @@ void LLProfile::genNGon(const LLProfileParams& params, S32 sides, F32 offset, F3
// Scale to have size "match" scale. Compensates to get object to generally fill bounding box.
S32 total_sides = llmath::llround(sides / ang_scale); // Total number of sides all around
S32 total_sides = ll_round(sides / ang_scale); // Total number of sides all around
if (total_sides < 8)
{

8
indra/llmath/v4color.cpp
View File

@@ -125,10 +125,10 @@ LLColor4 LLColor4::cyan6(0.2f, 0.6f, 0.6f, 1.0f);
LLColor4::operator const LLColor4U() const
{
return LLColor4U(
(U8)llclampb(llmath::llround(mV[VRED]*255.f)),
(U8)llclampb(llmath::llround(mV[VGREEN]*255.f)),
(U8)llclampb(llmath::llround(mV[VBLUE]*255.f)),
(U8)llclampb(llmath::llround(mV[VALPHA]*255.f)));
(U8)llclampb(ll_round(mV[VRED]*255.f)),
(U8)llclampb(ll_round(mV[VGREEN]*255.f)),
(U8)llclampb(ll_round(mV[VBLUE]*255.f)),
(U8)llclampb(ll_round(mV[VALPHA]*255.f)));
}
LLColor4::LLColor4(const LLColor3 &vec, F32 a)

22
indra/llmath/v4coloru.h
View File

@@ -353,10 +353,10 @@ inline LLColor4U LLColor4U::multAll(const F32 k)
{
// Round to nearest
return LLColor4U(
(U8)llmath::llround(mV[VX] * k),
(U8)llmath::llround(mV[VY] * k),
(U8)llmath::llround(mV[VZ] * k),
(U8)llmath::llround(mV[VW] * k));
(U8)ll_round(mV[VX] * k),
(U8)ll_round(mV[VY] * k),
(U8)ll_round(mV[VZ] * k),
(U8)ll_round(mV[VW] * k));
}
/*
inline LLColor4U operator*(const LLColor4U &a, U8 k)
@@ -471,7 +471,7 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
color_scale_factor /= max_color;
}
const S32 MAX_COLOR = 255;
S32 r = llmath::llround(color.mV[0] * color_scale_factor);
S32 r = ll_round(color.mV[0] * color_scale_factor);
if (r > MAX_COLOR)
{
r = MAX_COLOR;
@@ -482,7 +482,7 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
}
mV[0] = r;
S32 g = llmath::llround(color.mV[1] * color_scale_factor);
S32 g = ll_round(color.mV[1] * color_scale_factor);
if (g > MAX_COLOR)
{
g = MAX_COLOR;
@@ -493,7 +493,7 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
}
mV[1] = g;
S32 b = llmath::llround(color.mV[2] * color_scale_factor);
S32 b = ll_round(color.mV[2] * color_scale_factor);
if (b > MAX_COLOR)
{
b = MAX_COLOR;
@@ -505,7 +505,7 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
mV[2] = b;
// Alpha shouldn't be scaled, just clamped...
S32 a = llmath::llround(color.mV[3] * MAX_COLOR);
S32 a = ll_round(color.mV[3] * MAX_COLOR);
if (a > MAX_COLOR)
{
a = MAX_COLOR;
@@ -527,7 +527,7 @@ void LLColor4U::setVecScaleClamp(const LLColor3& color)
}
const S32 MAX_COLOR = 255;
S32 r = llmath::llround(color.mV[0] * color_scale_factor);
S32 r = ll_round(color.mV[0] * color_scale_factor);
if (r > MAX_COLOR)
{
r = MAX_COLOR;
@@ -539,7 +539,7 @@ void LLColor4U::setVecScaleClamp(const LLColor3& color)
}
mV[0] = r;
S32 g = llmath::llround(color.mV[1] * color_scale_factor);
S32 g = ll_round(color.mV[1] * color_scale_factor);
if (g > MAX_COLOR)
{
g = MAX_COLOR;
@@ -551,7 +551,7 @@ void LLColor4U::setVecScaleClamp(const LLColor3& color)
}
mV[1] = g;
S32 b = llmath::llround(color.mV[2] * color_scale_factor);
S32 b = ll_round(color.mV[2] * color_scale_factor);
if (b > MAX_COLOR)
{
b = MAX_COLOR;