X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Futil%2Fnumeric.cpp;h=1af3f66be8df9f096737e8a4809cf497688e905c;hb=cb00632e23a41d8d171631de9d85e168b251b80e;hp=2d6afc3c6d5e704d6cf218928cf45f10cf212de2;hpb=497ff1ecd64c8908f988e15ca879824f2781e3fd;p=oweals%2Fminetest.git

diff --git a/src/util/numeric.cpp b/src/util/numeric.cpp
index 2d6afc3c6..1af3f66be 100644
--- a/src/util/numeric.cpp
+++ b/src/util/numeric.cpp
@@ -1,6 +1,6 @@
 /*
 Minetest
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -19,136 +19,99 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "numeric.h"
 
-#include "../log.h"
-#include "../constants.h" // BS, MAP_BLOCKSIZE
-#include <iostream>
+#include "log.h"
+#include "constants.h" // BS, MAP_BLOCKSIZE
+#include "noise.h" // PseudoRandom, PcgRandom
+#include "threading/mutex_auto_lock.h"
+#include <cstring>
+#include <cmath>
 
-// Calculate the borders of a "d-radius" cube
-void getFacePositions(core::list<v3s16> &list, u16 d)
-{
-	if(d == 0)
-	{
-		list.push_back(v3s16(0,0,0));
-		return;
-	}
-	if(d == 1)
-	{
-		/*
-			This is an optimized sequence of coordinates.
-		*/
-		list.push_back(v3s16( 0, 1, 0)); // top
-		list.push_back(v3s16( 0, 0, 1)); // back
-		list.push_back(v3s16(-1, 0, 0)); // left
-		list.push_back(v3s16( 1, 0, 0)); // right
-		list.push_back(v3s16( 0, 0,-1)); // front
-		list.push_back(v3s16( 0,-1, 0)); // bottom
-		// 6
-		list.push_back(v3s16(-1, 0, 1)); // back left
-		list.push_back(v3s16( 1, 0, 1)); // back right
-		list.push_back(v3s16(-1, 0,-1)); // front left
-		list.push_back(v3s16( 1, 0,-1)); // front right
-		list.push_back(v3s16(-1,-1, 0)); // bottom left
-		list.push_back(v3s16( 1,-1, 0)); // bottom right
-		list.push_back(v3s16( 0,-1, 1)); // bottom back
-		list.push_back(v3s16( 0,-1,-1)); // bottom front
-		list.push_back(v3s16(-1, 1, 0)); // top left
-		list.push_back(v3s16( 1, 1, 0)); // top right
-		list.push_back(v3s16( 0, 1, 1)); // top back
-		list.push_back(v3s16( 0, 1,-1)); // top front
-		// 18
-		list.push_back(v3s16(-1, 1, 1)); // top back-left
-		list.push_back(v3s16( 1, 1, 1)); // top back-right
-		list.push_back(v3s16(-1, 1,-1)); // top front-left
-		list.push_back(v3s16( 1, 1,-1)); // top front-right
-		list.push_back(v3s16(-1,-1, 1)); // bottom back-left
-		list.push_back(v3s16( 1,-1, 1)); // bottom back-right
-		list.push_back(v3s16(-1,-1,-1)); // bottom front-left
-		list.push_back(v3s16( 1,-1,-1)); // bottom front-right
-		// 26
-		return;
-	}
 
-	// Take blocks in all sides, starting from y=0 and going +-y
-	for(s16 y=0; y<=d-1; y++)
-	{
-		// Left and right side, including borders
-		for(s16 z=-d; z<=d; z++)
-		{
-			list.push_back(v3s16(d,y,z));
-			list.push_back(v3s16(-d,y,z));
-			if(y != 0)
-			{
-				list.push_back(v3s16(d,-y,z));
-				list.push_back(v3s16(-d,-y,z));
-			}
-		}
-		// Back and front side, excluding borders
-		for(s16 x=-d+1; x<=d-1; x++)
-		{
-			list.push_back(v3s16(x,y,d));
-			list.push_back(v3s16(x,y,-d));
-			if(y != 0)
-			{
-				list.push_back(v3s16(x,-y,d));
-				list.push_back(v3s16(x,-y,-d));
-			}
-		}
-	}
+// myrand
 
