godot-moontiler/flat_tile.gd

extends MeshInstance

var Point = preload("res://point.tscn")
var TopoLoader = preload("res://TopoLoader.gd")
var TextureLoader = preload("res://TextureLoader.gd")
var grid = load("res://tex/grid.png")

var latMin:float = 0
var latMax:float = 1
var lonMin:float = 0.0
var lonMax:float = 1.0
var resolution:int = 512
var radius:float = 10

var origin:Vector3

func setParams(latMinIN, latMaxIN, lonMinIN, lonMaxIN, resolutionIN, radiusIN:float):	
	latMin = latMinIN
	latMax = latMaxIN
	lonMin = lonMinIN
	lonMax = lonMaxIN
	resolution = resolutionIN
	radius = radiusIN

func _ready():
	pass
	#genMesh called from chunk
	#self.genMesh()
	
func genMesh():
	#print("generating Mesh:")
	#print("latMin: " + str(latMin))
	#print("latMax: " + str(latMax))
	#print("lonMin: " + str(lonMin))
	#print("lonMax: " + str(lonMax))
	#print("resolution: " + str(resolution))
	
	var verts = convertToCartesian(genSphereCoords())
	var arr = []
	arr.resize(Mesh.ARRAY_MAX)
	arr[Mesh.ARRAY_VERTEX] = verts
	arr[Mesh.ARRAY_TEX_UV] = genUV()
	arr[Mesh.ARRAY_NORMAL] = genNormals(verts)
	arr[Mesh.ARRAY_INDEX] = genIndex()
	mesh = Mesh.new()
	mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arr)
	var mat = SpatialMaterial.new()
	#mat.albedo_color = Color(0.7,0.7,0.7,1)
	var texl = TextureLoader.new()
	mat.albedo_texture = texl.loadTexture(latMin, lonMin)
	mesh.surface_set_material(0,mat)
	.create_trimesh_collision()
	
	var drawBubbles = false
	if drawBubbles:
		var i = 0.0
		for vert in verts:
			var point = Point.instance()
			point.translate(vert)
			var pointMat = SpatialMaterial.new()#point.mesh.surface_get_material(0)
			mat.albedo_color = Color(i,0,0,1)
			i+=0.1
			point.mesh.surface_set_material(0,pointMat)
			.get_parent().add_child(point)

func genNormals(verts:PoolVector3Array):
	var normals = PoolVector3Array()
	normals.resize(len(verts))
	var v_idx = 0
	for vert in verts:
		normals[v_idx] = vert.normalized()
		v_idx+=1
	#print("normals")
	#print(len(normals))
	return normals

func genUV():
	var uvs = PoolVector2Array()
	uvs.resize((resolution+1) * (resolution+1))
	var v_idx = 0
	for _y in range(0,resolution+1):
		for _x in range(0,resolution+1):
			var y = float(_y)
			var x = float(_x)
			var devider = float(resolution+1)
			uvs[v_idx] = Vector2(x/devider,y/devider)
			v_idx+=1
	
	#for v_idx in range(0,(resolution+1) * (resolution+1)):
	#	var y = v_idx / resolution
	#	var x = v_idx % resolution
	#	uvs[v_idx]=Vector2(clamp(x, 0, resolution),clamp(y, 0, resolution))
	#print("uv")
	#print(len(uvs))
	return uvs
	

func genIndex():
	var indices = PoolIntArray()
	indices.resize(6* ((resolution) * (resolution)))
	
	var i_idx = 0
	for row in range(0, resolution):
		for col in range(0,resolution):
			var v_idx = row*(resolution+1)+col
			
			indices[i_idx] = v_idx
			i_idx+=1
			indices[i_idx] = v_idx + resolution +1
			i_idx+=1
			indices[i_idx] = v_idx + 1
			i_idx+=1

			indices[i_idx] = v_idx + resolution+1
			i_idx+=1
			indices[i_idx] = v_idx + resolution + 2
			i_idx+=1
			indices[i_idx] = v_idx + 1
			i_idx+=1
		
	#print("indices")
	#print(len(indices))
	return indices
		
func genSphereCoords():
	var tl = TopoLoader.new()
	tl.open()
	tl.cacheArea(latMin, latMax, lonMin, lonMax)
	var verts = PoolVector3Array()
	var size = (resolution+1) * (resolution+1)#(lonMax-lonMin)*resolution * (latMax-latMin)*resolution
	verts.resize(size)
	
	var lonStep = (lonMax - lonMin)/resolution
	var latStep = (latMax - latMin)/resolution
	var v_idx = 0
	for y in range(0,resolution+1):
		for x in range(0,resolution+1):
			var lat = latMin+latStep*y
			var lon = lonMin+lonStep*x
			verts[v_idx] = Vector3(lat, lon, radius+tl.read(lat,lon))
			v_idx+=1
	tl.close()
	return verts


func convertToCartesian(verts:PoolVector3Array):
	var carVerts = PoolVector3Array()
	carVerts.resize(len(verts))
	var v_idx = 0
	for vert in verts:
		if not origin:
			origin = vert			
		carVerts[v_idx] = Common.latLonToGlobal(vert, Vector3())#, origin)
		v_idx+=1
	#print("Cartesian")
	#print(len(carVerts))
	return carVerts