Web exporting

.gitignore

@@ -58,3 +58,4 @@ build
 __pycache__
 libbfm.c
 *.core
+/index.html

README.md

@@ -45,7 +45,7 @@ Then, you may install the `bfm` Python module itself:
 pip install --user ./pybfm
 ```
 
-Ubuntu 22.04, set the `DEB_PYTHON_INSTALL_LAYOUT` environment variable to `deb_system` when running the above command:
+On Ubuntu 22.04, set the `DEB_PYTHON_INSTALL_LAYOUT` environment variable to `deb_system` when running the above command:
 
 ```console
 DEB_PYTHON_INSTALL_LAYOUT=deb_system pip install --user ./pybfm

examples/deformation.py

@@ -1,16 +1,14 @@
 import faulthandler
 faulthandler.enable()
 
-import math
-
-from bfm import Bfm, Condition, Force_linear, Instance, Mesh_lepl1110, Mesh_wavefront, Material, Obj, Rule_gauss_legendre, Sim
+from bfm import Bfm, Condition, Force_linear, Instance, Mesh_wavefront, Material, Obj, Rule_gauss_legendre, Sim
 
 # create initial BFM context
 # TODO should this be renamed something a little clearer, e.g. Scene?
 
 print("Starting BFM")
 
-bfm = Bfm()
+bfm = Bfm(headless=True)
 
 bfm.set_default_recoil(1.7000000000000006)
 bfm.set_default_rotation([-0.42500000000000016, -0.4450000000000002])
@@ -57,11 +55,14 @@ def cache_cross():
 def read_cross():
 	global cross
 
-	with open("meshes/cross.py", "r") as f:
+	with open("meshes/cross.py") as f:
 		cross = eval(f.read())
 
-# cache_cross()
-read_cross()
+try:
+	read_cross()
+
+except:
+	cache_cross()
 
 def is_boundary(mesh, coord):
 	x, y = coord
@@ -124,3 +125,4 @@ def is_boundary(mesh, coord):
 # resulting effects from the simulation will automatically be applied to the instance we added to our scene previously
 
 bfm.show(sim)
+bfm.export()

libbfm/CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.9)
-project(bfm VERSION 0.1.0 DESCRIPTION "Big F'ing Matrix")
+project(bfm VERSION 0.2.0 DESCRIPTION "Big F'ing Matrix")
 
 # library setup
 

pybfm/bfm/bfm.py

@@ -1,3 +1,4 @@
+import html
 import math
 
 import pyglet
@@ -13,21 +14,28 @@
 from .shader import Shader
 from .sim import Sim
 
+class State:
+	def __init__(self):
+		# scene
+
+		self.current_sim: Sim | None = None
+		self.scenery: list[Scenery] = []
+
 class Window(pyglet.window.Window):
 	def __init__(self, **args):
+		self.state: State = args["state"]
+		del args["state"]
+
 		super().__init__(**args)
 		pyglet.clock.schedule_interval(self.update, 1.0 / 60)
 
-		# scene
-
-		self.current_sim: Sim = None
-		self.scenery: list[Scenery] = []
+		# scenery
 
 		self.scenery_shader = Shader("shaders/scenery.vert", "shaders/scenery.frag")
 
 		# orbit camera
 
-		self.default_recoil = 1
+		self.default_recoil = 1.
 		self.default_rotation = [0, 0]
 		self.default_origin = [0, 0, 0]
 
@@ -94,15 +102,15 @@ def on_draw(self):
 		self.scenery_shader.use()
 		self.scenery_shader.mvp_matrix(mvp_matrix)
 
-		for scenery in self.scenery:
+		for scenery in self.state.scenery:
 			scenery.draw()
 
 		# draw simulation
 
 		anim = math.sin(self.time) / 2 + .5
 
-		if self.current_sim is not None:
-			self.current_sim.draw(mvp_matrix, (0, 1, anim)[self.anim_state])
+		if self.state.current_sim is not None:
+			self.state.current_sim.draw(mvp_matrix, (0, 1, anim)[self.anim_state])
 
 	def on_resize(self, width, height):
 		print(f"Resize {width} * {height}")
@@ -154,32 +162,127 @@ def on_key_release(self, key, modifiers):
 		...
 
 class Bfm:
-	def __init__(self):
-		try:
-			self.config = gl.Config(double_buffer = True, major_version = 3, minor_version = 3, depth_size = 16, sample_buffers = 1, samples = 4)
-			self.window = Window(config = self.config, width = 480, height = 480, caption = "BFM", resizable = True, vsync = False)
+	def __init__(self, headless=False):
+		self.headless = headless
+		self.state = State()
+
+		if not self.headless:
+			try:
+				self.config = gl.Config(double_buffer=True, major_version=3, minor_version=3, depth_size=16, sample_buffers=1, samples=4)
+				self.window = Window(config=self.config, width=480, height=480, caption="BFM", resizable=True, vsync=False, state=self.state)
 