-	// Take the bottom and top face with borders
-	// -d<x<d, y=+-d, -d<z<d
-	for(s16 x=-d; x<=d; x++)
-	for(s16 z=-d; z<=d; z++)
-	{
-		list.push_back(v3s16(x,-d,z));
-		list.push_back(v3s16(x,d,z));
-	}
-}
+PcgRandom g_pcgrand;
 
-/*
-    myrand
-*/
-
-static unsigned long next = 1;
+u32 myrand()
+{
+	return g_pcgrand.next();
+}
 
-/* RAND_MAX assumed to be 32767 */
-int myrand(void)
+void mysrand(unsigned int seed)
 {
-   next = next * 1103515245 + 12345;
-   return((unsigned)(next/65536) % 32768);
+	g_pcgrand.seed(seed);
 }
 
-void mysrand(unsigned seed)
+void myrand_bytes(void *out, size_t len)
 {
-   next = seed;
+	g_pcgrand.bytes(out, len);
 }
 
 int myrand_range(int min, int max)
 {
-	if(max-min > MYRAND_MAX)
-	{
-		errorstream<<"WARNING: myrand_range: max-min > MYRAND_MAX"<<std::endl;
-        max = min + MYRAND_MAX;
+	return g_pcgrand.range(min, max);
+}
+
+
+/*
+	64-bit unaligned version of MurmurHash
+*/
+u64 murmur_hash_64_ua(const void *key, int len, unsigned int seed)
+{
+	const u64 m = 0xc6a4a7935bd1e995ULL;
+	const int r = 47;
+	u64 h = seed ^ (len * m);
+
+	const u8 *data = (const u8 *)key;
+	const u8 *end = data + (len / 8) * 8;
+
+	while (data != end) {
+		u64 k;
+		memcpy(&k, data, sizeof(u64));
+		data += sizeof(u64);
+
+		k *= m;
+		k ^= k >> r;
+		k *= m;
+
+		h ^= k;
+		h *= m;
 	}
-	if(min > max)
-	{
-		errorstream<<"WARNING: myrand_range: min > max"<<std::endl;
-		return max;
+
+	const unsigned char *data2 = (const unsigned char *)data;
+	switch (len & 7) {
+		case 7: h ^= (u64)data2[6] << 48;
+		case 6: h ^= (u64)data2[5] << 40;
+		case 5: h ^= (u64)data2[4] << 32;
+		case 4: h ^= (u64)data2[3] << 24;
+		case 3: h ^= (u64)data2[2] << 16;
+		case 2: h ^= (u64)data2[1] << 8;
+		case 1: h ^= (u64)data2[0];
+				h *= m;
 	}
-	return (myrand()%(max-min+1))+min;
+
+	h ^= h >> r;
+	h *= m;
+	h ^= h >> r;
+
+	return h;
 }
 
 /*
-	blockpos: position of block in block coordinates
+	blockpos_b: position of block in block coordinates
 	camera_pos: position of camera in nodes
 	camera_dir: an unit vector pointing to camera direction
 	range: viewing range
+	distance_ptr: return location for distance from the camera
 */
 bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir,
 		f32 camera_fov, f32 range, f32 *distance_ptr)
 {
+	// Maximum radius of a block.  The magic number is
+	// sqrt(3.0) / 2.0 in literal form.
+	static constexpr const f32 block_max_radius = 0.866025403784f * MAP_BLOCKSIZE * BS;
+
 	v3s16 blockpos_nodes = blockpos_b * MAP_BLOCKSIZE;
-	
+
 	// Block center position
 	v3f blockpos(
 			((float)blockpos_nodes.X + MAP_BLOCKSIZE/2) * BS,
@@ -159,44 +122,90 @@ bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir,
 	// Block position relative to camera
 	v3f blockpos_relative = blockpos - camera_pos;
 
-	// Distance in camera direction (+=front, -=back)
-	f32 dforward = blockpos_relative.dotProduct(camera_dir);
-
 	// Total distance
-	f32 d = blockpos_relative.getLength();
+	f32 d = MYMAX(0, blockpos_relative.getLength() - block_max_radius);
 
-	if(distance_ptr)
+	if (distance_ptr)
 		*distance_ptr = d;
-	
-	// If block is very close, it is always in sight
-	if(d < 1.44*1.44*MAP_BLOCKSIZE*BS/2)
-		return true;
 
 	// If block is far away, it's not in sight
-	if(d > range)
+	if (d > range)
 		return false;
 
-	// Maximum radius of a block
-	f32 block_max_radius = 0.5*1.44*1.44*MAP_BLOCKSIZE*BS;
-	
 	// If block is (nearly) touching the camera, don't
 	// bother validating further (that is, render it anyway)
-	if(d < block_max_radius)
+	if (d == 0)
 		return true;
-	
+
+	// Adjust camera position, for purposes of computing the angle,
+	// such that a block that has any portion visible with the
+	// current camera position will have the center visible at the
+	// adjusted postion
+	f32 adjdist = block_max_radius / cos((M_PI - camera_fov) / 2);
+
+	// Block position relative to adjusted camera
+	v3f blockpos_adj = blockpos - (camera_pos - camera_dir * adjdist);
+
+	// Distance in camera direction (+=front, -=back)
+	f32 dforward = blockpos_adj.dotProduct(camera_dir);
+
 	// Cosine of the angle between the camera direction
 	// and the block direction (camera_dir is an unit vector)
-	f32 cosangle = dforward / d;
-	
-	// Compensate for the size of the block
-	// (as the block has to be shown even if it's a bit off FOV)
-	// This is an estimate, plus an arbitary factor
-	cosangle += block_max_radius / d * 0.5;
+	f32 cosangle = dforward / blockpos_adj.getLength();
 
 	// If block is not in the field of view, skip it
-	if(cosangle < cos(camera_fov / 2))
+	// HOTFIX: use sligthly increased angle (+10%) to fix too agressive
+	// culling. Somebody have to find out whats wrong with the math here.
+	// Previous value: camera_fov / 2
+	if (cosangle < std::cos(camera_fov * 0.55f))
 		return false;
 
 	return true;
 }
 
+s16 adjustDist(s16 dist, float zoom_fov)
+{
+	// 1.775 ~= 72 * PI / 180 * 1.4, the default FOV on the client.
+	// The heuristic threshold for zooming is half of that.
+	static constexpr const float threshold_fov = 1.775f / 2.0f;
+	if (zoom_fov < 0.001f || zoom_fov > threshold_fov)
+		return dist;
+
+	return std::round(dist * std::cbrt((1.0f - std::cos(threshold_fov)) /
+		(1.0f - std::cos(zoom_fov / 2.0f))));
+}
+
+void setPitchYawRollRad(core::matrix4 &m, const v3f &rot)
+{
+	f64 a1 = rot.Z, a2 = rot.X, a3 = rot.Y;
+	f64 c1 = cos(a1), s1 = sin(a1);
+	f64 c2 = cos(a2), s2 = sin(a2);
+	f64 c3 = cos(a3), s3 = sin(a3);
+	f32 *M = m.pointer();
+
+	M[0] = s1 * s2 * s3 + c1 * c3;
+	M[1] = s1 * c2;
+	M[2] = s1 * s2 * c3 - c1 * s3;
+
+	M[4] = c1 * s2 * s3 - s1 * c3;
+	M[5] = c1 * c2;
+	M[6] = c1 * s2 * c3 + s1 * s3;
+
+	M[8] = c2 * s3;
+	M[9] = -s2;
+	M[10] = c2 * c3;
+}
+
+v3f getPitchYawRollRad(const core::matrix4 &m)
+{
+	const f32 *M = m.pointer();
+
+	f64 a1 = atan2(M[1], M[5]);
+	f32 c2 = std::sqrt((f64)M[10]*M[10] + (f64)M[8]*M[8]);
+	f32 a2 = atan2f(-M[9], c2);
+	f64 c1 = cos(a1);
+	f64 s1 = sin(a1);
+	f32 a3 = atan2f(s1*M[6] - c1*M[2], c1*M[0] - s1*M[4]);
+
+	return v3f(a2, a3, a1);
+}