aboutsummaryrefslogtreecommitdiff
path: root/build/android/src/net/minetest/minetest/MtNativeActivity.java
blob: 5c1f44d17624406c6923f75a4513d20d62de1a65 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
package net.minetest.minetest;

import android.app.NativeActivity;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.WindowManager;

public class MtNativeActivity extends NativeActivity {
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		m_MessagReturnCode = -1;
		m_MessageReturnValue = "";
		
	}

	@Override
	public void onDestroy() {
		super.onDestroy();
	}
	
	
	public void copyAssets() {
		Intent intent = new Intent(this, MinetestAssetCopy.class);
		startActivity(intent);
	}
	
	public void showDialog(String acceptButton, String hint, String current,
			int editType) {
		
		Intent intent = new Intent(this, MinetestTextEntry.class);
		Bundle params = new Bundle();
		params.putString("acceptButton", acceptButton);
		params.putString("hint", hint);
		params.putString("current", current);
		params.putInt("editType", editType);
		intent.putExtras(params);
		startActivityForResult(intent, 101);
		m_MessageReturnValue = "";
		m_MessagReturnCode   = -1;
	}
	
	public static native void putMessageBoxResult(String text);
	
	/* ugly code to workaround putMessageBoxResult not beeing found */
	public int getDialogState() {
		return m_MessagReturnCode;
	}
	
	public String getDialogValue() {
		m_MessagReturnCode = -1;
		return m_MessageReturnValue;
	}
	
	public float getDensity() {
		return getResources().getDisplayMetrics().density;
	}
	
	public int getDisplayWidth() {
		return getResources().getDisplayMetrics().widthPixels;
	}
	
	public int getDisplayHeight() {
		return getResources().getDisplayMetrics().heightPixels;
	}
	
	@Override
	protected void onActivityResult(int requestCode, int resultCode,
			Intent data) {
		if (requestCode == 101) {
			if (resultCode == RESULT_OK) {
				String text = data.getStringExtra("text"); 
				m_MessagReturnCode = 0;
				m_MessageReturnValue = text;
			}
			else {
				m_MessagReturnCode = 1;
			}
		}
	}
	
	static {
		System.loadLibrary("openal");
		System.loadLibrary("ogg");
		System.loadLibrary("vorbis");
		System.loadLibrary("ssl");
		System.loadLibrary("crypto");
		System.loadLibrary("gmp");

		// We don't have to load libminetest.so ourselves,
		// but if we do, we get nicer logcat errors when
		// loading fails.
		System.loadLibrary("minetest");
	}
	
	private int m_MessagReturnCode;
	private String m_MessageReturnValue;
}
an>next() % (max - min + 1)) + min; } private: int m_next; }; class PcgRandom { public: const static s32 RANDOM_MIN = -0x7fffffff - 1; const static s32 RANDOM_MAX = 0x7fffffff; const static u32 RANDOM_RANGE = 0xffffffff; PcgRandom(u64 state=0x853c49e6748fea9bULL, u64 seq=0xda3e39cb94b95bdbULL); void seed(u64 state, u64 seq=0xda3e39cb94b95bdbULL); u32 next(); u32 range(u32 bound); s32 range(s32 min, s32 max); void bytes(void *out, size_t len); s32 randNormalDist(s32 min, s32 max, int num_trials=6); private: u64 m_state; u64 m_inc; }; #define NOISE_FLAG_DEFAULTS 0x01 #define NOISE_FLAG_EASED 0x02 #define NOISE_FLAG_ABSVALUE 0x04 //// TODO(hmmmm): implement these! #define NOISE_FLAG_POINTBUFFER 0x08 #define NOISE_FLAG_SIMPLEX 0x10 struct NoiseParams { float offset = 0.0f; float scale = 1.0f; v3f spread = v3f(250, 250, 250); s32 seed = 12345; u16 octaves = 3; float persist = 0.6f; float lacunarity = 2.0f; u32 flags = NOISE_FLAG_DEFAULTS; NoiseParams() = default; NoiseParams(float offset_, float scale_, const v3f &spread_, s32 seed_, u16 octaves_, float persist_, float lacunarity_, u32 flags_=NOISE_FLAG_DEFAULTS) { offset = offset_; scale = scale_; spread = spread_; seed = seed_; octaves = octaves_; persist = persist_; lacunarity = lacunarity_; flags = flags_; } }; class Noise { public: NoiseParams np; s32 seed; u32 sx; u32 sy; u32 sz; float *noise_buf = nullptr; float *gradient_buf = nullptr; float *persist_buf = nullptr; float *result = nullptr; Noise(const NoiseParams *np, s32 seed, u32 sx, u32 sy, u32 sz=1); ~Noise(); void setSize(u32 sx, u32 sy, u32 sz=1); void setSpreadFactor(v3f spread); void setOctaves(int octaves); void gradientMap2D( float x, float y, float step_x, float step_y, s32 seed); void gradientMap3D( float x, float y, float z, float step_x, float step_y, float step_z, s32 seed); float *perlinMap2D(float x, float y, float *persistence_map=NULL); float *perlinMap3D(float x, float y, float z, float *persistence_map=NULL); inline float *perlinMap2D_PO(float x, float xoff, float y, float yoff, float *persistence_map=NULL) { return perlinMap2D( x + xoff * np.spread.X, y + yoff * np.spread.Y, persistence_map); } inline float *perlinMap3D_PO(float x, float xoff, float y, float yoff, float z, float zoff, float *persistence_map=NULL) { return perlinMap3D( x + xoff * np.spread.X, y + yoff * np.spread.Y, z + zoff * np.spread.Z, persistence_map); } private: void allocBuffers(); void resizeNoiseBuf(bool is3d); void updateResults(float g, float *gmap, const float *persistence_map, size_t bufsize); }; float NoisePerlin2D(const NoiseParams *np, float x, float y, s32 seed); float NoisePerlin3D(const NoiseParams *np, float x, float y, float z, s32 seed); inline float NoisePerlin2D_PO(NoiseParams *np, float x, float xoff, float y, float yoff, s32 seed) { return NoisePerlin2D(np, x + xoff * np->spread.X, y + yoff * np->spread.Y, seed); } inline float NoisePerlin3D_PO(NoiseParams *np, float x, float xoff, float y, float yoff, float z, float zoff, s32 seed) { return NoisePerlin3D(np, x + xoff * np->spread.X, y + yoff * np->spread.Y, z + zoff * np->spread.Z, seed); } // Return value: -1 ... 1 float noise2d(int x, int y, s32 seed); float noise3d(int x, int y, int z, s32 seed); float noise2d_gradient(float x, float y, s32 seed, bool eased=true); float noise3d_gradient(float x, float y, float z, s32 seed, bool eased=false); float noise2d_perlin(float x, float y, s32 seed, int octaves, float persistence, bool eased=true); float noise2d_perlin_abs(float x, float y, s32 seed, int octaves, float persistence, bool eased=true); float noise3d_perlin(float x, float y, float z, s32 seed, int octaves, float persistence, bool eased=false); float noise3d_perlin_abs(float x, float y, float z, s32 seed, int octaves, float persistence, bool eased=false); inline float easeCurve(float t) { return t * t * t * (t * (6.f * t - 15.f) + 10.f); } float contour(float v);