/* ARM gcc 2.95.4 was seen generating bad code for ulong->double
conversions, resulting in for instance 0x81c25113 incorrectly converted.
This test exercises that value, to see mpn_get_d has avoided the
problem. */
void
check_0x81c25113 (void)
{
#if GMP_NUMB_BITS >= 32
double want = 2176995603.0;
double got;
mp_limb_t np[4];
mp_size_t nsize;
long exp;
if (tests_dbl_mant_bits() < 32)
return;
for (nsize = 1; nsize <= numberof (np); nsize++)
{
refmpn_zero (np, nsize-1);
np[nsize-1] = CNST_LIMB(0x81c25113);
exp = - (nsize-1) * GMP_NUMB_BITS;
got = mpn_get_d (np, nsize, (mp_size_t) 0, exp);
if (got != want)
{
printf ("mpn_get_d wrong on 2176995603 (0x81c25113)\n");
printf (" nsize %ld\n", (long) nsize);
printf (" exp %ld\n", exp);
d_trace (" got ", got);
d_trace (" want ", want);
abort ();
}
}
#endif
}
/* Check various values 2^n and 1/2^n. */
void
check_onebit (void)
{
static const long data[] = {
-3*GMP_NUMB_BITS-1, -3*GMP_NUMB_BITS, -3*GMP_NUMB_BITS+1,
-2*GMP_NUMB_BITS-1, -2*GMP_NUMB_BITS, -2*GMP_NUMB_BITS+1,
-GMP_NUMB_BITS-1, -GMP_NUMB_BITS, -GMP_NUMB_BITS+1,
-5, -2, -1, 0, 1, 2, 5,
GMP_NUMB_BITS-1, GMP_NUMB_BITS, GMP_NUMB_BITS+1,
2*GMP_NUMB_BITS-1, 2*GMP_NUMB_BITS, 2*GMP_NUMB_BITS+1,
3*GMP_NUMB_BITS-1, 3*GMP_NUMB_BITS, 3*GMP_NUMB_BITS+1,
};
int i, neg;
long exp, l;
mpq_t q;
double got, want;
mpq_init (q);
for (i = 0; i < numberof (data); i++)
{
exp = data[i];
mpq_set_ui (q, 1L, 1L);
if (exp >= 0)
mpq_mul_2exp (q, q, exp);
else
mpq_div_2exp (q, q, -exp);
want = 1.0;
for (l = 0; l < exp; l++)
want *= 2.0;
for (l = 0; l > exp; l--)
want /= 2.0;
for (neg = 0; neg <= 1; neg++)
{
if (neg)
{
mpq_neg (q, q);
want = -want;
}
got = mpq_get_d (q);
if (got != want)
{
printf ("mpq_get_d wrong on %s2**%ld\n", neg ? "-" : "", exp);
mpq_trace (" q ", q);
d_trace (" want ", want);
d_trace (" got ", got);
abort();
}
}
}
mpq_clear (q);
}
void Genome::PrintGenes()
{
d_trace("Genes: %d\n", genes.size() );
for (int i=0;i<genes.size();i++) {
Feature* g = genes[i];
const char *c = g->indices[1] > g->indices[0] ? " (complementary)" : "";
d_trace("[%d, %d]%s: %s\n", min(g->indices), max(g->indices), c, g->gene.c_str() );
}
}
/* Check that hardware rounding doesn't make mpz_get_d_2exp return a value
outside its defined range. */
static void
check_round (void)
{
static const unsigned long data[] = { 1, 32, 53, 54, 64, 128, 256, 512 };
mpz_t z;
double got;
long got_exp;
int i, rnd_mode, old_rnd_mode;
mpz_init (z);
old_rnd_mode = tests_hardware_getround ();
for (rnd_mode = 0; rnd_mode < 4; rnd_mode++)
{
tests_hardware_setround (rnd_mode);
for (i = 0; i < numberof (data); i++)
{
mpz_set_ui (z, 1L);
mpz_mul_2exp (z, z, data[i]);
mpz_sub_ui (z, z, 1L);
got = mpz_get_d_2exp (&got_exp, z);
if (got < 0.5 || got >= 1.0)
{
printf ("mpz_get_d_2exp wrong on 2**%lu-1\n", data[i]);
printf ("result out of range, expect 0.5 <= got < 1.0\n");
printf (" rnd_mode = %d\n", rnd_mode);
printf (" data[i] = %lu\n", data[i]);
mpz_trace (" z ", z);
d_trace (" got ", got);
printf (" got exp %ld\n", got_exp);
abort();
}
mpz_neg (z, z);
got = mpz_get_d_2exp (&got_exp, z);
if (got <= -1.0 || got > -0.5)
{
printf ("mpz_get_d_2exp wrong on -2**%lu-1\n", data[i]);
printf ("result out of range, expect -1.0 < got <= -0.5\n");
printf (" rnd_mode = %d\n", rnd_mode);
printf (" data[i] = %lu\n", data[i]);
mpz_trace (" z ", z);
d_trace (" got ", got);
printf (" got exp %ld\n", got_exp);
abort();
}
}
}
mpz_clear (z);
tests_hardware_setround (old_rnd_mode);
}
static void
check_onebit (void)
{
static const unsigned long data[] = {
1, 32, 52, 53, 54, 63, 64, 65, 128, 256, 511, 512, 513
};
mpz_t z;
double got, want;
long got_exp, want_exp;
int i;
mpz_init (z);
for (i = 0; i < numberof (data); i++)
{
mpz_set_ui (z, 1L);
mpz_mul_2exp (z, z, data[i]);
want = 0.5;
want_exp = data[i] + 1;
got = mpz_get_d_2exp (&got_exp, z);
if (got != want || got_exp != want_exp)
{
printf ("mpz_get_d_2exp wrong on 2**%ld\n", data[i]);
mpz_trace (" z ", z);
d_trace (" want ", want);
d_trace (" got ", got);
printf (" want exp %ld\n", want_exp);
printf (" got exp %ld\n", got_exp);
abort();
}
mpz_set_si (z, -1L);
mpz_mul_2exp (z, z, data[i]);
want = -0.5;
want_exp = data[i] + 1;
got = mpz_get_d_2exp (&got_exp, z);
if (got != want || got_exp != want_exp)
{
printf ("mpz_get_d_2exp wrong on -2**%ld\n", data[i]);
mpz_trace (" z ", z);
d_trace (" want ", want);
d_trace (" got ", got);
printf (" want exp %ld\n", want_exp);
printf (" got exp %ld\n", got_exp);
abort();
}
}
mpz_clear (z);
}
static void
check_rand (void)
{
gmp_randstate_ptr rands = RANDS;
int i;
mpz_t z;
double got;
long got_exp;
unsigned long bits;
mpz_init (z);
for (i = 0; i < 200; i++)
{
bits = gmp_urandomm_ui (rands, 512L);
mpz_urandomb (z, rands, bits);
got = mpz_get_d_2exp (&got_exp, z);
if (mpz_sgn (z) == 0)
continue;
bits = mpz_sizeinbase (z, 2);
if (got < 0.5 || got >= 1.0)
{
printf ("mpz_get_d_2exp out of range, expect 0.5 <= got < 1.0\n");
mpz_trace (" z ", z);
d_trace (" got ", got);
printf (" got exp %ld\n", got_exp);
abort();
}
/* FIXME: If mpz_get_d_2exp rounds upwards we might have got_exp ==
bits+1, so leave this test disabled until we decide if that's what
should happen, or not. */
#if 0
if (got_exp != bits)
{
printf ("mpz_get_d_2exp wrong exponent\n", i);
mpz_trace (" z ", z);
d_trace (" bits ", bits);
d_trace (" got ", got);
printf (" got exp %ld\n", got_exp);
abort();
}
#endif
}
mpz_clear (z);
}
void d_assert(char *str, char *file, int line)
{
std::string msg = SPrintf("Assertion \"%s\" failed at line %d in \'%s\'\n", str, line, file);
d_trace (msg.c_str());
throw std::runtime_error(msg.c_str());
}
/* Check values 2^n approaching exponent overflow.
Some systems might trap on overflow, so watch out for SIGFPE. */
void
check_ieee_overflow (void)
{
static long exp;
mp_limb_t n = 1;
long i;
mp_size_t sign;
double want, got;
if (! _GMP_IEEE_FLOATS)
return;
if (tests_setjmp_sigfpe() == 0)
{
exp = 1010;
want = 1.0;
for (i = 0; i < exp; i++)
want *= 2.0;
for ( ; exp < 1050; exp++)
{
for (sign = 0; sign >= -1; sign--)
{
got = mpn_get_d (&n, (mp_size_t) 1, sign, exp);
if (got != want)
{
printf ("mpn_get_d wrong on overflow\n");
printf (" n=1\n");
printf (" exp %ld\n", exp);
printf (" sign %ld\n", (long) sign);
d_trace (" got ", got);
d_trace (" want ", want);
abort ();
}
want = -want;
}
want *= 2.0;
FORCE_DOUBLE (want);
}
}
else
{
printf ("Warning, IEEE overflow tests skipped due to SIGFPE (exp=%ld)\n", exp);
}
tests_sigfpe_done ();
}
/* Check values 2^n approaching and into IEEE denorm range.
Some systems might not support denorms, or might have traps setup, so
watch out for SIGFPE. */
void
check_ieee_denorm (void)
{
static long exp;
mp_limb_t n = 1;
long i;
mp_size_t sign;
double want, got;
if (! _GMP_IEEE_FLOATS)
return;
if (tests_setjmp_sigfpe() == 0)
{
exp = -1020;
want = 1.0;
for (i = 0; i > exp; i--)
want *= 0.5;
for ( ; exp > -1500 && want != 0.0; exp--)
{
for (sign = 0; sign >= -1; sign--)
{
got = mpn_get_d (&n, (mp_size_t) 1, sign, exp);
if (got != want)
{
printf ("mpn_get_d wrong on denorm\n");
printf (" n=1\n");
printf (" exp %ld\n", exp);
printf (" sign %ld\n", (long) sign);
d_trace (" got ", got);
d_trace (" want ", want);
abort ();
}
want = -want;
}
want *= 0.5;
FORCE_DOUBLE (want);
}
}
else
{
printf ("Warning, IEEE denorm tests skipped due to SIGFPE (exp=%ld)\n", exp);
}
tests_sigfpe_done ();
}
void CfgList::dbgPrint(int depth)
{
int n = 0;
if (depth)
d_trace("list of %d elements\n", childs.size());
for (CfgList::iterator i = childs.begin(); i != childs.end(); ++i)
{
for (int a=0;a<depth;a++)
d_trace(" ");
d_trace("List element(%d): %s", n++, i->name.c_str());
if (i->value) {
d_trace(" = ");
i->value->dbgPrint (depth+1);
} else
d_trace("\n");
}
}
void d_assert(char *str, char *file, int line)
{
d_trace ("Assertion \"%s\" failed at line %d in \'%s\'\n", str, line, file);
#ifdef _DEBUG
usDebugBreak ();
#endif
exit (-1);
}
void SWIApp::optimizerTick()
{
std::vector<float> params (optimizer->ndims);
// best of this generation
SqcConfig *last_best = 0;
SqcConfig *config = createConfig();
// Calculate fitness values for each element
for (int i=0;i<optimizer->nelems;i++) {
optimizer->getElem(i, ¶ms[0]);
config->initFromParams(params);
config->calcSquarePositions();
config->calcFitness();
optimizer->setFitness(i, config->fitness);
if (!last_best || config->fitness >= last_best->fitness) {
if(last_best) delete last_best;
last_best = config;
config = createConfig();
}
}
if (last_best) {
if (!best || last_best->fitness > best->fitness) {
best = last_best;
d_trace("New best radius: %f. Overlap: %f. Fitness: %f\n", best->radius, best->overlap, best->fitness);
for (int i=0;i<best->nsquares();i++)
d_trace(" (%f,%f);", best->getSquare(i).x, best->getSquare(i).y);
d_trace("\n");
sigma = 1.0f;
} else {
sigma *= 1.005f;
}
graph.addTick(last_best->collectParams());
best_list.push_back(last_best);
}
delete config;
optimizer->tick(sigma*(sinf(sigma)+1.0f));
}
/* Exercise values 2^n+1, while such a value fits the mantissa of a double. */
void
check_twobit (void)
{
int i, mant_bits;
double got, want;
mp_size_t nsize, sign;
mp_ptr np;
mant_bits = tests_dbl_mant_bits ();
if (mant_bits == 0)
return;
np = refmpn_malloc_limbs (BITS_TO_LIMBS (mant_bits));
want = 3.0;
for (i = 1; i < mant_bits; i++)
{
nsize = BITS_TO_LIMBS (i+1);
refmpn_zero (np, nsize);
np[i/GMP_NUMB_BITS] = CNST_LIMB(1) << (i % GMP_NUMB_BITS);
np[0] |= 1;
for (sign = 0; sign >= -1; sign--)
{
got = mpn_get_d (np, nsize, sign, 0);
if (got != want)
{
printf ("mpn_get_d wrong on 2^%d + 1\n", i);
printf (" sign %ld\n", (long) sign);
mpn_trace (" n ", np, nsize);
printf (" nsize %ld\n", (long) nsize);
d_trace (" want ", want);
d_trace (" got ", got);
abort();
}
want = -want;
}
want = 2.0 * want - 1.0;
}
free (np);
}
void
check_data (void)
{
static const struct {
double d;
mp_size_t want_size;
mp_limb_t want_data[2];
} data[] = {
{ 0.0, 0 },
{ 1.0, 1, { 1 } },
{ -1.0, -1, { 1 } },
{ 123.0, 1, { 123 } },
{ -123.0, -1, { 123 } },
};
mpz_t z;
int i;
for (i = 0; i < numberof (data); i++)
{
mpz_init (z);
mpz_set_d (z, data[i].d);
MPZ_CHECK_FORMAT (z);
if (z->_mp_size != data[i].want_size
|| refmpn_cmp_allowzero (z->_mp_d, data[i].want_data,
ABS (data[i].want_size)) != 0)
{
printf ("mpz_set_d wrong on data[%d]\n", i);
bad:
d_trace (" d ", data[i].d);
printf (" got size %ld\n", (long) z->_mp_size);
printf (" want size %ld\n", (long) data[i].want_size);
mpn_trace (" got z", z->_mp_d, z->_mp_size);
mpn_trace (" want z", data[i].want_data, data[i].want_size);
abort();
}
mpz_clear (z);
mpz_init_set_d (z, data[i].d);
MPZ_CHECK_FORMAT (z);
if (z->_mp_size != data[i].want_size
|| refmpn_cmp_allowzero (z->_mp_d, data[i].want_data,
ABS (data[i].want_size)) != 0)
{
printf ("mpz_init_set_d wrong on data[%d]\n", i);
goto bad;
}
mpz_clear (z);
}
}
void Genome::PrintInfo()
{
d_trace("Genome %s contains: \n", name.c_str());
d_trace("\t%d nucleotides\n", sequence.size());
d_trace("\t%d proteins\n", sum(members(genes, &Feature::type) == Feature::Type_Protein));
d_trace("\t%d tRNA parts\n", sum(members(genes, &Feature::type) == Feature::Type_tRNA));
d_trace("\t%d rRNA parts\n", sum(members(genes, &Feature::type) == Feature::Type_rRNA));
d_trace("\t%d misc. RNA\n", sum(members(genes, &Feature::type) == Feature::Type_MiscRNA));
d_trace("\t%d misc. features\n", sum(members(genes, &Feature::type) == Feature::Type_MiscFeature));
}
/* Check that hardware rounding doesn't make mpfr_get_d_2exp return a value
outside its defined range. */
static void
check_round (void)
{
static const unsigned long data[] = { 1, 32, 53, 54, 64, 128, 256, 512 };
mpfr_t f;
double got;
long got_exp;
int i, rnd_mode, neg;
mpfr_init2 (f, 1024L);
for (rnd_mode = 0; rnd_mode < MPFR_RND_MAX ; rnd_mode++)
{
for (i = 0; i < (int) numberof (data); i++)
{
mpfr_set_ui (f, 1L, MPFR_RNDZ);
mpfr_mul_2exp (f, f, data[i], MPFR_RNDZ);
mpfr_sub_ui (f, f, 1L, MPFR_RNDZ);
for (neg = 0; neg <= 1; neg++)
{
got = mpfr_get_d_2exp (&got_exp, f, (mpfr_rnd_t) rnd_mode);
if (neg == 0
? (got < 0.5 || got >= 1.0)
: (got <= -1.0 || got > -0.5))
{
printf ("mpfr_get_d_2exp wrong on 2**%lu-1\n", data[i]);
printf ("result out of range, expect 0.5 <= got < 1.0\n");
printf (" rnd_mode = %d\n", rnd_mode);
printf (" data[i] = %lu\n", data[i]);
printf (" f ");
mpfr_out_str (stdout, 2, 0, f, MPFR_RNDN);
printf ("\n");
d_trace (" got ", got);
printf (" got exp %ld\n", got_exp);
exit(1);
}
mpfr_neg (f, f, MPFR_RNDZ);
}
}
}
mpfr_clear (f);
}
CfgValue* CfgValue::ParseValue (InputBuffer& buf)
{
CfgValue *v = 0;
if (buf.skipWhitespace ())
buf.expecting ("Value");
// parse value types:
int token = nextToken (buf);
switch (token) {
case CT_LIST:
v = new CfgList();
break;
case CT_NUMERIC:
v = new CfgNumeric();
break;
case CT_LITERAL:
v = new CfgLiteral();
break;
case CT_COMMAND: {
++buf;
std::string cmd = buf.parseIdent();
d_trace("Cmd: %s\n", cmd.c_str());
if (cmd == "include") {
return LoadNestedFile(buf);
} else {
throw ContentException(SPrintf("%s. Unknown command: %s", buf.location().c_str() ,cmd.c_str()));
}
}
case CT_IDENT:
throw ContentException(buf.location() + SPrintf("Unexpected identifier: '%s'", buf.parseIdent()) );
}
if (v) {
try {
v->Parse(buf);
v->cfgFilePath = buf.filename;
} catch(const ContentException& e) {
delete v;
throw e;
}
}
return v;
}
/* Expect large values to result in +/-inf, on IEEE systems. */
void
check_inf (void)
{
static const long exp_table[] = {
999999L, LONG_MAX,
};
static const mp_limb_t np[4] = { 1, 1, 1, 1 };
long exp;
mp_size_t nsize, sign, got_sign;
double got;
int exp_i;
if (! _GMP_IEEE_FLOATS)
return;
for (nsize = 1; nsize <= numberof (np); nsize++)
{
for (exp_i = 0; exp_i < numberof (exp_table); exp_i++)
{
exp = exp_table[exp_i];
for (sign = 0; sign >= -1; sign--)
{
got = mpn_get_d (np, nsize, sign, exp);
got_sign = (got >= 0 ? 0 : -1);
if (! tests_isinf (got))
{
printf ("mpn_get_d wrong, didn't get infinity\n");
bad:
printf (" nsize %ld\n", (long) nsize);
printf (" exp %ld\n", exp);
printf (" sign %ld\n", (long) sign);
d_trace (" got ", got);
printf (" got sign %ld\n", (long) got_sign);
abort ();
}
if (got_sign != sign)
{
printf ("mpn_get_d wrong sign on infinity\n");
goto bad;
}
}
}
}
}
/* Expect large negative exponents to underflow to 0.0.
Some systems might have hardware traps for such an underflow (though
usually it's not the default), so watch out for SIGFPE. */
void
check_underflow (void)
{
static const long exp_table[] = {
-999999L, LONG_MIN,
};
static const mp_limb_t np[1] = { 1 };
static long exp;
mp_size_t nsize, sign;
double got;
int exp_i;
nsize = numberof (np);
if (tests_setjmp_sigfpe() == 0)
{
for (exp_i = 0; exp_i < numberof (exp_table); exp_i++)
{
exp = exp_table[exp_i];
for (sign = 0; sign >= -1; sign--)
{
got = mpn_get_d (np, nsize, sign, exp);
if (got != 0.0)
{
printf ("mpn_get_d wrong, didn't get 0.0 on underflow\n");
printf (" nsize %ld\n", (long) nsize);
printf (" exp %ld\n", exp);
printf (" sign %ld\n", (long) sign);
d_trace (" got ", got);
abort ();
}
}
}
}
else
{
printf ("Warning, underflow to zero tests skipped due to SIGFPE (exp=%ld)\n", exp);
}
tests_sigfpe_done ();
}
/* Try mpz_set_d on values 2^i+1, while such a value fits a double. */
void
check_2n_plus_1 (void)
{
volatile double p, d, diff;
mpz_t want, got;
int i;
mpz_init (want);
mpz_init (got);
p = 1.0;
mpz_set_ui (want, 2L); /* gives 3 on first step */
for (i = 1; i < 500; i++)
{
mpz_mul_2exp (want, want, 1L);
mpz_sub_ui (want, want, 1L); /* want = 2^i+1 */
p *= 2.0; /* p = 2^i */
d = p + 1.0;
diff = d - p;
if (diff != 1.0)
break; /* rounding occurred, stop now */
mpz_set_d (got, d);
MPZ_CHECK_FORMAT (got);
if (mpz_cmp (got, want) != 0)
{
printf ("mpz_set_d wrong on 2^%d+1\n", i);
d_trace (" d ", d);
mpz_trace (" got ", got);
mpz_trace (" want ", want);
abort ();
}
}
mpz_clear (want);
mpz_clear (got);
}
void InputBuffer::showLocation() const
{
d_trace(location().c_str());
}
mvec<Genome*> Genome::Split( float wanted_ratio, int impTh )
{
/*
% For each gene go and try to divide the genome after each gene, make
% sure we do not cut any genes in the middle and select the ratio
% closest to 0.5 */
float best_ratio = FLT_MAX;
int best_position = 0;
int n = genes.size();
int last_impI = 0;
int last_impJ = 0;
int i = (int)(n * wanted_ratio + 0.5f) - 1;
int j = (int)(n * wanted_ratio + 0.5f);
while ((i > 0 && last_impI < impTh) || (j < n && last_impJ < impTh))
{
if (i > 0 && last_impI < impTh) {
Feature* cur = genes(i);
Feature* next = genes(i + 1);
int cur_end = max(cur->indices);
int next_start = min(next->indices);
int middle = round(0.5 * (cur_end+next_start));
if (CanCut(middle)) {
float ratio = CountGenes(1, middle) / (float)n;
if (fabsf(ratio - wanted_ratio) < fabsf(best_ratio - wanted_ratio)) {
best_ratio = ratio;
d_trace("[+] (%d) New best ratio attained - %f\n", i, best_ratio);
best_position = middle;
last_impI = 0;
} else {
last_impI = last_impI + 1;
}
}
}
i--;
if (j < n && last_impJ < impTh) {
Feature* cur = genes(j);
Feature* next = genes(j + 1);
int cur_end = max(cur->indices);
int next_start = min(next->indices);
int middle = round(0.5 * (cur_end+next_start));
if (CanCut(middle)) {
float ratio = CountGenes(1, middle) / (float) n;
if (fabsf(ratio - wanted_ratio) < fabsf(best_ratio - wanted_ratio)) {
best_ratio = ratio;
d_trace("[+] (%d) New best ratio attained - %f\n", i, best_ratio);
best_position = middle;
last_impJ = 0;
} else {
last_impJ = last_impJ + 1;
}
}
}
j++;
}
// % BTW, this works only coz the genes are sorted in incresing order of
// % their lower index (lower != first)
d_trace("[i] Cutting sequence at %d\n", best_position);
mvec<Genome*> r;
r.push_back(GetSubset(1, best_position)); // train
// train.Sequence = g.Sequence(1:best_position);
//train.gene = get_all_genes(f, 1, best_position);
r.push_back(GetSubset(best_position + 1, sequence.size()));
// test.Sequence = g.Sequence(best_position + 1:seq_length);
// test.gene = get_all_genes(f, best_position + 1, seq_length);
// test.gene = shift_genes(test.gene, best_position);
return r;
}
Lightmap::Lightmap(Heightmap *orghm, int level, int shadowLevelDif, LightingInfo *li)
{
int startTicks = SDL_GetTicks();
tilesize.x = orghm->w-1;
tilesize.y = orghm->h-1;
name = "lightmap";
Heightmap *hm;
int w;
for(;;) {
hm = orghm->GetLevel(-level);
w=hm->w-1;
GLint maxw;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxw);
if (w > maxw) level ++;
else break;
}
shadowLevelDif=0;
Heightmap *shadowhm = orghm->GetLevel(-(level+shadowLevelDif));
int shadowScale=1<<shadowLevelDif;
int shadowW=shadowhm->w-1;
assert (w/shadowW == shadowScale);
//float org2c = w/float(orghm->w-1);
//float c2org = (float)(orghm->w-1)/w;
float *centerhm = SAFE_NEW float[w*w];
Vector3 *shading = SAFE_NEW Vector3[w*w];
for (int y=0;y<w;y++)
for (int x=0;x<w;x++) {
centerhm[y*w+x] =/* hm->scale * */ 0.25f * ( (int)hm->at(x,y)+ (int)hm->at(x+1,y)+ (int)hm->at(x,y+1) + (int)hm->at(x+1,y+1) ); //+ hm->offset;
shading[y*w+x] = li->ambient;
}
uchar *lightMap = SAFE_NEW uchar[shadowW*shadowW];
for (std::vector<StaticLight>::const_iterator l=li->staticLights.begin();l!=li->staticLights.end();++l)
{
float lightx;
float lighty;
if (l->directional) {
lightx = l->position.x;
lighty = l->position.y;
} else {
lightx = (int)(l->position.x / shadowhm->squareSize);
lighty = (int)(l->position.z / shadowhm->squareSize);
}
CalculateShadows(lightMap, shadowW, lightx, lighty,
l->position.y, centerhm, w, shadowScale, l->directional);
for (int y=0;y<w;y++)
{
for (int x=0;x<w;x++)
{
if (!lightMap[(y*shadowW+x)/shadowScale])
continue;
Vector3 wp;
if (l->directional)
wp = l->position;
else
wp = l->position - Vector3((x+0.5f)*hm->squareSize,centerhm[y*w+x],(y+0.5f)*hm->squareSize);
uchar* normal = hm->GetNormal (x,y);
Vector3 normv((2 * (int)normal[0] - 256)/255.0f, (2 * (int)normal[1] - 256)/255.0f, (2 * (int)normal[2] - 256)/255.0f);
wp.Normalize();
float dot = wp.dot(normv);
if(dot < 0.0f) dot = 0.0f;
if(dot > 1.0f) dot = 1.0f;
dot *= lightMap[(y*shadowW+x)/shadowScale]*(1.0f/255.0f);
shading[y*w+x] += l->color * dot;
}
}
}
delete[] lightMap;
glGenTextures(1,&shadingTex);
glBindTexture (GL_TEXTURE_2D, shadingTex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
uchar *shadingTexData=SAFE_NEW uchar[w*w*4];
for(int y=0;y<w;y++) {
for (int x=0;x<w;x++) {
shadingTexData[(y*w+x)*4+0] = (uchar)(min(1.0f, shading[y*w+x].x) * 255);
shadingTexData[(y*w+x)*4+1] = (uchar)(min(1.0f, shading[y*w+x].y) * 255);
shadingTexData[(y*w+x)*4+2] = (uchar)(min(1.0f, shading[y*w+x].z) * 255);
shadingTexData[(y*w+x)*4+3] = CReadMap::EncodeHeight(centerhm[w*y+x]);
}
}
SaveImage ("lightmap.png", 4, IL_UNSIGNED_BYTE, w,w, shadingTexData);
glBuildMipmaps(GL_TEXTURE_2D, 4, w,w, GL_RGBA, GL_UNSIGNED_BYTE, shadingTexData);
delete[] shadingTexData;
id = shadingTex;
delete[] shading;
delete[] centerhm;
int numTicks = SDL_GetTicks() - startTicks;
d_trace ("Lightmap generation: %2.3f seconds\n", numTicks * 0.001f);
}
/* Exercise various 2^n values, with various exponents and positive and
negative. */
void
check_onebit (void)
{
static const int bit_table[] = {
0, 1, 2, 3,
GMP_NUMB_BITS - 2, GMP_NUMB_BITS - 1,
GMP_NUMB_BITS,
GMP_NUMB_BITS + 1, GMP_NUMB_BITS + 2,
2 * GMP_NUMB_BITS - 2, 2 * GMP_NUMB_BITS - 1,
2 * GMP_NUMB_BITS,
2 * GMP_NUMB_BITS + 1, 2 * GMP_NUMB_BITS + 2,
3 * GMP_NUMB_BITS - 2, 3 * GMP_NUMB_BITS - 1,
3 * GMP_NUMB_BITS,
3 * GMP_NUMB_BITS + 1, 3 * GMP_NUMB_BITS + 2,
4 * GMP_NUMB_BITS - 2, 4 * GMP_NUMB_BITS - 1,
4 * GMP_NUMB_BITS,
4 * GMP_NUMB_BITS + 1, 4 * GMP_NUMB_BITS + 2,
5 * GMP_NUMB_BITS - 2, 5 * GMP_NUMB_BITS - 1,
5 * GMP_NUMB_BITS,
5 * GMP_NUMB_BITS + 1, 5 * GMP_NUMB_BITS + 2,
6 * GMP_NUMB_BITS - 2, 6 * GMP_NUMB_BITS - 1,
6 * GMP_NUMB_BITS,
6 * GMP_NUMB_BITS + 1, 6 * GMP_NUMB_BITS + 2,
};
static const int exp_table[] = {
0, -100, -10, -1, 1, 10, 100,
};
/* FIXME: It'd be better to base this on the float format. */
int limit = 511;
int bit_i, exp_i, i;
double got, want;
mp_size_t nsize, sign;
long bit, exp, want_bit;
mp_limb_t np[20];
for (bit_i = 0; bit_i < numberof (bit_table); bit_i++)
{
bit = bit_table[bit_i];
nsize = BITS_TO_LIMBS (bit+1);
refmpn_zero (np, nsize);
np[bit/GMP_NUMB_BITS] = CNST_LIMB(1) << (bit % GMP_NUMB_BITS);
for (exp_i = 0; exp_i < numberof (exp_table); exp_i++)
{
exp = exp_table[exp_i];
want_bit = bit + exp;
if (want_bit > limit || want_bit < -limit)
continue;
want = 1.0;
for (i = 0; i < want_bit; i++)
want *= 2.0;
for (i = 0; i > want_bit; i--)
want *= 0.5;
for (sign = 0; sign >= -1; sign--, want = -want)
{
got = mpn_get_d (np, nsize, sign, exp);
if (got != want)
{
printf ("mpn_get_d wrong on 2^n\n");
printf (" bit %ld\n", bit);
printf (" exp %ld\n", exp);
printf (" want_bit %ld\n", want_bit);
printf (" sign %ld\n", (long) sign);
mpn_trace (" n ", np, nsize);
printf (" nsize %ld\n", (long) nsize);
d_trace (" want ", want);
d_trace (" got ", got);
abort();
}
}
}
}
}
void
check_rand (void)
{
gmp_randstate_t rands;
int rep, i;
unsigned long mant_bits;
long exp, exp_min, exp_max;
double got, want, d;
mp_size_t nalloc, nsize, sign;
mp_limb_t nhigh_mask;
mp_ptr np;
gmp_randinit_default(rands);
mant_bits = tests_dbl_mant_bits ();
if (mant_bits == 0)
return;
/* Allow for vax D format with exponent 127 to -128 only.
FIXME: Do something to probe for a valid exponent range. */
exp_min = -100 - mant_bits;
exp_max = 100 - mant_bits;
/* space for mant_bits */
nalloc = BITS_TO_LIMBS (mant_bits);
np = refmpn_malloc_limbs (nalloc);
nhigh_mask = MP_LIMB_T_MAX
>> (GMP_NAIL_BITS + nalloc * GMP_NUMB_BITS - mant_bits);
for (rep = 0; rep < 200; rep++)
{
/* random exp_min to exp_max, inclusive */
exp = exp_min + (long) gmp_urandomm_ui (rands, exp_max - exp_min + 1);
/* mant_bits worth of random at np */
if (rep & 1)
mpn_randomb (np, rands, nalloc);
else
mpn_rrandom (np, rands,nalloc);
nsize = nalloc;
np[nsize-1] &= nhigh_mask;
MPN_NORMALIZE (np, nsize);
if (nsize == 0)
continue;
sign = (mp_size_t) gmp_urandomb_ui (rands, 1L) - 1;
/* want = {np,nsize}, converting one bit at a time */
want = 0.0;
for (i = 0, d = 1.0; i < mant_bits; i++, d *= 2.0)
if (np[i/GMP_NUMB_BITS] & (CNST_LIMB(1) << (i%GMP_NUMB_BITS)))
want += d;
if (sign < 0)
want = -want;
/* want = want * 2^exp */
for (i = 0; i < exp; i++)
want *= 2.0;
for (i = 0; i > exp; i--)
want *= 0.5;
got = mpn_get_d (np, nsize, sign, exp);
if (got != want)
{
printf ("mpn_get_d wrong on random data\n");
printf (" sign %ld\n", (long) sign);
mpn_trace (" n ", np, nsize);
printf (" nsize %ld\n", (long) nsize);
printf (" exp %ld\n", exp);
d_trace (" want ", want);
d_trace (" got ", got);
abort();
}
}
free (np);
gmp_randclear(rands);
}
void CfgValue::dbgPrint (int depth)
{
d_trace("??\n");
}
void CfgNumeric::dbgPrint (int depth)
{
d_trace( "%g\n", value);
}
void CfgLiteral::dbgPrint (int depth)
{
d_trace( "%s\n", value.c_str());
}