Merge branch 'temp_remove_pointcache' into blender2.8
This commit is contained in:
commit
b4a721af69
|
@ -21,15 +21,10 @@ import bpy
|
|||
from bpy.types import Menu, Panel
|
||||
|
||||
from bl_ui.properties_physics_common import (
|
||||
point_cache_ui,
|
||||
effector_weights_ui,
|
||||
)
|
||||
|
||||
|
||||
def cloth_panel_enabled(md):
|
||||
return md.point_cache.is_baked is False
|
||||
|
||||
|
||||
class CLOTH_MT_presets(Menu):
|
||||
bl_label = "Cloth Presets"
|
||||
preset_subdir = "cloth"
|
||||
|
@ -61,8 +56,6 @@ class PHYSICS_PT_cloth(PhysicButtonsPanel, Panel):
|
|||
|
||||
split = layout.split()
|
||||
|
||||
split.active = cloth_panel_enabled(md)
|
||||
|
||||
col = split.column()
|
||||
|
||||
col.label(text="Presets:")
|
||||
|
@ -110,15 +103,6 @@ class PHYSICS_PT_cloth(PhysicButtonsPanel, Panel):
|
|||
col.prop_search(cloth, "rest_shape_key", key, "key_blocks", text="")
|
||||
|
||||
|
||||
class PHYSICS_PT_cloth_cache(PhysicButtonsPanel, Panel):
|
||||
bl_label = "Cloth Cache"
|
||||
bl_options = {'DEFAULT_CLOSED'}
|
||||
|
||||
def draw(self, context):
|
||||
md = context.cloth
|
||||
point_cache_ui(self, context, md.point_cache, cloth_panel_enabled(md), 'CLOTH')
|
||||
|
||||
|
||||
class PHYSICS_PT_cloth_collision(PhysicButtonsPanel, Panel):
|
||||
bl_label = "Cloth Collision"
|
||||
bl_options = {'DEFAULT_CLOSED'}
|
||||
|
@ -126,7 +110,6 @@ class PHYSICS_PT_cloth_collision(PhysicButtonsPanel, Panel):
|
|||
def draw_header(self, context):
|
||||
cloth = context.cloth.collision_settings
|
||||
|
||||
self.layout.active = cloth_panel_enabled(context.cloth)
|
||||
self.layout.prop(cloth, "use_collision", text="")
|
||||
|
||||
def draw(self, context):
|
||||
|
@ -136,7 +119,7 @@ class PHYSICS_PT_cloth_collision(PhysicButtonsPanel, Panel):
|
|||
md = context.cloth
|
||||
ob = context.object
|
||||
|
||||
layout.active = cloth.use_collision and cloth_panel_enabled(md)
|
||||
layout.active = cloth.use_collision
|
||||
|
||||
split = layout.split()
|
||||
|
||||
|
@ -165,7 +148,6 @@ class PHYSICS_PT_cloth_stiffness(PhysicButtonsPanel, Panel):
|
|||
def draw_header(self, context):
|
||||
cloth = context.cloth.settings
|
||||
|
||||
self.layout.active = cloth_panel_enabled(context.cloth)
|
||||
self.layout.prop(cloth, "use_stiffness_scale", text="")
|
||||
|
||||
def draw(self, context):
|
||||
|
@ -175,7 +157,7 @@ class PHYSICS_PT_cloth_stiffness(PhysicButtonsPanel, Panel):
|
|||
ob = context.object
|
||||
cloth = context.cloth.settings
|
||||
|
||||
layout.active = (cloth.use_stiffness_scale and cloth_panel_enabled(md))
|
||||
layout.active = cloth.use_stiffness_scale
|
||||
|
||||
split = layout.split()
|
||||
|
||||
|
@ -197,7 +179,6 @@ class PHYSICS_PT_cloth_sewing(PhysicButtonsPanel, Panel):
|
|||
def draw_header(self, context):
|
||||
cloth = context.cloth.settings
|
||||
|
||||
self.layout.active = cloth_panel_enabled(context.cloth)
|
||||
self.layout.prop(cloth, "use_sewing_springs", text="")
|
||||
|
||||
def draw(self, context):
|
||||
|
@ -207,7 +188,7 @@ class PHYSICS_PT_cloth_sewing(PhysicButtonsPanel, Panel):
|
|||
ob = context.object
|
||||
cloth = context.cloth.settings
|
||||
|
||||
layout.active = (cloth.use_sewing_springs and cloth_panel_enabled(md))
|
||||
layout.active = cloth.use_sewing_springs
|
||||
|
||||
layout.prop(cloth, "sewing_force_max", text="Sewing Force")
|
||||
|
||||
|
|
|
@ -97,111 +97,6 @@ class PHYSICS_PT_add(PhysicButtonsPanel, Panel):
|
|||
'CONSTRAINT') # RB_TODO needs better icon
|
||||
|
||||
|
||||
# cache-type can be 'CLOTH', 'SMOKE' etc
|
||||
|
||||
def point_cache_ui(self, context, cache, enabled, cachetype):
|
||||
layout = self.layout
|
||||
|
||||
layout.context_pointer_set("point_cache", cache)
|
||||
|
||||
if not cachetype == 'RIGID_BODY':
|
||||
row = layout.row()
|
||||
row.template_list("UI_UL_list", "point_caches", cache, "point_caches",
|
||||
cache.point_caches, "active_index", rows=1)
|
||||
col = row.column(align=True)
|
||||
col.operator("ptcache.add", icon='ZOOMIN', text="")
|
||||
col.operator("ptcache.remove", icon='ZOOMOUT', text="")
|
||||
|
||||
row = layout.row()
|
||||
if cachetype == 'SMOKE':
|
||||
row.prop(cache, "use_external")
|
||||
row.prop(cache, "use_library_path", "Use Lib Path")
|
||||
|
||||
if cache.use_external:
|
||||
split = layout.split(percentage=0.35)
|
||||
col = split.column()
|
||||
col.label(text="Index Number:")
|
||||
col.label(text="File Path:")
|
||||
|
||||
col = split.column()
|
||||
col.prop(cache, "index", text="")
|
||||
col.prop(cache, "filepath", text="")
|
||||
|
||||
cache_info = cache.info
|
||||
if cache_info:
|
||||
layout.label(text=cache_info)
|
||||
else:
|
||||
if cachetype in {'SMOKE', 'DYNAMIC_PAINT'}:
|
||||
if not bpy.data.is_saved:
|
||||
layout.label(text="Cache is disabled until the file is saved")
|
||||
layout.enabled = False
|
||||
|
||||
if not cache.use_external or cachetype == 'SMOKE':
|
||||
row = layout.row(align=True)
|
||||
|
||||
if cachetype != 'DYNAMIC_PAINT':
|
||||
row.enabled = enabled
|
||||
row.prop(cache, "frame_start")
|
||||
row.prop(cache, "frame_end")
|
||||
if cachetype not in {'SMOKE', 'CLOTH', 'DYNAMIC_PAINT', 'RIGID_BODY'}:
|
||||
row.prop(cache, "frame_step")
|
||||
|
||||
if cachetype != 'SMOKE':
|
||||
layout.label(text=cache.info)
|
||||
|
||||
can_bake = True
|
||||
|
||||
if cachetype not in {'SMOKE', 'DYNAMIC_PAINT', 'RIGID_BODY'}:
|
||||
split = layout.split()
|
||||
split.enabled = enabled and bpy.data.is_saved
|
||||
|
||||
col = split.column()
|
||||
col.prop(cache, "use_disk_cache")
|
||||
|
||||
col = split.column()
|
||||
col.active = cache.use_disk_cache
|
||||
col.prop(cache, "use_library_path", "Use Lib Path")
|
||||
|
||||
row = layout.row()
|
||||
row.enabled = enabled and bpy.data.is_saved
|
||||
row.active = cache.use_disk_cache
|
||||
row.label(text="Compression:")
|
||||
row.prop(cache, "compression", expand=True)
|
||||
|
||||
layout.separator()
|
||||
|
||||
if cache.id_data.library and not cache.use_disk_cache:
|
||||
can_bake = False
|
||||
|
||||
col = layout.column(align=True)
|
||||
col.label(text="Linked object baking requires Disk Cache to be enabled", icon='INFO')
|
||||
else:
|
||||
layout.separator()
|
||||
|
||||
split = layout.split()
|
||||
split.active = can_bake
|
||||
|
||||
col = split.column()
|
||||
|
||||
if cache.is_baked is True:
|
||||
col.operator("ptcache.free_bake", text="Free Bake")
|
||||
else:
|
||||
col.operator("ptcache.bake", text="Bake").bake = True
|
||||
|
||||
sub = col.row()
|
||||
sub.enabled = (cache.is_frame_skip or cache.is_outdated) and enabled
|
||||
sub.operator("ptcache.bake", text="Calculate To Frame").bake = False
|
||||
|
||||
sub = col.column()
|
||||
sub.enabled = enabled
|
||||
sub.operator("ptcache.bake_from_cache", text="Current Cache to Bake")
|
||||
|
||||
col = split.column()
|
||||
col.operator("ptcache.bake_all", text="Bake All Dynamics").bake = True
|
||||
col.operator("ptcache.free_bake_all", text="Free All Bakes")
|
||||
col.operator("ptcache.bake_all", text="Update All To Frame").bake = False
|
||||
|
||||
|
||||
def effector_weights_ui(self, context, weights, weight_type):
|
||||
layout = self.layout
|
||||
|
||||
|
|
|
@ -21,7 +21,6 @@ import bpy
|
|||
from bpy.types import Panel, UIList
|
||||
|
||||
from bl_ui.properties_physics_common import (
|
||||
point_cache_ui,
|
||||
effector_weights_ui,
|
||||
)
|
||||
|
||||
|
@ -386,28 +385,6 @@ class PHYSICS_PT_dp_effects(PhysicButtonsPanel, Panel):
|
|||
row.prop(surface, "shrink_speed")
|
||||
|
||||
|
||||
class PHYSICS_PT_dp_cache(PhysicButtonsPanel, Panel):
|
||||
bl_label = "Dynamic Paint Cache"
|
||||
bl_options = {'DEFAULT_CLOSED'}
|
||||
|
||||
@classmethod
|
||||
def poll(cls, context):
|
||||
md = context.dynamic_paint
|
||||
rd = context.scene.render
|
||||
return (md and
|
||||
md.ui_type == 'CANVAS' and
|
||||
md.canvas_settings and
|
||||
md.canvas_settings.canvas_surfaces.active and
|
||||
md.canvas_settings.canvas_surfaces.active.is_cache_user and
|
||||
(not rd.use_game_engine))
|
||||
|
||||
def draw(self, context):
|
||||
surface = context.dynamic_paint.canvas_settings.canvas_surfaces.active
|
||||
cache = surface.point_cache
|
||||
|
||||
point_cache_ui(self, context, cache, (cache.is_baked is False), 'DYNAMIC_PAINT')
|
||||
|
||||
|
||||
class PHYSICS_PT_dp_brush_source(PhysicButtonsPanel, Panel):
|
||||
bl_label = "Dynamic Paint Source"
|
||||
|
||||
|
|
|
@ -21,7 +21,6 @@ import bpy
|
|||
from bpy.types import Panel
|
||||
|
||||
from bl_ui.properties_physics_common import (
|
||||
point_cache_ui,
|
||||
effector_weights_ui,
|
||||
)
|
||||
|
||||
|
@ -54,8 +53,6 @@ class PHYSICS_PT_smoke(PhysicButtonsPanel, Panel):
|
|||
|
||||
split = layout.split()
|
||||
|
||||
split.enabled = not domain.point_cache.is_baked
|
||||
|
||||
col = split.column()
|
||||
col.label(text="Resolution:")
|
||||
col.prop(domain, "resolution_max", text="Divisions")
|
||||
|
@ -169,7 +166,6 @@ class PHYSICS_PT_smoke_fire(PhysicButtonsPanel, Panel):
|
|||
domain = context.smoke.domain_settings
|
||||
|
||||
split = layout.split()
|
||||
split.enabled = not domain.point_cache.is_baked
|
||||
|
||||
col = split.column(align=True)
|
||||
col.label(text="Reaction:")
|
||||
|
@ -205,7 +201,6 @@ class PHYSICS_PT_smoke_adaptive_domain(PhysicButtonsPanel, Panel):
|
|||
layout.active = domain.use_adaptive_domain
|
||||
|
||||
split = layout.split()
|
||||
split.enabled = (not domain.point_cache.is_baked)
|
||||
|
||||
col = split.column(align=True)
|
||||
col.label(text="Resolution:")
|
||||
|
@ -240,7 +235,6 @@ class PHYSICS_PT_smoke_highres(PhysicButtonsPanel, Panel):
|
|||
layout.active = md.use_high_resolution
|
||||
|
||||
split = layout.split()
|
||||
split.enabled = not md.point_cache.is_baked
|
||||
|
||||
col = split.column()
|
||||
col.label(text="Resolution:")
|
||||
|
@ -302,10 +296,7 @@ class PHYSICS_PT_smoke_cache(PhysicButtonsPanel, Panel):
|
|||
|
||||
layout.prop(domain, "cache_file_format")
|
||||
|
||||
if cache_file_format == 'POINTCACHE':
|
||||
layout.label(text="Compression:")
|
||||
layout.prop(domain, "point_cache_compress_type", expand=True)
|
||||
elif cache_file_format == 'OPENVDB':
|
||||
if cache_file_format == 'OPENVDB':
|
||||
if not bpy.app.build_options.openvdb:
|
||||
layout.label("Built without OpenVDB support")
|
||||
return
|
||||
|
@ -316,9 +307,6 @@ class PHYSICS_PT_smoke_cache(PhysicButtonsPanel, Panel):
|
|||
row.label("Data Depth:")
|
||||
row.prop(domain, "data_depth", expand=True, text="Data Depth")
|
||||
|
||||
cache = domain.point_cache
|
||||
point_cache_ui(self, context, cache, (cache.is_baked is False), 'SMOKE')
|
||||
|
||||
|
||||
class PHYSICS_PT_smoke_field_weights(PhysicButtonsPanel, Panel):
|
||||
bl_label = "Smoke Field Weights"
|
||||
|
|
|
@ -21,15 +21,10 @@ import bpy
|
|||
from bpy.types import Panel
|
||||
|
||||
from bl_ui.properties_physics_common import (
|
||||
point_cache_ui,
|
||||
effector_weights_ui,
|
||||
)
|
||||
|
||||
|
||||
def softbody_panel_enabled(md):
|
||||
return (md.point_cache.is_baked is False)
|
||||
|
||||
|
||||
class PhysicButtonsPanel:
|
||||
bl_space_type = 'PROPERTIES'
|
||||
bl_region_type = 'WINDOW'
|
||||
|
@ -55,7 +50,6 @@ class PHYSICS_PT_softbody(PhysicButtonsPanel, Panel):
|
|||
|
||||
# General
|
||||
split = layout.split()
|
||||
split.enabled = softbody_panel_enabled(md)
|
||||
|
||||
col = split.column()
|
||||
col.label(text="Object:")
|
||||
|
@ -68,15 +62,6 @@ class PHYSICS_PT_softbody(PhysicButtonsPanel, Panel):
|
|||
col.prop(softbody, "speed")
|
||||
|
||||
|
||||
class PHYSICS_PT_softbody_cache(PhysicButtonsPanel, Panel):
|
||||
bl_label = "Soft Body Cache"
|
||||
bl_options = {'DEFAULT_CLOSED'}
|
||||
|
||||
def draw(self, context):
|
||||
md = context.soft_body
|
||||
point_cache_ui(self, context, md.point_cache, softbody_panel_enabled(md), 'SOFTBODY')
|
||||
|
||||
|
||||
class PHYSICS_PT_softbody_goal(PhysicButtonsPanel, Panel):
|
||||
bl_label = "Soft Body Goal"
|
||||
bl_options = {'DEFAULT_CLOSED'}
|
||||
|
@ -84,7 +69,6 @@ class PHYSICS_PT_softbody_goal(PhysicButtonsPanel, Panel):
|
|||
def draw_header(self, context):
|
||||
softbody = context.soft_body.settings
|
||||
|
||||
self.layout.active = softbody_panel_enabled(context.soft_body)
|
||||
self.layout.prop(softbody, "use_goal", text="")
|
||||
|
||||
def draw(self, context):
|
||||
|
@ -94,7 +78,7 @@ class PHYSICS_PT_softbody_goal(PhysicButtonsPanel, Panel):
|
|||
softbody = md.settings
|
||||
ob = context.object
|
||||
|
||||
layout.active = softbody.use_goal and softbody_panel_enabled(md)
|
||||
layout.active = softbody.use_goal
|
||||
|
||||
split = layout.split()
|
||||
|
||||
|
@ -123,7 +107,6 @@ class PHYSICS_PT_softbody_edge(PhysicButtonsPanel, Panel):
|
|||
def draw_header(self, context):
|
||||
softbody = context.soft_body.settings
|
||||
|
||||
self.layout.active = softbody_panel_enabled(context.soft_body)
|
||||
self.layout.prop(softbody, "use_edges", text="")
|
||||
|
||||
def draw(self, context):
|
||||
|
@ -133,7 +116,7 @@ class PHYSICS_PT_softbody_edge(PhysicButtonsPanel, Panel):
|
|||
softbody = md.settings
|
||||
ob = context.object
|
||||
|
||||
layout.active = softbody.use_edges and softbody_panel_enabled(md)
|
||||
layout.active = softbody.use_edges
|
||||
|
||||
split = layout.split()
|
||||
|
||||
|
@ -172,7 +155,6 @@ class PHYSICS_PT_softbody_collision(PhysicButtonsPanel, Panel):
|
|||
def draw_header(self, context):
|
||||
softbody = context.soft_body.settings
|
||||
|
||||
self.layout.active = softbody_panel_enabled(context.soft_body)
|
||||
self.layout.prop(softbody, "use_self_collision", text="")
|
||||
|
||||
def draw(self, context):
|
||||
|
@ -181,7 +163,7 @@ class PHYSICS_PT_softbody_collision(PhysicButtonsPanel, Panel):
|
|||
md = context.soft_body
|
||||
softbody = md.settings
|
||||
|
||||
layout.active = softbody.use_self_collision and softbody_panel_enabled(md)
|
||||
layout.active = softbody.use_self_collision
|
||||
|
||||
layout.label(text="Collision Ball Size Calculation:")
|
||||
layout.prop(softbody, "collision_type", expand=True)
|
||||
|
@ -203,8 +185,6 @@ class PHYSICS_PT_softbody_solver(PhysicButtonsPanel, Panel):
|
|||
md = context.soft_body
|
||||
softbody = md.settings
|
||||
|
||||
layout.active = softbody_panel_enabled(md)
|
||||
|
||||
# Solver
|
||||
split = layout.split()
|
||||
|
||||
|
|
|
@ -27,7 +27,6 @@ from bpy.types import (
|
|||
from rna_prop_ui import PropertyPanel
|
||||
|
||||
from bl_ui.properties_physics_common import (
|
||||
point_cache_ui,
|
||||
effector_weights_ui,
|
||||
)
|
||||
|
||||
|
@ -371,24 +370,6 @@ class SCENE_PT_rigid_body_world(SceneButtonsPanel, Panel):
|
|||
col.prop(rbw, "solver_iterations", text="Solver Iterations")
|
||||
|
||||
|
||||
class SCENE_PT_rigid_body_cache(SceneButtonsPanel, Panel):
|
||||
bl_label = "Rigid Body Cache"
|
||||
bl_options = {'DEFAULT_CLOSED'}
|
||||
COMPAT_ENGINES = {'BLENDER_RENDER'}
|
||||
|
||||
@classmethod
|
||||
def poll(cls, context):
|
||||
rd = context.scene.render
|
||||
scene = context.scene
|
||||
return scene and scene.rigidbody_world and (rd.engine in cls.COMPAT_ENGINES)
|
||||
|
||||
def draw(self, context):
|
||||
scene = context.scene
|
||||
rbw = scene.rigidbody_world
|
||||
|
||||
point_cache_ui(self, context, rbw.point_cache, rbw.point_cache.is_baked is False and rbw.enabled, 'RIGID_BODY')
|
||||
|
||||
|
||||
class SCENE_PT_rigid_body_field_weights(SceneButtonsPanel, Panel):
|
||||
bl_label = "Rigid Body Field Weights"
|
||||
bl_options = {'DEFAULT_CLOSED'}
|
||||
|
|
|
@ -236,9 +236,6 @@ int cloth_uses_vgroup(struct ClothModifierData *clmd);
|
|||
void bvhtree_update_from_cloth(struct ClothModifierData *clmd, bool moving);
|
||||
void bvhselftree_update_from_cloth(struct ClothModifierData *clmd, bool moving);
|
||||
|
||||
// needed for button_object.c
|
||||
void cloth_clear_cache (struct Object *ob, struct ClothModifierData *clmd, float framenr );
|
||||
|
||||
// needed for cloth.c
|
||||
int cloth_add_spring (struct ClothModifierData *clmd, unsigned int indexA, unsigned int indexB, float restlength, int spring_type);
|
||||
|
||||
|
|
|
@ -73,7 +73,6 @@ void dynamicPaint_freeCanvas(struct DynamicPaintModifierData *pmd);
|
|||
void dynamicPaint_freeBrush(struct DynamicPaintModifierData *pmd);
|
||||
void dynamicPaint_freeSurfaceData(struct DynamicPaintSurface *surface);
|
||||
|
||||
void dynamicPaint_cacheUpdateFrames(struct DynamicPaintSurface *surface);
|
||||
bool dynamicPaint_surfaceHasColorPreview(struct DynamicPaintSurface *surface);
|
||||
bool dynamicPaint_outputLayerExists(struct DynamicPaintSurface *surface, struct Object *ob, int output);
|
||||
void dynamicPaintSurface_updateType(struct DynamicPaintSurface *surface);
|
||||
|
|
|
@ -1,341 +0,0 @@
|
|||
/*
|
||||
* ***** BEGIN GPL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2006 Blender Foundation.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): Campbell Barton <ideasman42@gmail.com>
|
||||
*
|
||||
* ***** END GPL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#ifndef __BKE_POINTCACHE_H__
|
||||
#define __BKE_POINTCACHE_H__
|
||||
|
||||
/** \file BKE_pointcache.h
|
||||
* \ingroup bke
|
||||
*/
|
||||
|
||||
#include "DNA_ID.h"
|
||||
#include "DNA_dynamicpaint_types.h"
|
||||
#include "DNA_object_force.h"
|
||||
#include <stdio.h> /* for FILE */
|
||||
|
||||
/* Point cache clearing option, for BKE_ptcache_id_clear, before
|
||||
* and after are non inclusive (they wont remove the cfra) */
|
||||
#define PTCACHE_CLEAR_ALL 0
|
||||
#define PTCACHE_CLEAR_FRAME 1
|
||||
#define PTCACHE_CLEAR_BEFORE 2
|
||||
#define PTCACHE_CLEAR_AFTER 3
|
||||
|
||||
/* Point cache reset options */
|
||||
#define PTCACHE_RESET_DEPSGRAPH 0
|
||||
#define PTCACHE_RESET_BAKED 1
|
||||
#define PTCACHE_RESET_OUTDATED 2
|
||||
/* #define PTCACHE_RESET_FREE 3 */ /*UNUSED*/
|
||||
|
||||
/* Add the blendfile name after blendcache_ */
|
||||
#define PTCACHE_EXT ".bphys"
|
||||
#define PTCACHE_PATH "blendcache_"
|
||||
|
||||
/* File open options, for BKE_ptcache_file_open */
|
||||
#define PTCACHE_FILE_READ 0
|
||||
#define PTCACHE_FILE_WRITE 1
|
||||
#define PTCACHE_FILE_UPDATE 2
|
||||
|
||||
/* PTCacheID types */
|
||||
#define PTCACHE_TYPE_SOFTBODY 0
|
||||
#define PTCACHE_TYPE_CLOTH 1
|
||||
#define PTCACHE_TYPE_SMOKE_DOMAIN 2
|
||||
#define PTCACHE_TYPE_SMOKE_HIGHRES 3
|
||||
#define PTCACHE_TYPE_DYNAMICPAINT 4
|
||||
#define PTCACHE_TYPE_RIGIDBODY 5
|
||||
|
||||
/* high bits reserved for flags that need to be stored in file */
|
||||
#define PTCACHE_TYPEFLAG_COMPRESS (1 << 16)
|
||||
#define PTCACHE_TYPEFLAG_EXTRADATA (1 << 17)
|
||||
|
||||
#define PTCACHE_TYPEFLAG_TYPEMASK 0x0000FFFF
|
||||
#define PTCACHE_TYPEFLAG_FLAGMASK 0xFFFF0000
|
||||
|
||||
/* PTCache read return code */
|
||||
#define PTCACHE_READ_EXACT 1
|
||||
#define PTCACHE_READ_INTERPOLATED 2
|
||||
#define PTCACHE_READ_OLD 3
|
||||
|
||||
/* Structs */
|
||||
struct ClothModifierData;
|
||||
struct ListBase;
|
||||
struct Main;
|
||||
struct Object;
|
||||
struct PointCacheKey;
|
||||
struct PointCache;
|
||||
struct Scene;
|
||||
struct SmokeModifierData;
|
||||
struct SoftBody;
|
||||
struct RigidBodyWorld;
|
||||
|
||||
struct OpenVDBReader;
|
||||
struct OpenVDBWriter;
|
||||
|
||||
/* temp structure for read/write */
|
||||
typedef struct PTCacheData {
|
||||
unsigned int index;
|
||||
float loc[3];
|
||||
float vel[3];
|
||||
float rot[4];
|
||||
float ave[3];
|
||||
float size;
|
||||
float times[3];
|
||||
} PTCacheData;
|
||||
|
||||
typedef struct PTCacheFile {
|
||||
FILE *fp;
|
||||
|
||||
int frame, old_format;
|
||||
unsigned int totpoint, type;
|
||||
unsigned int data_types, flag;
|
||||
|
||||
struct PTCacheData data;
|
||||
void *cur[BPHYS_TOT_DATA];
|
||||
} PTCacheFile;
|
||||
|
||||
#define PTCACHE_VEL_PER_SEC 1
|
||||
|
||||
enum {
|
||||
PTCACHE_FILE_PTCACHE = 0,
|
||||
PTCACHE_FILE_OPENVDB = 1,
|
||||
};
|
||||
|
||||
typedef struct PTCacheID {
|
||||
struct PTCacheID *next, *prev;
|
||||
|
||||
struct Scene *scene;
|
||||
struct Object *ob;
|
||||
void *calldata;
|
||||
unsigned int type, file_type;
|
||||
unsigned int stack_index;
|
||||
unsigned int flag;
|
||||
|
||||
unsigned int default_step;
|
||||
unsigned int max_step;
|
||||
|
||||
/* flags defined in DNA_object_force.h */
|
||||
unsigned int data_types, info_types;
|
||||
|
||||
/* copies point data to cache data */
|
||||
int (*write_point)(int index, void *calldata, void **data, int cfra);
|
||||
/* copies cache cata to point data */
|
||||
void (*read_point)(int index, void *calldata, void **data, float cfra, float *old_data);
|
||||
/* interpolated between previously read point data and cache data */
|
||||
void (*interpolate_point)(int index, void *calldata, void **data, float cfra, float cfra1, float cfra2, float *old_data);
|
||||
|
||||
/* copies point data to cache data */
|
||||
int (*write_stream)(PTCacheFile *pf, void *calldata);
|
||||
/* copies cache cata to point data */
|
||||
int (*read_stream)(PTCacheFile *pf, void *calldata);
|
||||
|
||||
/* copies point data to cache data */
|
||||
int (*write_openvdb_stream)(struct OpenVDBWriter *writer, void *calldata);
|
||||
/* copies cache cata to point data */
|
||||
int (*read_openvdb_stream)(struct OpenVDBReader *reader, void *calldata);
|
||||
|
||||
/* copies custom extradata to cache data */
|
||||
void (*write_extra_data)(void *calldata, struct PTCacheMem *pm, int cfra);
|
||||
/* copies custom extradata to cache data */
|
||||
void (*read_extra_data)(void *calldata, struct PTCacheMem *pm, float cfra);
|
||||
/* copies custom extradata to cache data */
|
||||
void (*interpolate_extra_data)(void *calldata, struct PTCacheMem *pm, float cfra, float cfra1, float cfra2);
|
||||
|
||||
/* total number of simulated points (the cfra parameter is just for using same function pointer with totwrite) */
|
||||
int (*totpoint)(void *calldata, int cfra);
|
||||
/* report error if number of points does not match */
|
||||
void (*error)(void *calldata, const char *message);
|
||||
/* number of points written for current cache frame */
|
||||
int (*totwrite)(void *calldata, int cfra);
|
||||
|
||||
int (*write_header)(PTCacheFile *pf);
|
||||
int (*read_header)(PTCacheFile *pf);
|
||||
|
||||
struct PointCache *cache;
|
||||
/* used for setting the current cache from ptcaches list */
|
||||
struct PointCache **cache_ptr;
|
||||
struct ListBase *ptcaches;
|
||||
} PTCacheID;
|
||||
|
||||
typedef struct PTCacheBaker {
|
||||
struct Main *main;
|
||||
struct Scene *scene;
|
||||
int bake;
|
||||
int render;
|
||||
int anim_init;
|
||||
int quick_step;
|
||||
struct PTCacheID pid;
|
||||
|
||||
void (*update_progress)(void *data, float progress, int *cancel);
|
||||
void *bake_job;
|
||||
} PTCacheBaker;
|
||||
|
||||
/* PTCacheEditKey->flag */
|
||||
#define PEK_SELECT 1
|
||||
#define PEK_TAG 2
|
||||
#define PEK_HIDE 4
|
||||
#define PEK_USE_WCO 8
|
||||
|
||||
typedef struct PTCacheEditKey {
|
||||
float *co;
|
||||
float *vel;
|
||||
float *rot;
|
||||
float *time;
|
||||
|
||||
float world_co[3];
|
||||
float ftime;
|
||||
float length;
|
||||
short flag;
|
||||
} PTCacheEditKey;
|
||||
|
||||
/* PTCacheEditPoint->flag */
|
||||
#define PEP_TAG 1
|
||||
#define PEP_EDIT_RECALC 2
|
||||
#define PEP_TRANSFORM 4
|
||||
#define PEP_HIDE 8
|
||||
|
||||
typedef struct PTCacheEditPoint {
|
||||
struct PTCacheEditKey *keys;
|
||||
int totkey;
|
||||
short flag;
|
||||
} PTCacheEditPoint;
|
||||
|
||||
typedef struct PTCacheUndo {
|
||||
struct PTCacheUndo *next, *prev;
|
||||
struct PTCacheEditPoint *points;
|
||||
|
||||
/* particles stuff */
|
||||
struct ParticleData *particles;
|
||||
struct KDTree *emitter_field;
|
||||
float *emitter_cosnos;
|
||||
int psys_flag;
|
||||
|
||||
/* cache stuff */
|
||||
struct ListBase mem_cache;
|
||||
|
||||
int totpoint;
|
||||
char name[64];
|
||||
} PTCacheUndo;
|
||||
|
||||
typedef struct PTCacheEdit {
|
||||
ListBase undo;
|
||||
struct PTCacheUndo *curundo;
|
||||
PTCacheEditPoint *points;
|
||||
|
||||
struct PTCacheID pid;
|
||||
|
||||
int totpoint, totframes, totcached, edited;
|
||||
|
||||
unsigned char sel_col[3];
|
||||
unsigned char nosel_col[3];
|
||||
} PTCacheEdit;
|
||||
|
||||
typedef struct PointCacheKey {
|
||||
float co[3]; /* location */
|
||||
float vel[3]; /* velocity */
|
||||
float rot[4]; /* rotation quaternion */
|
||||
float ave[3]; /* angular velocity */
|
||||
float time; /* when this key happens */
|
||||
} PointCacheKey;
|
||||
|
||||
void BKE_ptcache_make_key(struct PointCacheKey *key, int index, void **data, float time);
|
||||
|
||||
/**************** Creating ID's ****************************/
|
||||
void BKE_ptcache_id_from_softbody(PTCacheID *pid, struct Object *ob, struct SoftBody *sb);
|
||||
void BKE_ptcache_id_from_cloth(PTCacheID *pid, struct Object *ob, struct ClothModifierData *clmd);
|
||||
void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct SmokeModifierData *smd);
|
||||
void BKE_ptcache_id_from_dynamicpaint(PTCacheID *pid, struct Object *ob, struct DynamicPaintSurface *surface);
|
||||
void BKE_ptcache_id_from_rigidbody(PTCacheID *pid, struct Object *ob, struct RigidBodyWorld *rbw);
|
||||
|
||||
void BKE_ptcache_ids_from_object(struct ListBase *lb, struct Object *ob, struct Scene *scene, int duplis);
|
||||
|
||||
/***************** Global funcs ****************************/
|
||||
void BKE_ptcache_remove(void);
|
||||
|
||||
/************ ID specific functions ************************/
|
||||
void BKE_ptcache_id_clear(PTCacheID *id, int mode, unsigned int cfra);
|
||||
int BKE_ptcache_id_exist(PTCacheID *id, int cfra);
|
||||
int BKE_ptcache_id_reset(struct Scene *scene, PTCacheID *id, int mode);
|
||||
void BKE_ptcache_id_time(PTCacheID *pid, struct Scene *scene, float cfra, int *startframe, int *endframe, float *timescale);
|
||||
int BKE_ptcache_object_reset(struct Scene *scene, struct Object *ob, int mode);
|
||||
|
||||
void BKE_ptcache_update_info(PTCacheID *pid);
|
||||
|
||||
/*********** General cache reading/writing ******************/
|
||||
|
||||
/* Size of cache data type. */
|
||||
int BKE_ptcache_data_size(int data_type);
|
||||
|
||||
/* Is point with indes in memory cache */
|
||||
int BKE_ptcache_mem_index_find(struct PTCacheMem *pm, unsigned int index);
|
||||
|
||||
/* Memory cache read/write helpers. */
|
||||
void BKE_ptcache_mem_pointers_init(struct PTCacheMem *pm);
|
||||
void BKE_ptcache_mem_pointers_incr(struct PTCacheMem *pm);
|
||||
int BKE_ptcache_mem_pointers_seek(int point_index, struct PTCacheMem *pm);
|
||||
|
||||
/* Main cache reading call. */
|
||||
int BKE_ptcache_read(PTCacheID *pid, float cfra);
|
||||
|
||||
/* Main cache writing call. */
|
||||
int BKE_ptcache_write(PTCacheID *pid, unsigned int cfra);
|
||||
|
||||
/******************* Allocate & free ***************/
|
||||
struct PointCache *BKE_ptcache_add(struct ListBase *ptcaches);
|
||||
void BKE_ptcache_free_mem(struct ListBase *mem_cache);
|
||||
void BKE_ptcache_free(struct PointCache *cache);
|
||||
void BKE_ptcache_free_list(struct ListBase *ptcaches);
|
||||
struct PointCache *BKE_ptcache_copy_list(struct ListBase *ptcaches_new, const struct ListBase *ptcaches_old, bool copy_data);
|
||||
|
||||
/********************** Baking *********************/
|
||||
|
||||
/* Bakes cache with cache_step sized jumps in time, not accurate but very fast. */
|
||||
void BKE_ptcache_quick_cache_all(struct Main *bmain, struct Scene *scene);
|
||||
|
||||
/* Bake cache or simulate to current frame with settings defined in the baker. */
|
||||
void BKE_ptcache_bake(struct PTCacheBaker *baker);
|
||||
|
||||
/* Convert disk cache to memory cache. */
|
||||
void BKE_ptcache_disk_to_mem(struct PTCacheID *pid);
|
||||
|
||||
/* Convert memory cache to disk cache. */
|
||||
void BKE_ptcache_mem_to_disk(struct PTCacheID *pid);
|
||||
|
||||
/* Convert disk cache to memory cache and vice versa. Clears the cache that was converted. */
|
||||
void BKE_ptcache_toggle_disk_cache(struct PTCacheID *pid);
|
||||
|
||||
/* Rename all disk cache files with a new name. Doesn't touch the actual content of the files. */
|
||||
void BKE_ptcache_disk_cache_rename(struct PTCacheID *pid, const char *name_src, const char *name_dst);
|
||||
|
||||
/* Loads simulation from external (disk) cache files. */
|
||||
void BKE_ptcache_load_external(struct PTCacheID *pid);
|
||||
|
||||
/* Set correct flags after successful simulation step */
|
||||
void BKE_ptcache_validate(struct PointCache *cache, int framenr);
|
||||
|
||||
/* Set correct flags after unsuccessful simulation step */
|
||||
void BKE_ptcache_invalidate(struct PointCache *cache);
|
||||
|
||||
#endif
|
|
@ -99,7 +99,6 @@ void BKE_rigidbody_remove_constraint(struct Scene *scene, struct Object *ob);
|
|||
void BKE_rigidbody_aftertrans_update(struct Object *ob, float loc[3], float rot[3], float quat[4], float rotAxis[3], float rotAngle);
|
||||
void BKE_rigidbody_sync_transforms(struct RigidBodyWorld *rbw, struct Object *ob, float ctime);
|
||||
bool BKE_rigidbody_check_sim_running(struct RigidBodyWorld *rbw, float ctime);
|
||||
void BKE_rigidbody_cache_reset(struct RigidBodyWorld *rbw);
|
||||
void BKE_rigidbody_rebuild_world(struct Scene *scene, float ctime);
|
||||
void BKE_rigidbody_do_simulation(struct Scene *scene, float ctime);
|
||||
|
||||
|
|
|
@ -149,7 +149,6 @@ set(SRC
|
|||
intern/paint.c
|
||||
intern/pbvh.c
|
||||
intern/pbvh_bmesh.c
|
||||
intern/pointcache.c
|
||||
intern/property.c
|
||||
intern/report.c
|
||||
intern/rigidbody.c
|
||||
|
@ -260,7 +259,6 @@ set(SRC
|
|||
BKE_packedFile.h
|
||||
BKE_paint.h
|
||||
BKE_pbvh.h
|
||||
BKE_pointcache.h
|
||||
BKE_property.h
|
||||
BKE_report.h
|
||||
BKE_rigidbody.h
|
||||
|
|
|
@ -462,19 +462,6 @@ void BKE_bpath_traverse_id(Main *bmain, ID *id, BPathVisitor visit_cb, const int
|
|||
Object *ob = (Object *)id;
|
||||
ModifierData *md;
|
||||
|
||||
#define BPATH_TRAVERSE_POINTCACHE(ptcaches) \
|
||||
{ \
|
||||
PointCache *cache; \
|
||||
for (cache = (ptcaches).first; cache; cache = cache->next) { \
|
||||
if (cache->flag & PTCACHE_DISK_CACHE) { \
|
||||
rewrite_path_fixed(cache->path, \
|
||||
visit_cb, \
|
||||
absbase, \
|
||||
bpath_user_data); \
|
||||
} \
|
||||
} \
|
||||
} (void)0
|
||||
|
||||
/* do via modifiers instead */
|
||||
#if 0
|
||||
if (ob->fluidsimSettings) {
|
||||
|
@ -489,16 +476,6 @@ void BKE_bpath_traverse_id(Main *bmain, ID *id, BPathVisitor visit_cb, const int
|
|||
rewrite_path_fixed(fluidmd->fss->surfdataPath, visit_cb, absbase, bpath_user_data);
|
||||
}
|
||||
}
|
||||
else if (md->type == eModifierType_Smoke) {
|
||||
SmokeModifierData *smd = (SmokeModifierData *)md;
|
||||
if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
|
||||
BPATH_TRAVERSE_POINTCACHE(smd->domain->ptcaches[0]);
|
||||
}
|
||||
}
|
||||
else if (md->type == eModifierType_Cloth) {
|
||||
ClothModifierData *clmd = (ClothModifierData *) md;
|
||||
BPATH_TRAVERSE_POINTCACHE(clmd->ptcaches);
|
||||
}
|
||||
else if (md->type == eModifierType_Ocean) {
|
||||
OceanModifierData *omd = (OceanModifierData *) md;
|
||||
rewrite_path_fixed(omd->cachepath, visit_cb, absbase, bpath_user_data);
|
||||
|
@ -509,12 +486,6 @@ void BKE_bpath_traverse_id(Main *bmain, ID *id, BPathVisitor visit_cb, const int
|
|||
}
|
||||
}
|
||||
|
||||
if (ob->soft) {
|
||||
BPATH_TRAVERSE_POINTCACHE(ob->soft->ptcaches);
|
||||
}
|
||||
|
||||
#undef BPATH_TRAVERSE_POINTCACHE
|
||||
|
||||
break;
|
||||
}
|
||||
case ID_SO:
|
||||
|
|
|
@ -45,7 +45,6 @@
|
|||
#include "BKE_effect.h"
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_pointcache.h"
|
||||
|
||||
#include "BPH_mass_spring.h"
|
||||
|
||||
|
@ -126,9 +125,6 @@ void cloth_init(ClothModifierData *clmd )
|
|||
|
||||
if (!clmd->sim_parms->effector_weights)
|
||||
clmd->sim_parms->effector_weights = BKE_add_effector_weights(NULL);
|
||||
|
||||
if (clmd->point_cache)
|
||||
clmd->point_cache->step = 1;
|
||||
}
|
||||
|
||||
static BVHTree *bvhselftree_build_from_cloth (ClothModifierData *clmd, float epsilon)
|
||||
|
@ -299,30 +295,16 @@ void bvhselftree_update_from_cloth(ClothModifierData *clmd, bool moving)
|
|||
}
|
||||
}
|
||||
|
||||
void cloth_clear_cache(Object *ob, ClothModifierData *clmd, float framenr)
|
||||
{
|
||||
PTCacheID pid;
|
||||
|
||||
BKE_ptcache_id_from_cloth(&pid, ob, clmd);
|
||||
BKE_ptcache_id_clear(&pid, PTCACHE_CLEAR_AFTER, framenr);
|
||||
}
|
||||
|
||||
static int do_init_cloth(Object *ob, ClothModifierData *clmd, DerivedMesh *result, int framenr)
|
||||
{
|
||||
PointCache *cache;
|
||||
|
||||
cache= clmd->point_cache;
|
||||
|
||||
/* initialize simulation data if it didn't exist already */
|
||||
if (clmd->clothObject == NULL) {
|
||||
if (!cloth_from_object(ob, clmd, result, framenr, 1)) {
|
||||
BKE_ptcache_invalidate(cache);
|
||||
modifier_setError(&(clmd->modifier), "Can't initialize cloth");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (clmd->clothObject == NULL) {
|
||||
BKE_ptcache_invalidate(cache);
|
||||
modifier_setError(&(clmd->modifier), "Null cloth object");
|
||||
return 0;
|
||||
}
|
||||
|
@ -385,27 +367,14 @@ static int do_step_cloth(Object *ob, ClothModifierData *clmd, DerivedMesh *resul
|
|||
************************************************/
|
||||
void clothModifier_do(ClothModifierData *clmd, Scene *scene, Object *ob, DerivedMesh *dm, float (*vertexCos)[3])
|
||||
{
|
||||
PointCache *cache;
|
||||
PTCacheID pid;
|
||||
float timescale;
|
||||
int framenr, startframe, endframe;
|
||||
int cache_result;
|
||||
int framenr = scene->r.cfra, startframe = scene->r.sfra, endframe = scene->r.efra;
|
||||
|
||||
clmd->scene= scene; /* nice to pass on later :) */
|
||||
framenr= (int)scene->r.cfra;
|
||||
cache= clmd->point_cache;
|
||||
|
||||
BKE_ptcache_id_from_cloth(&pid, ob, clmd);
|
||||
BKE_ptcache_id_time(&pid, scene, framenr, &startframe, &endframe, ×cale);
|
||||
clmd->sim_parms->timescale= timescale;
|
||||
clmd->sim_parms->timescale= 1.0f;
|
||||
|
||||
if (clmd->sim_parms->reset || (clmd->clothObject && dm->getNumVerts(dm) != clmd->clothObject->mvert_num)) {
|
||||
clmd->sim_parms->reset = 0;
|
||||
cache->flag |= PTCACHE_OUTDATED;
|
||||
BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
|
||||
BKE_ptcache_validate(cache, 0);
|
||||
cache->last_exact= 0;
|
||||
cache->flag &= ~PTCACHE_REDO_NEEDED;
|
||||
}
|
||||
|
||||
// unused in the moment, calculated separately in implicit.c
|
||||
|
@ -413,7 +382,6 @@ void clothModifier_do(ClothModifierData *clmd, Scene *scene, Object *ob, Derived
|
|||
|
||||
/* simulation is only active during a specific period */
|
||||
if (framenr < startframe) {
|
||||
BKE_ptcache_invalidate(cache);
|
||||
return;
|
||||
}
|
||||
else if (framenr > endframe) {
|
||||
|
@ -425,56 +393,18 @@ void clothModifier_do(ClothModifierData *clmd, Scene *scene, Object *ob, Derived
|
|||
return;
|
||||
|
||||
if (framenr == startframe) {
|
||||
BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
|
||||
do_init_cloth(ob, clmd, dm, framenr);
|
||||
BKE_ptcache_validate(cache, framenr);
|
||||
cache->flag &= ~PTCACHE_REDO_NEEDED;
|
||||
clmd->clothObject->last_frame= framenr;
|
||||
return;
|
||||
}
|
||||
|
||||
/* try to read from cache */
|
||||
cache_result = BKE_ptcache_read(&pid, (float)framenr+scene->r.subframe);
|
||||
|
||||
if (cache_result == PTCACHE_READ_EXACT || cache_result == PTCACHE_READ_INTERPOLATED) {
|
||||
BKE_cloth_solver_set_positions(clmd);
|
||||
cloth_to_object (ob, clmd, vertexCos);
|
||||
|
||||
BKE_ptcache_validate(cache, framenr);
|
||||
|
||||
if (cache_result == PTCACHE_READ_INTERPOLATED && cache->flag & PTCACHE_REDO_NEEDED)
|
||||
BKE_ptcache_write(&pid, framenr);
|
||||
|
||||
clmd->clothObject->last_frame= framenr;
|
||||
|
||||
return;
|
||||
}
|
||||
else if (cache_result==PTCACHE_READ_OLD) {
|
||||
BKE_cloth_solver_set_positions(clmd);
|
||||
}
|
||||
else if ( /*ob->id.lib ||*/ (cache->flag & PTCACHE_BAKED)) { /* 2.4x disabled lib, but this can be used in some cases, testing further - campbell */
|
||||
/* if baked and nothing in cache, do nothing */
|
||||
BKE_ptcache_invalidate(cache);
|
||||
return;
|
||||
}
|
||||
|
||||
if (framenr!=clmd->clothObject->last_frame+1)
|
||||
return;
|
||||
|
||||
/* if on second frame, write cache for first frame */
|
||||
if (cache->simframe == startframe && (cache->flag & PTCACHE_OUTDATED || cache->last_exact==0))
|
||||
BKE_ptcache_write(&pid, startframe);
|
||||
|
||||
clmd->sim_parms->timescale *= framenr - cache->simframe;
|
||||
clmd->sim_parms->timescale *= 1.0f;
|
||||
|
||||
/* do simulation */
|
||||
BKE_ptcache_validate(cache, framenr);
|
||||
|
||||
if (!do_step_cloth(ob, clmd, dm, framenr)) {
|
||||
BKE_ptcache_invalidate(cache);
|
||||
}
|
||||
else
|
||||
BKE_ptcache_write(&pid, framenr);
|
||||
do_step_cloth(ob, clmd, dm, framenr);
|
||||
|
||||
cloth_to_object (ob, clmd, vertexCos);
|
||||
clmd->clothObject->last_frame= framenr;
|
||||
|
|
|
@ -54,6 +54,7 @@
|
|||
#include "DNA_mesh_types.h"
|
||||
#include "DNA_node_types.h"
|
||||
#include "DNA_object_types.h"
|
||||
#include "DNA_object_force.h"
|
||||
#include "DNA_scene_types.h"
|
||||
#include "DNA_screen_types.h"
|
||||
#include "DNA_windowmanager_types.h"
|
||||
|
@ -77,7 +78,6 @@
|
|||
#include "BKE_modifier.h"
|
||||
#include "BKE_object.h"
|
||||
#include "BKE_paint.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_scene.h"
|
||||
#include "BKE_screen.h"
|
||||
#include "BKE_tracking.h"
|
||||
|
@ -1795,38 +1795,6 @@ static unsigned int flush_layer_node(Scene *sce, DagNode *node, int curtime)
|
|||
return node->lay;
|
||||
}
|
||||
|
||||
/* node was checked to have lasttime != curtime, and is of type ID_OB */
|
||||
static void flush_pointcache_reset(Main *bmain, Scene *scene, DagNode *node,
|
||||
int curtime, unsigned int lay, bool reset)
|
||||
{
|
||||
DagAdjList *itA;
|
||||
Object *ob;
|
||||
|
||||
node->lasttime = curtime;
|
||||
|
||||
for (itA = node->child; itA; itA = itA->next) {
|
||||
if (itA->node->type == ID_OB) {
|
||||
if (itA->node->lasttime != curtime) {
|
||||
ob = (Object *)(itA->node->ob);
|
||||
|
||||
if (reset || (ob->recalc & OB_RECALC_ALL)) {
|
||||
if (BKE_ptcache_object_reset(scene, ob, PTCACHE_RESET_DEPSGRAPH)) {
|
||||
/* Don't tag nodes which are on invisible layer. */
|
||||
if (itA->node->lay & lay) {
|
||||
ob->recalc |= OB_RECALC_DATA;
|
||||
lib_id_recalc_data_tag(bmain, &ob->id);
|
||||
}
|
||||
}
|
||||
|
||||
flush_pointcache_reset(bmain, scene, itA->node, curtime, lay, true);
|
||||
}
|
||||
else
|
||||
flush_pointcache_reset(bmain, scene, itA->node, curtime, lay, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* flush layer flags to dependencies */
|
||||
static void dag_scene_flush_layers(Scene *sce, int lay)
|
||||
{
|
||||
|
@ -1904,7 +1872,6 @@ void DAG_scene_flush_update(Main *bmain, Scene *sce, unsigned int lay, const sho
|
|||
{
|
||||
DagNode *firstnode;
|
||||
DagAdjList *itA;
|
||||
Object *ob;
|
||||
int lasttime;
|
||||
|
||||
if (!DEG_depsgraph_use_legacy()) {
|
||||
|
@ -1932,24 +1899,6 @@ void DAG_scene_flush_update(Main *bmain, Scene *sce, unsigned int lay, const sho
|
|||
if (!time) {
|
||||
sce->theDag->time++; /* so we know which nodes were accessed */
|
||||
lasttime = sce->theDag->time;
|
||||
for (itA = firstnode->child; itA; itA = itA->next) {
|
||||
if (itA->node->lasttime != lasttime && itA->node->type == ID_OB) {
|
||||
ob = (Object *)(itA->node->ob);
|
||||
|
||||
if (ob->recalc & OB_RECALC_ALL) {
|
||||
if (BKE_ptcache_object_reset(sce, ob, PTCACHE_RESET_DEPSGRAPH)) {
|
||||
ob->recalc |= OB_RECALC_DATA;
|
||||
lib_id_recalc_data_tag(bmain, &ob->id);
|
||||
}
|
||||
|
||||
flush_pointcache_reset(bmain, sce, itA->node, lasttime,
|
||||
lay, true);
|
||||
}
|
||||
else
|
||||
flush_pointcache_reset(bmain, sce, itA->node, lasttime,
|
||||
lay, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
dag_tag_renderlayers(sce, lay);
|
||||
|
@ -2466,7 +2415,6 @@ static void dag_id_flush_update(Main *bmain, Scene *sce, ID *id)
|
|||
/* set flags & pointcache for object */
|
||||
if (GS(id->name) == ID_OB) {
|
||||
ob = (Object *)id;
|
||||
BKE_ptcache_object_reset(sce, ob, PTCACHE_RESET_DEPSGRAPH);
|
||||
|
||||
/* So if someone tagged object recalc directly,
|
||||
* id_tag_update bit-field stays relevant
|
||||
|
@ -2497,7 +2445,6 @@ static void dag_id_flush_update(Main *bmain, Scene *sce, ID *id)
|
|||
if (!(ob && obt == ob) && obt->data == id) {
|
||||
obt->recalc |= OB_RECALC_DATA;
|
||||
lib_id_recalc_data_tag(bmain, &obt->id);
|
||||
BKE_ptcache_object_reset(sce, obt, PTCACHE_RESET_DEPSGRAPH);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -2536,7 +2483,6 @@ static void dag_id_flush_update(Main *bmain, Scene *sce, ID *id)
|
|||
obt->flag |= (OB_RECALC_OB | OB_RECALC_DATA);
|
||||
lib_id_recalc_tag(bmain, &obt->id);
|
||||
lib_id_recalc_data_tag(bmain, &obt->id);
|
||||
BKE_ptcache_object_reset(sce, obt, PTCACHE_RESET_DEPSGRAPH);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -47,6 +47,7 @@
|
|||
#include "DNA_meshdata_types.h"
|
||||
#include "DNA_modifier_types.h"
|
||||
#include "DNA_object_types.h"
|
||||
#include "DNA_object_force.h"
|
||||
#include "DNA_scene_types.h"
|
||||
#include "DNA_texture_types.h"
|
||||
|
||||
|
@ -66,7 +67,6 @@
|
|||
#include "BKE_material.h"
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_object.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_scene.h"
|
||||
#include "BKE_texture.h"
|
||||
|
||||
|
@ -837,8 +837,7 @@ static void surface_freeUnusedData(DynamicPaintSurface *surface)
|
|||
if (!surface->data) return;
|
||||
|
||||
/* free bakedata if not active or surface is baked */
|
||||
if (!(surface->flags & MOD_DPAINT_ACTIVE) ||
|
||||
(surface->pointcache && surface->pointcache->flag & PTCACHE_BAKED))
|
||||
if (!(surface->flags & MOD_DPAINT_ACTIVE))
|
||||
{
|
||||
free_bakeData(surface->data);
|
||||
}
|
||||
|
@ -871,10 +870,6 @@ void dynamicPaint_freeSurfaceData(DynamicPaintSurface *surface)
|
|||
|
||||
void dynamicPaint_freeSurface(DynamicPaintSurface *surface)
|
||||
{
|
||||
/* point cache */
|
||||
BKE_ptcache_free_list(&(surface->ptcaches));
|
||||
surface->pointcache = NULL;
|
||||
|
||||
if (surface->effector_weights)
|
||||
MEM_freeN(surface->effector_weights);
|
||||
surface->effector_weights = NULL;
|
||||
|
@ -935,11 +930,6 @@ DynamicPaintSurface *dynamicPaint_createNewSurface(DynamicPaintCanvasSettings *c
|
|||
surface->format = MOD_DPAINT_SURFACE_F_VERTEX;
|
||||
surface->type = MOD_DPAINT_SURFACE_T_PAINT;
|
||||
|
||||
/* cache */
|
||||
surface->pointcache = BKE_ptcache_add(&(surface->ptcaches));
|
||||
surface->pointcache->flag |= PTCACHE_DISK_CACHE;
|
||||
surface->pointcache->step = 1;
|
||||
|
||||
/* Set initial values */
|
||||
surface->flags = MOD_DPAINT_ANTIALIAS | MOD_DPAINT_MULALPHA | MOD_DPAINT_DRY_LOG | MOD_DPAINT_DISSOLVE_LOG |
|
||||
MOD_DPAINT_ACTIVE | MOD_DPAINT_PREVIEW | MOD_DPAINT_OUT1 | MOD_DPAINT_USE_DRYING;
|
||||
|
@ -1804,15 +1794,6 @@ static DerivedMesh *dynamicPaint_Modifier_apply(DynamicPaintModifierData *pmd,
|
|||
return result;
|
||||
}
|
||||
|
||||
/* update cache frame range */
|
||||
void dynamicPaint_cacheUpdateFrames(DynamicPaintSurface *surface)
|
||||
{
|
||||
if (surface->pointcache) {
|
||||
surface->pointcache->startframe = surface->start_frame;
|
||||
surface->pointcache->endframe = surface->end_frame;
|
||||
}
|
||||
}
|
||||
|
||||
static void canvas_copyDerivedMesh(DynamicPaintCanvasSettings *canvas, DerivedMesh *dm)
|
||||
{
|
||||
if (canvas->dm) {
|
||||
|
@ -1857,29 +1838,10 @@ static void dynamicPaint_frameUpdate(DynamicPaintModifierData *pmd, Scene *scene
|
|||
CLAMP(current_frame, surface->start_frame, surface->end_frame);
|
||||
|
||||
if (no_surface_data || current_frame != surface->current_frame || (int)scene->r.cfra == surface->start_frame) {
|
||||
PointCache *cache = surface->pointcache;
|
||||
PTCacheID pid;
|
||||
surface->current_frame = current_frame;
|
||||
|
||||
/* read point cache */
|
||||
BKE_ptcache_id_from_dynamicpaint(&pid, ob, surface);
|
||||
pid.cache->startframe = surface->start_frame;
|
||||
pid.cache->endframe = surface->end_frame;
|
||||
BKE_ptcache_id_time(&pid, scene, (float)scene->r.cfra, NULL, NULL, NULL);
|
||||
|
||||
/* reset non-baked cache at first frame */
|
||||
if ((int)scene->r.cfra == surface->start_frame && !(cache->flag & PTCACHE_BAKED)) {
|
||||
cache->flag |= PTCACHE_REDO_NEEDED;
|
||||
BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
|
||||
cache->flag &= ~PTCACHE_REDO_NEEDED;
|
||||
}
|
||||
|
||||
/* try to read from cache */
|
||||
if (BKE_ptcache_read(&pid, (float)scene->r.cfra)) {
|
||||
BKE_ptcache_validate(cache, (int)scene->r.cfra);
|
||||
}
|
||||
/* if read failed and we're on surface range do recalculate */
|
||||
else if ((int)scene->r.cfra == current_frame && !(cache->flag & PTCACHE_BAKED)) {
|
||||
/* if we're on surface range do recalculate */
|
||||
if ((int)scene->r.cfra == current_frame) {
|
||||
/* calculate surface frame */
|
||||
canvas->flags |= MOD_DPAINT_BAKING;
|
||||
dynamicPaint_calculateFrame(surface, scene, ob, current_frame);
|
||||
|
@ -1891,9 +1853,6 @@ static void dynamicPaint_frameUpdate(DynamicPaintModifierData *pmd, Scene *scene
|
|||
{
|
||||
canvas_copyDerivedMesh(canvas, dm);
|
||||
}
|
||||
|
||||
BKE_ptcache_validate(cache, surface->current_frame);
|
||||
BKE_ptcache_write(&pid, surface->current_frame);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -50,6 +50,8 @@
|
|||
#include "DNA_mesh_types.h"
|
||||
#include "DNA_meshdata_types.h"
|
||||
#include "DNA_movieclip_types.h"
|
||||
#include "DNA_object_force.h"
|
||||
#include "DNA_object_types.h"
|
||||
#include "DNA_scene_types.h"
|
||||
#include "DNA_screen_types.h"
|
||||
#include "DNA_sequence_types.h"
|
||||
|
@ -102,7 +104,6 @@
|
|||
#include "BKE_node.h"
|
||||
#include "BKE_object.h"
|
||||
#include "BKE_paint.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_property.h"
|
||||
#include "BKE_rigidbody.h"
|
||||
#include "BKE_sca.h"
|
||||
|
@ -1160,8 +1161,6 @@ SoftBody *copy_softbody(const SoftBody *sb, bool copy_caches)
|
|||
|
||||
sbn->scratch = NULL;
|
||||
|
||||
sbn->pointcache = BKE_ptcache_copy_list(&sbn->ptcaches, &sb->ptcaches, copy_caches);
|
||||
|
||||
if (sb->effector_weights)
|
||||
sbn->effector_weights = MEM_dupallocN(sb->effector_weights);
|
||||
|
||||
|
@ -3897,25 +3896,6 @@ bool BKE_object_modifier_use_time(Object *ob, ModifierData *md)
|
|||
return false;
|
||||
}
|
||||
|
||||
/* set "ignore cache" flag for all caches on this object */
|
||||
static void object_cacheIgnoreClear(Object *ob, int state)
|
||||
{
|
||||
ListBase pidlist;
|
||||
PTCacheID *pid;
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, NULL, 0);
|
||||
|
||||
for (pid = pidlist.first; pid; pid = pid->next) {
|
||||
if (pid->cache) {
|
||||
if (state)
|
||||
pid->cache->flag |= PTCACHE_IGNORE_CLEAR;
|
||||
else
|
||||
pid->cache->flag &= ~PTCACHE_IGNORE_CLEAR;
|
||||
}
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
}
|
||||
|
||||
/* Note: this function should eventually be replaced by depsgraph functionality.
|
||||
* Avoid calling this in new code unless there is a very good reason for it!
|
||||
*/
|
||||
|
@ -3974,13 +3954,8 @@ bool BKE_object_modifier_update_subframe(Scene *scene, Object *ob, bool update_m
|
|||
/* was originally OB_RECALC_ALL - TODO - which flags are really needed??? */
|
||||
ob->recalc |= OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME;
|
||||
BKE_animsys_evaluate_animdata(scene, &ob->id, ob->adt, frame, ADT_RECALC_ANIM);
|
||||
if (update_mesh) {
|
||||
/* ignore cache clear during subframe updates
|
||||
* to not mess up cache validity */
|
||||
object_cacheIgnoreClear(ob, 1);
|
||||
if (update_mesh)
|
||||
BKE_object_handle_update(G.main->eval_ctx, scene, ob);
|
||||
object_cacheIgnoreClear(ob, 0);
|
||||
}
|
||||
else
|
||||
BKE_object_where_is_calc_time(scene, ob, frame);
|
||||
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -61,7 +61,6 @@
|
|||
#include "BKE_library_query.h"
|
||||
#include "BKE_mesh.h"
|
||||
#include "BKE_object.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_rigidbody.h"
|
||||
#include "BKE_scene.h"
|
||||
|
||||
|
@ -108,10 +107,6 @@ void BKE_rigidbody_free_world(RigidBodyWorld *rbw)
|
|||
if (rbw->objects)
|
||||
free(rbw->objects);
|
||||
|
||||
/* free cache */
|
||||
BKE_ptcache_free_list(&(rbw->ptcaches));
|
||||
rbw->pointcache = NULL;
|
||||
|
||||
/* free effector weights */
|
||||
if (rbw->effector_weights)
|
||||
MEM_freeN(rbw->effector_weights);
|
||||
|
@ -921,9 +916,6 @@ RigidBodyWorld *BKE_rigidbody_create_world(Scene *scene)
|
|||
rbw->steps_per_second = 60; /* Bullet default (60 Hz) */
|
||||
rbw->num_solver_iterations = 10; /* 10 is bullet default */
|
||||
|
||||
rbw->pointcache = BKE_ptcache_add(&(rbw->ptcaches));
|
||||
rbw->pointcache->step = 1;
|
||||
|
||||
/* return this sim world */
|
||||
return rbw;
|
||||
}
|
||||
|
@ -939,8 +931,6 @@ RigidBodyWorld *BKE_rigidbody_world_copy(RigidBodyWorld *rbw)
|
|||
if (rbwn->constraints)
|
||||
id_us_plus(&rbwn->constraints->id);
|
||||
|
||||
rbwn->pointcache = BKE_ptcache_copy_list(&rbwn->ptcaches, &rbw->ptcaches, false);
|
||||
|
||||
rbwn->objects = NULL;
|
||||
rbwn->physics_world = NULL;
|
||||
rbwn->numbodies = 0;
|
||||
|
@ -973,10 +963,9 @@ void BKE_rigidbody_world_id_loop(RigidBodyWorld *rbw, RigidbodyWorldIDFunc func,
|
|||
}
|
||||
|
||||
/* Add rigid body settings to the specified object */
|
||||
RigidBodyOb *BKE_rigidbody_create_object(Scene *scene, Object *ob, short type)
|
||||
RigidBodyOb *BKE_rigidbody_create_object(Scene *UNUSED(scene), Object *ob, short type)
|
||||
{
|
||||
RigidBodyOb *rbo;
|
||||
RigidBodyWorld *rbw = scene->rigidbody_world;
|
||||
|
||||
/* sanity checks
|
||||
* - rigidbody world must exist
|
||||
|
@ -1020,18 +1009,14 @@ RigidBodyOb *BKE_rigidbody_create_object(Scene *scene, Object *ob, short type)
|
|||
/* set initial transform */
|
||||
mat4_to_loc_quat(rbo->pos, rbo->orn, ob->obmat);
|
||||
|
||||
/* flag cache as outdated */
|
||||
BKE_rigidbody_cache_reset(rbw);
|
||||
|
||||
/* return this object */
|
||||
return rbo;
|
||||
}
|
||||
|
||||
/* Add rigid body constraint to the specified object */
|
||||
RigidBodyCon *BKE_rigidbody_create_constraint(Scene *scene, Object *ob, short type)
|
||||
RigidBodyCon *BKE_rigidbody_create_constraint(Scene *UNUSED(scene), Object *ob, short type)
|
||||
{
|
||||
RigidBodyCon *rbc;
|
||||
RigidBodyWorld *rbw = scene->rigidbody_world;
|
||||
|
||||
/* sanity checks
|
||||
* - rigidbody world must exist
|
||||
|
@ -1081,9 +1066,6 @@ RigidBodyCon *BKE_rigidbody_create_constraint(Scene *scene, Object *ob, short ty
|
|||
rbc->motor_ang_max_impulse = 1.0f;
|
||||
rbc->motor_ang_target_velocity = 1.0f;
|
||||
|
||||
/* flag cache as outdated */
|
||||
BKE_rigidbody_cache_reset(rbw);
|
||||
|
||||
/* return this object */
|
||||
return rbc;
|
||||
}
|
||||
|
@ -1143,9 +1125,6 @@ void BKE_rigidbody_remove_object(Scene *scene, Object *ob)
|
|||
|
||||
/* remove object's settings */
|
||||
BKE_rigidbody_free_object(ob);
|
||||
|
||||
/* flag cache as outdated */
|
||||
BKE_rigidbody_cache_reset(rbw);
|
||||
}
|
||||
|
||||
void BKE_rigidbody_remove_constraint(Scene *scene, Object *ob)
|
||||
|
@ -1159,9 +1138,6 @@ void BKE_rigidbody_remove_constraint(Scene *scene, Object *ob)
|
|||
}
|
||||
/* remove object's settings */
|
||||
BKE_rigidbody_free_constraint(ob);
|
||||
|
||||
/* flag cache as outdated */
|
||||
BKE_rigidbody_cache_reset(rbw);
|
||||
}
|
||||
|
||||
|
||||
|
@ -1428,9 +1404,9 @@ static void rigidbody_update_simulation_post_step(RigidBodyWorld *rbw)
|
|||
}
|
||||
}
|
||||
|
||||
bool BKE_rigidbody_check_sim_running(RigidBodyWorld *rbw, float ctime)
|
||||
bool BKE_rigidbody_check_sim_running(RigidBodyWorld *rbw, float UNUSED(ctime))
|
||||
{
|
||||
return (rbw && (rbw->flag & RBW_FLAG_MUTED) == 0 && ctime > rbw->pointcache->startframe);
|
||||
return (rbw && (rbw->flag & RBW_FLAG_MUTED) == 0);
|
||||
}
|
||||
|
||||
/* Sync rigid body and object transformations */
|
||||
|
@ -1493,12 +1469,6 @@ void BKE_rigidbody_aftertrans_update(Object *ob, float loc[3], float rot[3], flo
|
|||
// RB_TODO update rigid body physics object's loc/rot for dynamic objects here as well (needs to be done outside bullet's update loop)
|
||||
}
|
||||
|
||||
void BKE_rigidbody_cache_reset(RigidBodyWorld *rbw)
|
||||
{
|
||||
if (rbw)
|
||||
rbw->pointcache->flag |= PTCACHE_OUTDATED;
|
||||
}
|
||||
|
||||
/* ------------------ */
|
||||
|
||||
/* Rebuild rigid body world */
|
||||
|
@ -1506,27 +1476,10 @@ void BKE_rigidbody_cache_reset(RigidBodyWorld *rbw)
|
|||
void BKE_rigidbody_rebuild_world(Scene *scene, float ctime)
|
||||
{
|
||||
RigidBodyWorld *rbw = scene->rigidbody_world;
|
||||
PointCache *cache;
|
||||
PTCacheID pid;
|
||||
int startframe, endframe;
|
||||
|
||||
BKE_ptcache_id_from_rigidbody(&pid, NULL, rbw);
|
||||
BKE_ptcache_id_time(&pid, scene, ctime, &startframe, &endframe, NULL);
|
||||
cache = rbw->pointcache;
|
||||
|
||||
/* flag cache as outdated if we don't have a world or number of objects in the simulation has changed */
|
||||
if (rbw->physics_world == NULL || rbw->numbodies != BLI_listbase_count(&rbw->group->gobject)) {
|
||||
cache->flag |= PTCACHE_OUTDATED;
|
||||
}
|
||||
int startframe = scene->r.sfra;
|
||||
|
||||
if (ctime == startframe + 1 && rbw->ltime == startframe) {
|
||||
if (cache->flag & PTCACHE_OUTDATED) {
|
||||
BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
|
||||
rigidbody_update_simulation(scene, rbw, true);
|
||||
BKE_ptcache_validate(cache, (int)ctime);
|
||||
cache->last_exact = 0;
|
||||
cache->flag &= ~PTCACHE_REDO_NEEDED;
|
||||
}
|
||||
rigidbody_update_simulation(scene, rbw, true);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1535,13 +1488,7 @@ void BKE_rigidbody_do_simulation(Scene *scene, float ctime)
|
|||
{
|
||||
float timestep;
|
||||
RigidBodyWorld *rbw = scene->rigidbody_world;
|
||||
PointCache *cache;
|
||||
PTCacheID pid;
|
||||
int startframe, endframe;
|
||||
|
||||
BKE_ptcache_id_from_rigidbody(&pid, NULL, rbw);
|
||||
BKE_ptcache_id_time(&pid, scene, ctime, &startframe, &endframe, NULL);
|
||||
cache = rbw->pointcache;
|
||||
int startframe = scene->r.sfra, endframe = scene->r.efra;
|
||||
|
||||
if (ctime <= startframe) {
|
||||
rbw->ltime = startframe;
|
||||
|
@ -1552,27 +1499,14 @@ void BKE_rigidbody_do_simulation(Scene *scene, float ctime)
|
|||
ctime = endframe;
|
||||
}
|
||||
|
||||
/* don't try to run the simulation if we don't have a world yet but allow reading baked cache */
|
||||
if (rbw->physics_world == NULL && !(cache->flag & PTCACHE_BAKED))
|
||||
/* don't try to run the simulation if we don't have a world yet */
|
||||
if (rbw->physics_world == NULL)
|
||||
return;
|
||||
else if (rbw->objects == NULL)
|
||||
rigidbody_update_ob_array(rbw);
|
||||
|
||||
/* try to read from cache */
|
||||
// RB_TODO deal with interpolated, old and baked results
|
||||
if (BKE_ptcache_read(&pid, ctime)) {
|
||||
BKE_ptcache_validate(cache, (int)ctime);
|
||||
rbw->ltime = ctime;
|
||||
return;
|
||||
}
|
||||
|
||||
/* advance simulation, we can only step one frame forward */
|
||||
if (ctime == rbw->ltime + 1 && !(cache->flag & PTCACHE_BAKED)) {
|
||||
/* write cache for first frame when on second frame */
|
||||
if (rbw->ltime == startframe && (cache->flag & PTCACHE_OUTDATED || cache->last_exact == 0)) {
|
||||
BKE_ptcache_write(&pid, startframe);
|
||||
}
|
||||
|
||||
if (ctime == rbw->ltime + 1) {
|
||||
/* update and validate simulation */
|
||||
rigidbody_update_simulation(scene, rbw, false);
|
||||
|
||||
|
@ -1583,10 +1517,6 @@ void BKE_rigidbody_do_simulation(Scene *scene, float ctime)
|
|||
|
||||
rigidbody_update_simulation_post_step(rbw);
|
||||
|
||||
/* write cache for current frame */
|
||||
BKE_ptcache_validate(cache, (int)ctime);
|
||||
BKE_ptcache_write(&pid, (unsigned int)ctime);
|
||||
|
||||
rbw->ltime = ctime;
|
||||
}
|
||||
}
|
||||
|
@ -1621,7 +1551,6 @@ void BKE_rigidbody_remove_constraint(Scene *scene, Object *ob) {}
|
|||
void BKE_rigidbody_sync_transforms(RigidBodyWorld *rbw, Object *ob, float ctime) {}
|
||||
void BKE_rigidbody_aftertrans_update(Object *ob, float loc[3], float rot[3], float quat[4], float rotAxis[3], float rotAngle) {}
|
||||
bool BKE_rigidbody_check_sim_running(RigidBodyWorld *rbw, float ctime) { return false; }
|
||||
void BKE_rigidbody_cache_reset(RigidBodyWorld *rbw) {}
|
||||
void BKE_rigidbody_rebuild_world(Scene *scene, float ctime) {}
|
||||
void BKE_rigidbody_do_simulation(Scene *scene, float ctime) {}
|
||||
|
||||
|
|
|
@ -56,6 +56,7 @@
|
|||
#include "DNA_lamp_types.h"
|
||||
#include "DNA_meshdata_types.h"
|
||||
#include "DNA_modifier_types.h"
|
||||
#include "DNA_object_force.h"
|
||||
#include "DNA_object_types.h"
|
||||
#include "DNA_scene_types.h"
|
||||
#include "DNA_smoke_types.h"
|
||||
|
@ -76,7 +77,6 @@
|
|||
#include "BKE_main.h"
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_object.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_scene.h"
|
||||
#include "BKE_smoke.h"
|
||||
#include "BKE_texture.h"
|
||||
|
@ -355,9 +355,6 @@ static void smokeModifier_freeDomain(SmokeModifierData *smd)
|
|||
MEM_freeN(smd->domain->effector_weights);
|
||||
smd->domain->effector_weights = NULL;
|
||||
|
||||
BKE_ptcache_free_list(&(smd->domain->ptcaches[0]));
|
||||
smd->domain->point_cache[0] = NULL;
|
||||
|
||||
MEM_freeN(smd->domain);
|
||||
smd->domain = NULL;
|
||||
}
|
||||
|
@ -482,13 +479,6 @@ void smokeModifier_createType(struct SmokeModifierData *smd)
|
|||
|
||||
smd->domain->smd = smd;
|
||||
|
||||
smd->domain->point_cache[0] = BKE_ptcache_add(&(smd->domain->ptcaches[0]));
|
||||
smd->domain->point_cache[0]->flag |= PTCACHE_DISK_CACHE;
|
||||
smd->domain->point_cache[0]->step = 1;
|
||||
|
||||
/* Deprecated */
|
||||
smd->domain->point_cache[1] = NULL;
|
||||
BLI_listbase_clear(&smd->domain->ptcaches[1]);
|
||||
/* set some standard values */
|
||||
smd->domain->fluid = NULL;
|
||||
smd->domain->fluid_mutex = BLI_rw_mutex_alloc();
|
||||
|
@ -533,7 +523,6 @@ void smokeModifier_createType(struct SmokeModifierData *smd)
|
|||
smd->domain->openvdb_comp = VDB_COMPRESSION_ZIP;
|
||||
#endif
|
||||
smd->domain->data_depth = 0;
|
||||
smd->domain->cache_file_format = PTCACHE_FILE_PTCACHE;
|
||||
}
|
||||
else if (smd->type & MOD_SMOKE_TYPE_FLOW)
|
||||
{
|
||||
|
@ -2429,28 +2418,16 @@ static void smokeModifier_process(SmokeModifierData *smd, Scene *scene, Object *
|
|||
else if (smd->type & MOD_SMOKE_TYPE_DOMAIN)
|
||||
{
|
||||
SmokeDomainSettings *sds = smd->domain;
|
||||
PointCache *cache = NULL;
|
||||
PTCacheID pid;
|
||||
int startframe, endframe, framenr;
|
||||
float timescale;
|
||||
|
||||
framenr = scene->r.cfra;
|
||||
int startframe = scene->r.sfra, endframe = scene->r.efra, framenr = scene->r.cfra;
|
||||
|
||||
//printf("time: %d\n", scene->r.cfra);
|
||||
|
||||
cache = sds->point_cache[0];
|
||||
BKE_ptcache_id_from_smoke(&pid, ob, smd);
|
||||
BKE_ptcache_id_time(&pid, scene, framenr, &startframe, &endframe, ×cale);
|
||||
|
||||
if (!smd->domain->fluid || framenr == startframe)
|
||||
{
|
||||
BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
|
||||
smokeModifier_reset_ex(smd, false);
|
||||
BKE_ptcache_validate(cache, framenr);
|
||||
cache->flag &= ~PTCACHE_REDO_NEEDED;
|
||||
}
|
||||
|
||||
if (!smd->domain->fluid && (framenr != startframe) && (smd->domain->flags & MOD_SMOKE_FILE_LOAD) == 0 && (cache->flag & PTCACHE_BAKED) == 0)
|
||||
if (!smd->domain->fluid && (framenr != startframe) && (smd->domain->flags & MOD_SMOKE_FILE_LOAD) == 0)
|
||||
return;
|
||||
|
||||
smd->domain->flags &= ~MOD_SMOKE_FILE_LOAD;
|
||||
|
@ -2466,13 +2443,6 @@ static void smokeModifier_process(SmokeModifierData *smd, Scene *scene, Object *
|
|||
return;
|
||||
}
|
||||
|
||||
/* try to read from cache */
|
||||
if (BKE_ptcache_read(&pid, (float)framenr) == PTCACHE_READ_EXACT) {
|
||||
BKE_ptcache_validate(cache, framenr);
|
||||
smd->time = framenr;
|
||||
return;
|
||||
}
|
||||
|
||||
/* only calculate something when we advanced a single frame */
|
||||
if (framenr != (int)smd->time + 1)
|
||||
return;
|
||||
|
@ -2485,11 +2455,6 @@ static void smokeModifier_process(SmokeModifierData *smd, Scene *scene, Object *
|
|||
double start = PIL_check_seconds_timer();
|
||||
#endif
|
||||
|
||||
/* if on second frame, write cache for first frame */
|
||||
if ((int)smd->time == startframe && (cache->flag & PTCACHE_OUTDATED || cache->last_exact == 0)) {
|
||||
BKE_ptcache_write(&pid, startframe);
|
||||
}
|
||||
|
||||
// set new time
|
||||
smd->time = scene->r.cfra;
|
||||
|
||||
|
@ -2520,10 +2485,6 @@ static void smokeModifier_process(SmokeModifierData *smd, Scene *scene, Object *
|
|||
smoke_turbulence_step(sds->wt, sds->fluid);
|
||||
}
|
||||
|
||||
BKE_ptcache_validate(cache, framenr);
|
||||
if (framenr != startframe)
|
||||
BKE_ptcache_write(&pid, framenr);
|
||||
|
||||
#ifdef DEBUG_TIME
|
||||
double end = PIL_check_seconds_timer();
|
||||
printf("Frame: %d, Time: %f\n\n", (int)smd->time, (float)(end - start));
|
||||
|
|
|
@ -63,6 +63,7 @@ variables on the UI for now
|
|||
#include "DNA_curve_types.h"
|
||||
#include "DNA_mesh_types.h"
|
||||
#include "DNA_meshdata_types.h"
|
||||
#include "DNA_object_force.h"
|
||||
|
||||
#include "BLI_math.h"
|
||||
#include "BLI_utildefines.h"
|
||||
|
@ -75,7 +76,6 @@ variables on the UI for now
|
|||
#include "BKE_global.h"
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_softbody.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_deform.h"
|
||||
#include "BKE_mesh.h"
|
||||
#include "BKE_scene.h"
|
||||
|
@ -3273,8 +3273,6 @@ SoftBody *sbNew(Scene *scene)
|
|||
sb->shearstiff = 1.0f;
|
||||
sb->solverflags |= SBSO_OLDERR;
|
||||
|
||||
sb->pointcache = BKE_ptcache_add(&sb->ptcaches);
|
||||
|
||||
if (!sb->effector_weights)
|
||||
sb->effector_weights = BKE_add_effector_weights(NULL);
|
||||
|
||||
|
@ -3287,8 +3285,6 @@ SoftBody *sbNew(Scene *scene)
|
|||
void sbFree(SoftBody *sb)
|
||||
{
|
||||
free_softbody_intern(sb);
|
||||
BKE_ptcache_free_list(&sb->ptcaches);
|
||||
sb->pointcache = NULL;
|
||||
if (sb->effector_weights)
|
||||
MEM_freeN(sb->effector_weights);
|
||||
MEM_freeN(sb);
|
||||
|
@ -3595,30 +3591,19 @@ static void softbody_step(Scene *scene, Object *ob, SoftBody *sb, float dtime)
|
|||
void sbObjectStep(Scene *scene, Object *ob, float cfra, float (*vertexCos)[3], int numVerts)
|
||||
{
|
||||
SoftBody *sb= ob->soft;
|
||||
PointCache *cache;
|
||||
PTCacheID pid;
|
||||
float dtime, timescale;
|
||||
int framedelta, framenr, startframe, endframe;
|
||||
int cache_result;
|
||||
float dtime, timescale = 1.0f;
|
||||
int framedelta, framenr = (int)cfra, startframe = scene->r.sfra, endframe = scene->r.efra;
|
||||
|
||||
cache= sb->pointcache;
|
||||
|
||||
framenr= (int)cfra;
|
||||
framedelta= framenr - cache->simframe;
|
||||
|
||||
BKE_ptcache_id_from_softbody(&pid, ob, sb);
|
||||
BKE_ptcache_id_time(&pid, scene, framenr, &startframe, &endframe, ×cale);
|
||||
framedelta = 1;
|
||||
|
||||
/* check for changes in mesh, should only happen in case the mesh
|
||||
* structure changes during an animation */
|
||||
if (sb->bpoint && numVerts != sb->totpoint) {
|
||||
BKE_ptcache_invalidate(cache);
|
||||
return;
|
||||
}
|
||||
|
||||
/* clamp frame ranges */
|
||||
if (framenr < startframe) {
|
||||
BKE_ptcache_invalidate(cache);
|
||||
return;
|
||||
}
|
||||
else if (framenr > endframe) {
|
||||
|
@ -3655,50 +3640,17 @@ void sbObjectStep(Scene *scene, Object *ob, float cfra, float (*vertexCos)[3], i
|
|||
return;
|
||||
}
|
||||
if (framenr == startframe) {
|
||||
BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
|
||||
|
||||
/* first frame, no simulation to do, just set the positions */
|
||||
softbody_update_positions(ob, sb, vertexCos, numVerts);
|
||||
|
||||
BKE_ptcache_validate(cache, framenr);
|
||||
cache->flag &= ~PTCACHE_REDO_NEEDED;
|
||||
|
||||
sb->last_frame = framenr;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/* try to read from cache */
|
||||
cache_result = BKE_ptcache_read(&pid, (float)framenr+scene->r.subframe);
|
||||
|
||||
if (cache_result == PTCACHE_READ_EXACT || cache_result == PTCACHE_READ_INTERPOLATED) {
|
||||
softbody_to_object(ob, vertexCos, numVerts, sb->local);
|
||||
|
||||
BKE_ptcache_validate(cache, framenr);
|
||||
|
||||
if (cache_result == PTCACHE_READ_INTERPOLATED && cache->flag & PTCACHE_REDO_NEEDED)
|
||||
BKE_ptcache_write(&pid, framenr);
|
||||
|
||||
sb->last_frame = framenr;
|
||||
|
||||
return;
|
||||
}
|
||||
else if (cache_result==PTCACHE_READ_OLD) {
|
||||
; /* do nothing */
|
||||
}
|
||||
else if (/*ob->id.lib || */(cache->flag & PTCACHE_BAKED)) { /* "library linking & pointcaches" has to be solved properly at some point */
|
||||
/* if baked and nothing in cache, do nothing */
|
||||
BKE_ptcache_invalidate(cache);
|
||||
return;
|
||||
}
|
||||
|
||||
if (framenr!=sb->last_frame+1)
|
||||
return;
|
||||
|
||||
/* if on second frame, write cache for first frame */
|
||||
if (cache->simframe == startframe && (cache->flag & PTCACHE_OUTDATED || cache->last_exact==0))
|
||||
BKE_ptcache_write(&pid, startframe);
|
||||
|
||||
softbody_update_positions(ob, sb, vertexCos, numVerts);
|
||||
|
||||
/* checking time: */
|
||||
|
@ -3709,9 +3661,6 @@ void sbObjectStep(Scene *scene, Object *ob, float cfra, float (*vertexCos)[3], i
|
|||
|
||||
softbody_to_object(ob, vertexCos, numVerts, 0);
|
||||
|
||||
BKE_ptcache_validate(cache, framenr);
|
||||
BKE_ptcache_write(&pid, framenr);
|
||||
|
||||
sb->last_frame = framenr;
|
||||
}
|
||||
|
||||
|
|
|
@ -80,6 +80,7 @@
|
|||
#include "DNA_nla_types.h"
|
||||
#include "DNA_node_types.h"
|
||||
#include "DNA_object_fluidsim.h" // NT
|
||||
#include "DNA_object_force.h"
|
||||
#include "DNA_object_types.h"
|
||||
#include "DNA_packedFile_types.h"
|
||||
#include "DNA_property_types.h"
|
||||
|
@ -133,7 +134,6 @@
|
|||
#include "BKE_node.h" // for tree type defines
|
||||
#include "BKE_object.h"
|
||||
#include "BKE_paint.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_report.h"
|
||||
#include "BKE_sca.h" // for init_actuator
|
||||
#include "BKE_scene.h"
|
||||
|
@ -3926,83 +3926,6 @@ static void direct_link_material(FileData *fd, Material *ma)
|
|||
}
|
||||
|
||||
/* ************ READ PARTICLE SETTINGS ***************** */
|
||||
/* update this also to writefile.c */
|
||||
static const char *ptcache_data_struct[] = {
|
||||
"", // BPHYS_DATA_INDEX
|
||||
"", // BPHYS_DATA_LOCATION
|
||||
"", // BPHYS_DATA_VELOCITY
|
||||
"", // BPHYS_DATA_ROTATION
|
||||
"", // BPHYS_DATA_AVELOCITY / BPHYS_DATA_XCONST */
|
||||
"", // BPHYS_DATA_SIZE:
|
||||
"", // BPHYS_DATA_TIMES:
|
||||
"BoidData" // case BPHYS_DATA_BOIDS:
|
||||
};
|
||||
|
||||
static void direct_link_pointcache_cb(FileData *fd, void *data)
|
||||
{
|
||||
PTCacheMem *pm = data;
|
||||
PTCacheExtra *extra;
|
||||
int i;
|
||||
for (i = 0; i < BPHYS_TOT_DATA; i++) {
|
||||
pm->data[i] = newdataadr(fd, pm->data[i]);
|
||||
|
||||
/* the cache saves non-struct data without DNA */
|
||||
if (pm->data[i] && ptcache_data_struct[i][0]=='\0' && (fd->flags & FD_FLAGS_SWITCH_ENDIAN)) {
|
||||
int tot = (BKE_ptcache_data_size (i) * pm->totpoint) / sizeof(int); /* data_size returns bytes */
|
||||
int *poin = pm->data[i];
|
||||
|
||||
BLI_endian_switch_int32_array(poin, tot);
|
||||
}
|
||||
}
|
||||
|
||||
link_list(fd, &pm->extradata);
|
||||
|
||||
for (extra=pm->extradata.first; extra; extra=extra->next)
|
||||
extra->data = newdataadr(fd, extra->data);
|
||||
}
|
||||
|
||||
static void direct_link_pointcache(FileData *fd, PointCache *cache)
|
||||
{
|
||||
if ((cache->flag & PTCACHE_DISK_CACHE)==0) {
|
||||
link_list_ex(fd, &cache->mem_cache, direct_link_pointcache_cb);
|
||||
}
|
||||
else
|
||||
BLI_listbase_clear(&cache->mem_cache);
|
||||
|
||||
cache->flag &= ~PTCACHE_SIMULATION_VALID;
|
||||
cache->simframe = 0;
|
||||
cache->edit = NULL;
|
||||
cache->free_edit = NULL;
|
||||
cache->cached_frames = NULL;
|
||||
}
|
||||
|
||||
static void direct_link_pointcache_list(FileData *fd, ListBase *ptcaches, PointCache **ocache, int force_disk)
|
||||
{
|
||||
if (ptcaches->first) {
|
||||
PointCache *cache= NULL;
|
||||
link_list(fd, ptcaches);
|
||||
for (cache=ptcaches->first; cache; cache=cache->next) {
|
||||
direct_link_pointcache(fd, cache);
|
||||
if (force_disk) {
|
||||
cache->flag |= PTCACHE_DISK_CACHE;
|
||||
cache->step = 1;
|
||||
}
|
||||
}
|
||||
|
||||
*ocache = newdataadr(fd, *ocache);
|
||||
}
|
||||
else if (*ocache) {
|
||||
/* old "single" caches need to be linked too */
|
||||
*ocache = newdataadr(fd, *ocache);
|
||||
direct_link_pointcache(fd, *ocache);
|
||||
if (force_disk) {
|
||||
(*ocache)->flag |= PTCACHE_DISK_CACHE;
|
||||
(*ocache)->step = 1;
|
||||
}
|
||||
|
||||
ptcaches->first = ptcaches->last = *ocache;
|
||||
}
|
||||
}
|
||||
|
||||
static void lib_link_partdeflect(FileData *fd, ID *id, PartDeflect *pd)
|
||||
{
|
||||
|
@ -4723,8 +4646,6 @@ static void direct_link_modifiers(FileData *fd, ListBase *lb)
|
|||
clmd->sim_parms= newdataadr(fd, clmd->sim_parms);
|
||||
clmd->coll_parms= newdataadr(fd, clmd->coll_parms);
|
||||
|
||||
direct_link_pointcache_list(fd, &clmd->ptcaches, &clmd->point_cache, 0);
|
||||
|
||||
if (clmd->sim_parms) {
|
||||
if (clmd->sim_parms->presets > 10)
|
||||
clmd->sim_parms->presets = 0;
|
||||
|
@ -4769,24 +4690,6 @@ static void direct_link_modifiers(FileData *fd, ListBase *lb)
|
|||
smd->domain->effector_weights = newdataadr(fd, smd->domain->effector_weights);
|
||||
if (!smd->domain->effector_weights)
|
||||
smd->domain->effector_weights = BKE_add_effector_weights(NULL);
|
||||
|
||||
direct_link_pointcache_list(fd, &(smd->domain->ptcaches[0]), &(smd->domain->point_cache[0]), 1);
|
||||
|
||||
/* Smoke uses only one cache from now on, so store pointer convert */
|
||||
if (smd->domain->ptcaches[1].first || smd->domain->point_cache[1]) {
|
||||
if (smd->domain->point_cache[1]) {
|
||||
PointCache *cache = newdataadr(fd, smd->domain->point_cache[1]);
|
||||
if (cache->flag & PTCACHE_FAKE_SMOKE) {
|
||||
/* Smoke was already saved in "new format" and this cache is a fake one. */
|
||||
}
|
||||
else {
|
||||
printf("High resolution smoke cache not available due to pointcache update. Please reset the simulation.\n");
|
||||
}
|
||||
BKE_ptcache_free(cache);
|
||||
}
|
||||
BLI_listbase_clear(&smd->domain->ptcaches[1]);
|
||||
smd->domain->point_cache[1] = NULL;
|
||||
}
|
||||
}
|
||||
else if (smd->type == MOD_SMOKE_TYPE_FLOW) {
|
||||
smd->domain = NULL;
|
||||
|
@ -4831,7 +4734,6 @@ static void direct_link_modifiers(FileData *fd, ListBase *lb)
|
|||
for (surface=pmd->canvas->surfaces.first; surface; surface=surface->next) {
|
||||
surface->canvas = pmd->canvas;
|
||||
surface->data = NULL;
|
||||
direct_link_pointcache_list(fd, &(surface->ptcaches), &(surface->pointcache), 1);
|
||||
|
||||
if (!(surface->effector_weights = newdataadr(fd, surface->effector_weights)))
|
||||
surface->effector_weights = BKE_add_effector_weights(NULL);
|
||||
|
@ -5092,8 +4994,6 @@ static void direct_link_object(FileData *fd, Object *ob)
|
|||
sb->effector_weights = newdataadr(fd, sb->effector_weights);
|
||||
if (!sb->effector_weights)
|
||||
sb->effector_weights = BKE_add_effector_weights(NULL);
|
||||
|
||||
direct_link_pointcache_list(fd, &sb->ptcaches, &sb->pointcache, 0);
|
||||
}
|
||||
ob->bsoft = newdataadr(fd, ob->bsoft);
|
||||
ob->fluidsimSettings= newdataadr(fd, ob->fluidsimSettings); /* NT */
|
||||
|
@ -5744,13 +5644,6 @@ static void direct_link_scene(FileData *fd, Scene *sce)
|
|||
rbw->effector_weights = newdataadr(fd, rbw->effector_weights);
|
||||
if (!rbw->effector_weights)
|
||||
rbw->effector_weights = BKE_add_effector_weights(NULL);
|
||||
|
||||
/* link cache */
|
||||
direct_link_pointcache_list(fd, &rbw->ptcaches, &rbw->pointcache, false);
|
||||
/* make sure simulation starts from the beginning after loading file */
|
||||
if (rbw->pointcache) {
|
||||
rbw->ltime = (float)rbw->pointcache->startframe;
|
||||
}
|
||||
}
|
||||
|
||||
sce->preview = direct_link_preview_image(fd, sce->preview);
|
||||
|
|
|
@ -53,6 +53,7 @@
|
|||
#include "DNA_meshdata_types.h"
|
||||
#include "DNA_node_types.h"
|
||||
#include "DNA_object_fluidsim.h" // NT
|
||||
#include "DNA_object_force.h"
|
||||
#include "DNA_object_types.h"
|
||||
#include "DNA_view3d_types.h"
|
||||
#include "DNA_screen_types.h"
|
||||
|
@ -78,7 +79,6 @@
|
|||
#include "BKE_mesh.h" // for ME_ defines (patching)
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_multires.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_screen.h"
|
||||
#include "BKE_sequencer.h"
|
||||
#include "BKE_texture.h"
|
||||
|
|
|
@ -36,12 +36,14 @@
|
|||
#include "DNA_camera_types.h"
|
||||
#include "DNA_cloth_types.h"
|
||||
#include "DNA_constraint_types.h"
|
||||
#include "DNA_dynamicpaint_types.h"
|
||||
#include "DNA_genfile.h"
|
||||
#include "DNA_key_types.h"
|
||||
#include "DNA_linestyle_types.h"
|
||||
#include "DNA_mesh_types.h"
|
||||
#include "DNA_meshdata_types.h"
|
||||
#include "DNA_object_fluidsim.h" // NT
|
||||
#include "DNA_object_force.h"
|
||||
#include "DNA_object_types.h"
|
||||
#include "DNA_property_types.h"
|
||||
#include "DNA_text_types.h"
|
||||
|
@ -64,7 +66,6 @@
|
|||
#include "BKE_main.h" // for Main
|
||||
#include "BKE_mesh.h" // for ME_ defines (patching)
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_property.h" // for BKE_bproperty_object_get
|
||||
#include "BKE_scene.h"
|
||||
#include "BKE_screen.h"
|
||||
|
|
|
@ -59,6 +59,7 @@
|
|||
#include "DNA_nla_types.h"
|
||||
#include "DNA_node_types.h"
|
||||
#include "DNA_object_fluidsim.h" // NT
|
||||
#include "DNA_object_force.h"
|
||||
#include "DNA_object_types.h"
|
||||
#include "DNA_property_types.h"
|
||||
#include "DNA_view3d_types.h"
|
||||
|
@ -88,7 +89,6 @@
|
|||
#include "BKE_main.h" // for Main
|
||||
#include "BKE_mesh.h" // for ME_ defines (patching)
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_property.h" // for BKE_bproperty_object_get
|
||||
#include "BKE_scene.h"
|
||||
#include "BKE_sequencer.h"
|
||||
|
@ -2669,7 +2669,6 @@ void blo_do_versions_pre250(FileData *fd, Library *lib, Main *main)
|
|||
Mesh *me;
|
||||
bNodeTree *ntree;
|
||||
Tex *tex;
|
||||
ModifierData *md;
|
||||
|
||||
/* unless the file was created 2.44.3 but not 2.45, update the constraints */
|
||||
if (!(main->versionfile == 244 && main->subversionfile == 3) &&
|
||||
|
@ -2750,22 +2749,6 @@ void blo_do_versions_pre250(FileData *fd, Library *lib, Main *main)
|
|||
}
|
||||
}
|
||||
|
||||
/* add point caches */
|
||||
for (ob = main->object.first; ob; ob = ob->id.next) {
|
||||
if (ob->soft && !ob->soft->pointcache)
|
||||
ob->soft->pointcache = BKE_ptcache_add(&ob->soft->ptcaches);
|
||||
|
||||
for (md = ob->modifiers.first; md; md = md->next) {
|
||||
if (md->type == eModifierType_Cloth) {
|
||||
ClothModifierData *clmd = (ClothModifierData*) md;
|
||||
if (!clmd->point_cache) {
|
||||
clmd->point_cache = BKE_ptcache_add(&clmd->ptcaches);
|
||||
clmd->point_cache->step = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Copy over old per-level multires vertex data
|
||||
* into a single vertex array in struct Multires */
|
||||
for (me = main->mesh.first; me; me = me->id.next) {
|
||||
|
|
|
@ -158,7 +158,6 @@
|
|||
#include "BKE_subsurf.h"
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_fcurve.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_mesh.h"
|
||||
|
||||
#ifdef USE_NODE_COMPAT_CUSTOMNODES
|
||||
|
@ -1058,57 +1057,6 @@ static void write_userdef(WriteData *wd)
|
|||
}
|
||||
}
|
||||
|
||||
/* update this also to readfile.c */
|
||||
static const char *ptcache_data_struct[] = {
|
||||
"", // BPHYS_DATA_INDEX
|
||||
"", // BPHYS_DATA_LOCATION
|
||||
"", // BPHYS_DATA_VELOCITY
|
||||
"", // BPHYS_DATA_ROTATION
|
||||
"", // BPHYS_DATA_AVELOCITY / BPHYS_DATA_XCONST */
|
||||
"", // BPHYS_DATA_SIZE:
|
||||
"", // BPHYS_DATA_TIMES:
|
||||
"BoidData" // case BPHYS_DATA_BOIDS:
|
||||
};
|
||||
static const char *ptcache_extra_struct[] = {
|
||||
"",
|
||||
"ParticleSpring"
|
||||
};
|
||||
static void write_pointcaches(WriteData *wd, ListBase *ptcaches)
|
||||
{
|
||||
PointCache *cache = ptcaches->first;
|
||||
int i;
|
||||
|
||||
for (; cache; cache=cache->next) {
|
||||
writestruct(wd, DATA, "PointCache", 1, cache);
|
||||
|
||||
if ((cache->flag & PTCACHE_DISK_CACHE)==0) {
|
||||
PTCacheMem *pm = cache->mem_cache.first;
|
||||
|
||||
for (; pm; pm=pm->next) {
|
||||
PTCacheExtra *extra = pm->extradata.first;
|
||||
|
||||
writestruct(wd, DATA, "PTCacheMem", 1, pm);
|
||||
|
||||
for (i=0; i<BPHYS_TOT_DATA; i++) {
|
||||
if (pm->data[i] && pm->data_types & (1<<i)) {
|
||||
if (ptcache_data_struct[i][0] == '\0')
|
||||
writedata(wd, DATA, MEM_allocN_len(pm->data[i]), pm->data[i]);
|
||||
else
|
||||
writestruct(wd, DATA, ptcache_data_struct[i], pm->totpoint, pm->data[i]);
|
||||
}
|
||||
}
|
||||
|
||||
for (; extra; extra=extra->next) {
|
||||
if (ptcache_extra_struct[extra->type][0] == '\0')
|
||||
continue;
|
||||
writestruct(wd, DATA, "PTCacheExtra", 1, extra);
|
||||
writestruct(wd, DATA, ptcache_extra_struct[extra->type], extra->totdata, extra->data);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void write_properties(WriteData *wd, ListBase *lb)
|
||||
{
|
||||
bProperty *prop;
|
||||
|
@ -1418,30 +1366,14 @@ static void write_modifiers(WriteData *wd, ListBase *modbase)
|
|||
writestruct(wd, DATA, "ClothSimSettings", 1, clmd->sim_parms);
|
||||
writestruct(wd, DATA, "ClothCollSettings", 1, clmd->coll_parms);
|
||||
writestruct(wd, DATA, "EffectorWeights", 1, clmd->sim_parms->effector_weights);
|
||||
write_pointcaches(wd, &clmd->ptcaches);
|
||||
}
|
||||
else if (md->type==eModifierType_Smoke) {
|
||||
SmokeModifierData *smd = (SmokeModifierData*) md;
|
||||
|
||||
if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
|
||||
if (smd->domain) {
|
||||
write_pointcaches(wd, &(smd->domain->ptcaches[0]));
|
||||
|
||||
/* create fake pointcache so that old blender versions can read it */
|
||||
smd->domain->point_cache[1] = BKE_ptcache_add(&smd->domain->ptcaches[1]);
|
||||
smd->domain->point_cache[1]->flag |= PTCACHE_DISK_CACHE|PTCACHE_FAKE_SMOKE;
|
||||
smd->domain->point_cache[1]->step = 1;
|
||||
|
||||
write_pointcaches(wd, &(smd->domain->ptcaches[1]));
|
||||
}
|
||||
|
||||
writestruct(wd, DATA, "SmokeDomainSettings", 1, smd->domain);
|
||||
|
||||
if (smd->domain) {
|
||||
/* cleanup the fake pointcache */
|
||||
BKE_ptcache_free_list(&smd->domain->ptcaches[1]);
|
||||
smd->domain->point_cache[1] = NULL;
|
||||
|
||||
writestruct(wd, DATA, "EffectorWeights", 1, smd->domain->effector_weights);
|
||||
}
|
||||
}
|
||||
|
@ -1467,8 +1399,6 @@ static void write_modifiers(WriteData *wd, ListBase *modbase)
|
|||
writestruct(wd, DATA, "DynamicPaintSurface", 1, surface);
|
||||
/* write caches and effector weights */
|
||||
for (surface=pmd->canvas->surfaces.first; surface; surface=surface->next) {
|
||||
write_pointcaches(wd, &(surface->ptcaches));
|
||||
|
||||
writestruct(wd, DATA, "EffectorWeights", 1, surface->effector_weights);
|
||||
}
|
||||
}
|
||||
|
@ -1568,7 +1498,6 @@ static void write_objects(WriteData *wd, ListBase *idbase)
|
|||
writestruct(wd, DATA, "PartDeflect", 1, ob->pd);
|
||||
writestruct(wd, DATA, "SoftBody", 1, ob->soft);
|
||||
if (ob->soft) {
|
||||
write_pointcaches(wd, &ob->soft->ptcaches);
|
||||
writestruct(wd, DATA, "EffectorWeights", 1, ob->soft->effector_weights);
|
||||
}
|
||||
writestruct(wd, DATA, "BulletSoftBody", 1, ob->bsoft);
|
||||
|
@ -2438,7 +2367,6 @@ static void write_scenes(WriteData *wd, ListBase *scebase)
|
|||
if (sce->rigidbody_world) {
|
||||
writestruct(wd, DATA, "RigidBodyWorld", 1, sce->rigidbody_world);
|
||||
writestruct(wd, DATA, "EffectorWeights", 1, sce->rigidbody_world->effector_weights);
|
||||
write_pointcaches(wd, &(sce->rigidbody_world->ptcaches));
|
||||
}
|
||||
|
||||
write_previews(wd, sce->preview);
|
||||
|
|
|
@ -75,7 +75,6 @@
|
|||
#include "BKE_mball.h"
|
||||
#include "BKE_mesh.h"
|
||||
#include "BKE_object.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_property.h"
|
||||
#include "BKE_sca.h"
|
||||
#include "BKE_softbody.h"
|
||||
|
@ -430,21 +429,9 @@ void ED_object_editmode_exit(bContext *C, int flag)
|
|||
|
||||
/* freedata only 0 now on file saves and render */
|
||||
if (freedata) {
|
||||
ListBase pidlist;
|
||||
PTCacheID *pid;
|
||||
|
||||
/* for example; displist make is different in editmode */
|
||||
scene->obedit = NULL; // XXX for context
|
||||
|
||||
/* flag object caches as outdated */
|
||||
BKE_ptcache_ids_from_object(&pidlist, obedit, scene, 0);
|
||||
for (pid = pidlist.first; pid; pid = pid->next) {
|
||||
pid->cache->flag |= PTCACHE_OUTDATED;
|
||||
}
|
||||
BLI_freelistN(&pidlist);
|
||||
|
||||
BKE_ptcache_object_reset(scene, obedit, PTCACHE_RESET_OUTDATED);
|
||||
|
||||
/* also flush ob recalc, doesn't take much overhead, but used for particles */
|
||||
DAG_id_tag_update(&obedit->id, OB_RECALC_OB | OB_RECALC_DATA);
|
||||
|
||||
|
|
|
@ -40,7 +40,6 @@ set(SRC
|
|||
dynamicpaint_ops.c
|
||||
physics_fluid.c
|
||||
physics_ops.c
|
||||
physics_pointcache.c
|
||||
rigidbody_constraint.c
|
||||
rigidbody_object.c
|
||||
rigidbody_world.c
|
||||
|
|
|
@ -45,15 +45,6 @@ void DPAINT_OT_surface_slot_remove(struct wmOperatorType *ot);
|
|||
void DPAINT_OT_type_toggle(struct wmOperatorType *ot);
|
||||
void DPAINT_OT_output_toggle(struct wmOperatorType *ot);
|
||||
|
||||
/* physics_pointcache.c */
|
||||
void PTCACHE_OT_bake_all(struct wmOperatorType *ot);
|
||||
void PTCACHE_OT_free_bake_all(struct wmOperatorType *ot);
|
||||
void PTCACHE_OT_bake(struct wmOperatorType *ot);
|
||||
void PTCACHE_OT_free_bake(struct wmOperatorType *ot);
|
||||
void PTCACHE_OT_bake_from_cache(struct wmOperatorType *ot);
|
||||
void PTCACHE_OT_add(struct wmOperatorType *ot);
|
||||
void PTCACHE_OT_remove(struct wmOperatorType *ot);
|
||||
|
||||
/* rigidbody_object.c */
|
||||
void RIGIDBODY_OT_object_add(struct wmOperatorType *ot);
|
||||
void RIGIDBODY_OT_object_remove(struct wmOperatorType *ot);
|
||||
|
|
|
@ -68,19 +68,6 @@ static void operatortypes_fluid(void)
|
|||
WM_operatortype_append(FLUID_OT_bake);
|
||||
}
|
||||
|
||||
/**************************** point cache **********************************/
|
||||
|
||||
static void operatortypes_pointcache(void)
|
||||
{
|
||||
WM_operatortype_append(PTCACHE_OT_bake_all);
|
||||
WM_operatortype_append(PTCACHE_OT_free_bake_all);
|
||||
WM_operatortype_append(PTCACHE_OT_bake);
|
||||
WM_operatortype_append(PTCACHE_OT_free_bake);
|
||||
WM_operatortype_append(PTCACHE_OT_bake_from_cache);
|
||||
WM_operatortype_append(PTCACHE_OT_add);
|
||||
WM_operatortype_append(PTCACHE_OT_remove);
|
||||
}
|
||||
|
||||
/********************************* dynamic paint ***********************************/
|
||||
|
||||
static void operatortypes_dynamicpaint(void)
|
||||
|
@ -92,30 +79,15 @@ static void operatortypes_dynamicpaint(void)
|
|||
WM_operatortype_append(DPAINT_OT_output_toggle);
|
||||
}
|
||||
|
||||
//static void keymap_pointcache(wmWindowManager *wm)
|
||||
//{
|
||||
// wmKeyMap *keymap = WM_keymap_find(wm, "Pointcache", 0, 0);
|
||||
//
|
||||
// WM_keymap_add_item(keymap, "PHYSICS_OT_bake_all", AKEY, KM_PRESS, 0, 0);
|
||||
// WM_keymap_add_item(keymap, "PHYSICS_OT_free_all", PADPLUSKEY, KM_PRESS, KM_CTRL, 0);
|
||||
// WM_keymap_add_item(keymap, "PHYSICS_OT_bake_particle_system", PADMINUS, KM_PRESS, KM_CTRL, 0);
|
||||
// WM_keymap_add_item(keymap, "PHYSICS_OT_free_particle_system", LKEY, KM_PRESS, 0, 0);
|
||||
//}
|
||||
|
||||
/****************************** general ************************************/
|
||||
|
||||
void ED_operatortypes_physics(void)
|
||||
{
|
||||
operatortypes_rigidbody();
|
||||
operatortypes_fluid();
|
||||
operatortypes_pointcache();
|
||||
operatortypes_dynamicpaint();
|
||||
}
|
||||
|
||||
void ED_keymap_physics(wmKeyConfig *UNUSED(keyconf))
|
||||
{
|
||||
//keymap_pointcache(keyconf);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -1,464 +0,0 @@
|
|||
/*
|
||||
* ***** BEGIN GPL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2007 by Janne Karhu.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/** \file blender/editors/physics/physics_pointcache.c
|
||||
* \ingroup edphys
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
#include "BLI_blenlib.h"
|
||||
#include "BLI_utildefines.h"
|
||||
|
||||
#include "DNA_object_types.h"
|
||||
#include "DNA_scene_types.h"
|
||||
|
||||
#include "BKE_context.h"
|
||||
#include "BKE_screen.h"
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_pointcache.h"
|
||||
|
||||
#include "WM_api.h"
|
||||
#include "WM_types.h"
|
||||
|
||||
#include "RNA_access.h"
|
||||
#include "RNA_define.h"
|
||||
|
||||
#include "physics_intern.h"
|
||||
|
||||
static int ptcache_bake_all_poll(bContext *C)
|
||||
{
|
||||
return CTX_data_scene(C) != NULL;
|
||||
}
|
||||
|
||||
static int ptcache_poll(bContext *C)
|
||||
{
|
||||
PointerRNA ptr= CTX_data_pointer_get_type(C, "point_cache", &RNA_PointCache);
|
||||
return (ptr.data && ptr.id.data);
|
||||
}
|
||||
|
||||
typedef struct PointCacheJob {
|
||||
void *owner;
|
||||
short *stop, *do_update;
|
||||
float *progress;
|
||||
|
||||
PTCacheBaker *baker;
|
||||
} PointCacheJob;
|
||||
|
||||
static void ptcache_job_free(void *customdata)
|
||||
{
|
||||
PointCacheJob *job = customdata;
|
||||
MEM_freeN(job->baker);
|
||||
MEM_freeN(job);
|
||||
}
|
||||
|
||||
static int ptcache_job_break(void *customdata)
|
||||
{
|
||||
PointCacheJob *job = customdata;
|
||||
|
||||
if (G.is_break) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (job->stop && *(job->stop)) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void ptcache_job_update(void *customdata, float progress, int *cancel)
|
||||
{
|
||||
PointCacheJob *job = customdata;
|
||||
|
||||
if (ptcache_job_break(job)) {
|
||||
*cancel = 1;
|
||||
}
|
||||
|
||||
*(job->do_update) = true;
|
||||
*(job->progress) = progress;
|
||||
}
|
||||
|
||||
static void ptcache_job_startjob(void *customdata, short *stop, short *do_update, float *progress)
|
||||
{
|
||||
PointCacheJob *job = customdata;
|
||||
|
||||
job->stop = stop;
|
||||
job->do_update = do_update;
|
||||
job->progress = progress;
|
||||
|
||||
G.is_break = false;
|
||||
|
||||
/* XXX annoying hack: needed to prevent data corruption when changing
|
||||
* scene frame in separate threads
|
||||
*/
|
||||
G.is_rendering = true;
|
||||
BKE_spacedata_draw_locks(true);
|
||||
|
||||
BKE_ptcache_bake(job->baker);
|
||||
|
||||
*do_update = true;
|
||||
*stop = 0;
|
||||
}
|
||||
|
||||
static void ptcache_job_endjob(void *customdata)
|
||||
{
|
||||
PointCacheJob *job = customdata;
|
||||
Scene *scene = job->baker->scene;
|
||||
|
||||
G.is_rendering = false;
|
||||
BKE_spacedata_draw_locks(false);
|
||||
|
||||
WM_set_locked_interface(G.main->wm.first, false);
|
||||
|
||||
WM_main_add_notifier(NC_SCENE | ND_FRAME, scene);
|
||||
WM_main_add_notifier(NC_OBJECT | ND_POINTCACHE, job->baker->pid.ob);
|
||||
}
|
||||
|
||||
static void ptcache_free_bake(PointCache *cache)
|
||||
{
|
||||
if (cache->edit) {
|
||||
cache->edit = NULL;
|
||||
cache->flag &= ~PTCACHE_BAKED;
|
||||
}
|
||||
else {
|
||||
cache->flag &= ~PTCACHE_BAKED;
|
||||
}
|
||||
}
|
||||
|
||||
static PTCacheBaker *ptcache_baker_create(bContext *C, wmOperator *op, bool all)
|
||||
{
|
||||
PTCacheBaker *baker = MEM_callocN(sizeof(PTCacheBaker), "PTCacheBaker");
|
||||
|
||||
baker->main = CTX_data_main(C);
|
||||
baker->scene = CTX_data_scene(C);
|
||||
baker->bake = RNA_boolean_get(op->ptr, "bake");
|
||||
baker->render = 0;
|
||||
baker->anim_init = 0;
|
||||
baker->quick_step = 1;
|
||||
|
||||
if (!all) {
|
||||
PointerRNA ptr = CTX_data_pointer_get_type(C, "point_cache", &RNA_PointCache);
|
||||
Object *ob = ptr.id.data;
|
||||
PointCache *cache = ptr.data;
|
||||
|
||||
ListBase pidlist;
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, baker->scene, MAX_DUPLI_RECUR);
|
||||
|
||||
for (PTCacheID *pid = pidlist.first; pid; pid = pid->next) {
|
||||
if (pid->cache == cache) {
|
||||
baker->pid = *pid;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
}
|
||||
|
||||
return baker;
|
||||
}
|
||||
|
||||
static int ptcache_bake_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
bool all = STREQ(op->type->idname, "PTCACHE_OT_bake_all");
|
||||
|
||||
PTCacheBaker *baker = ptcache_baker_create(C, op, all);
|
||||
BKE_ptcache_bake(baker);
|
||||
MEM_freeN(baker);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
static int ptcache_bake_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
|
||||
{
|
||||
bool all = STREQ(op->type->idname, "PTCACHE_OT_bake_all");
|
||||
|
||||
PointCacheJob *job = MEM_mallocN(sizeof(PointCacheJob), "PointCacheJob");
|
||||
job->baker = ptcache_baker_create(C, op, all);
|
||||
job->baker->bake_job = job;
|
||||
job->baker->update_progress = ptcache_job_update;
|
||||
|
||||
wmJob *wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), CTX_data_scene(C),
|
||||
"Point Cache", WM_JOB_PROGRESS, WM_JOB_TYPE_POINTCACHE);
|
||||
|
||||
WM_jobs_customdata_set(wm_job, job, ptcache_job_free);
|
||||
WM_jobs_timer(wm_job, 0.1, NC_OBJECT | ND_POINTCACHE, NC_OBJECT | ND_POINTCACHE);
|
||||
WM_jobs_callbacks(wm_job, ptcache_job_startjob, NULL, NULL, ptcache_job_endjob);
|
||||
|
||||
WM_set_locked_interface(CTX_wm_manager(C), true);
|
||||
|
||||
WM_jobs_start(CTX_wm_manager(C), wm_job);
|
||||
|
||||
WM_event_add_modal_handler(C, op);
|
||||
|
||||
/* we must run modal until the bake job is done, otherwise the undo push
|
||||
* happens before the job ends, which can lead to race conditions between
|
||||
* the baking and file writing code */
|
||||
return OPERATOR_RUNNING_MODAL;
|
||||
}
|
||||
|
||||
static int ptcache_bake_modal(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
|
||||
{
|
||||
Scene *scene = (Scene *) op->customdata;
|
||||
|
||||
/* no running blender, remove handler and pass through */
|
||||
if (0 == WM_jobs_test(CTX_wm_manager(C), scene, WM_JOB_TYPE_POINTCACHE)) {
|
||||
return OPERATOR_FINISHED | OPERATOR_PASS_THROUGH;
|
||||
}
|
||||
|
||||
return OPERATOR_PASS_THROUGH;
|
||||
}
|
||||
|
||||
static void ptcache_bake_cancel(bContext *C, wmOperator *op)
|
||||
{
|
||||
wmWindowManager *wm = CTX_wm_manager(C);
|
||||
Scene *scene = (Scene *) op->customdata;
|
||||
|
||||
/* kill on cancel, because job is using op->reports */
|
||||
WM_jobs_kill_type(wm, scene, WM_JOB_TYPE_POINTCACHE);
|
||||
}
|
||||
|
||||
static int ptcache_free_bake_all_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
Base *base;
|
||||
PTCacheID *pid;
|
||||
ListBase pidlist;
|
||||
|
||||
for (base=scene->base.first; base; base= base->next) {
|
||||
BKE_ptcache_ids_from_object(&pidlist, base->object, scene, MAX_DUPLI_RECUR);
|
||||
|
||||
for (pid=pidlist.first; pid; pid=pid->next) {
|
||||
ptcache_free_bake(pid->cache);
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_POINTCACHE, base->object);
|
||||
}
|
||||
|
||||
WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
void PTCACHE_OT_bake_all(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name = "Bake All Physics";
|
||||
ot->description = "Bake all physics";
|
||||
ot->idname = "PTCACHE_OT_bake_all";
|
||||
|
||||
/* api callbacks */
|
||||
ot->exec = ptcache_bake_exec;
|
||||
ot->invoke = ptcache_bake_invoke;
|
||||
ot->modal = ptcache_bake_modal;
|
||||
ot->cancel = ptcache_bake_cancel;
|
||||
ot->poll = ptcache_bake_all_poll;
|
||||
|
||||
/* flags */
|
||||
ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
|
||||
RNA_def_boolean(ot->srna, "bake", 1, "Bake", "");
|
||||
}
|
||||
void PTCACHE_OT_free_bake_all(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name = "Free All Physics Bakes";
|
||||
ot->idname = "PTCACHE_OT_free_bake_all";
|
||||
ot->description = "Free all baked caches of all objects in the current scene";
|
||||
|
||||
/* api callbacks */
|
||||
ot->exec = ptcache_free_bake_all_exec;
|
||||
ot->poll = ptcache_bake_all_poll;
|
||||
|
||||
/* flags */
|
||||
ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
}
|
||||
|
||||
static int ptcache_free_bake_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
{
|
||||
PointerRNA ptr= CTX_data_pointer_get_type(C, "point_cache", &RNA_PointCache);
|
||||
PointCache *cache= ptr.data;
|
||||
Object *ob= ptr.id.data;
|
||||
|
||||
ptcache_free_bake(cache);
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_POINTCACHE, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
static int ptcache_bake_from_cache_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
{
|
||||
PointerRNA ptr= CTX_data_pointer_get_type(C, "point_cache", &RNA_PointCache);
|
||||
PointCache *cache= ptr.data;
|
||||
Object *ob= ptr.id.data;
|
||||
|
||||
cache->flag |= PTCACHE_BAKED;
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_POINTCACHE, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
void PTCACHE_OT_bake(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name = "Bake Physics";
|
||||
ot->description = "Bake physics";
|
||||
ot->idname = "PTCACHE_OT_bake";
|
||||
|
||||
/* api callbacks */
|
||||
ot->exec = ptcache_bake_exec;
|
||||
ot->invoke = ptcache_bake_invoke;
|
||||
ot->modal = ptcache_bake_modal;
|
||||
ot->cancel = ptcache_bake_cancel;
|
||||
ot->poll = ptcache_poll;
|
||||
|
||||
/* flags */
|
||||
ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
|
||||
RNA_def_boolean(ot->srna, "bake", 0, "Bake", "");
|
||||
}
|
||||
void PTCACHE_OT_free_bake(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name = "Free Physics Bake";
|
||||
ot->description = "Free physics bake";
|
||||
ot->idname = "PTCACHE_OT_free_bake";
|
||||
|
||||
/* api callbacks */
|
||||
ot->exec = ptcache_free_bake_exec;
|
||||
ot->poll = ptcache_poll;
|
||||
|
||||
/* flags */
|
||||
ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
}
|
||||
void PTCACHE_OT_bake_from_cache(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name = "Bake From Cache";
|
||||
ot->description = "Bake from cache";
|
||||
ot->idname = "PTCACHE_OT_bake_from_cache";
|
||||
|
||||
/* api callbacks */
|
||||
ot->exec = ptcache_bake_from_cache_exec;
|
||||
ot->poll = ptcache_poll;
|
||||
|
||||
/* flags */
|
||||
ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
}
|
||||
|
||||
static int ptcache_add_new_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
PointerRNA ptr= CTX_data_pointer_get_type(C, "point_cache", &RNA_PointCache);
|
||||
Object *ob= ptr.id.data;
|
||||
PointCache *cache= ptr.data;
|
||||
PTCacheID *pid;
|
||||
ListBase pidlist;
|
||||
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, scene, MAX_DUPLI_RECUR);
|
||||
|
||||
for (pid=pidlist.first; pid; pid=pid->next) {
|
||||
if (pid->cache == cache) {
|
||||
PointCache *cache_new = BKE_ptcache_add(pid->ptcaches);
|
||||
cache_new->step = pid->default_step;
|
||||
*(pid->cache_ptr) = cache_new;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
|
||||
WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_POINTCACHE, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
static int ptcache_remove_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
{
|
||||
PointerRNA ptr= CTX_data_pointer_get_type(C, "point_cache", &RNA_PointCache);
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
Object *ob= ptr.id.data;
|
||||
PointCache *cache= ptr.data;
|
||||
PTCacheID *pid;
|
||||
ListBase pidlist;
|
||||
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, scene, MAX_DUPLI_RECUR);
|
||||
|
||||
for (pid=pidlist.first; pid; pid=pid->next) {
|
||||
if (pid->cache == cache) {
|
||||
if (pid->ptcaches->first == pid->ptcaches->last)
|
||||
continue; /* don't delete last cache */
|
||||
|
||||
BLI_remlink(pid->ptcaches, pid->cache);
|
||||
BKE_ptcache_free(pid->cache);
|
||||
*(pid->cache_ptr) = pid->ptcaches->first;
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_POINTCACHE, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
void PTCACHE_OT_add(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name = "Add New Cache";
|
||||
ot->description = "Add new cache";
|
||||
ot->idname = "PTCACHE_OT_add";
|
||||
|
||||
/* api callbacks */
|
||||
ot->exec = ptcache_add_new_exec;
|
||||
ot->poll = ptcache_poll;
|
||||
|
||||
/* flags */
|
||||
ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
}
|
||||
void PTCACHE_OT_remove(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name = "Delete Current Cache";
|
||||
ot->description = "Delete current cache";
|
||||
ot->idname = "PTCACHE_OT_remove";
|
||||
|
||||
/* api callbacks */
|
||||
ot->exec = ptcache_remove_exec;
|
||||
ot->poll = ptcache_poll;
|
||||
|
||||
/* flags */
|
||||
ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
}
|
||||
|
|
@ -44,7 +44,6 @@
|
|||
|
||||
#include "BKE_context.h"
|
||||
#include "BKE_screen.h"
|
||||
#include "BKE_pointcache.h"
|
||||
|
||||
#include "ED_anim_api.h"
|
||||
#include "ED_keyframes_draw.h"
|
||||
|
@ -91,155 +90,6 @@ static void time_draw_sfra_efra(Scene *scene, View2D *v2d)
|
|||
fdrawline((float)PEFRA, v2d->cur.ymin, (float)PEFRA, v2d->cur.ymax);
|
||||
}
|
||||
|
||||
static void time_draw_cache(SpaceTime *stime, Object *ob, Scene *scene)
|
||||
{
|
||||
PTCacheID *pid;
|
||||
ListBase pidlist;
|
||||
SpaceTimeCache *stc = stime->caches.first;
|
||||
const float cache_draw_height = (4.0f * UI_DPI_FAC * U.pixelsize);
|
||||
float yoffs = 0.f;
|
||||
|
||||
if (!(stime->cache_display & TIME_CACHE_DISPLAY) || (!ob))
|
||||
return;
|
||||
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, scene, 0);
|
||||
|
||||
/* iterate over pointcaches on the active object,
|
||||
* add spacetimecache and vertex array for each */
|
||||
for (pid = pidlist.first; pid; pid = pid->next) {
|
||||
float col[4], *fp;
|
||||
int i, sta = pid->cache->startframe, end = pid->cache->endframe;
|
||||
int len = (end - sta + 1) * 4;
|
||||
|
||||
switch (pid->type) {
|
||||
case PTCACHE_TYPE_SOFTBODY:
|
||||
if (!(stime->cache_display & TIME_CACHE_SOFTBODY)) continue;
|
||||
break;
|
||||
case PTCACHE_TYPE_CLOTH:
|
||||
if (!(stime->cache_display & TIME_CACHE_CLOTH)) continue;
|
||||
break;
|
||||
case PTCACHE_TYPE_SMOKE_DOMAIN:
|
||||
case PTCACHE_TYPE_SMOKE_HIGHRES:
|
||||
if (!(stime->cache_display & TIME_CACHE_SMOKE)) continue;
|
||||
break;
|
||||
case PTCACHE_TYPE_DYNAMICPAINT:
|
||||
if (!(stime->cache_display & TIME_CACHE_DYNAMICPAINT)) continue;
|
||||
break;
|
||||
case PTCACHE_TYPE_RIGIDBODY:
|
||||
if (!(stime->cache_display & TIME_CACHE_RIGIDBODY)) continue;
|
||||
break;
|
||||
}
|
||||
|
||||
if (pid->cache->cached_frames == NULL)
|
||||
continue;
|
||||
|
||||
/* make sure we have stc with correct array length */
|
||||
if (stc == NULL || MEM_allocN_len(stc->array) != len * 2 * sizeof(float)) {
|
||||
if (stc) {
|
||||
MEM_freeN(stc->array);
|
||||
}
|
||||
else {
|
||||
stc = MEM_callocN(sizeof(SpaceTimeCache), "spacetimecache");
|
||||
BLI_addtail(&stime->caches, stc);
|
||||
}
|
||||
|
||||
stc->array = MEM_callocN(len * 2 * sizeof(float), "SpaceTimeCache array");
|
||||
}
|
||||
|
||||
/* fill the vertex array with a quad for each cached frame */
|
||||
for (i = sta, fp = stc->array; i <= end; i++) {
|
||||
if (pid->cache->cached_frames[i - sta]) {
|
||||
fp[0] = (float)i - 0.5f;
|
||||
fp[1] = 0.0;
|
||||
fp += 2;
|
||||
|
||||
fp[0] = (float)i - 0.5f;
|
||||
fp[1] = 1.0;
|
||||
fp += 2;
|
||||
|
||||
fp[0] = (float)i + 0.5f;
|
||||
fp[1] = 1.0;
|
||||
fp += 2;
|
||||
|
||||
fp[0] = (float)i + 0.5f;
|
||||
fp[1] = 0.0;
|
||||
fp += 2;
|
||||
}
|
||||
}
|
||||
|
||||
glPushMatrix();
|
||||
glTranslatef(0.0, (float)V2D_SCROLL_HEIGHT + yoffs, 0.0);
|
||||
glScalef(1.0, cache_draw_height, 0.0);
|
||||
|
||||
switch (pid->type) {
|
||||
case PTCACHE_TYPE_SOFTBODY:
|
||||
col[0] = 1.0; col[1] = 0.4; col[2] = 0.02;
|
||||
col[3] = 0.1;
|
||||
break;
|
||||
case PTCACHE_TYPE_CLOTH:
|
||||
col[0] = 0.1; col[1] = 0.1; col[2] = 0.75;
|
||||
col[3] = 0.1;
|
||||
break;
|
||||
case PTCACHE_TYPE_SMOKE_DOMAIN:
|
||||
case PTCACHE_TYPE_SMOKE_HIGHRES:
|
||||
col[0] = 0.2; col[1] = 0.2; col[2] = 0.2;
|
||||
col[3] = 0.1;
|
||||
break;
|
||||
case PTCACHE_TYPE_DYNAMICPAINT:
|
||||
col[0] = 1.0; col[1] = 0.1; col[2] = 0.75;
|
||||
col[3] = 0.1;
|
||||
break;
|
||||
case PTCACHE_TYPE_RIGIDBODY:
|
||||
col[0] = 1.0; col[1] = 0.6; col[2] = 0.0;
|
||||
col[3] = 0.1;
|
||||
break;
|
||||
default:
|
||||
col[0] = 1.0; col[1] = 0.0; col[2] = 1.0;
|
||||
col[3] = 0.1;
|
||||
BLI_assert(0);
|
||||
break;
|
||||
}
|
||||
glColor4fv(col);
|
||||
|
||||
glEnable(GL_BLEND);
|
||||
|
||||
glRectf((float)sta, 0.0, (float)end, 1.0);
|
||||
|
||||
col[3] = 0.4f;
|
||||
if (pid->cache->flag & PTCACHE_BAKED) {
|
||||
col[0] -= 0.4f; col[1] -= 0.4f; col[2] -= 0.4f;
|
||||
}
|
||||
else if (pid->cache->flag & PTCACHE_OUTDATED) {
|
||||
col[0] += 0.4f; col[1] += 0.4f; col[2] += 0.4f;
|
||||
}
|
||||
glColor4fv(col);
|
||||
|
||||
glEnableClientState(GL_VERTEX_ARRAY);
|
||||
glVertexPointer(2, GL_FLOAT, 0, stc->array);
|
||||
glDrawArrays(GL_QUADS, 0, (fp - stc->array) / 2);
|
||||
glDisableClientState(GL_VERTEX_ARRAY);
|
||||
|
||||
glDisable(GL_BLEND);
|
||||
|
||||
glPopMatrix();
|
||||
|
||||
yoffs += cache_draw_height;
|
||||
|
||||
stc = stc->next;
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
|
||||
/* free excessive caches */
|
||||
while (stc) {
|
||||
SpaceTimeCache *tmp = stc->next;
|
||||
BLI_remlink(&stime->caches, stc);
|
||||
MEM_freeN(stc->array);
|
||||
MEM_freeN(stc);
|
||||
stc = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
static void time_cache_free(SpaceTime *stime)
|
||||
{
|
||||
SpaceTimeCache *stc;
|
||||
|
@ -498,7 +348,6 @@ static void time_main_region_draw(const bContext *C, ARegion *ar)
|
|||
/* draw entirely, view changes should be handled here */
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
SpaceTime *stime = CTX_wm_space_time(C);
|
||||
Object *obact = CTX_data_active_object(C);
|
||||
View2D *v2d = &ar->v2d;
|
||||
View2DGrid *grid;
|
||||
View2DScrollers *scrollers;
|
||||
|
@ -536,9 +385,6 @@ static void time_main_region_draw(const bContext *C, ARegion *ar)
|
|||
UI_view2d_view_orthoSpecial(ar, v2d, 1);
|
||||
ED_markers_draw(C, 0);
|
||||
|
||||
/* caches */
|
||||
time_draw_cache(stime, obact, scene);
|
||||
|
||||
/* callback */
|
||||
UI_view2d_view_ortho(v2d);
|
||||
ED_region_draw_cb_draw(C, ar, REGION_DRAW_POST_VIEW);
|
||||
|
|
|
@ -37,6 +37,7 @@
|
|||
#include "DNA_material_types.h"
|
||||
#include "DNA_mesh_types.h"
|
||||
#include "DNA_meta_types.h"
|
||||
#include "DNA_object_force.h"
|
||||
#include "DNA_rigidbody_types.h"
|
||||
#include "DNA_scene_types.h"
|
||||
#include "DNA_smoke_types.h"
|
||||
|
@ -71,7 +72,6 @@
|
|||
#include "BKE_movieclip.h"
|
||||
#include "BKE_object.h"
|
||||
#include "BKE_paint.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_scene.h"
|
||||
#include "BKE_subsurf.h"
|
||||
#include "BKE_unit.h"
|
||||
|
@ -6694,6 +6694,7 @@ void draw_object(Scene *scene, ARegion *ar, View3D *v3d, Base *base, const short
|
|||
/* only draw domains */
|
||||
if (smd->domain) {
|
||||
SmokeDomainSettings *sds = smd->domain;
|
||||
const bool show_smoke = true; /* XXX was checking cached frame range before */
|
||||
float viewnormal[3];
|
||||
|
||||
glLoadMatrixf(rv3d->viewmat);
|
||||
|
@ -6734,7 +6735,7 @@ void draw_object(Scene *scene, ARegion *ar, View3D *v3d, Base *base, const short
|
|||
}
|
||||
|
||||
/* don't show smoke before simulation starts, this could be made an option in the future */
|
||||
if (sds->fluid && CFRA >= sds->point_cache[0]->startframe) {
|
||||
if (sds->fluid && show_smoke) {
|
||||
float p0[3], p1[3];
|
||||
|
||||
/* get view vector */
|
||||
|
|
|
@ -83,7 +83,6 @@
|
|||
#include "BKE_node.h"
|
||||
#include "BKE_object.h"
|
||||
#include "BKE_paint.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_report.h"
|
||||
#include "BKE_rigidbody.h"
|
||||
#include "BKE_scene.h"
|
||||
|
@ -6127,8 +6126,6 @@ void special_aftertrans_update(bContext *C, TransInfo *t)
|
|||
|
||||
for (i = 0; i < t->total; i++) {
|
||||
TransData *td = t->data + i;
|
||||
ListBase pidlist;
|
||||
PTCacheID *pid;
|
||||
ob = td->ob;
|
||||
|
||||
if (td->flag & TD_NOACTION)
|
||||
|
@ -6137,17 +6134,6 @@ void special_aftertrans_update(bContext *C, TransInfo *t)
|
|||
if (td->flag & TD_SKIP)
|
||||
continue;
|
||||
|
||||
/* flag object caches as outdated */
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, t->scene, MAX_DUPLI_RECUR);
|
||||
for (pid = pidlist.first; pid; pid = pid->next) {
|
||||
pid->cache->flag |= PTCACHE_OUTDATED;
|
||||
}
|
||||
BLI_freelistN(&pidlist);
|
||||
|
||||
/* pointcache refresh */
|
||||
if (BKE_ptcache_object_reset(t->scene, ob, PTCACHE_RESET_OUTDATED))
|
||||
DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
|
||||
|
||||
/* Needed for proper updating of "quick cached" dynamics. */
|
||||
/* Creates troubles for moving animated objects without */
|
||||
/* autokey though, probably needed is an anim sys override? */
|
||||
|
|
|
@ -55,7 +55,6 @@
|
|||
#include "BKE_context.h"
|
||||
#include "BKE_curve.h"
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_editmesh.h"
|
||||
#include "BKE_lattice.h"
|
||||
|
||||
|
|
|
@ -108,8 +108,6 @@ typedef struct DynamicPaintSurface {
|
|||
struct EffectorWeights *effector_weights;
|
||||
|
||||
/* cache */
|
||||
struct PointCache *pointcache;
|
||||
struct ListBase ptcaches;
|
||||
int current_frame;
|
||||
|
||||
/* surface */
|
||||
|
|
|
@ -592,8 +592,6 @@ typedef struct ClothModifierData {
|
|||
struct Cloth *clothObject; /* The internal data structure for cloth. */
|
||||
struct ClothSimSettings *sim_parms; /* definition is in DNA_cloth_types.h */
|
||||
struct ClothCollSettings *coll_parms; /* definition is in DNA_cloth_types.h */
|
||||
struct PointCache *point_cache; /* definition is in DNA_object_force.h */
|
||||
struct ListBase ptcaches;
|
||||
/* XXX nasty hack, remove once hair can be separated from cloth modifier data */
|
||||
struct ClothHairData *hairdata;
|
||||
/* grid geometry values of hair continuum */
|
||||
|
@ -746,7 +744,6 @@ typedef struct FluidsimModifierData {
|
|||
ModifierData modifier;
|
||||
|
||||
struct FluidsimSettings *fss; /* definition is in DNA_object_fluidsim.h */
|
||||
struct PointCache *point_cache; /* definition is in DNA_object_force.h */
|
||||
} FluidsimModifierData;
|
||||
|
||||
typedef struct ShrinkwrapModifierData {
|
||||
|
|
|
@ -127,87 +127,6 @@ typedef struct EffectorWeights {
|
|||
/* EffectorWeights->flag */
|
||||
#define EFF_WEIGHT_DO_HAIR 1
|
||||
|
||||
/* Point cache file data types:
|
||||
* - used as (1<<flag) so poke jahka if you reach the limit of 15
|
||||
* - to add new data types update:
|
||||
* * BKE_ptcache_data_size()
|
||||
* * ptcache_file_init_pointers()
|
||||
*/
|
||||
#define BPHYS_DATA_INDEX 0
|
||||
#define BPHYS_DATA_LOCATION 1
|
||||
#define BPHYS_DATA_SMOKE_LOW 1
|
||||
#define BPHYS_DATA_VELOCITY 2
|
||||
#define BPHYS_DATA_SMOKE_HIGH 2
|
||||
#define BPHYS_DATA_ROTATION 3
|
||||
#define BPHYS_DATA_DYNAMICPAINT 3
|
||||
#define BPHYS_DATA_AVELOCITY 4 /* used for particles */
|
||||
#define BPHYS_DATA_XCONST 4 /* used for cloth */
|
||||
#define BPHYS_DATA_SIZE 5
|
||||
#define BPHYS_DATA_TIMES 6
|
||||
#define BPHYS_DATA_BOIDS 7
|
||||
|
||||
#define BPHYS_TOT_DATA 8
|
||||
|
||||
#define BPHYS_EXTRA_FLUID_SPRINGS 1
|
||||
|
||||
typedef struct PTCacheExtra {
|
||||
struct PTCacheExtra *next, *prev;
|
||||
unsigned int type, totdata;
|
||||
void *data;
|
||||
} PTCacheExtra;
|
||||
|
||||
typedef struct PTCacheMem {
|
||||
struct PTCacheMem *next, *prev;
|
||||
unsigned int frame, totpoint;
|
||||
unsigned int data_types, flag;
|
||||
|
||||
void *data[8]; /* BPHYS_TOT_DATA */
|
||||
void *cur[8]; /* BPHYS_TOT_DATA */
|
||||
|
||||
struct ListBase extradata;
|
||||
} PTCacheMem;
|
||||
|
||||
typedef struct PointCache {
|
||||
struct PointCache *next, *prev;
|
||||
int flag; /* generic flag */
|
||||
|
||||
int step; /* The number of frames between cached frames.
|
||||
* This should probably be an upper bound for a per point adaptive step in the future,
|
||||
* buf for now it's the same for all points. Without adaptivity this can effect the perceived
|
||||
* simulation quite a bit though. If for example particles are colliding with a horizontal
|
||||
* plane (with high damping) they quickly come to a stop on the plane, however there are still
|
||||
* forces acting on the particle (gravity and collisions), so the particle velocity isn't necessarily
|
||||
* zero for the whole duration of the frame even if the particle seems stationary. If all simulation
|
||||
* frames aren't cached (step > 1) these velocities are interpolated into movement for the non-cached
|
||||
* frames. The result will look like the point is oscillating around the collision location. So for
|
||||
* now cache step should be set to 1 for accurate reproduction of collisions.
|
||||
*/
|
||||
|
||||
int simframe; /* current frame of simulation (only if SIMULATION_VALID) */
|
||||
int startframe; /* simulation start frame */
|
||||
int endframe; /* simulation end frame */
|
||||
int editframe; /* frame being edited (runtime only) */
|
||||
int last_exact; /* last exact frame that's cached */
|
||||
int last_valid; /* used for editing cache - what is the last baked frame */
|
||||
int pad;
|
||||
|
||||
/* for external cache files */
|
||||
int totpoint; /* number of cached points */
|
||||
int index; /* modifier stack index */
|
||||
short compression, rt;
|
||||
|
||||
char name[64];
|
||||
char prev_name[64];
|
||||
char info[64];
|
||||
char path[1024]; /* file path, 1024 = FILE_MAX */
|
||||
char *cached_frames; /* array of length endframe-startframe+1 with flags to indicate cached frames */
|
||||
/* can be later used for other per frame flags too if needed */
|
||||
struct ListBase mem_cache;
|
||||
|
||||
struct PTCacheEdit *edit;
|
||||
void (*free_edit)(struct PTCacheEdit *edit); /* free callback */
|
||||
} PointCache;
|
||||
|
||||
typedef struct SBVertex {
|
||||
float vec[4];
|
||||
} SBVertex;
|
||||
|
@ -336,9 +255,6 @@ typedef struct SoftBody {
|
|||
float shearstiff;
|
||||
float inpush;
|
||||
|
||||
struct PointCache *pointcache;
|
||||
struct ListBase ptcaches;
|
||||
|
||||
struct EffectorWeights *effector_weights;
|
||||
/* reverse esimated obmatrix .. no need to store in blend file .. how ever who cares */
|
||||
float lcom[3];
|
||||
|
@ -392,31 +308,6 @@ typedef struct SoftBody {
|
|||
#define PFIELD_Z_POS 1
|
||||
#define PFIELD_Z_NEG 2
|
||||
|
||||
/* pointcache->flag */
|
||||
#define PTCACHE_BAKED 1
|
||||
#define PTCACHE_OUTDATED 2
|
||||
#define PTCACHE_SIMULATION_VALID 4
|
||||
#define PTCACHE_BAKING 8
|
||||
//#define PTCACHE_BAKE_EDIT 16
|
||||
//#define PTCACHE_BAKE_EDIT_ACTIVE 32
|
||||
#define PTCACHE_DISK_CACHE 64
|
||||
//#define PTCACHE_QUICK_CACHE 128 /* removed since 2.64 - [#30974], could be added back in a more useful way */
|
||||
#define PTCACHE_FRAMES_SKIPPED 256
|
||||
#define PTCACHE_EXTERNAL 512
|
||||
#define PTCACHE_READ_INFO 1024
|
||||
/* don't use the filename of the blendfile the data is linked from (write a local cache) */
|
||||
#define PTCACHE_IGNORE_LIBPATH 2048
|
||||
/* high resolution cache is saved for smoke for backwards compatibility, so set this flag to know it's a "fake" cache */
|
||||
#define PTCACHE_FAKE_SMOKE (1<<12)
|
||||
#define PTCACHE_IGNORE_CLEAR (1<<13)
|
||||
|
||||
/* PTCACHE_OUTDATED + PTCACHE_FRAMES_SKIPPED */
|
||||
#define PTCACHE_REDO_NEEDED 258
|
||||
|
||||
#define PTCACHE_COMPRESS_NO 0
|
||||
#define PTCACHE_COMPRESS_LZO 1
|
||||
#define PTCACHE_COMPRESS_LZMA 2
|
||||
|
||||
/* ob->softflag */
|
||||
#define OB_SB_ENABLE 1 /* deprecated, use modifier */
|
||||
#define OB_SB_GOAL 2
|
||||
|
|
|
@ -58,9 +58,6 @@ typedef struct RigidBodyWorld {
|
|||
int pad;
|
||||
float ltime; /* last frame world was evaluated for (internal) */
|
||||
|
||||
/* cache */
|
||||
struct PointCache *pointcache;
|
||||
struct ListBase ptcaches;
|
||||
int numbodies; /* number of objects in rigid body group */
|
||||
|
||||
short steps_per_second; /* number of simulation steps thaken per second */
|
||||
|
|
|
@ -146,9 +146,6 @@ typedef struct SmokeDomainSettings {
|
|||
char data_depth;
|
||||
char pad[2];
|
||||
|
||||
/* Smoke uses only one cache from now on (index [0]), but keeping the array for now for reading old files. */
|
||||
struct PointCache *point_cache[2]; /* definition is in DNA_object_force.h */
|
||||
struct ListBase ptcaches[2];
|
||||
struct EffectorWeights *effector_weights;
|
||||
int border_collisions; /* How domain border collisions are handled */
|
||||
float time_scale;
|
||||
|
|
|
@ -445,7 +445,6 @@ extern StructRNA RNA_Palette;
|
|||
extern StructRNA RNA_PaletteColor;
|
||||
extern StructRNA RNA_Panel;
|
||||
extern StructRNA RNA_PivotConstraint;
|
||||
extern StructRNA RNA_PointCache;
|
||||
extern StructRNA RNA_PointDensity;
|
||||
extern StructRNA RNA_PointDensityTexture;
|
||||
extern StructRNA RNA_PointLamp;
|
||||
|
|
|
@ -100,11 +100,6 @@ static void rna_DynamicPaint_redoModifier(Main *UNUSED(bmain), Scene *UNUSED(sce
|
|||
DAG_id_tag_update(ptr->id.data, OB_RECALC_DATA);
|
||||
}
|
||||
|
||||
static void rna_DynamicPaintSurfaces_updateFrames(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
|
||||
{
|
||||
dynamicPaint_cacheUpdateFrames((DynamicPaintSurface *)ptr->data);
|
||||
}
|
||||
|
||||
static void rna_DynamicPaintSurface_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
|
||||
{
|
||||
dynamicPaint_resetSurface(scene, (DynamicPaintSurface *)ptr->data);
|
||||
|
@ -183,20 +178,20 @@ static void rna_DynamicPaint_surfaces_begin(CollectionPropertyIterator *iter, Po
|
|||
rna_iterator_listbase_begin(iter, &canvas->surfaces, NULL);
|
||||
}
|
||||
|
||||
static int rna_Surface_active_point_index_get(PointerRNA *ptr)
|
||||
static int rna_Surface_active_index_get(PointerRNA *ptr)
|
||||
{
|
||||
DynamicPaintCanvasSettings *canvas = (DynamicPaintCanvasSettings *)ptr->data;
|
||||
return canvas->active_sur;
|
||||
}
|
||||
|
||||
static void rna_Surface_active_point_index_set(struct PointerRNA *ptr, int value)
|
||||
static void rna_Surface_active_index_set(struct PointerRNA *ptr, int value)
|
||||
{
|
||||
DynamicPaintCanvasSettings *canvas = (DynamicPaintCanvasSettings *)ptr->data;
|
||||
canvas->active_sur = value;
|
||||
return;
|
||||
}
|
||||
|
||||
static void rna_Surface_active_point_range(PointerRNA *ptr, int *min, int *max,
|
||||
static void rna_Surface_active_range(PointerRNA *ptr, int *min, int *max,
|
||||
int *UNUSED(softmin), int *UNUSED(softmax))
|
||||
{
|
||||
DynamicPaintCanvasSettings *canvas = (DynamicPaintCanvasSettings *)ptr->data;
|
||||
|
@ -221,7 +216,7 @@ static void rna_DynamicPaint_uvlayer_set(PointerRNA *ptr, const char *value)
|
|||
}
|
||||
}
|
||||
|
||||
/* is point cache used */
|
||||
/* is cache used */
|
||||
static int rna_DynamicPaint_is_cache_user_get(PointerRNA *ptr)
|
||||
{
|
||||
DynamicPaintSurface *surface = (DynamicPaintSurface *)ptr->data;
|
||||
|
@ -310,9 +305,9 @@ static void rna_def_canvas_surfaces(BlenderRNA *brna, PropertyRNA *cprop)
|
|||
|
||||
prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
|
||||
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
|
||||
RNA_def_property_int_funcs(prop, "rna_Surface_active_point_index_get", "rna_Surface_active_point_index_set",
|
||||
"rna_Surface_active_point_range");
|
||||
RNA_def_property_ui_text(prop, "Active Point Cache Index", "");
|
||||
RNA_def_property_int_funcs(prop, "rna_Surface_active_index_get", "rna_Surface_active_index_set",
|
||||
"rna_Surface_active_range");
|
||||
RNA_def_property_ui_text(prop, "Active Surface Index", "");
|
||||
|
||||
prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
|
||||
RNA_def_property_struct_type(prop, "DynamicPaintSurface");
|
||||
|
@ -472,7 +467,7 @@ static void rna_def_canvas_surface(BlenderRNA *brna)
|
|||
RNA_def_property_range(prop, 1.0, MAXFRAMEF);
|
||||
RNA_def_property_ui_range(prop, 1.0, 9999, 1, -1);
|
||||
RNA_def_property_ui_text(prop, "Start Frame", "Simulation start frame");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_DynamicPaintSurfaces_updateFrames");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_NONE);
|
||||
RNA_def_property_int_sdna(prop, NULL, "end_frame");
|
||||
|
@ -480,7 +475,7 @@ static void rna_def_canvas_surface(BlenderRNA *brna)
|
|||
RNA_def_property_range(prop, 1.0, MAXFRAMEF);
|
||||
RNA_def_property_ui_range(prop, 1.0, 9999.0, 1, -1);
|
||||
RNA_def_property_ui_text(prop, "End Frame", "Simulation end frame");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_DynamicPaintSurfaces_updateFrames");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "frame_substeps", PROP_INT, PROP_NONE);
|
||||
RNA_def_property_int_sdna(prop, NULL, "substeps");
|
||||
|
@ -721,13 +716,6 @@ static void rna_def_canvas_surface(BlenderRNA *brna)
|
|||
RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_DPAINT_WAVE_OPEN_BORDERS);
|
||||
RNA_def_property_ui_text(prop, "Open Borders", "Pass waves through mesh edges");
|
||||
|
||||
|
||||
/* cache */
|
||||
prop = RNA_def_property(srna, "point_cache", PROP_POINTER, PROP_NONE);
|
||||
RNA_def_property_flag(prop, PROP_NEVER_NULL);
|
||||
RNA_def_property_pointer_sdna(prop, NULL, "pointcache");
|
||||
RNA_def_property_ui_text(prop, "Point Cache", "");
|
||||
|
||||
/* is cache used */
|
||||
prop = RNA_def_property(srna, "is_cache_user", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_funcs(prop, "rna_DynamicPaint_is_cache_user_get", NULL);
|
||||
|
|
|
@ -51,7 +51,6 @@
|
|||
#include "BKE_global.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_pointcache.h"
|
||||
|
||||
static StructRNA *rna_FluidSettings_refine(struct PointerRNA *ptr)
|
||||
{
|
||||
|
|
|
@ -690,12 +690,6 @@ static PointerRNA rna_SoftBodyModifier_settings_get(PointerRNA *ptr)
|
|||
return rna_pointer_inherit_refine(ptr, &RNA_SoftBodySettings, ob->soft);
|
||||
}
|
||||
|
||||
static PointerRNA rna_SoftBodyModifier_point_cache_get(PointerRNA *ptr)
|
||||
{
|
||||
Object *ob = (Object *)ptr->id.data;
|
||||
return rna_pointer_inherit_refine(ptr, &RNA_PointCache, ob->soft->pointcache);
|
||||
}
|
||||
|
||||
static PointerRNA rna_CollisionModifier_settings_get(PointerRNA *ptr)
|
||||
{
|
||||
Object *ob = (Object *)ptr->id.data;
|
||||
|
@ -1858,12 +1852,6 @@ static void rna_def_modifier_softbody(BlenderRNA *brna)
|
|||
RNA_def_property_struct_type(prop, "SoftBodySettings");
|
||||
RNA_def_property_pointer_funcs(prop, "rna_SoftBodyModifier_settings_get", NULL, NULL, NULL);
|
||||
RNA_def_property_ui_text(prop, "Soft Body Settings", "");
|
||||
|
||||
prop = RNA_def_property(srna, "point_cache", PROP_POINTER, PROP_NONE);
|
||||
RNA_def_property_flag(prop, PROP_NEVER_NULL);
|
||||
RNA_def_property_struct_type(prop, "PointCache");
|
||||
RNA_def_property_pointer_funcs(prop, "rna_SoftBodyModifier_point_cache_get", NULL, NULL, NULL);
|
||||
RNA_def_property_ui_text(prop, "Soft Body Point Cache", "");
|
||||
}
|
||||
|
||||
static void rna_def_modifier_boolean(BlenderRNA *brna)
|
||||
|
@ -2612,10 +2600,6 @@ static void rna_def_modifier_cloth(BlenderRNA *brna)
|
|||
RNA_def_property_struct_type(prop, "ClothSolverResult");
|
||||
RNA_def_property_pointer_sdna(prop, NULL, "solver_result");
|
||||
RNA_def_property_ui_text(prop, "Solver Result", "");
|
||||
|
||||
prop = RNA_def_property(srna, "point_cache", PROP_POINTER, PROP_NONE);
|
||||
RNA_def_property_flag(prop, PROP_NEVER_NULL);
|
||||
RNA_def_property_ui_text(prop, "Point Cache", "");
|
||||
|
||||
prop = RNA_def_property(srna, "hair_grid_min", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_float_sdna(prop, NULL, "hair_grid_min");
|
||||
|
|
|
@ -90,231 +90,16 @@ static EnumPropertyItem empty_vortex_shape_items[] = {
|
|||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
#include "DNA_dynamicpaint_types.h"
|
||||
#include "DNA_modifier_types.h"
|
||||
#include "DNA_texture_types.h"
|
||||
|
||||
#include "BKE_context.h"
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_depsgraph.h"
|
||||
|
||||
#include "ED_object.h"
|
||||
|
||||
static void rna_Cache_change(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
|
||||
{
|
||||
Object *ob = (Object *)ptr->id.data;
|
||||
PointCache *cache = (PointCache *)ptr->data;
|
||||
PTCacheID *pid = NULL;
|
||||
ListBase pidlist;
|
||||
|
||||
if (!ob)
|
||||
return;
|
||||
|
||||
cache->flag |= PTCACHE_OUTDATED;
|
||||
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, NULL, 0);
|
||||
|
||||
DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
|
||||
|
||||
for (pid = pidlist.first; pid; pid = pid->next) {
|
||||
if (pid->cache == cache)
|
||||
break;
|
||||
}
|
||||
|
||||
if (pid) {
|
||||
/* Just make sure this wasn't changed. */
|
||||
if (pid->type == PTCACHE_TYPE_SMOKE_DOMAIN)
|
||||
cache->step = 1;
|
||||
BKE_ptcache_update_info(pid);
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
}
|
||||
|
||||
static void rna_Cache_toggle_disk_cache(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
|
||||
{
|
||||
Object *ob = (Object *)ptr->id.data;
|
||||
PointCache *cache = (PointCache *)ptr->data;
|
||||
PTCacheID *pid = NULL;
|
||||
ListBase pidlist;
|
||||
|
||||
if (!ob)
|
||||
return;
|
||||
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, NULL, 0);
|
||||
|
||||
for (pid = pidlist.first; pid; pid = pid->next) {
|
||||
if (pid->cache == cache)
|
||||
break;
|
||||
}
|
||||
|
||||
/* smoke can only use disk cache */
|
||||
if (pid && pid->type != PTCACHE_TYPE_SMOKE_DOMAIN)
|
||||
BKE_ptcache_toggle_disk_cache(pid);
|
||||
else
|
||||
cache->flag ^= PTCACHE_DISK_CACHE;
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
}
|
||||
|
||||
static void rna_Cache_idname_change(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
|
||||
{
|
||||
Object *ob = (Object *)ptr->id.data;
|
||||
PointCache *cache = (PointCache *)ptr->data;
|
||||
PTCacheID *pid = NULL, *pid2 = NULL;
|
||||
ListBase pidlist;
|
||||
bool use_new_name = true;
|
||||
|
||||
if (!ob)
|
||||
return;
|
||||
|
||||
/* TODO: check for proper characters */
|
||||
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, NULL, 0);
|
||||
|
||||
if (cache->flag & PTCACHE_EXTERNAL) {
|
||||
for (pid = pidlist.first; pid; pid = pid->next) {
|
||||
if (pid->cache == cache)
|
||||
break;
|
||||
}
|
||||
|
||||
if (!pid)
|
||||
return;
|
||||
|
||||
BKE_ptcache_load_external(pid);
|
||||
|
||||
DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
|
||||
WM_main_add_notifier(NC_OBJECT | ND_POINTCACHE, ob);
|
||||
}
|
||||
else {
|
||||
for (pid = pidlist.first; pid; pid = pid->next) {
|
||||
if (pid->cache == cache)
|
||||
pid2 = pid;
|
||||
else if (cache->name[0] != '\0' && STREQ(cache->name, pid->cache->name)) {
|
||||
/*TODO: report "name exists" to user */
|
||||
BLI_strncpy(cache->name, cache->prev_name, sizeof(cache->name));
|
||||
use_new_name = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (use_new_name) {
|
||||
if (pid2 && cache->flag & PTCACHE_DISK_CACHE) {
|
||||
char old_name[80];
|
||||
char new_name[80];
|
||||
|
||||
BLI_strncpy(old_name, cache->prev_name, sizeof(old_name));
|
||||
BLI_strncpy(new_name, cache->name, sizeof(new_name));
|
||||
|
||||
BKE_ptcache_disk_cache_rename(pid2, old_name, new_name);
|
||||
}
|
||||
|
||||
BLI_strncpy(cache->prev_name, cache->name, sizeof(cache->prev_name));
|
||||
}
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
}
|
||||
|
||||
static void rna_Cache_list_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
|
||||
{
|
||||
PointCache *cache = ptr->data;
|
||||
ListBase lb;
|
||||
|
||||
while (cache->prev)
|
||||
cache = cache->prev;
|
||||
|
||||
lb.first = cache;
|
||||
lb.last = NULL; /* not used by listbase_begin */
|
||||
|
||||
rna_iterator_listbase_begin(iter, &lb, NULL);
|
||||
}
|
||||
static void rna_Cache_active_point_cache_index_range(PointerRNA *ptr, int *min, int *max,
|
||||
int *UNUSED(softmin), int *UNUSED(softmax))
|
||||
{
|
||||
Object *ob = ptr->id.data;
|
||||
PointCache *cache = ptr->data;
|
||||
PTCacheID *pid;
|
||||
ListBase pidlist;
|
||||
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, NULL, 0);
|
||||
|
||||
*min = 0;
|
||||
*max = 0;
|
||||
|
||||
for (pid = pidlist.first; pid; pid = pid->next) {
|
||||
if (pid->cache == cache) {
|
||||
*max = max_ii(0, BLI_listbase_count(pid->ptcaches) - 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
}
|
||||
|
||||
static int rna_Cache_active_point_cache_index_get(PointerRNA *ptr)
|
||||
{
|
||||
Object *ob = ptr->id.data;
|
||||
PointCache *cache = ptr->data;
|
||||
PTCacheID *pid;
|
||||
ListBase pidlist;
|
||||
int num = 0;
|
||||
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, NULL, 0);
|
||||
|
||||
for (pid = pidlist.first; pid; pid = pid->next) {
|
||||
if (pid->cache == cache) {
|
||||
num = BLI_findindex(pid->ptcaches, cache);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
|
||||
return num;
|
||||
}
|
||||
|
||||
static void rna_Cache_active_point_cache_index_set(struct PointerRNA *ptr, int value)
|
||||
{
|
||||
Object *ob = ptr->id.data;
|
||||
PointCache *cache = ptr->data;
|
||||
PTCacheID *pid;
|
||||
ListBase pidlist;
|
||||
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, NULL, 0);
|
||||
|
||||
for (pid = pidlist.first; pid; pid = pid->next) {
|
||||
if (pid->cache == cache) {
|
||||
*(pid->cache_ptr) = BLI_findlink(pid->ptcaches, value);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
}
|
||||
|
||||
static void rna_PointCache_frame_step_range(PointerRNA *ptr, int *min, int *max,
|
||||
int *UNUSED(softmin), int *UNUSED(softmax))
|
||||
{
|
||||
Object *ob = ptr->id.data;
|
||||
PointCache *cache = ptr->data;
|
||||
PTCacheID *pid;
|
||||
ListBase pidlist;
|
||||
|
||||
*min = 1;
|
||||
*max = 20;
|
||||
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, NULL, 0);
|
||||
|
||||
for (pid = pidlist.first; pid; pid = pid->next) {
|
||||
if (pid->cache == cache) {
|
||||
*max = pid->max_step;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
}
|
||||
|
||||
static char *rna_CollisionSettings_path(PointerRNA *UNUSED(ptr))
|
||||
{
|
||||
/* both methods work ok, but return the shorter path */
|
||||
|
@ -555,18 +340,8 @@ static void rna_EffectorWeight_update(Main *UNUSED(bmain), Scene *UNUSED(scene),
|
|||
{
|
||||
ID *id = ptr->id.data;
|
||||
|
||||
if (id && GS(id->name) == ID_SCE) {
|
||||
Scene *scene = (Scene *)id;
|
||||
Base *base;
|
||||
|
||||
for (base = scene->base.first; base; base = base->next) {
|
||||
BKE_ptcache_object_reset(scene, base->object, PTCACHE_RESET_DEPSGRAPH);
|
||||
}
|
||||
}
|
||||
else {
|
||||
DAG_id_tag_update(id, OB_RECALC_DATA);
|
||||
WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
|
||||
}
|
||||
DAG_id_tag_update(id, OB_RECALC_DATA);
|
||||
WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
|
||||
}
|
||||
|
||||
static void rna_EffectorWeight_dependency_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
|
||||
|
@ -703,140 +478,6 @@ static EnumPropertyItem *rna_Effector_shape_itemf(bContext *UNUSED(C), PointerRN
|
|||
|
||||
#else
|
||||
|
||||
/* ptcache.point_caches */
|
||||
static void rna_def_ptcache_point_caches(BlenderRNA *brna, PropertyRNA *cprop)
|
||||
{
|
||||
StructRNA *srna;
|
||||
PropertyRNA *prop;
|
||||
|
||||
/* FunctionRNA *func; */
|
||||
/* PropertyRNA *parm; */
|
||||
|
||||
RNA_def_property_srna(cprop, "PointCaches");
|
||||
srna = RNA_def_struct(brna, "PointCaches", NULL);
|
||||
RNA_def_struct_sdna(srna, "PointCache");
|
||||
RNA_def_struct_ui_text(srna, "Point Caches", "Collection of point caches");
|
||||
|
||||
prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
|
||||
RNA_def_property_int_funcs(prop, "rna_Cache_active_point_cache_index_get",
|
||||
"rna_Cache_active_point_cache_index_set",
|
||||
"rna_Cache_active_point_cache_index_range");
|
||||
RNA_def_property_ui_text(prop, "Active Point Cache Index", "");
|
||||
RNA_def_property_update(prop, NC_OBJECT, "rna_Cache_change");
|
||||
}
|
||||
|
||||
static void rna_def_pointcache(BlenderRNA *brna)
|
||||
{
|
||||
StructRNA *srna;
|
||||
PropertyRNA *prop;
|
||||
|
||||
static EnumPropertyItem point_cache_compress_items[] = {
|
||||
{PTCACHE_COMPRESS_NO, "NO", 0, "No", "No compression"},
|
||||
{PTCACHE_COMPRESS_LZO, "LIGHT", 0, "Light", "Fast but not so effective compression"},
|
||||
{PTCACHE_COMPRESS_LZMA, "HEAVY", 0, "Heavy", "Effective but slow compression"},
|
||||
{0, NULL, 0, NULL, NULL}
|
||||
};
|
||||
|
||||
srna = RNA_def_struct(brna, "PointCache", NULL);
|
||||
RNA_def_struct_ui_text(srna, "Point Cache", "Point cache for physics simulations");
|
||||
RNA_def_struct_ui_icon(srna, ICON_PHYSICS);
|
||||
|
||||
prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
|
||||
RNA_def_property_int_sdna(prop, NULL, "startframe");
|
||||
RNA_def_property_range(prop, -MAXFRAME, MAXFRAME);
|
||||
RNA_def_property_ui_range(prop, 1, MAXFRAME, 1, 1);
|
||||
RNA_def_property_ui_text(prop, "Start", "Frame on which the simulation starts");
|
||||
|
||||
prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_TIME);
|
||||
RNA_def_property_int_sdna(prop, NULL, "endframe");
|
||||
RNA_def_property_range(prop, 1, MAXFRAME);
|
||||
RNA_def_property_ui_text(prop, "End", "Frame on which the simulation stops");
|
||||
|
||||
prop = RNA_def_property(srna, "frame_step", PROP_INT, PROP_NONE);
|
||||
RNA_def_property_int_sdna(prop, NULL, "step");
|
||||
RNA_def_property_range(prop, 1, 20);
|
||||
RNA_def_property_int_funcs(prop, NULL, NULL, "rna_PointCache_frame_step_range");
|
||||
RNA_def_property_ui_text(prop, "Cache Step", "Number of frames between cached frames");
|
||||
RNA_def_property_update(prop, NC_OBJECT, "rna_Cache_change");
|
||||
|
||||
prop = RNA_def_property(srna, "index", PROP_INT, PROP_NONE);
|
||||
RNA_def_property_int_sdna(prop, NULL, "index");
|
||||
RNA_def_property_range(prop, -1, 100);
|
||||
RNA_def_property_ui_text(prop, "Cache Index", "Index number of cache files");
|
||||
RNA_def_property_update(prop, NC_OBJECT, "rna_Cache_idname_change");
|
||||
|
||||
prop = RNA_def_property(srna, "compression", PROP_ENUM, PROP_NONE);
|
||||
RNA_def_property_enum_items(prop, point_cache_compress_items);
|
||||
RNA_def_property_ui_text(prop, "Cache Compression", "Compression method to be used");
|
||||
|
||||
/* flags */
|
||||
prop = RNA_def_property(srna, "is_baked", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", PTCACHE_BAKED);
|
||||
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
|
||||
|
||||
prop = RNA_def_property(srna, "is_baking", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", PTCACHE_BAKING);
|
||||
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
|
||||
|
||||
prop = RNA_def_property(srna, "use_disk_cache", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", PTCACHE_DISK_CACHE);
|
||||
RNA_def_property_ui_text(prop, "Disk Cache", "Save cache files to disk (.blend file must be saved first)");
|
||||
RNA_def_property_update(prop, NC_OBJECT, "rna_Cache_toggle_disk_cache");
|
||||
|
||||
prop = RNA_def_property(srna, "is_outdated", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", PTCACHE_OUTDATED);
|
||||
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
|
||||
RNA_def_property_ui_text(prop, "Cache is outdated", "");
|
||||
|
||||
prop = RNA_def_property(srna, "is_frame_skip", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", PTCACHE_FRAMES_SKIPPED);
|
||||
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
|
||||
|
||||
prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
|
||||
RNA_def_property_string_sdna(prop, NULL, "name");
|
||||
RNA_def_property_ui_text(prop, "Name", "Cache name");
|
||||
RNA_def_property_update(prop, NC_OBJECT, "rna_Cache_idname_change");
|
||||
RNA_def_struct_name_property(srna, prop);
|
||||
|
||||
prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_DIRPATH);
|
||||
RNA_def_property_string_sdna(prop, NULL, "path");
|
||||
RNA_def_property_ui_text(prop, "File Path", "Cache file path");
|
||||
RNA_def_property_update(prop, NC_OBJECT, "rna_Cache_idname_change");
|
||||
|
||||
/* removed, see PTCACHE_QUICK_CACHE */
|
||||
#if 0
|
||||
prop = RNA_def_property(srna, "use_quick_cache", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", PTCACHE_QUICK_CACHE);
|
||||
RNA_def_property_ui_text(prop, "Quick Cache", "Update simulation with cache steps");
|
||||
RNA_def_property_update(prop, NC_OBJECT, "rna_Cache_change");
|
||||
#endif
|
||||
|
||||
prop = RNA_def_property(srna, "info", PROP_STRING, PROP_NONE);
|
||||
RNA_def_property_string_sdna(prop, NULL, "info");
|
||||
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
|
||||
RNA_def_property_ui_text(prop, "Cache Info", "Info on current cache status");
|
||||
|
||||
prop = RNA_def_property(srna, "use_external", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", PTCACHE_EXTERNAL);
|
||||
RNA_def_property_ui_text(prop, "External", "Read cache from an external location");
|
||||
RNA_def_property_update(prop, NC_OBJECT, "rna_Cache_idname_change");
|
||||
|
||||
prop = RNA_def_property(srna, "use_library_path", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", PTCACHE_IGNORE_LIBPATH);
|
||||
RNA_def_property_ui_text(prop, "Library Path",
|
||||
"Use this file's path for the disk cache when library linked into another file "
|
||||
"(for local bakes per scene file, disable this option)");
|
||||
RNA_def_property_update(prop, NC_OBJECT, "rna_Cache_idname_change");
|
||||
|
||||
prop = RNA_def_property(srna, "point_caches", PROP_COLLECTION, PROP_NONE);
|
||||
RNA_def_property_collection_funcs(prop, "rna_Cache_list_begin", "rna_iterator_listbase_next",
|
||||
"rna_iterator_listbase_end", "rna_iterator_listbase_get",
|
||||
NULL, NULL, NULL, NULL);
|
||||
RNA_def_property_struct_type(prop, "PointCache");
|
||||
RNA_def_property_ui_text(prop, "Point Cache List", "Point cache list");
|
||||
rna_def_ptcache_point_caches(brna, prop);
|
||||
}
|
||||
|
||||
static void rna_def_collision(BlenderRNA *brna)
|
||||
{
|
||||
StructRNA *srna;
|
||||
|
@ -1801,7 +1442,6 @@ static void rna_def_softbody(BlenderRNA *brna)
|
|||
|
||||
void RNA_def_object_force(BlenderRNA *brna)
|
||||
{
|
||||
rna_def_pointcache(brna);
|
||||
rna_def_collision(brna);
|
||||
rna_def_effector_weight(brna);
|
||||
rna_def_field(brna);
|
||||
|
|
|
@ -109,8 +109,7 @@ static EnumPropertyItem rigidbody_mesh_source_items[] = {
|
|||
static void rna_RigidBodyWorld_reset(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
|
||||
{
|
||||
RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data;
|
||||
|
||||
BKE_rigidbody_cache_reset(rbw);
|
||||
UNUSED_VARS(rbw);
|
||||
}
|
||||
|
||||
static char *rna_RigidBodyWorld_path(PointerRNA *UNUSED(ptr))
|
||||
|
@ -149,10 +148,10 @@ static void rna_RigidBodyWorld_split_impulse_set(PointerRNA *ptr, int value)
|
|||
static void rna_RigidBodyOb_reset(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
|
||||
{
|
||||
RigidBodyWorld *rbw = scene->rigidbody_world;
|
||||
|
||||
BKE_rigidbody_cache_reset(rbw);
|
||||
UNUSED_VARS(rbw);
|
||||
}
|
||||
|
||||
|
||||
static void rna_RigidBodyOb_shape_update(Main *bmain, Scene *scene, PointerRNA *ptr)
|
||||
{
|
||||
Object *ob = ptr->id.data;
|
||||
|
@ -162,12 +161,10 @@ static void rna_RigidBodyOb_shape_update(Main *bmain, Scene *scene, PointerRNA *
|
|||
WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
|
||||
}
|
||||
|
||||
static void rna_RigidBodyOb_shape_reset(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
|
||||
static void rna_RigidBodyOb_shape_reset(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
|
||||
{
|
||||
RigidBodyWorld *rbw = scene->rigidbody_world;
|
||||
RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
|
||||
|
||||
BKE_rigidbody_cache_reset(rbw);
|
||||
if (rbo->physics_shape)
|
||||
rbo->flag |= RBO_FLAG_NEEDS_RESHAPE;
|
||||
}
|
||||
|
@ -721,12 +718,6 @@ static void rna_def_rigidbody_world(BlenderRNA *brna)
|
|||
"stability a little so use only when necessary)");
|
||||
RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
|
||||
|
||||
/* cache */
|
||||
prop = RNA_def_property(srna, "point_cache", PROP_POINTER, PROP_NONE);
|
||||
RNA_def_property_flag(prop, PROP_NEVER_NULL);
|
||||
RNA_def_property_pointer_sdna(prop, NULL, "pointcache");
|
||||
RNA_def_property_ui_text(prop, "Point Cache", "");
|
||||
|
||||
/* effector weights */
|
||||
prop = RNA_def_property(srna, "effector_weights", PROP_POINTER, PROP_NONE);
|
||||
RNA_def_property_struct_type(prop, "EffectorWeights");
|
||||
|
|
|
@ -422,7 +422,6 @@ EnumPropertyItem rna_enum_bake_pass_filter_type_items[] = {
|
|||
#include "BKE_image.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_node.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_scene.h"
|
||||
#include "BKE_depsgraph.h"
|
||||
#include "BKE_mesh.h"
|
||||
|
@ -1511,15 +1510,6 @@ static void rna_Scene_use_nodes_update(bContext *C, PointerRNA *ptr)
|
|||
ED_node_composit_default(C, scene);
|
||||
}
|
||||
|
||||
static void rna_Physics_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
|
||||
{
|
||||
Scene *scene = (Scene *)ptr->id.data;
|
||||
Base *base;
|
||||
|
||||
for (base = scene->base.first; base; base = base->next)
|
||||
BKE_ptcache_object_reset(scene, base->object, PTCACHE_RESET_DEPSGRAPH);
|
||||
}
|
||||
|
||||
static void rna_Scene_editmesh_select_mode_set(PointerRNA *ptr, const int *value)
|
||||
{
|
||||
Scene *scene = (Scene *)ptr->id.data;
|
||||
|
@ -6668,12 +6658,10 @@ void RNA_def_scene(BlenderRNA *brna)
|
|||
RNA_def_property_array(prop, 3);
|
||||
RNA_def_property_ui_range(prop, -200.0f, 200.0f, 1, 2);
|
||||
RNA_def_property_ui_text(prop, "Gravity", "Constant acceleration in a given direction");
|
||||
RNA_def_property_update(prop, 0, "rna_Physics_update");
|
||||
|
||||
prop = RNA_def_property(srna, "use_gravity", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "physics_settings.flag", PHYS_GLOBAL_GRAVITY);
|
||||
RNA_def_property_ui_text(prop, "Global Gravity", "Use global gravity for all dynamics");
|
||||
RNA_def_property_update(prop, 0, "rna_Physics_update");
|
||||
|
||||
/* Render Data */
|
||||
prop = RNA_def_property(srna, "render", PROP_POINTER, PROP_NONE);
|
||||
|
|
|
@ -80,7 +80,6 @@ EnumPropertyItem rna_enum_symmetrize_direction_items[] = {
|
|||
|
||||
#include "BKE_context.h"
|
||||
#include "BKE_DerivedMesh.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_depsgraph.h"
|
||||
#include "BKE_pbvh.h"
|
||||
|
||||
|
|
|
@ -35,7 +35,6 @@
|
|||
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_smoke.h"
|
||||
#include "BKE_pointcache.h"
|
||||
|
||||
#include "BLI_threads.h"
|
||||
|
||||
|
@ -67,20 +66,11 @@ static void rna_Smoke_dependency_update(Main *bmain, Scene *scene, PointerRNA *p
|
|||
DAG_relations_tag_update(bmain);
|
||||
}
|
||||
|
||||
static void rna_Smoke_resetCache(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
|
||||
{
|
||||
SmokeDomainSettings *settings = (SmokeDomainSettings *)ptr->data;
|
||||
if (settings->smd && settings->smd->domain)
|
||||
settings->point_cache[0]->flag |= PTCACHE_OUTDATED;
|
||||
DAG_id_tag_update(ptr->id.data, OB_RECALC_DATA);
|
||||
}
|
||||
|
||||
static void rna_Smoke_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
|
||||
{
|
||||
SmokeDomainSettings *settings = (SmokeDomainSettings *)ptr->data;
|
||||
|
||||
smokeModifier_reset(settings->smd);
|
||||
rna_Smoke_resetCache(bmain, scene, ptr);
|
||||
|
||||
rna_Smoke_update(bmain, scene, ptr);
|
||||
}
|
||||
|
@ -91,9 +81,6 @@ static void rna_Smoke_reset_dependency(Main *bmain, Scene *scene, PointerRNA *pt
|
|||
|
||||
smokeModifier_reset(settings->smd);
|
||||
|
||||
if (settings->smd && settings->smd->domain)
|
||||
settings->smd->domain->point_cache[0]->flag |= PTCACHE_OUTDATED;
|
||||
|
||||
rna_Smoke_dependency_update(bmain, scene, ptr);
|
||||
}
|
||||
|
||||
|
@ -392,12 +379,6 @@ static void rna_def_smoke_domain_settings(BlenderRNA *brna)
|
|||
{ 0, NULL, 0, NULL, NULL }
|
||||
};
|
||||
|
||||
static EnumPropertyItem smoke_cache_comp_items[] = {
|
||||
{SM_CACHE_LIGHT, "CACHELIGHT", 0, "Light", "Fast but not so effective compression"},
|
||||
{SM_CACHE_HEAVY, "CACHEHEAVY", 0, "Heavy", "Effective but slow compression"},
|
||||
{0, NULL, 0, NULL, NULL}
|
||||
};
|
||||
|
||||
static EnumPropertyItem smoke_highres_sampling_items[] = {
|
||||
{SM_HRES_FULLSAMPLE, "FULLSAMPLE", 0, "Full Sample", ""},
|
||||
{SM_HRES_LINEAR, "LINEAR", 0, "Linear", ""},
|
||||
|
@ -419,14 +400,6 @@ static void rna_def_smoke_domain_settings(BlenderRNA *brna)
|
|||
{0, NULL, 0, NULL, NULL}
|
||||
};
|
||||
|
||||
static EnumPropertyItem cache_file_type_items[] = {
|
||||
{PTCACHE_FILE_PTCACHE, "POINTCACHE", 0, "Point Cache", "Blender specific point cache file format"},
|
||||
#ifdef WITH_OPENVDB
|
||||
{PTCACHE_FILE_OPENVDB, "OPENVDB", 0, "OpenVDB", "OpenVDB file format"},
|
||||
#endif
|
||||
{0, NULL, 0, NULL, NULL}
|
||||
};
|
||||
|
||||
srna = RNA_def_struct(brna, "SmokeDomainSettings", NULL);
|
||||
RNA_def_struct_ui_text(srna, "Domain Settings", "Smoke domain settings");
|
||||
RNA_def_struct_sdna(srna, "SmokeDomainSettings");
|
||||
|
@ -472,7 +445,7 @@ static void rna_def_smoke_domain_settings(BlenderRNA *brna)
|
|||
RNA_def_property_ui_range(prop, -5.0, 5.0, 0.02, 5);
|
||||
RNA_def_property_ui_text(prop, "Density",
|
||||
"How much density affects smoke motion (higher value results in faster rising smoke)");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "beta", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_float_sdna(prop, NULL, "beta");
|
||||
|
@ -480,7 +453,7 @@ static void rna_def_smoke_domain_settings(BlenderRNA *brna)
|
|||
RNA_def_property_ui_range(prop, -5.0, 5.0, 0.02, 5);
|
||||
RNA_def_property_ui_text(prop, "Heat",
|
||||
"How much heat affects smoke motion (higher value results in faster rising smoke)");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "collision_group", PROP_POINTER, PROP_NONE);
|
||||
RNA_def_property_pointer_sdna(prop, NULL, "coll_group");
|
||||
|
@ -508,34 +481,24 @@ static void rna_def_smoke_domain_settings(BlenderRNA *brna)
|
|||
RNA_def_property_range(prop, 0.0, 10.0);
|
||||
RNA_def_property_ui_range(prop, 0.0, 10.0, 1, 2);
|
||||
RNA_def_property_ui_text(prop, "Strength", "Strength of noise");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "dissolve_speed", PROP_INT, PROP_NONE);
|
||||
RNA_def_property_int_sdna(prop, NULL, "diss_speed");
|
||||
RNA_def_property_range(prop, 1.0, 10000.0);
|
||||
RNA_def_property_ui_range(prop, 1.0, 10000.0, 1, -1);
|
||||
RNA_def_property_ui_text(prop, "Dissolve Speed", "Dissolve Speed");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "use_dissolve_smoke", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_DISSOLVE);
|
||||
RNA_def_property_ui_text(prop, "Dissolve Smoke", "Enable smoke to disappear over time");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "use_dissolve_smoke_log", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_DISSOLVE_LOG);
|
||||
RNA_def_property_ui_text(prop, "Logarithmic dissolve", "Using 1/x ");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
|
||||
prop = RNA_def_property(srna, "point_cache", PROP_POINTER, PROP_NONE);
|
||||
RNA_def_property_flag(prop, PROP_NEVER_NULL);
|
||||
RNA_def_property_pointer_sdna(prop, NULL, "point_cache[0]");
|
||||
RNA_def_property_ui_text(prop, "Point Cache", "");
|
||||
|
||||
prop = RNA_def_property(srna, "point_cache_compress_type", PROP_ENUM, PROP_NONE);
|
||||
RNA_def_property_enum_sdna(prop, NULL, "cache_comp");
|
||||
RNA_def_property_enum_items(prop, smoke_cache_comp_items);
|
||||
RNA_def_property_ui_text(prop, "Cache Compression", "Compression method to be used");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "openvdb_cache_compress_type", PROP_ENUM, PROP_NONE);
|
||||
RNA_def_property_enum_sdna(prop, NULL, "openvdb_comp");
|
||||
|
@ -565,21 +528,21 @@ static void rna_def_smoke_domain_settings(BlenderRNA *brna)
|
|||
prop = RNA_def_property(srna, "highres_sampling", PROP_ENUM, PROP_NONE);
|
||||
RNA_def_property_enum_items(prop, smoke_highres_sampling_items);
|
||||
RNA_def_property_ui_text(prop, "Emitter", "Method for sampling the high resolution flow");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "time_scale", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_float_sdna(prop, NULL, "time_scale");
|
||||
RNA_def_property_range(prop, 0.2, 1.5);
|
||||
RNA_def_property_ui_range(prop, 0.2, 1.5, 0.02, 5);
|
||||
RNA_def_property_ui_text(prop, "Time Scale", "Adjust simulation speed");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "vorticity", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_float_sdna(prop, NULL, "vorticity");
|
||||
RNA_def_property_range(prop, 0.01, 4.0);
|
||||
RNA_def_property_ui_range(prop, 0.01, 4.0, 0.02, 5);
|
||||
RNA_def_property_ui_text(prop, "Vorticity", "Amount of turbulence/rotation in fluid");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "density_grid", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_array(prop, 32);
|
||||
|
@ -639,36 +602,36 @@ static void rna_def_smoke_domain_settings(BlenderRNA *brna)
|
|||
RNA_def_property_range(prop, 0.01, 4.0);
|
||||
RNA_def_property_ui_range(prop, 0.01, 2.0, 1.0, 5);
|
||||
RNA_def_property_ui_text(prop, "Speed", "Speed of the burning reaction (use larger values for smaller flame)");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "flame_smoke", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_range(prop, 0.0, 8.0);
|
||||
RNA_def_property_ui_range(prop, 0.0, 4.0, 1.0, 5);
|
||||
RNA_def_property_ui_text(prop, "Smoke", "Amount of smoke created by burning fuel");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "flame_vorticity", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_range(prop, 0.0, 2.0);
|
||||
RNA_def_property_ui_range(prop, 0.0, 1.0, 1.0, 5);
|
||||
RNA_def_property_ui_text(prop, "Vorticity", "Additional vorticity for the flames");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "flame_ignition", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_range(prop, 0.5, 5.0);
|
||||
RNA_def_property_ui_range(prop, 0.5, 2.5, 1.0, 5);
|
||||
RNA_def_property_ui_text(prop, "Ignition", "Minimum temperature of flames");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "flame_max_temp", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_range(prop, 1.0, 10.0);
|
||||
RNA_def_property_ui_range(prop, 1.0, 5.0, 1.0, 5);
|
||||
RNA_def_property_ui_text(prop, "Maximum", "Maximum temperature of flames");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "flame_smoke_color", PROP_FLOAT, PROP_COLOR_GAMMA);
|
||||
RNA_def_property_array(prop, 3);
|
||||
RNA_def_property_ui_text(prop, "Smoke Color", "Color of smoke emitted from burning fuel");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "use_adaptive_domain", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_ADAPTIVE_DOMAIN);
|
||||
|
@ -681,27 +644,21 @@ static void rna_def_smoke_domain_settings(BlenderRNA *brna)
|
|||
RNA_def_property_range(prop, 0, 512);
|
||||
RNA_def_property_ui_range(prop, 0, 512, 2, -1);
|
||||
RNA_def_property_ui_text(prop, "Additional", "Maximum number of additional cells");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "adapt_margin", PROP_INT, PROP_NONE);
|
||||
RNA_def_property_int_sdna(prop, NULL, "adapt_margin");
|
||||
RNA_def_property_range(prop, 2, 24);
|
||||
RNA_def_property_ui_range(prop, 2, 24, 2, -1);
|
||||
RNA_def_property_ui_text(prop, "Margin", "Margin added around fluid to minimize boundary interference");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
|
||||
prop = RNA_def_property(srna, "adapt_threshold", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_range(prop, 0.01, 0.5);
|
||||
RNA_def_property_ui_range(prop, 0.01, 0.5, 1.0, 5);
|
||||
RNA_def_property_ui_text(prop, "Threshold",
|
||||
"Maximum amount of fluid cell can contain before it is considered empty");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
|
||||
prop = RNA_def_property(srna, "cache_file_format", PROP_ENUM, PROP_NONE);
|
||||
RNA_def_property_enum_sdna(prop, NULL, "cache_file_format");
|
||||
RNA_def_property_enum_items(prop, cache_file_type_items);
|
||||
RNA_def_property_ui_text(prop, "File Format", "Select the file format to be used for caching");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_update");
|
||||
}
|
||||
|
||||
static void rna_def_smoke_flow_settings(BlenderRNA *brna)
|
||||
|
|
|
@ -37,6 +37,7 @@
|
|||
#include "DNA_cloth_types.h"
|
||||
#include "DNA_key_types.h"
|
||||
#include "DNA_scene_types.h"
|
||||
#include "DNA_object_force.h"
|
||||
#include "DNA_object_types.h"
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
@ -51,7 +52,6 @@
|
|||
#include "BKE_key.h"
|
||||
#include "BKE_library_query.h"
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_pointcache.h"
|
||||
|
||||
#include "depsgraph_private.h"
|
||||
|
||||
|
@ -63,10 +63,9 @@ static void initData(ModifierData *md)
|
|||
|
||||
clmd->sim_parms = MEM_callocN(sizeof(ClothSimSettings), "cloth sim parms");
|
||||
clmd->coll_parms = MEM_callocN(sizeof(ClothCollSettings), "cloth coll parms");
|
||||
clmd->point_cache = BKE_ptcache_add(&clmd->ptcaches);
|
||||
|
||||
/* check for alloc failing */
|
||||
if (!clmd->sim_parms || !clmd->coll_parms || !clmd->point_cache)
|
||||
if (!clmd->sim_parms || !clmd->coll_parms)
|
||||
return;
|
||||
|
||||
cloth_init(clmd);
|
||||
|
@ -188,15 +187,10 @@ static void copyData(ModifierData *md, ModifierData *target)
|
|||
if (tclmd->coll_parms)
|
||||
MEM_freeN(tclmd->coll_parms);
|
||||
|
||||
BKE_ptcache_free_list(&tclmd->ptcaches);
|
||||
tclmd->point_cache = NULL;
|
||||
|
||||
tclmd->sim_parms = MEM_dupallocN(clmd->sim_parms);
|
||||
if (clmd->sim_parms->effector_weights)
|
||||
tclmd->sim_parms->effector_weights = MEM_dupallocN(clmd->sim_parms->effector_weights);
|
||||
tclmd->coll_parms = MEM_dupallocN(clmd->coll_parms);
|
||||
tclmd->point_cache = BKE_ptcache_add(&tclmd->ptcaches);
|
||||
tclmd->point_cache->step = 1;
|
||||
tclmd->clothObject = NULL;
|
||||
tclmd->hairdata = NULL;
|
||||
tclmd->solver_result = NULL;
|
||||
|
@ -225,9 +219,6 @@ static void freeData(ModifierData *md)
|
|||
if (clmd->coll_parms)
|
||||
MEM_freeN(clmd->coll_parms);
|
||||
|
||||
BKE_ptcache_free_list(&clmd->ptcaches);
|
||||
clmd->point_cache = NULL;
|
||||
|
||||
if (clmd->hairdata)
|
||||
MEM_freeN(clmd->hairdata);
|
||||
|
||||
|
|
|
@ -34,6 +34,7 @@
|
|||
|
||||
#include "DNA_object_types.h"
|
||||
#include "DNA_meshdata_types.h"
|
||||
#include "DNA_object_force.h"
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
|
@ -45,7 +46,6 @@
|
|||
#include "BKE_cdderivedmesh.h"
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_scene.h"
|
||||
|
||||
static void initData(ModifierData *md)
|
||||
|
|
|
@ -69,7 +69,6 @@
|
|||
#include "BKE_main.h"
|
||||
#include "BKE_modifier.h"
|
||||
#include "BKE_node.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_report.h"
|
||||
#include "BKE_scene.h"
|
||||
#include "BKE_sequencer.h"
|
||||
|
@ -3070,21 +3069,6 @@ static void validate_render_settings(Render *re)
|
|||
}
|
||||
}
|
||||
|
||||
static void update_physics_cache(Render *re, Scene *scene, int UNUSED(anim_init))
|
||||
{
|
||||
PTCacheBaker baker;
|
||||
|
||||
memset(&baker, 0, sizeof(baker));
|
||||
baker.main = re->main;
|
||||
baker.scene = scene;
|
||||
baker.bake = 0;
|
||||
baker.render = 1;
|
||||
baker.anim_init = 1;
|
||||
baker.quick_step = 1;
|
||||
|
||||
BKE_ptcache_bake(&baker);
|
||||
}
|
||||
|
||||
void RE_SetActiveRenderView(Render *re, const char *viewname)
|
||||
{
|
||||
BLI_strncpy(re->viewname, viewname, sizeof(re->viewname));
|
||||
|
@ -3097,7 +3081,7 @@ const char *RE_GetActiveRenderView(Render *re)
|
|||
|
||||
/* evaluating scene options for general Blender render */
|
||||
static int render_initialize_from_main(Render *re, RenderData *rd, Main *bmain, Scene *scene, SceneRenderLayer *srl,
|
||||
Object *camera_override, unsigned int lay_override, int anim, int anim_init)
|
||||
Object *camera_override, unsigned int lay_override, int anim, int UNUSED(anim_init))
|
||||
{
|
||||
int winx, winy;
|
||||
rcti disprect;
|
||||
|
@ -3141,16 +3125,6 @@ static int render_initialize_from_main(Render *re, RenderData *rd, Main *bmain,
|
|||
|
||||
/* check all scenes involved */
|
||||
tag_scenes_for_render(re);
|
||||
|
||||
/*
|
||||
* Disabled completely for now,
|
||||
* can be later set as render profile option
|
||||
* and default for background render.
|
||||
*/
|
||||
if (0) {
|
||||
/* make sure dynamics are up to date */
|
||||
update_physics_cache(re, scene, anim_init);
|
||||
}
|
||||
|
||||
if (srl || scene->r.scemode & R_SINGLE_LAYER) {
|
||||
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
|
||||
|
|
|
@ -225,7 +225,7 @@ static int read_voxeldata_header(FILE *fp, struct VoxelData *vd)
|
|||
return 1;
|
||||
}
|
||||
|
||||
static void init_frame_smoke(VoxelData *vd, int cfra)
|
||||
static void init_frame_smoke(VoxelData *vd, int UNUSED(cfra))
|
||||
{
|
||||
#ifdef WITH_SMOKE
|
||||
Object *ob;
|
||||
|
@ -248,9 +248,7 @@ static void init_frame_smoke(VoxelData *vd, int cfra)
|
|||
return;
|
||||
}
|
||||
|
||||
if (cfra < sds->point_cache[0]->startframe)
|
||||
; /* don't show smoke before simulation starts, this could be made an option in the future */
|
||||
else if (vd->smoked_type == TEX_VD_SMOKEHEAT) {
|
||||
if (vd->smoked_type == TEX_VD_SMOKEHEAT) {
|
||||
size_t totRes;
|
||||
size_t i;
|
||||
float *heat;
|
||||
|
|
Loading…
Reference in New Issue