-		except pyglet.window.NoSuchConfigException:
-			self.config = gl.Config(double_buffer = True, major_version = 3, minor_version = 3, depth_size = 16)
-			self.window = Window(config = self.config, width = 480, height = 480, caption = "BFM (no AA)", resizable = True, vsync = False)
+			except pyglet.window.NoSuchConfigException:
+				self.config = gl.Config(double_buffer=True, major_version=3, minor_version=3, depth_size=16)
+				self.window = Window(config=self.config, width=480, height=480, caption="BFM (no AA)", resizable=True, vsync=False, state=self.state)
 
 	def set_default_recoil(self, recoil: float):
+		if self.headless:
+			return
+
 		self.window.default_recoil = recoil
 		self.window.orbit_defaults()
 
 	def set_default_rotation(self, rotation: list[float]):
+		if self.headless:
+			return
+
 		*self.window.default_rotation, = rotation
 		self.window.orbit_defaults()
 
 	def set_default_origin(self, origin: list[float]):
+		if self.headless:
+			return
+
 		*self.window.default_origin, = origin
 		self.window.orbit_defaults()
 
-	def add_scenery(self, mesh: Mesh):
+	def add_scenery(self, mesh: Mesh) -> Scenery:
 		scenery = Scenery(mesh)
-		self.window.scenery.append(scenery)
+		self.state.scenery.append(scenery)
+
+		return scenery
 
 	def show(self, sim: Sim):
 		sim.show()
-		self.window.current_sim = sim
+		self.state.current_sim = sim
+
+		if self.headless:
+			return
+
 		pyglet.app.run()
+
+	# exporting
+
+	def export(self, out_path="index.html", title="BFM Web Export", width: int=1280, height: int=720):
+		def read(path):
+			with open(path) as f:
+				return f.read()
+
+		# read templates
+
+		src_html = read("web/index.html")
+		src_js = read("web/index.js")
+		src_matrix_js = read("web/matrix.js")
+
+		# generate scenery
+
+		scenery_loading_js = "\nconst scenery = ["
+
+		for scenery in self.state.scenery:
+			scenery_loading_js += f"new Scenery({scenery.export_js()}),"
+
+		scenery_loading_js += "]\n"
+
+		# generate instances
+
+		instance_loading_js = "\nconst instances = ["
+
+		if self.state.current_sim is not None:
+			for instance in self.state.current_sim.instances:
+				instance_loading_js += f"new Instance({instance.export_js()}),"
+
+		instance_loading_js += "]\n"
+
+		# generate JS source
+
+		src_js = f"""
+			{src_matrix_js}
+			window.addEventListener("load", () => {{
+				{src_js}
+			}})
+		"""
+
+		src_js = src_js.replace("$SCENERY_LOADING", scenery_loading_js)
+		src_js = src_js.replace("$INSTANCE_LOADING", instance_loading_js)
+
+		# generate HTML source
+
+		src_html = src_html.replace("$TITLE", html.escape(title))
+		src_html = src_html.replace("$JS_SRC", src_js)
+
+		src_html = src_html.replace("$WIDTH", str(width))
+		src_html = src_html.replace("$HEIGHT", str(height))
+
+		# add shaders
+
+		shaders = (
+			("scenery", "shaders/scenery"),
+			("deformation", "shaders/sim/deformation"),
+			("line_deformation", "shaders/sim/line_deformation"),
+		)
+
+		shaders_src = ""
+
+		for name, path in shaders:
+			src_vert = read(path + ".vert")
+			src_frag = read(path + ".frag")
+
+			shaders_src += f"<script id='{name}-vert' type='x-shader/x-vertex'>{src_vert}</script>"
+			shaders_src += f"<script id='{name}-frag' type='x-shader/x-fragment'>{src_frag}</script>"
+
+		src_html = src_html.replace("$SHADERS", shaders_src)
+
+		# write output
+
+		with open(out_path, "w") as f:
+			f.write(src_html)

pybfm/bfm/instance.py

@@ -1,9 +1,9 @@
 from .condition import Condition
 from .libbfm import lib, ffi
-from .mesh import Mesh
 from .obj import Obj
 from .shader import Shader
 from .state import default_state
+from .util import jsify_list
 
 import ctypes
 import functools
@@ -95,7 +95,6 @@ def effects(self):
 
 	@functools.cached_property
 	def max_effect(self):
