new demo version 0.7.5!

Author: rlguy

README.md

@@ -11,7 +11,7 @@ Want to try the FLIP Fluids addon before buying the [full marketplace product](h
 
 ### Getting Started
 
-Download the latest FLIP Fluids Demo installation file here: [FLIP_Fluids_addon_0.7.4_demo_(22_jan_2024.zip)](https://github.com/rlguy/Blender-FLIP-Fluids/releases/download/v0.7.4/FLIP_Fluids_addon_0.7.4_demo_.22_jan_2024.zip)
+Download the latest FLIP Fluids Demo installation file here: [FLIP_Fluids_addon_0.7.5_demo_(12_mar_2024.zip)](https://github.com/rlguy/Blender-FLIP-Fluids/releases/download/v0.7.5/FLIP_Fluids_addon_0.7.5_demo_.12_mar_2024.zip)
 
 After downloading the demo addon, follow our [Installation Instructions](https://github.com/rlguy/Blender-FLIP-Fluids/wiki/Addon-Installation-and-Uninstallation). The instructions are similar to installing any other Blender addon.
 

cmake/CMakeLists.txt

@@ -53,8 +53,8 @@ set(CMAKE_BUILD_TYPE Release)
 set(FLUIDENGINE_VERSION_TYPE_IS_STABLE_BUILD TRUE)
 set(FLUIDENGINE_VERSION_MAJOR 0)
 set(FLUIDENGINE_VERSION_MINOR 7)
-set(FLUIDENGINE_VERSION_REVISION 4)
-set(FLUIDENGINE_VERSION_DATE "22-JAN-2024")
+set(FLUIDENGINE_VERSION_REVISION 5)
+set(FLUIDENGINE_VERSION_DATE "12-MAR-2024")
 
 if(FLUIDENGINE_VERSION_TYPE_IS_STABLE_BUILD)
     set(FLUIDENGINE_VERSION_TYPE_LABEL "Demo")

src/addon/__init__.py.in

@@ -15,7 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 bl_info = {
-    "name" : "FLIP Fluids Demo @FLUIDENGINE_VERSION_MAJOR@.@FLUIDENGINE_VERSION_MINOR@.@FLUIDENGINE_VERSION_REVISION@",
+    "name" : "FLIP Fluids Demo",
     "description": "A FLIP Fluid Simulation Tool for Blender (v@FLUIDENGINE_VERSION_LABEL@)",
     "author" : "Ryan Guy & Dennis Fassbaender <support[at]flipfluids.com>",
     "version" : (@FLUIDENGINE_VERSION_MAJOR@, @FLUIDENGINE_VERSION_MINOR@, @FLUIDENGINE_VERSION_REVISION@),

src/addon/bake.py

@@ -14,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-import sys, os, shutil, json, traceback, math
+import sys, os, shutil, json, traceback, math, time
 
 from .objects import flip_fluid_map
 from .objects import flip_fluid_geometry_database
@@ -160,7 +160,8 @@ def __extract_keyframed_mesh(object_name, frameno):
         raise Exception(msg)
 
     tmesh = TriangleMesh.from_bobj(bobj_data)
-    tmesh.apply_transform(__extract_transform_data(object_name, frameno))
+    transform_data = __extract_transform_data(object_name, frameno)
+    tmesh.apply_transform(transform_data)
 
     data = __get_simulation_data()
     scale = data.domain_data.initialize.scale
@@ -1044,6 +1045,11 @@ def __initialize_fluid_simulation_settings(fluidsim, data):
     # World Settings
     world = dprops.world
     fluidsim.add_body_force(__get_parameter_data(world.gravity, frameno))
+    fluidsim.force_field_weight_fluid_particles = __get_parameter_data(world.force_field_weight_fluid_particles, frameno)
+    fluidsim.force_field_weight_whitewater_foam = __get_parameter_data(world.force_field_weight_whitewater_foam, frameno)
+    fluidsim.force_field_weight_whitewater_bubble = __get_parameter_data(world.force_field_weight_whitewater_bubble, frameno)
+    fluidsim.force_field_weight_whitewater_spray = __get_parameter_data(world.force_field_weight_whitewater_spray, frameno)
+    fluidsim.force_field_weight_whitewater_dust = __get_parameter_data(world.force_field_weight_whitewater_dust, frameno)
 
     # Caches created in older versions may not contain force field data. Ignore these features
     # if force field data cannot be found in the cache
@@ -1295,6 +1301,9 @@ def __initialize_fluid_simulation_settings(fluidsim, data):
     fluidsim.enable_asynchronous_meshing = \
         __get_parameter_data(advanced.enable_asynchronous_meshing, frameno)
 
+    fluidsim.enable_fracture_optimization = \
+        __get_parameter_data(advanced.enable_fracture_optimization, frameno)
+
     fluidsim.enable_static_solid_levelset_precomputation = \
         __get_parameter_data(advanced.precompute_static_obstacles, frameno)
 
@@ -1633,15 +1642,20 @@ def __update_dynamic_force_field_mesh(animated_object, object_data):
     animated_object.update_mesh_animated(mesh_previous, mesh_current, mesh_next)
 
 
-def __update_animatable_inflow_properties(data, frameid):
+def __update_animatable_inflow_properties(data, mesh_geometry_data, frameid):
     inflow_objects = data.inflow_objects
     inflow_data = data.inflow_data
 
     for idx, inflow in enumerate(inflow_objects):
         data = inflow_data[idx]
 
-        if __is_object_dynamic(data.name):
-            __update_dynamic_object_mesh(inflow, data)
+        name_slug = __get_name_slug(data.name)
+        object_geometry_data = mesh_geometry_data[name_slug]
+        if object_geometry_data["is_motion_dynamic"]:
+            mesh_previous = object_geometry_data["triangle_mesh_previous"]
+            mesh_current = object_geometry_data["triangle_mesh_current"]
+            mesh_next = object_geometry_data["triangle_mesh_next"]
+            inflow.update_mesh_animated(mesh_previous, mesh_current, mesh_next)
 
         inflow.enable = __get_parameter_data(data.is_enabled, frameid)
         inflow.set_velocity(__get_inflow_object_velocity(data, frameid))
@@ -1662,15 +1676,20 @@ def __update_animatable_inflow_properties(data, frameid):
         inflow.set_source_color(__get_parameter_data(data.color, frameid))
 
 
-def __update_animatable_outflow_properties(data, frameid):
+def __update_animatable_outflow_properties(data, mesh_geometry_data, frameid):
     outflow_objects = data.outflow_objects
     outflow_data = data.outflow_data
 
     for idx, outflow in enumerate(outflow_objects):
         data = outflow_data[idx]
 
-        if __is_object_dynamic(data.name):
-            __update_dynamic_object_mesh(outflow, data)
+        name_slug = __get_name_slug(data.name)
+        object_geometry_data = mesh_geometry_data[name_slug]
+        if object_geometry_data["is_motion_dynamic"]:
+            mesh_previous = object_geometry_data["triangle_mesh_previous"]
+            mesh_current = object_geometry_data["triangle_mesh_current"]
+            mesh_next = object_geometry_data["triangle_mesh_next"]
+            outflow.update_mesh_animated(mesh_previous, mesh_current, mesh_next)
 
         outflow.enable = __get_parameter_data(data.is_enabled, frameid)
         outflow.fluid_outflow =  __get_parameter_data(data.remove_fluid, frameid)
@@ -1716,7 +1735,7 @@ def __update_animatable_force_field_properties(data, frameid):
             force_field.gravity_scale_width = __get_parameter_data(data.gravity_scale_width_curve, frameid)
 
 
-def __update_animatable_obstacle_properties(data, frameid):
+def __update_animatable_obstacle_properties(data, mesh_geometry_data, frameid):
     obstacle_objects = data.obstacle_objects
     obstacle_data = data.obstacle_data
 
@@ -1752,11 +1771,19 @@ def __update_animatable_obstacle_properties(data, frameid):
 
     #### END WORKAROUND ####
 
+    total_update_time = 0.0
+    start_mesh_object = time.time()
+
     for idx, mesh_object in enumerate(obstacle_objects):
         data = obstacle_data[idx]
 
-        if __is_object_dynamic(data.name):
-            __update_dynamic_object_mesh(mesh_object, data)
+        name_slug = __get_name_slug(data.name)
+        object_geometry_data = mesh_geometry_data[name_slug]
+        if object_geometry_data["is_motion_dynamic"]:
+            mesh_previous = object_geometry_data["triangle_mesh_previous"]
+            mesh_current = object_geometry_data["triangle_mesh_current"]
+            mesh_next = object_geometry_data["triangle_mesh_next"]
+            mesh_object.update_mesh_animated(mesh_previous, mesh_current, mesh_next)
 
         mesh_object.enable = __get_parameter_data(data.is_enabled, frameid)
         mesh_object.friction = __get_parameter_data(data.friction, frameid, value_min=0.0)
@@ -2009,6 +2036,17 @@ def __update_animatable_domain_properties(fluidsim, data, frameno):
             gravity = [0.0, 0.0, 0.0]
     __set_body_force_property(fluidsim, gravity)
 
+    weight_fluid_particles = __get_parameter_data(world.force_field_weight_fluid_particles, frameno)
+    weight_whitewater_foam = __get_parameter_data(world.force_field_weight_whitewater_foam, frameno)
+    weight_whitewater_bubble = __get_parameter_data(world.force_field_weight_whitewater_bubble, frameno)
+    weight_whitewater_spray = __get_parameter_data(world.force_field_weight_whitewater_spray, frameno)
+    weight_whitewater_dust = __get_parameter_data(world.force_field_weight_whitewater_dust, frameno)
+    __set_property(fluidsim, 'force_field_weight_fluid_particles', weight_fluid_particles)
+    __set_property(fluidsim, 'force_field_weight_whitewater_foam', weight_whitewater_foam)
+    __set_property(fluidsim, 'force_field_weight_whitewater_bubble', weight_whitewater_bubble)
+    __set_property(fluidsim, 'force_field_weight_whitewater_spray', weight_whitewater_spray)
+    __set_property(fluidsim, 'force_field_weight_whitewater_dust', weight_whitewater_dust)
+
     is_viscosity_enabled = __get_parameter_data(world.enable_viscosity, frameno)
     if is_viscosity_enabled:
         surface = dprops.surface
@@ -2190,6 +2228,9 @@ def __update_animatable_domain_properties(fluidsim, data, frameno):
     enable_async_meshing = __get_parameter_data(advanced.enable_asynchronous_meshing, frameno)
     __set_property(fluidsim, 'enable_asynchronous_meshing', enable_async_meshing)
 
+    enable_fracture_optimization = __get_parameter_data(advanced.enable_fracture_optimization, frameno)
+    __set_property(fluidsim, 'enable_fracture_optimization', enable_fracture_optimization)
+
     precomp_static_sdf = __get_parameter_data(advanced.precompute_static_obstacles, frameno)
     __set_property(fluidsim, 'enable_static_solid_levelset_precomputation', precomp_static_sdf)
 
@@ -2211,10 +2252,15 @@ def __update_animatable_domain_properties(fluidsim, data, frameno):
 
 
 def __update_animatable_properties(fluidsim, data, frameno):
-    __update_animatable_inflow_properties(data, frameno)
-    __update_animatable_outflow_properties(data, frameno)
+    geometry_database = __get_geometry_database()
+    simulation_data = __get_simulation_data()
+    timeline_frame = __get_timeline_frame()
+    geometry_data = geometry_database.get_mesh_geometry_data_dict_for_frame(simulation_data, timeline_frame)
+    
+    __update_animatable_inflow_properties(data, geometry_data, frameno)
+    __update_animatable_outflow_properties(data, geometry_data, frameno)
     __update_animatable_force_field_properties(data, frameno)
-    __update_animatable_obstacle_properties(data, frameno)
+    __update_animatable_obstacle_properties(data, geometry_data, frameno)
     __update_animatable_meshing_volume_properties(data, frameno)
     __update_animatable_domain_properties(fluidsim, data, frameno)
 

src/addon/export.py

@@ -416,9 +416,6 @@ def add_objects_to_geometry_exporter(geometry_exporter):
     objects = bpy.context.scene.flip_fluid.get_simulation_objects(skip_hide_viewport=True)
     disable_topology_warning = dprops.advanced.disable_changing_topology_warning
 
-    for obj in objects:
-        print(obj)
-
     # Add regular FLIP Fluid objects
     for obj in objects:
         props = obj.flip_fluid.get_property_group()

src/addon/materials/material_library/surface/FF Water (clear).blend

@@ -19,6 +19,8 @@
 from .flip_fluid_geometry_export_object import GeometryExportType, MotionExportType
 from ..filesystem import filesystem_protection_layer as fpl
 
+from ..pyfluid import TriangleMesh
+
 
 class GeometryDatabase():
     def __init__(self, db_filepath, clear_database=False):
@@ -598,6 +600,169 @@ def get_curve_animated(self, name_slug, frameno):
         return result[0]
 
 
+    def get_mesh_geometry_data_dict_for_frame(self, simulation_data, frameno):
+        cmd = """ SELECT object_id, object_slug, object_motion_type FROM object"""
+        self._cursor.execute(cmd)
+        result = self._cursor.fetchall()
+
+        geometry_data = {}
+        object_id_to_name_slug = {}
+        for row in result:
+            object_id = row[0]
+            name_slug = row[1]
+            object_motion_type = row[2]
+            is_static = object_motion_type == 'STATIC'
+            is_dynamic = not is_static
+
+            geometry_data[name_slug] = {
+                "object_id": object_id,
+                "object_motion_type": object_motion_type,
+                "is_motion_static": is_static,
+                "is_motion_dynamic": is_dynamic,
+                "static_bobj_data": None,
+                "transform_previous": None,
+                "transform_current": None,
+                "transform_next": None,
+                "triangle_mesh_previous": None,
+                "triangle_mesh_current": None,
+                "triangle_mesh_next": None,
+            }
+            object_id_to_name_slug[object_id] = name_slug
+
+
+        # Retreive static meshes for static and keyframed objects
+        cmd = """SELECT object_id, mesh_static_data FROM mesh_static"""
+        self._cursor.execute(cmd)
+        result_static_bobj_data = self._cursor.fetchall()
+
+        static_bobj_data = {}
+        for row in result_static_bobj_data:
+            object_id = row[0]
+            bobj_data = row[1]
+            static_bobj_data[object_id] = bobj_data
+
+            name_slug = object_id_to_name_slug[object_id]
+            geometry_data[name_slug]["static_bobj_data"] = bobj_data
+
+        frame_previous = frameno - 1
+        frame_current = frameno
+        frame_next = frameno + 1
+
+        # Retrieve keyframed mesh transforms
+        cmd = """
+            SELECT object_id,
+                   m00, m01, m02, m03, 
+                   m10, m11, m12, m13, 
+                   m20, m21, m22, m23, 
+                   m30, m31, m32, m33 FROM mesh_keyframed 
+            WHERE frame_id=?
+            """
+
+        self._cursor.execute(cmd, (frame_previous,))
+        result_frame_previous = self._cursor.fetchall()
+        self._cursor.execute(cmd, (frame_current,))
+        result_frame_current = self._cursor.fetchall()
+        self._cursor.execute(cmd, (frame_next,))
+        result_frame_next = self._cursor.fetchall()
+
+        for row in result_frame_previous:
+            object_id = row[0]
+            transform = list(row[1:])
+            name_slug = object_id_to_name_slug[object_id]
+            geometry_data[name_slug]["transform_previous"] = transform
+
+        for row in result_frame_current:
+            object_id = row[0]
+            transform = list(row[1:])
+            name_slug = object_id_to_name_slug[object_id]
+            geometry_data[name_slug]["transform_current"] = transform
+
+        for row in result_frame_next:
+            object_id = row[0]
+            transform = list(row[1:])
+            name_slug = object_id_to_name_slug[object_id]
+            geometry_data[name_slug]["transform_next"] = transform
+
+        for name_slug, entry in geometry_data.items():
+            if not entry["object_motion_type"] == 'KEYFRAMED':
+                continue
+            if entry["transform_previous"] is None:
+                entry["transform_previous"] = entry["transform_current"]
+            if entry["transform_next"] is None:
+                entry["transform_next"] = entry["transform_current"]
+
+        # Generate keyframed triangle meshes from transforms
+        scale = simulation_data.domain_data.initialize.scale
+        bbox = simulation_data.domain_data.initialize.bbox
+        for name_slug, entry in geometry_data.items():
+            if not entry["object_motion_type"] == 'KEYFRAMED':
+                continue
+
+            mesh_previous = TriangleMesh.from_bobj(entry["static_bobj_data"])
+            mesh_current = TriangleMesh.from_bobj(entry["static_bobj_data"])
+            mesh_next = TriangleMesh.from_bobj(entry["static_bobj_data"])
+            mesh_previous.apply_transform(entry["transform_previous"])
+            mesh_current.apply_transform(entry["transform_current"])
+            mesh_next.apply_transform(entry["transform_next"])
+            mesh_previous.translate(-bbox.x, -bbox.y, -bbox.z)
+            mesh_current.translate(-bbox.x, -bbox.y, -bbox.z)
+            mesh_next.translate(-bbox.x, -bbox.y, -bbox.z)
+            mesh_previous.scale(scale)
+            mesh_current.scale(scale)
+            mesh_next.scale(scale)
+
+            entry["triangle_mesh_previous"] = mesh_previous
+            entry["triangle_mesh_current"] = mesh_current
+            entry["triangle_mesh_next"] = mesh_next
+
+        # Retrieve animated triangle meshes
+        cmd = """SELECT object_id, mesh_animated_data FROM mesh_animated WHERE frame_id=?"""
+
+        self._cursor.execute(cmd, (frame_previous,))
+        result_frame_previous = self._cursor.fetchall()
+        self._cursor.execute(cmd, (frame_current,))
+        result_frame_current = self._cursor.fetchall()
+        self._cursor.execute(cmd, (frame_next,))
+        result_frame_next = self._cursor.fetchall()
+
+        for row in result_frame_previous:
+            object_id = row[0]
+            bobj_data = row[1]
+            name_slug = object_id_to_name_slug[object_id]
+            mesh = TriangleMesh.from_bobj(bobj_data)
+            mesh.translate(-bbox.x, -bbox.y, -bbox.z)
+            mesh.scale(scale)
+            geometry_data[name_slug]["triangle_mesh_previous"] = mesh
+
+        for row in result_frame_current:
+            object_id = row[0]
+            bobj_data = row[1]
+            name_slug = object_id_to_name_slug[object_id]
+            mesh = TriangleMesh.from_bobj(bobj_data)
+            mesh.translate(-bbox.x, -bbox.y, -bbox.z)
+            mesh.scale(scale)
+            geometry_data[name_slug]["triangle_mesh_current"] = mesh
+
+        for row in result_frame_next:
+            object_id = row[0]
+            bobj_data = row[1]
+            name_slug = object_id_to_name_slug[object_id]
+            mesh = TriangleMesh.from_bobj(bobj_data)
+            mesh.translate(-bbox.x, -bbox.y, -bbox.z)
+            mesh.scale(scale)
+            geometry_data[name_slug]["triangle_mesh_next"] = mesh
+
+        for name_slug, entry in geometry_data.items():
+            if not entry["object_motion_type"] == 'ANIMATED':
+                continue
+            if entry["triangle_mesh_previous"] is None:
+                entry["triangle_mesh_previous"] = entry["triangle_mesh_current"]
+            if entry["triangle_mesh_next"] is None:
+                entry["triangle_mesh_next"] = entry["triangle_mesh_current"]
+
+        return geometry_data
+
+
 
 
     ###########################################################################