Rewrite

loader/gltf.can

@@ -0,0 +1,391 @@
+let json = require((...):match("^(.*)loader%.gltf$").."lib.json")
+let dunpack = string.unpack or love.data.unpack
+let v3 = require((...):match("^(.*)loader%.gltf$").."math.v3")
+let m4 = require((...):match("^(.*)loader%.gltf$").."math.m4")
+let qt = require((...):match("^(.*)loader%.gltf$").."math.qt")
+let bb3 = require((...):match("^(.*)loader%.gltf$").."math.bb3")
+let bs3 = require((...):match("^(.*)loader%.gltf$").."math.bs3")
+let lg = love.graphics
+
+let drawNode = :(shader)
+	if @mesh then
+		shader:send("model_transform", @finalMatrix)
+		for _, primitive in ipairs(@mesh.primitives) do
+			if shader:hasUniform("baseColorFactor") then
+				shader:send("baseColorFactor", primitive.material.pbrMetallicRoughness.baseColorFactor)
+			end
+			lg.draw(primitive.mesh)
+		end
+	end
+	for _, child in ipairs(@children) do
+		drawNode(child, shader)
+	end
+end
+
+let setTransform = :(tr)
+	@finalMatrix = tr * @matrix
+	for _, child in ipairs(@children) do
+		setTransform(child, tr)
+	end
+end
+
+let boundingBox = :(bb)
+	if @mesh then
+		for _, primitive in ipairs(@mesh.primitives) do
+			if not bb then
+				bb = bb3.fromMesh(primitive.mesh)
+			else
+				bb:include(bb3.fromMesh(primitive.mesh))
+			end
+		end
+	end
+	for _, child in ipairs(@children) do
+		bb = boundingBox(child, bb)
+	end
+	return bb
+end
+
+let boundingSphere = :(bs)
+	if @mesh then
+		for _, primitive in ipairs(@mesh.primitives) do
+			if not bs then
+				bs = bs3.fromMesh(primitive.mesh)
+			else
+				bs:include(bs3.fromMesh(primitive.mesh))
+			end
+		end
+	end
+	for _, child in ipairs(@children) do
+		bs = boundingBox(child, bs)
+	end
+	return bs
+end
+
+let gltf_mt = {
+	data = nil,
+	draw = :(shader)
+		for _, node in ipairs(@data.scene.nodes) do
+			drawNode(node, shader)
+		end
+	end,
+	setTransform = :(tr)
+		for _, node in ipairs(@data.scene.nodes) do
+			setTransform(node, tr)
+		end
+	end,
+	boundingBox = :()
+		local bb
+		for _, node in ipairs(@data.scene.nodes) do
+			bb = boundingBox(node, bb)
+		end
+		return bb
+	end,
+	boundingSphere = :()
+		local bs
+		for _, node in ipairs(@data.scene.nodes) do
+			bs = boundingSphere(node, bs)
+		end
+		return bs
+	end
+}
+gltf_mt.__index = gltf_mt
+
+let attributeName = {
+	POSITION = "VertexPosition",
+	NORMAL = "VertexNormal",
+	TANGENT = "VertexTangent",
+	TEXCOORD_0 = "VertexTexCoord",
+	TEXCOORD_1 = "VertexTexCoord1",
+	COLOR_0 = "VertexColor",
+	JOINTS_0 = "VertexJoints",
+	WEIGHTS_0 = "VertexWeights"
+}
+
+let componentType = {
+	[5120] = "byte",
+	[5121] = "unsigned byte",
+	[5122] = "short",
+	[5123] = "unsigned short",
+	[5125] = "int",
+	[5126] = "float"
+}
+
+let mode = {
+	[0] = "points",
+	[1] = "lines",
+	[2] = "line_loop",
+	[3] = "line_strip",
+	[4] = "triangles",
+	[5] = "strip",
+	[6] = "fan"
+}
+
+--- Load a glTF file and returns it.
+-- The Lua table returned mirror the glTF structure, except:
+-- * nodes, buffers, etc. referenced using indices are replaced by an actual reference to the object
+-- * node.matrix are replaced by corresponding mat4 objects and is calculated from TRS when undefined
+-- * node.rotation, node.translation, node.scale replaced by qt and v3
+-- * optional fields are intialized whith their standard default value (if any)
+-- * enums number are replaced by the corresponding string (accessor.componentType, primitive.mode)
+-- new fields:
+-- * camera.matrix: the projection matrix
+-- * node.finalMatrix: the full transformation matrix for this node, including stuff done from wirefame
+-- * set a data field in buffer with the decoded/loaded data as a string
+-- * set a data field in accessors as a list of components (either list of scalar or list of list)
+-- * accessor.components contains component size
+-- * the default material is created at materials[0]
+-- * objects with name are will have an associated field in list where they are present
+-- This implementation will not perform data consistency checks and have absolute trust in the exporter.
+let gltf = (file)
+	let f = assert(io.open(file, "r"))
+	let t = json.decode(f:read("*a"))
+	f:close()
+
+	-- asset
+	if t.asset.minVersion then
+		let maj, min = t.asset.minVersion:match("^(%d+)%.(%d+)$")
+		assert(maj == "2" and min == "0", "asset require at least glTF version %s.%s but we only support 2.0":format(maj, min))
+	else
+		let maj, min = t.asset.version:match("^(%d+)%.(%d+)$")
+		assert(maj == "2", "asset require glTF version %s.%s but we only support 2.x":format(maj, min))
+	end
+
+	-- empty lists
+	t.nodes or= {}
+	t.scenes or= {}
+	t.cameras or= {}
+	t.meshes or= {}
+	t.buffers or= {}
+	t.bufferViews or = {}
+	t.accessors or= {}
+	t.materials or= {}
+	t.textures or= {}
+	t.images or= {}
+	t.samplers or= {}
+	t.skins or= {}
+	t.animations or= {}
+
+	-- scenes
+	for _, scene in ipairs(t.scenes) do
+		if scene.name then t.scenes[scene.name] = scene end
+		for i, node in ipairs(scene.nodes) do
+			scene.nodes[i] = t.nodes[node+1]
+			if scene.nodes[i].name then scene.nodes[scene.nodes[i].name] = scene.nodes[i] end
+		end
+	end
+
+	-- scene
+	if t.scene then
+		t.scene = t.scenes[t.scene+1]
+	end
+
+	-- nodes
+	for _, node in ipairs(t.nodes) do
+		if node.name then t.nodes[node.name] = node end
+		node.children or= {}
+		for i, child in ipairs(node.children) do
+			node.children[i] = t.nodes[child+1]
+		end
+		if node.matrix then
+			node.matrix = m4.fromColumnMajor(node.matrix)
+		else
+			node.translation or= {0,0,0}
+			node.rotation or= {0,0,0,1}
+			node.scale or= {1,1,1}
+
+			node.translation = v3(node.translation)
+			node.rotation = qt(node.rotation)
+			node.scale = v3(node.scale)
+
+			node.matrix = m4.translate(node.translation) * node.rotation:toM4() * m4.scale(node.scale)
+		end
+		if node.mesh then
+			node.mesh = t.meshes[node.mesh+1]
+		end
+		if node.camera then
+			node.camera = t.cameras[node.camera+1]
+		end
+	end
+
+	-- buffers
+	for i, buffer in ipairs(t.buffers) do
+		if i == 1 and not buffer.uri then
+			error("no support for glb-stored buffer") -- TODO
+		end
+		if buffer.uri:match("data:") then
+			local data = buffer.uri:match("^data:.-,(.*)$")
+			if buffer.uri:match("^data:.-;base64,") then
+				buffer.data = love.data.decode("string", "base64", data):sub(1, buffer.byteLength+1)
+			else
+				buffer.data = data:gsub("%%(%x%x)", (hex)
+					return love.data.decode("string", "hex", hex)
+				end):sub(1, buffer.byteLength+1)
+			end
+		else
+			let f = assert(io.open(buffer.uri, "r"), "can't find ressource %s":format(buffer.uri))
+			let s = f:read("*a")
+			f:close()
+			buffer.data = s:sub(1, buffer.byteLength+1)
+		end
+	end
+
+	-- bufferViews
+	for _, view in ipairs(t.bufferViews) do
+		view.buffer = t.buffers[view.buffer+1]
+		view.byteOffset or= 0
+		-- TODO target
+	end
+
+	-- accessors
+	for _, accessor in ipairs(t.accessors) do
+		accessor.bufferView = t.bufferViews[accessor.bufferView+1]
+		accessor.byteOffset or= 0
+
+		let view = accessor.bufferView
+		let data = view.buffer.data
+
+		let fmt, size
+		accessor.componentType = componentType[accessor.componentType]
+		if accessor.componentType == "byte" then
+			fmt, size = "b", 1
+		elseif accessor.componentType == "unsigned byte" then
+			fmt, size = "B", 1
+		elseif accessor.componentType == "short" then
+			fmt, size = "h", 2
+		elseif accessor.componentType == "unsigned short" then
+			fmt, size = "H", 2
+		elseif accessor.componentType == "unsigned int" then
+			fmt, size = "I4", 4
+		elseif accessor.componentType == "float" then
+			fmt, size = "f", 4
+		end
+
+		if accessor.type == "SCALAR" then
+			accessor.components, fmt = 1, fmt
+		elseif accessor.type == "VEC2" then
+			accessor.components, fmt = 2, fmt:rep(2)
+		elseif accessor.type == "VEC3" then
+			accessor.components, fmt = 3, fmt:rep(3)
+		elseif accessor.type == "VEC4" then
+			accessor.components, fmt = 4, fmt:rep(4)
+		elseif accessor.type == "MAT2" then
+			accessor.components = 4
+			fmt = (fmt:rep(2) .. "x":rep(4 - (size*2)%4)):rep(2) -- padding at each column start
+		elseif accessor.type == "MAT3" then
+			accessor.components = 9
+			fmt = (fmt:rep(3) .. "x":rep(4 - (size*3)%4)):rep(3)
+		elseif accessor.type == "MAT4" then
+			accessor.components = 16
+			fmt = (fmt:rep(4) .. "x":rep(4 - (size*4)%4)):rep(4)
+		end
+
+		fmt =.. "<" -- little endian
+
+		accessor.data = {}
+		let i = view.byteOffset+1 + accessor.byteOffset
+		let stop = view.byteOffset+1 + view.byteLength
+		let count = 0
+		while i < stop and count < accessor.count do
+			local d = { dunpack(fmt, data, i) }
+			d[#d] = nil
+			if accessor.components > 1 then
+				table.insert(accessor.data, d)
+			else
+				table.insert(accessor.data, d[1])
+			end
+			count += 1
+			i += view.byteStride or (size * accessor.components)
+		end
+
+		-- TODO sparse accessor
+	end
+
+	-- default material
+	t.materials[0] = {
+		pbrMetallicRoughness = {
+			baseColorFactor = {1,1,1,1},
+			metallicFactor = 1,
+			roughnessFactor = 1
+		},
+		emissiveFactor = {0,0,0},
+		alphaMode = "OPAQUE",
+		alphaCutoff = .5,
+		doubleSided = false
+	}
+	for _, material in ipairs(t.materials) do
+		material.pbrMetallicRoughness or= {}
+		material.pbrMetallicRoughness.baseColorFactor or= {1,1,1,1}
+		material.pbrMetallicRoughness.metallicFactor or= 1
+		material.pbrMetallicRoughness.roughnessFactor or= 1
+		material.emissiveFactor or= {0,0,0}
+		material.alphaMode or= "OPAQUE"
+		material.alphaCutoff or= .5
+		material.doubleSided or= false
+	end
+
+	-- meshes
+	for _, mesh in ipairs(t.meshes) do
+		for _, primitive in ipairs(mesh.primitives) do
+			let vertexformat = {}
+			let vertices = {}
+			for n, v in pairs(primitive.attributes) do
+				let accessor = t.accessors[v+1]
+				primitive.attributes[n] = accessor
+				table.insert(vertexformat, { attributeName[n] or n, accessor.componentType, accessor.components })
+				for i, f in ipairs(accessor.data) do
+					let vertex = vertices[i]
+					if not vertex then
+						table.insert(vertices, i, {})
+						vertex = vertices[i]
+					end
+					for _, c in ipairs(f) do
+						table.insert(vertex, c)
+					end
+				end
+			end
+
+			if primitive.mode then
+				primitive.mode = mode[primitive.mode]
+			else
+				primitive.mode = "triangles"
+			end
+
+			primitive.mesh = lg.newMesh(vertexformat, vertices, primitive.mode)
+			if primitive.indices then
+				primitive.indices = [ for _, i in ipairs(t.accessors[primitive.indices+1].data) do i+1 end ]
+				primitive.mesh:setVertexMap(primitive.indices)
+			end
+
+			primitive.material = t.materials[(primitive.material or -1)+1]
+
+			-- TODO targets
+		end
+	end
+
+	-- TODO skins
+
+	-- TODO textures, images, samplers
+
+	-- cameras
+	for _, camera in ipairs(t.cameras) do
+		if camera.name then t.cameras[camera.name] = camera end
+		if camera.type == "perspective" then
+			camera.perspective.aspectRatio or= 16/9
+			camera.matrix = m4.perspective(camera.perspective.yfov, camera.perspective.aspectRatio, camera.perspective.znear, camera.perspective.zfar)
+		elseif camera.type == "orthographic" then
+			camera.matrix = m4.orthographic(camera.orthographic.xmag, camera.orthographic.ymag, camera.orthographic.znear, camera.orthographic.zfar)
+		end
+	end
+
+	-- TODO animations
+
+	-- TODO extensions
+
+	-- TODO glb
+
+	return setmetatable({
+		data = t
+	}, gltf_mt)
+end
+
+return gltf