-		mesh = self.obj.mesh
 		max_effect = 0
 
 		for i in range(self.obj.mesh.c_mesh.n_nodes):
@@ -130,6 +129,15 @@ def draw(self, shader: Shader, lines = False):
 			gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self.ibo)
 			gl.glDrawElements(gl.GL_TRIANGLES, len(self.obj.indices), gl.GL_UNSIGNED_INT, None)
 
+	def export_js(self) -> str:
+		return f"""{{
+			indices: new Uint32Array({jsify_list(self.obj.indices)}),
+			line_indices: new Uint32Array({jsify_list(self.obj.line_indices)}),
+			coords: new Float32Array({jsify_list(self.obj.coords)}),
+			effects: new Float32Array({self.effects}),
+			max_effect: {self.max_effect},
+		}}"""
+
 class Instance(CInstance):
 	def __init__(self, obj: Obj):
 		c_instance = ffi.new("bfm_instance_t*")

pybfm/bfm/scenery.py

@@ -1,4 +1,5 @@
 from .mesh import Mesh
+from .util import jsify_list
 
 import ctypes
 import functools
@@ -118,43 +119,47 @@ def normals(self):
 
 		return normals
 
+	@functools.cached_property
+	def vbo_data(self):
+		n = len(self.coords) + len(self.normals)
+		data = [0] * n
+
+		for i in range(0, len(self.coords), 3):
+			data[i * 2 + 0] = self.coords[i + 0]
+			data[i * 2 + 1] = self.coords[i + 1]
+			data[i * 2 + 2] = self.coords[i + 2]
+
+			data[i * 2 + 3] = self.normals[i + 0]
+			data[i * 2 + 4] = self.normals[i + 1]
+			data[i * 2 + 5] = self.normals[i + 2]
+
+		return data
+
 	def gen_buffers(self):
 		# create VAO
 
 		self.vao = gl.GLuint(0)
 		gl.glGenVertexArrays(1, ctypes.byref(self.vao))
 		gl.glBindVertexArray(self.vao)
 
-		# create coords VBO
+		# create VBO
 
 		self.vbo = gl.GLuint(0)
 		gl.glGenBuffers(1, ctypes.byref(self.vbo))
 		gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vbo)
 
-		coords_t = gl.GLfloat * len(self.coords)
+		data_t = gl.GLfloat * len(self.vbo_data)
+		float_size = ctypes.sizeof(gl.GLfloat)
 
 		gl.glBufferData(gl.GL_ARRAY_BUFFER,
-			ctypes.sizeof(coords_t),
-			(coords_t) (*self.coords),
+			ctypes.sizeof(data_t),
+			(data_t) (*self.vbo_data),
 			gl.GL_STATIC_DRAW)
 
-		gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, 0)
+		gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, float_size * 6, 0)
 		gl.glEnableVertexAttribArray(0)
 
-		# create normals VBO
-
-		self.normals_vbo = gl.GLuint(0)
-		gl.glGenBuffers(1, ctypes.byref(self.normals_vbo))
-		gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.normals_vbo)
-
-		normals_t = gl.GLfloat * len(self.normals)
-
-		gl.glBufferData(gl.GL_ARRAY_BUFFER,
-			ctypes.sizeof(normals_t),
-			(normals_t) (*self.normals),
-			gl.GL_STATIC_DRAW)
-
-		gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, 0)
+		gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT, gl.GL_FALSE, float_size * 6, float_size * 3)
 		gl.glEnableVertexAttribArray(1)
 
 		# create IBO
@@ -173,3 +178,9 @@ def gen_buffers(self):
 	def draw(self):
 		gl.glBindVertexArray(self.vao)
 		gl.glDrawElements(gl.GL_TRIANGLES, len(self.indices), gl.GL_UNSIGNED_INT, None)
+
+	def export_js(self) -> str:
+		return f"""{{
+			indices: new Uint32Array({jsify_list(self.indices)}),
+			vbo_data: new Float32Array({jsify_list(self.vbo_data)}),
+		}}"""

pybfm/bfm/util.py

@@ -0,0 +1,4 @@
+from typing import List
+
+def jsify_list(l: List):
+	return "[" + ",".join(map(lambda x: str(round(x, 3)), l)) + "]"

pybfm/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bfm"
-version = "0.1.0"
+version = "0.2.0"
 description = "Python wrapper around BFM library for FEM/FEA"
 authors = [
 	{name = "Alexandre Dewilde", email = "alexandredewilde.contact@gmail.com"},

shaders/scenery.frag

@@ -1,4 +1,6 @@
-#version 330
+#version 300 es
+
+precision mediump float;
 
 out vec4 out_colour;