forked from bartvdbraak/blender
Merged changes in the trunk up to revision 29702.
This commit is contained in:
commit
cb805085ef
@ -110,7 +110,7 @@ OPTION(WITH_LZO "Enable fast LZO compression (used for pointcache)" ON
|
||||
OPTION(WITH_LZMA "Enable best LZMA compression, (used for pointcache)" ON)
|
||||
|
||||
# Misc
|
||||
OPTION(WITH_RAYOPTIMIZATION "Enable use of SIMD (SSE) optimizations for the raytracer" OFF)
|
||||
OPTION(WITH_RAYOPTIMIZATION "Enable use of SIMD (SSE) optimizations for the raytracer" ON)
|
||||
OPTION(WITH_CXX_GUARDEDALLOC "Enable GuardedAlloc for C++ memory allocation tracking" OFF)
|
||||
OPTION(WITH_INSTALL "Install accompanying scripts and language files needed to run blender" ON)
|
||||
|
||||
|
@ -168,7 +168,7 @@ BF_EXPAT_LIBPATH = '/usr/lib'
|
||||
WITH_BF_OPENMP = True
|
||||
|
||||
#Ray trace optimization
|
||||
WITH_BF_RAYOPTIMIZATION = False
|
||||
WITH_BF_RAYOPTIMIZATION = True
|
||||
BF_RAYOPTIMIZATION_SSE_FLAGS = ['-msse','-pthread']
|
||||
|
||||
##
|
||||
|
@ -169,7 +169,7 @@ BF_OPENCOLLADA_LIB = 'OpenCOLLADAStreamWriter OpenCOLLADASaxFrameworkLoader Open
|
||||
BF_OPENCOLLADA_LIBPATH = '${BF_OPENCOLLADA}/lib ${BF_ICONV_LIBPATH}'
|
||||
|
||||
#Ray trace optimization
|
||||
WITH_BF_RAYOPTIMIZATION = False
|
||||
WITH_BF_RAYOPTIMIZATION = True
|
||||
BF_RAYOPTIMIZATION_SSE_FLAGS = ['-msse']
|
||||
|
||||
CCFLAGS = [ '-pipe', '-funsigned-char', '-fno-strict-aliasing' ]
|
||||
|
@ -150,7 +150,7 @@ BF_OPENCOLLADA_LIB = 'OpenCOLLADAStreamWriter OpenCOLLADASaxFrameworkLoader Open
|
||||
BF_OPENCOLLADA_LIBPATH = '${BF_OPENCOLLADA}/lib'
|
||||
|
||||
#Ray trace optimization
|
||||
WITH_BF_RAYOPTIMIZATION = False
|
||||
WITH_BF_RAYOPTIMIZATION = True
|
||||
BF_RAYOPTIMIZATION_SSE_FLAGS = ['/arch:SSE']
|
||||
|
||||
WITH_BF_STATICOPENGL = False
|
||||
|
@ -163,7 +163,7 @@ BF_OPENCOLLADA_LIB = 'OpenCOLLADAStreamWriter OpenCOLLADASaxFrameworkLoader Open
|
||||
BF_OPENCOLLADA_LIBPATH = '${BF_OPENCOLLADA}/lib'
|
||||
|
||||
#Ray trace optimization
|
||||
WITH_BF_RAYOPTIMIZATION = False
|
||||
WITH_BF_RAYOPTIMIZATION = True
|
||||
BF_RAYOPTIMIZATION_SSE_FLAGS = ['/arch:SSE','/arch:SSE2']
|
||||
|
||||
WITH_BF_STATICOPENGL = False
|
||||
|
@ -19,6 +19,7 @@
|
||||
import sys, os
|
||||
import http, http.client, http.server, urllib, socket, socketserver, threading
|
||||
import subprocess, shutil, time, hashlib
|
||||
import pickle
|
||||
import select # for select.error
|
||||
|
||||
from netrender.utils import *
|
||||
@ -870,14 +871,18 @@ class RenderHandler(http.server.BaseHTTPRequestHandler):
|
||||
self.send_head(http.client.NO_CONTENT)
|
||||
|
||||
class RenderMasterServer(socketserver.ThreadingMixIn, http.server.HTTPServer):
|
||||
def __init__(self, address, handler_class, path):
|
||||
def __init__(self, address, handler_class, path, subdir=True):
|
||||
super().__init__(address, handler_class)
|
||||
self.jobs = []
|
||||
self.jobs_map = {}
|
||||
self.slaves = []
|
||||
self.slaves_map = {}
|
||||
self.job_id = 0
|
||||
self.path = path + "master_" + str(os.getpid()) + os.sep
|
||||
|
||||
if subdir:
|
||||
self.path = path + "master_" + str(os.getpid()) + os.sep
|
||||
else:
|
||||
self.path = path
|
||||
|
||||
self.slave_timeout = 5 # 5 mins: need a parameter for that
|
||||
|
||||
@ -892,6 +897,22 @@ class RenderMasterServer(socketserver.ThreadingMixIn, http.server.HTTPServer):
|
||||
if not os.path.exists(self.path):
|
||||
os.mkdir(self.path)
|
||||
|
||||
def restore(self, jobs, slaves, balancer = None):
|
||||
self.jobs = jobs
|
||||
self.jobs_map = {}
|
||||
|
||||
for job in self.jobs:
|
||||
self.jobs_map[job.id] = job
|
||||
self.job_id = max(self.job_id, int(job.id))
|
||||
|
||||
self.slaves = slaves
|
||||
for slave in self.slaves:
|
||||
self.slaves_map[slave.id] = slave
|
||||
|
||||
if balancer:
|
||||
self.balancer = balancer
|
||||
|
||||
|
||||
def nextJobID(self):
|
||||
self.job_id += 1
|
||||
return str(self.job_id)
|
||||
@ -1010,8 +1031,29 @@ class RenderMasterServer(socketserver.ThreadingMixIn, http.server.HTTPServer):
|
||||
def clearMaster(path):
|
||||
shutil.rmtree(path)
|
||||
|
||||
def createMaster(address, clear, path):
|
||||
filepath = os.path.join(path, "blender_master.data")
|
||||
|
||||
if not clear and os.path.exists(filepath):
|
||||
print("loading saved master:", filepath)
|
||||
with open(filepath, 'rb') as f:
|
||||
path, jobs, slaves = pickle.load(f)
|
||||
|
||||
httpd = RenderMasterServer(address, RenderHandler, path, subdir=False)
|
||||
httpd.restore(jobs, slaves)
|
||||
|
||||
return httpd
|
||||
|
||||
return RenderMasterServer(address, RenderHandler, path)
|
||||
|
||||
def saveMaster(path, httpd):
|
||||
filepath = os.path.join(path, "blender_master.data")
|
||||
|
||||
with open(filepath, 'wb') as f:
|
||||
pickle.dump((httpd.path, httpd.jobs, httpd.slaves), f, pickle.HIGHEST_PROTOCOL)
|
||||
|
||||
def runMaster(address, broadcast, clear, path, update_stats, test_break):
|
||||
httpd = RenderMasterServer(address, RenderHandler, path)
|
||||
httpd = createMaster(address, clear, path)
|
||||
httpd.timeout = 1
|
||||
httpd.stats = update_stats
|
||||
|
||||
@ -1040,4 +1082,6 @@ def runMaster(address, broadcast, clear, path, update_stats, test_break):
|
||||
httpd.server_close()
|
||||
if clear:
|
||||
clearMaster(httpd.path)
|
||||
else:
|
||||
saveMaster(path, httpd)
|
||||
|
||||
|
@ -47,7 +47,9 @@ def update(job):
|
||||
|
||||
new_path = path + ".remap" + ext
|
||||
|
||||
all = main_file.filepath == main_file.original_path
|
||||
# Disable for now. Partial repath should work anyway
|
||||
#all = main_file.filepath != main_file.original_path
|
||||
all = False
|
||||
|
||||
for rfile in job.files[1:]:
|
||||
if all or rfile.original_path != rfile.filepath:
|
||||
|
@ -531,6 +531,11 @@ class Text(bpy_types.ID):
|
||||
self.clear()
|
||||
self.write(string)
|
||||
|
||||
@property
|
||||
def users_logic(self):
|
||||
"""Logic bricks that use this text"""
|
||||
import bpy
|
||||
return tuple(obj for obj in bpy.data.objects if self in [cont.text for cont in obj.game.controllers if cont.type == 'PYTHON'])
|
||||
|
||||
import collections
|
||||
|
||||
|
@ -631,8 +631,10 @@ if __name__ == "__main__":
|
||||
props = [(prop.identifier, prop) for prop in v.properties]
|
||||
|
||||
for prop_id, prop in sorted(props):
|
||||
data += "%s.%s: %s %s\n" % (struct_id_str, prop.identifier, prop.type, prop.description)
|
||||
data += "%s.%s -> %s: %s%s %s\n" % (struct_id_str, prop.identifier, prop.identifier, prop.type, ", (read-only)" if prop.is_readonly else "", prop.description)
|
||||
|
||||
|
||||
text = bpy.data.texts.new(name="api.py")
|
||||
text.from_string(data)
|
||||
if bpy.app.background:
|
||||
print(data)
|
||||
else:
|
||||
text = bpy.data.texts.new(name="api.py")
|
||||
text.from_string(data)
|
||||
|
@ -367,21 +367,36 @@ class DATA_PT_textboxes(DataButtonsPanel):
|
||||
|
||||
text = context.curve
|
||||
wide_ui = context.region.width > narrowui
|
||||
|
||||
for box in text.textboxes:
|
||||
split = layout.box().split()
|
||||
|
||||
|
||||
split = layout.split()
|
||||
col = split.column()
|
||||
col.operator("font.textbox_add", icon='ZOOMIN')
|
||||
if wide_ui:
|
||||
col = split.column()
|
||||
|
||||
for i, box in enumerate(text.textboxes):
|
||||
|
||||
boxy = layout.box()
|
||||
|
||||
row = boxy.row()
|
||||
|
||||
split = row.split()
|
||||
|
||||
col = split.column(align=True)
|
||||
|
||||
col.label(text="Dimensions:")
|
||||
col.prop(box, "width", text="Width")
|
||||
col.prop(box, "height", text="Height")
|
||||
|
||||
if wide_ui:
|
||||
col = split.column(align=True)
|
||||
|
||||
col.label(text="Offset:")
|
||||
col.prop(box, "x", text="X")
|
||||
col.prop(box, "y", text="Y")
|
||||
|
||||
|
||||
row.operator("font.textbox_remove", text='', icon='X').index = i
|
||||
|
||||
|
||||
classes = [
|
||||
DATA_PT_context_curve,
|
||||
|
@ -608,6 +608,7 @@ class RENDER_PT_motion_blur(RenderButtonsPanel):
|
||||
|
||||
row = layout.row()
|
||||
row.prop(rd, "motion_blur_samples")
|
||||
row.prop(rd, "motion_blur_shutter")
|
||||
|
||||
|
||||
class RENDER_PT_dimensions(RenderButtonsPanel):
|
||||
|
@ -291,6 +291,10 @@ class SEQUENCER_MT_strip(bpy.types.Menu):
|
||||
|
||||
layout.operator_menu_enum("sequencer.swap", "side")
|
||||
|
||||
layout.separator()
|
||||
|
||||
layout.operator("sequencer.swap_data")
|
||||
|
||||
|
||||
class SequencerButtonsPanel(bpy.types.Panel):
|
||||
bl_space_type = 'SEQUENCE_EDITOR'
|
||||
@ -347,15 +351,14 @@ class SEQUENCER_PT_edit(SequencerButtonsPanel):
|
||||
|
||||
row = layout.row()
|
||||
row.prop(strip, "lock")
|
||||
row.prop(strip, "frame_locked", text="Frame Lock")
|
||||
|
||||
col = layout.column()
|
||||
col.enabled = not strip.lock
|
||||
col.prop(strip, "channel")
|
||||
col.prop(strip, "frame_start")
|
||||
subrow = col.split(percentage=0.66)
|
||||
subrow.prop(strip, "length")
|
||||
subrow.label(text="%.2f sec" % (strip.length / (render.fps / render.fps_base)))
|
||||
subrow.prop(strip, "frame_final_length")
|
||||
subrow.label(text="%.2f sec" % (strip.frame_final_length / (render.fps / render.fps_base)))
|
||||
|
||||
col = layout.column(align=True)
|
||||
col.label(text="Offset:")
|
||||
|
@ -98,10 +98,32 @@ class TIME_MT_view(bpy.types.Menu):
|
||||
layout.prop(st, "show_cframe_indicator")
|
||||
layout.prop(st, "only_selected")
|
||||
|
||||
layout.separator()
|
||||
|
||||
layout.menu("TIME_MT_cache")
|
||||
|
||||
layout.separator()
|
||||
|
||||
layout.operator("marker.camera_bind")
|
||||
|
||||
class TIME_MT_cache(bpy.types.Menu):
|
||||
bl_label = "Cache"
|
||||
|
||||
def draw(self, context):
|
||||
layout = self.layout
|
||||
|
||||
st = context.space_data
|
||||
|
||||
layout.prop(st, "show_cache")
|
||||
|
||||
layout.separator()
|
||||
|
||||
col = layout.column()
|
||||
col.enabled = st.show_cache
|
||||
col.prop(st, "cache_softbody")
|
||||
col.prop(st, "cache_particles")
|
||||
col.prop(st, "cache_cloth")
|
||||
col.prop(st, "cache_smoke")
|
||||
|
||||
class TIME_MT_frame(bpy.types.Menu):
|
||||
bl_label = "Frame"
|
||||
@ -171,6 +193,7 @@ class TIME_MT_autokey(bpy.types.Menu):
|
||||
classes = [
|
||||
TIME_HT_header,
|
||||
TIME_MT_view,
|
||||
TIME_MT_cache,
|
||||
TIME_MT_frame,
|
||||
TIME_MT_autokey,
|
||||
TIME_MT_playback]
|
||||
|
@ -2163,6 +2163,7 @@ class VIEW3D_PT_etch_a_ton(bpy.types.Panel):
|
||||
col.prop(toolsettings, "etch_autoname")
|
||||
col.prop(toolsettings, "etch_number")
|
||||
col.prop(toolsettings, "etch_side")
|
||||
col.operator("sketch.convert", text="Convert")
|
||||
|
||||
|
||||
class VIEW3D_PT_context_properties(bpy.types.Panel):
|
||||
|
@ -41,6 +41,9 @@ class VIEW3D_PT_tools_objectmode(View3DPanel):
|
||||
col.operator("transform.rotate")
|
||||
col.operator("transform.resize", text="Scale")
|
||||
|
||||
col = layout.column(align=True)
|
||||
col.operator("object.origin_set", text="Origin")
|
||||
|
||||
col = layout.column(align=True)
|
||||
col.label(text="Object:")
|
||||
col.operator("object.duplicate_move")
|
||||
|
@ -99,7 +99,7 @@ extern void shadeMeshMCol(struct Scene *scene, struct Object *ob, struct Mesh *m
|
||||
int surfindex_displist(DispList *dl, int a, int *b, int *p1, int *p2, int *p3, int *p4);
|
||||
void imagestodisplist(void);
|
||||
void reshadeall_displist(struct Scene *scene);
|
||||
void filldisplist(struct ListBase *dispbase, struct ListBase *to);
|
||||
void filldisplist(struct ListBase *dispbase, struct ListBase *to, int flipnormal);
|
||||
|
||||
void fastshade_free_render(void);
|
||||
|
||||
|
@ -75,6 +75,9 @@ void key_to_latt(struct KeyBlock *kb, struct Lattice *lt);
|
||||
void latt_to_key(struct Lattice *lt, struct KeyBlock *kb);
|
||||
void key_to_curve(struct KeyBlock *kb, struct Curve *cu, struct ListBase *nurb);
|
||||
void curve_to_key(struct Curve *cu, struct KeyBlock *kb, struct ListBase *nurb);
|
||||
float (*key_to_vertcos(struct Object *ob, struct KeyBlock *kb))[3];
|
||||
void vertcos_to_key(struct Object *ob, struct KeyBlock *kb, float (*vertCos)[3]);
|
||||
void offset_to_key(struct Object *ob, struct KeyBlock *kb, float (*ofs)[3]);
|
||||
|
||||
#ifdef __cplusplus
|
||||
};
|
||||
|
@ -70,7 +70,7 @@ typedef struct SculptSession {
|
||||
int totvert, totface;
|
||||
float *face_normals;
|
||||
struct Object *ob;
|
||||
struct KeyBlock *kb, *refkb;
|
||||
struct KeyBlock *kb;
|
||||
|
||||
/* Mesh connectivity */
|
||||
struct ListBase *fmap;
|
||||
@ -94,6 +94,8 @@ typedef struct SculptSession {
|
||||
struct StrokeCache *cache;
|
||||
|
||||
struct GPUDrawObject *drawobject;
|
||||
|
||||
int modifiers_active;
|
||||
} SculptSession;
|
||||
|
||||
void free_sculptsession(struct Object *ob);
|
||||
|
@ -191,17 +191,22 @@ int shuffle_seq(struct ListBase * seqbasep, struct Sequence *test, struct Scene
|
||||
int shuffle_seq_time(ListBase * seqbasep, struct Scene *evil_scene);
|
||||
int seqbase_isolated_sel_check(struct ListBase *seqbase);
|
||||
void free_imbuf_seq(struct Scene *scene, struct ListBase * seqbasep, int check_mem_usage);
|
||||
struct Sequence *seq_dupli_recursive(struct Scene *scene, struct Sequence * seq, int dupe_flag);
|
||||
int seq_swap(struct Sequence *seq_a, struct Sequence *seq_b);
|
||||
|
||||
void seq_update_sound(struct Scene* scene, struct Sequence *seq);
|
||||
void seq_update_muting(struct Scene* scene, struct Editing *ed);
|
||||
void seqbase_sound_reload(Scene *scene, ListBase *seqbase);
|
||||
void seqbase_unique_name_recursive(ListBase *seqbasep, struct Sequence *seq);
|
||||
void seqbase_dupli_recursive(struct Scene *scene, ListBase *nseqbase, ListBase *seqbase, int dupe_flag);
|
||||
|
||||
void clear_scene_in_allseqs(struct Scene *sce);
|
||||
|
||||
struct Sequence *get_seq_by_name(struct ListBase *seqbase, const char *name, int recursive);
|
||||
|
||||
struct Sequence *active_seq_get(struct Scene *scene);
|
||||
void active_seq_set(struct Scene *scene, struct Sequence *seq);
|
||||
struct Sequence *seq_active_get(struct Scene *scene);
|
||||
void seq_active_set(struct Scene *scene, struct Sequence *seq);
|
||||
int seq_active_pair_get(struct Scene *scene, struct Sequence **seq_act, struct Sequence **seq_other);
|
||||
|
||||
/* api for adding new sequence strips */
|
||||
typedef struct SeqLoadInfo {
|
||||
@ -223,6 +228,11 @@ typedef struct SeqLoadInfo {
|
||||
#define SEQ_LOAD_MOVIE_SOUND 1<<2
|
||||
#define SEQ_LOAD_SOUND_CACHE 1<<3
|
||||
|
||||
|
||||
/* seq_dupli' flags */
|
||||
#define SEQ_DUPE_UNIQUE_NAME 1<<0
|
||||
#define SEQ_DUPE_CONTEXT 1<<1
|
||||
|
||||
/* use as an api function */
|
||||
typedef struct Sequence *(*SeqLoadFunc)(struct bContext *, ListBase *, struct SeqLoadInfo *);
|
||||
|
||||
|
@ -64,6 +64,7 @@ void colorband_table_RGBA(struct ColorBand *coba, float **array, int *size);
|
||||
|
||||
void default_tex(struct Tex *tex);
|
||||
struct Tex *add_texture(const char *name);
|
||||
void tex_set_type(struct Tex *tex, int type);
|
||||
void default_mtex(struct MTex *mtex);
|
||||
struct MTex *add_mtex(void);
|
||||
struct Tex *copy_texture(struct Tex *tex);
|
||||
|
@ -1159,7 +1159,7 @@ static void ccgSubSurf__calcVertNormals(CCGSubSurf *ss,
|
||||
int normalDataOffset = ss->normalDataOffset;
|
||||
int vertDataSize = ss->meshIFC.vertDataSize;
|
||||
|
||||
//#pragma omp parallel for private(ptrIdx) schedule(static)
|
||||
#pragma omp parallel for private(ptrIdx) if(numEffectedF*edgeSize*edgeSize*4 >= CCG_OMP_LIMIT)
|
||||
for (ptrIdx=0; ptrIdx<numEffectedF; ptrIdx++) {
|
||||
CCGFace *f = (CCGFace*) effectedF[ptrIdx];
|
||||
int S, x, y;
|
||||
@ -1285,7 +1285,7 @@ static void ccgSubSurf__calcVertNormals(CCGSubSurf *ss,
|
||||
}
|
||||
}
|
||||
|
||||
//#pragma omp parallel for private(ptrIdx) schedule(static)
|
||||
#pragma omp parallel for private(ptrIdx) if(numEffectedF*edgeSize*edgeSize*4 >= CCG_OMP_LIMIT)
|
||||
for (ptrIdx=0; ptrIdx<numEffectedF; ptrIdx++) {
|
||||
CCGFace *f = (CCGFace*) effectedF[ptrIdx];
|
||||
int S, x, y;
|
||||
@ -1351,7 +1351,7 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss,
|
||||
int vertDataSize = ss->meshIFC.vertDataSize;
|
||||
void *q = ss->q, *r = ss->r;
|
||||
|
||||
//#pragma omp parallel for private(ptrIdx) schedule(static)
|
||||
#pragma omp parallel for private(ptrIdx) if(numEffectedF*edgeSize*edgeSize*4 >= CCG_OMP_LIMIT)
|
||||
for (ptrIdx=0; ptrIdx<numEffectedF; ptrIdx++) {
|
||||
CCGFace *f = (CCGFace*) effectedF[ptrIdx];
|
||||
int S, x, y;
|
||||
@ -1685,17 +1685,17 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss,
|
||||
}
|
||||
}
|
||||
|
||||
//#pragma omp parallel private(ptrIdx)
|
||||
#pragma omp parallel private(ptrIdx) if(numEffectedF*edgeSize*edgeSize*4 >= CCG_OMP_LIMIT)
|
||||
{
|
||||
void *q, *r;
|
||||
|
||||
//#pragma omp critical
|
||||
#pragma omp critical
|
||||
{
|
||||
q = MEM_mallocN(ss->meshIFC.vertDataSize, "CCGSubsurf q");
|
||||
r = MEM_mallocN(ss->meshIFC.vertDataSize, "CCGSubsurf r");
|
||||
}
|
||||
|
||||
//#pragma omp for schedule(static)
|
||||
#pragma omp for schedule(static)
|
||||
for (ptrIdx=0; ptrIdx<numEffectedF; ptrIdx++) {
|
||||
CCGFace *f = (CCGFace*) effectedF[ptrIdx];
|
||||
int S, x, y;
|
||||
@ -1779,7 +1779,7 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss,
|
||||
}
|
||||
}
|
||||
|
||||
//#pragma omp critical
|
||||
#pragma omp critical
|
||||
{
|
||||
MEM_freeN(q);
|
||||
MEM_freeN(r);
|
||||
@ -1791,14 +1791,14 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss,
|
||||
gridSize = 1 + (1<<((nextLvl)-1));
|
||||
cornerIdx = gridSize-1;
|
||||
|
||||
//#pragma omp parallel for private(i) schedule(static)
|
||||
#pragma omp parallel for private(i) if(numEffectedF*edgeSize*edgeSize*4 >= CCG_OMP_LIMIT)
|
||||
for (i=0; i<numEffectedE; i++) {
|
||||
CCGEdge *e = effectedE[i];
|
||||
VertDataCopy(EDGE_getCo(e, nextLvl, 0), VERT_getCo(e->v0, nextLvl));
|
||||
VertDataCopy(EDGE_getCo(e, nextLvl, edgeSize-1), VERT_getCo(e->v1, nextLvl));
|
||||
}
|
||||
|
||||
//#pragma omp parallel for private(i) schedule(static)
|
||||
#pragma omp parallel for private(i) if(numEffectedF*edgeSize*edgeSize*4 >= CCG_OMP_LIMIT)
|
||||
for (i=0; i<numEffectedF; i++) {
|
||||
CCGFace *f = effectedF[i];
|
||||
int S, x;
|
||||
|
@ -39,6 +39,10 @@ typedef enum {
|
||||
|
||||
/***/
|
||||
|
||||
#define CCG_OMP_LIMIT 1000000
|
||||
|
||||
/***/
|
||||
|
||||
typedef struct _CCGSubSurf CCGSubSurf;
|
||||
|
||||
CCGSubSurf* ccgSubSurf_new (CCGMeshIFC *ifc, int subdivisionLevels, CCGAllocatorIFC *allocatorIFC, CCGAllocatorHDL allocator);
|
||||
|
@ -247,8 +247,8 @@ void DM_to_mesh(DerivedMesh *dm, Mesh *me)
|
||||
|
||||
/* if the number of verts has changed, remove invalid data */
|
||||
if(tmp.totvert != me->totvert) {
|
||||
if(me->key) me->key->id.us--;
|
||||
me->key = NULL;
|
||||
if(tmp.key) tmp.key->id.us--;
|
||||
tmp.key = NULL;
|
||||
}
|
||||
|
||||
*me = tmp;
|
||||
|
@ -65,7 +65,6 @@
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_idprop.h"
|
||||
#include "BKE_library.h"
|
||||
#include "BKE_ipo.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_node.h"
|
||||
#include "BKE_report.h"
|
||||
@ -287,10 +286,6 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, char *filename)
|
||||
//setscreen(G.curscreen);
|
||||
}
|
||||
|
||||
// XXX temporarily here
|
||||
if(G.main->versionfile < 250)
|
||||
do_versions_ipos_to_animato(G.main); // XXX fixme... complicated versionpatching
|
||||
|
||||
if(recover && bfd->filename[0] && G.relbase_valid) {
|
||||
/* in case of autosave or quit.blend, use original filename instead
|
||||
* use relbase_valid to make sure the file is saved, else we get <memory2> in the filename */
|
||||
|
@ -186,6 +186,16 @@ static ListBase *cdDM_getFaceMap(Object *ob, DerivedMesh *dm)
|
||||
return cddm->fmap;
|
||||
}
|
||||
|
||||
static int can_pbvh_draw(Object *ob, DerivedMesh *dm)
|
||||
{
|
||||
CDDerivedMesh *cddm = (CDDerivedMesh*) dm;
|
||||
Mesh *me= (ob)? ob->data: NULL;
|
||||
|
||||
if(ob->sculpt->modifiers_active) return 0;
|
||||
|
||||
return (cddm->mvert == me->mvert) || ob->sculpt->kb;
|
||||
}
|
||||
|
||||
static struct PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm)
|
||||
{
|
||||
CDDerivedMesh *cddm = (CDDerivedMesh*) dm;
|
||||
@ -200,7 +210,7 @@ static struct PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm)
|
||||
return NULL;
|
||||
if(ob->sculpt->pbvh) {
|
||||
cddm->pbvh= ob->sculpt->pbvh;
|
||||
cddm->pbvh_draw = (cddm->mvert == me->mvert) || ob->sculpt->kb;
|
||||
cddm->pbvh_draw = can_pbvh_draw(ob, dm);
|
||||
}
|
||||
|
||||
/* always build pbvh from original mesh, and only use it for drawing if
|
||||
@ -208,7 +218,7 @@ static struct PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm)
|
||||
that this is actually for, to support a pbvh on a modified mesh */
|
||||
if(!cddm->pbvh && ob->type == OB_MESH) {
|
||||
cddm->pbvh = BLI_pbvh_new();
|
||||
cddm->pbvh_draw = (cddm->mvert == me->mvert) || ob->sculpt->kb;
|
||||
cddm->pbvh_draw = can_pbvh_draw(ob, dm);
|
||||
BLI_pbvh_build_mesh(cddm->pbvh, me->mface, me->mvert,
|
||||
me->totface, me->totvert);
|
||||
}
|
||||
@ -734,7 +744,7 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm,
|
||||
if( flag != lastFlag ) {
|
||||
if( startFace < i ) {
|
||||
if( lastFlag != 0 ) { /* if the flag is 0 it means the face is hidden or invisible */
|
||||
if (lastFlag==1 && mcol)
|
||||
if (lastFlag==1 && col)
|
||||
GPU_color_switch(1);
|
||||
else
|
||||
GPU_color_switch(0);
|
||||
@ -747,7 +757,7 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm,
|
||||
}
|
||||
if( startFace < dm->drawObject->nelements/3 ) {
|
||||
if( lastFlag != 0 ) { /* if the flag is 0 it means the face is hidden or invisible */
|
||||
if (lastFlag==1 && mcol)
|
||||
if (lastFlag==1 && col)
|
||||
GPU_color_switch(1);
|
||||
else
|
||||
GPU_color_switch(0);
|
||||
|
@ -2286,9 +2286,6 @@ void DAG_id_flush_update(ID *id, short flag)
|
||||
/* no point in trying in this cases */
|
||||
if(!id || id->us <= 1)
|
||||
id= NULL;
|
||||
/* for locked shape keys we make an exception */
|
||||
else if(ob_get_key(ob) && (ob->shapeflag & OB_SHAPE_LOCK))
|
||||
id= NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -925,7 +925,7 @@ static void curve_to_displist(Curve *cu, ListBase *nubase, ListBase *dispbase)
|
||||
}
|
||||
|
||||
|
||||
void filldisplist(ListBase *dispbase, ListBase *to)
|
||||
void filldisplist(ListBase *dispbase, ListBase *to, int flipnormal)
|
||||
{
|
||||
EditVert *eve, *v1, *vlast;
|
||||
EditFace *efa;
|
||||
@ -1019,6 +1019,9 @@ void filldisplist(ListBase *dispbase, ListBase *to)
|
||||
index[0]= (intptr_t)efa->v1->tmp.l;
|
||||
index[1]= (intptr_t)efa->v2->tmp.l;
|
||||
index[2]= (intptr_t)efa->v3->tmp.l;
|
||||
|
||||
if(flipnormal)
|
||||
SWAP(int, index[0], index[2]);
|
||||
|
||||
index+= 3;
|
||||
efa= efa->next;
|
||||
@ -1095,13 +1098,13 @@ static void bevels_to_filledpoly(Curve *cu, ListBase *dispbase)
|
||||
dl= dl->next;
|
||||
}
|
||||
|
||||
filldisplist(&front, dispbase);
|
||||
filldisplist(&back, dispbase);
|
||||
filldisplist(&front, dispbase, 1);
|
||||
filldisplist(&back, dispbase, 0);
|
||||
|
||||
freedisplist(&front);
|
||||
freedisplist(&back);
|
||||
|
||||
filldisplist(dispbase, dispbase);
|
||||
filldisplist(dispbase, dispbase, 0);
|
||||
|
||||
}
|
||||
|
||||
@ -1113,7 +1116,7 @@ static void curve_to_filledpoly(Curve *cu, ListBase *nurb, ListBase *dispbase)
|
||||
bevels_to_filledpoly(cu, dispbase);
|
||||
}
|
||||
else {
|
||||
filldisplist(dispbase, dispbase);
|
||||
filldisplist(dispbase, dispbase, 0);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1315,7 +1318,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *dispba
|
||||
ModifierData *preTesselatePoint;
|
||||
Curve *cu= ob->data;
|
||||
ListBase *nurb= cu->editnurb?cu->editnurb:&cu->nurb;
|
||||
int required_mode, totvert;
|
||||
int required_mode, totvert = 0;
|
||||
int editmode = (!forRender && cu->editnurb);
|
||||
DerivedMesh *dm= NULL, *ndm;
|
||||
float (*vertCos)[3] = NULL;
|
||||
@ -1855,6 +1858,12 @@ void makeDispListCurveTypes(Scene *scene, Object *ob, int forOrco)
|
||||
DM_set_object_boundbox (ob, ob->derivedFinal);
|
||||
} else {
|
||||
boundbox_displist (ob);
|
||||
|
||||
/* if there is no derivedMesh, object's boundbox is unneeded */
|
||||
if (ob->bb) {
|
||||
MEM_freeN(ob->bb);
|
||||
ob->bb= NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -38,6 +38,7 @@
|
||||
|
||||
#include "BLI_blenlib.h"
|
||||
#include "BLI_editVert.h"
|
||||
#include "BLI_math_vector.h"
|
||||
|
||||
#include "DNA_anim_types.h"
|
||||
#include "DNA_key_types.h"
|
||||
@ -1719,3 +1720,202 @@ void key_to_mesh(KeyBlock *kb, Mesh *me)
|
||||
VECCOPY(mvert->co, fp);
|
||||
}
|
||||
}
|
||||
|
||||
/************************* vert coords ************************/
|
||||
float (*key_to_vertcos(Object *ob, KeyBlock *kb))[3]
|
||||
{
|
||||
float (*vertCos)[3], *co;
|
||||
float *fp= kb->data;
|
||||
int tot= 0, a;
|
||||
|
||||
/* Count of vertex coords in array */
|
||||
if(ob->type == OB_MESH) {
|
||||
Mesh *me= (Mesh*)ob->data;
|
||||
tot= me->totvert;
|
||||
} else if(ob->type == OB_LATTICE) {
|
||||
Lattice *lt= (Lattice*)ob->data;
|
||||
tot= lt->pntsu*lt->pntsv*lt->pntsw;
|
||||
} else if(ELEM(ob->type, OB_CURVE, OB_SURF)) {
|
||||
Curve *cu= (Curve*)ob->data;
|
||||
tot= count_curveverts(&cu->nurb);
|
||||
}
|
||||
|
||||
if (tot == 0) return NULL;
|
||||
|
||||
vertCos= MEM_callocN(tot*sizeof(*vertCos), "key_to_vertcos vertCos");
|
||||
|
||||
/* Copy coords to array */
|
||||
co= (float*)vertCos;
|
||||
|
||||
if(ELEM(ob->type, OB_MESH, OB_LATTICE)) {
|
||||
for (a= 0; a<tot; a++, fp+=3, co+=3) {
|
||||
copy_v3_v3(co, fp);
|
||||
}
|
||||
} else if(ELEM(ob->type, OB_CURVE, OB_SURF)) {
|
||||
Curve *cu= (Curve*)ob->data;
|
||||
Nurb *nu= cu->nurb.first;
|
||||
BezTriple *bezt;
|
||||
BPoint *bp;
|
||||
|
||||
while (nu) {
|
||||
if(nu->bezt) {
|
||||
int i;
|
||||
bezt= nu->bezt;
|
||||
a= nu->pntsu;
|
||||
|
||||
while (a--) {
|
||||
for (i= 0; i<3; i++) {
|
||||
copy_v3_v3(co, fp);
|
||||
fp+= 3; co+= 3;
|
||||
}
|
||||
|
||||
fp+= 3; /* skip alphas */
|
||||
|
||||
bezt++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
bp= nu->bp;
|
||||
a= nu->pntsu*nu->pntsv;
|
||||
|
||||
while (a--) {
|
||||
copy_v3_v3(co, fp);
|
||||
|
||||
fp+= 4;
|
||||
co+= 3;
|
||||
|
||||
bp++;
|
||||
}
|
||||
}
|
||||
|
||||
nu= nu->next;
|
||||
}
|
||||
}
|
||||
|
||||
return vertCos;
|
||||
}
|
||||
|
||||
void vertcos_to_key(Object *ob, KeyBlock *kb, float (*vertCos)[3])
|
||||
{
|
||||
float *co= (float*)vertCos, *fp;
|
||||
int tot= 0, a, elemsize;
|
||||
|
||||
if (kb->data) MEM_freeN(kb->data);
|
||||
|
||||
/* Count of vertex coords in array */
|
||||
if(ob->type == OB_MESH) {
|
||||
Mesh *me= (Mesh*)ob->data;
|
||||
tot= me->totvert;
|
||||
elemsize= me->key->elemsize;
|
||||
} else if(ob->type == OB_LATTICE) {
|
||||
Lattice *lt= (Lattice*)ob->data;
|
||||
tot= lt->pntsu*lt->pntsv*lt->pntsw;
|
||||
elemsize= lt->key->elemsize;
|
||||
} else if(ELEM(ob->type, OB_CURVE, OB_SURF)) {
|
||||
Curve *cu= (Curve*)ob->data;
|
||||
elemsize= cu->key->elemsize;
|
||||
tot= count_curveverts(&cu->nurb);
|
||||
}
|
||||
|
||||
fp= kb->data= MEM_callocN(tot*elemsize, "key_to_vertcos vertCos");
|
||||
|
||||
if (tot == 0) return;
|
||||
|
||||
/* Copy coords to keyblock */
|
||||
|
||||
if(ELEM(ob->type, OB_MESH, OB_LATTICE)) {
|
||||
for (a= 0; a<tot; a++, fp+=3, co+=3) {
|
||||
copy_v3_v3(fp, co);
|
||||
}
|
||||
} else if(ELEM(ob->type, OB_CURVE, OB_SURF)) {
|
||||
Curve *cu= (Curve*)ob->data;
|
||||
Nurb *nu= cu->nurb.first;
|
||||
BezTriple *bezt;
|
||||
BPoint *bp;
|
||||
|
||||
while (nu) {
|
||||
if(nu->bezt) {
|
||||
int i;
|
||||
bezt= nu->bezt;
|
||||
a= nu->pntsu;
|
||||
|
||||
while (a--) {
|
||||
for (i= 0; i<3; i++) {
|
||||
copy_v3_v3(fp, co);
|
||||
fp+= 3; co+= 3;
|
||||
}
|
||||
|
||||
fp+= 3; /* skip alphas */
|
||||
|
||||
bezt++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
bp= nu->bp;
|
||||
a= nu->pntsu*nu->pntsv;
|
||||
|
||||
while (a--) {
|
||||
copy_v3_v3(fp, co);
|
||||
|
||||
fp+= 4;
|
||||
co+= 3;
|
||||
|
||||
bp++;
|
||||
}
|
||||
}
|
||||
|
||||
nu= nu->next;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void offset_to_key(Object *ob, KeyBlock *kb, float (*ofs)[3])
|
||||
{
|
||||
int a;
|
||||
float *co= (float*)ofs, *fp= kb->data;
|
||||
|
||||
if(ELEM(ob->type, OB_MESH, OB_LATTICE)) {
|
||||
for (a= 0; a<kb->totelem; a++, fp+=3, co+=3) {
|
||||
add_v3_v3(fp, co);
|
||||
}
|
||||
} else if(ELEM(ob->type, OB_CURVE, OB_SURF)) {
|
||||
Curve *cu= (Curve*)ob->data;
|
||||
Nurb *nu= cu->nurb.first;
|
||||
BezTriple *bezt;
|
||||
BPoint *bp;
|
||||
|
||||
while (nu) {
|
||||
if(nu->bezt) {
|
||||
int i;
|
||||
bezt= nu->bezt;
|
||||
a= nu->pntsu;
|
||||
|
||||
while (a--) {
|
||||
for (i= 0; i<3; i++) {
|
||||
add_v3_v3(fp, co);
|
||||
fp+= 3; co+= 3;
|
||||
}
|
||||
|
||||
fp+= 3; /* skip alphas */
|
||||
|
||||
bezt++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
bp= nu->bp;
|
||||
a= nu->pntsu*nu->pntsv;
|
||||
|
||||
while (a--) {
|
||||
add_v3_v3(fp, co);
|
||||
|
||||
fp+= 4;
|
||||
co+= 3;
|
||||
|
||||
bp++;
|
||||
}
|
||||
}
|
||||
|
||||
nu= nu->next;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1186,6 +1186,12 @@ void mesh_to_curve(Scene *scene, Object *ob)
|
||||
|
||||
if (needsFree) {
|
||||
ob->derivedFinal = NULL;
|
||||
|
||||
/* curve object could have got bounding box only in special cases */
|
||||
if(ob->bb) {
|
||||
MEM_freeN(ob->bb);
|
||||
ob->bb= NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -459,6 +459,7 @@ void multiresModifier_subdivide(MultiresModifierData *mmd, Object *ob, int updat
|
||||
|
||||
/* create subsurf DM from original mesh at high level */
|
||||
cddm = CDDM_from_mesh(me, NULL);
|
||||
DM_set_only_copy(cddm, CD_MASK_BAREMESH);
|
||||
highdm = subsurf_dm_create_local(ob, cddm, totlvl, simple, 0);
|
||||
|
||||
/* create multires DM from original mesh at low level */
|
||||
@ -560,7 +561,7 @@ static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, int invert, int
|
||||
dGridSize = multires_side_tot[totlvl];
|
||||
dSkip = (dGridSize-1)/(gridSize-1);
|
||||
|
||||
//#pragma omp parallel for private(i) schedule(static)
|
||||
#pragma omp parallel for private(i) if(me->totface*gridSize*gridSize*4 >= CCG_OMP_LIMIT)
|
||||
for(i = 0; i < me->totface; ++i) {
|
||||
const int numVerts = mface[i].v4 ? 4 : 3;
|
||||
MDisps *mdisp = &mdisps[i];
|
||||
@ -568,7 +569,7 @@ static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, int invert, int
|
||||
|
||||
/* when adding new faces in edit mode, need to allocate disps */
|
||||
if(!mdisp->disps)
|
||||
//#pragma omp critical
|
||||
#pragma omp critical
|
||||
{
|
||||
multires_reallocate_mdisps(me, mdisps, totlvl);
|
||||
}
|
||||
@ -656,6 +657,7 @@ static void multiresModifier_update(DerivedMesh *dm)
|
||||
/* create subsurf DM from original mesh at high level */
|
||||
if (ob->derivedDeform) cddm = CDDM_copy(ob->derivedDeform);
|
||||
else cddm = CDDM_from_mesh(me, NULL);
|
||||
DM_set_only_copy(cddm, CD_MASK_BAREMESH);
|
||||
|
||||
highdm = subsurf_dm_create_local(ob, cddm, totlvl, mmd->simple, 0);
|
||||
|
||||
@ -709,6 +711,7 @@ static void multiresModifier_update(DerivedMesh *dm)
|
||||
|
||||
if (ob->derivedDeform) cddm = CDDM_copy(ob->derivedDeform);
|
||||
else cddm = CDDM_from_mesh(me, NULL);
|
||||
DM_set_only_copy(cddm, CD_MASK_BAREMESH);
|
||||
|
||||
subdm = subsurf_dm_create_local(ob, cddm, mmd->totlvl, mmd->simple, 0);
|
||||
cddm->release(cddm);
|
||||
|
@ -2465,7 +2465,7 @@ void ntreeCompositExecTree(bNodeTree *ntree, RenderData *rd, int do_preview)
|
||||
node= getExecutableNode(ntree);
|
||||
if(node) {
|
||||
|
||||
if(ntree->progress)
|
||||
if(ntree->progress && totnode)
|
||||
ntree->progress(ntree->prh, (1.0 - curnode/(float)totnode));
|
||||
if(ntree->stats_draw) {
|
||||
char str[64];
|
||||
|
@ -652,6 +652,14 @@ void unlink_object(Scene *scene, Object *ob)
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(sl->spacetype==SPACE_BUTS) {
|
||||
SpaceButs *sbuts= (SpaceButs *)sl;
|
||||
|
||||
if(sbuts->pinid==(ID *)ob) {
|
||||
sbuts->flag&= ~SB_PIN_CONTEXT;
|
||||
sbuts->pinid= NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sa= sa->next;
|
||||
|
@ -44,6 +44,7 @@
|
||||
#include "DNA_group_types.h"
|
||||
#include "DNA_scene_types.h"
|
||||
#include "DNA_screen_types.h"
|
||||
#include "DNA_sequence_types.h"
|
||||
|
||||
#include "BKE_anim.h"
|
||||
#include "BKE_animsys.h"
|
||||
@ -199,6 +200,10 @@ Scene *copy_scene(Main *bmain, Scene *sce, int type)
|
||||
scen->r.qtcodecdata->cdParms = MEM_dupallocN(scen->r.qtcodecdata->cdParms);
|
||||
}
|
||||
|
||||
if(sce->r.ffcodecdata.properties) { /* intentionally check scen not sce. */
|
||||
scen->r.ffcodecdata.properties= IDP_CopyProperty(sce->r.ffcodecdata.properties);
|
||||
}
|
||||
|
||||
/* NOTE: part of SCE_COPY_LINK_DATA and SCE_COPY_FULL operations
|
||||
* are done outside of blenkernel with ED_objects_single_users! */
|
||||
|
||||
@ -213,6 +218,12 @@ Scene *copy_scene(Main *bmain, Scene *sce, int type)
|
||||
id_us_plus((ID *)scen->world);
|
||||
scen->world= copy_world(scen->world);
|
||||
}
|
||||
|
||||
if(sce->ed) {
|
||||
scen->ed= MEM_callocN( sizeof(Editing), "addseq");
|
||||
scen->ed->seqbasep= &scen->ed->seqbase;
|
||||
seqbase_dupli_recursive(sce, &scen->ed->seqbase, &sce->ed->seqbase, 0);
|
||||
}
|
||||
}
|
||||
|
||||
sound_create_scene(scen);
|
||||
|
@ -2802,7 +2802,7 @@ static void init_speed_effect(Sequence *seq)
|
||||
v = (SpeedControlVars *)seq->effectdata;
|
||||
v->globalSpeed = 1.0;
|
||||
v->frameMap = 0;
|
||||
v->flags = SEQ_SPEED_COMPRESS_IPO_Y;
|
||||
v->flags = 0;
|
||||
v->length = 0;
|
||||
}
|
||||
|
||||
@ -2925,14 +2925,8 @@ void sequence_effect_speed_rebuild_map(Scene *scene, Sequence * seq, int force)
|
||||
|
||||
for (cfra = 1; cfra < v->length; cfra++) {
|
||||
if(fcu) {
|
||||
if((seq->flag & SEQ_IPO_FRAME_LOCKED) != 0) {
|
||||
ctime = seq->startdisp + cfra;
|
||||
div = 1.0;
|
||||
} else {
|
||||
ctime= cfra;
|
||||
div= v->length / 100.0f;
|
||||
if(div==0.0) return;
|
||||
}
|
||||
ctime = seq->startdisp + cfra;
|
||||
div = 1.0;
|
||||
|
||||
facf = evaluate_fcurve(fcu, ctime/div);
|
||||
} else {
|
||||
@ -2956,14 +2950,8 @@ void sequence_effect_speed_rebuild_map(Scene *scene, Sequence * seq, int force)
|
||||
for (cfra = 0; cfra < v->length; cfra++) {
|
||||
|
||||
if(fcu) {
|
||||
if((seq->flag & SEQ_IPO_FRAME_LOCKED) != 0) {
|
||||
ctime = seq->startdisp + cfra;
|
||||
div = 1.0;
|
||||
} else {
|
||||
ctime= cfra;
|
||||
div= v->length / 100.0f;
|
||||
if(div==0.0) return;
|
||||
}
|
||||
ctime = seq->startdisp + cfra;
|
||||
div = 1.0;
|
||||
|
||||
facf = evaluate_fcurve(fcu, ctime / div);
|
||||
if (v->flags & SEQ_SPEED_COMPRESS_IPO_Y) {
|
||||
|
@ -3790,6 +3790,34 @@ ListBase *seq_seqbase(ListBase *seqbase, Sequence *seq)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int seq_swap(Sequence *seq_a, Sequence *seq_b)
|
||||
{
|
||||
if(seq_a->len != seq_b->len)
|
||||
return 0;
|
||||
|
||||
/* type checking, could be more advanced but disalow sound vs non-sound copy */
|
||||
if(seq_a->type != seq_b->type) {
|
||||
if(seq_a->type == SEQ_SOUND || seq_b->type == SEQ_SOUND) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
SWAP(Sequence, *seq_a, *seq_b);
|
||||
SWAP(void *, seq_a->prev, seq_b->prev);
|
||||
SWAP(void *, seq_a->next, seq_b->next);
|
||||
|
||||
SWAP(int, seq_a->start, seq_b->start);
|
||||
SWAP(int, seq_a->startofs, seq_b->startofs);
|
||||
SWAP(int, seq_a->endofs, seq_b->endofs);
|
||||
SWAP(int, seq_a->startstill, seq_b->startstill);
|
||||
SWAP(int, seq_a->endstill, seq_b->endstill);
|
||||
SWAP(int, seq_a->machine, seq_b->machine);
|
||||
SWAP(int, seq_a->startdisp, seq_b->startdisp);
|
||||
SWAP(int, seq_a->enddisp, seq_b->enddisp);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* XXX - hackish function needed for transforming strips! TODO - have some better solution */
|
||||
void seq_offset_animdata(Scene *scene, Sequence *seq, int ofs)
|
||||
{
|
||||
@ -3832,14 +3860,14 @@ Sequence *get_seq_by_name(ListBase *seqbase, const char *name, int recursive)
|
||||
}
|
||||
|
||||
|
||||
Sequence *active_seq_get(Scene *scene)
|
||||
Sequence *seq_active_get(Scene *scene)
|
||||
{
|
||||
Editing *ed= seq_give_editing(scene, FALSE);
|
||||
if(ed==NULL) return NULL;
|
||||
return ed->act_seq;
|
||||
}
|
||||
|
||||
void active_seq_set(Scene *scene, Sequence *seq)
|
||||
void seq_active_set(Scene *scene, Sequence *seq)
|
||||
{
|
||||
Editing *ed= seq_give_editing(scene, FALSE);
|
||||
if(ed==NULL) return;
|
||||
@ -3847,6 +3875,35 @@ void active_seq_set(Scene *scene, Sequence *seq)
|
||||
ed->act_seq= seq;
|
||||
}
|
||||
|
||||
int seq_active_pair_get(Scene *scene, Sequence **seq_act, Sequence **seq_other)
|
||||
{
|
||||
Editing *ed= seq_give_editing(scene, FALSE);
|
||||
|
||||
*seq_act= seq_active_get(scene);
|
||||
|
||||
if(*seq_act == NULL) {
|
||||
return 0;
|
||||
}
|
||||
else {
|
||||
Sequence *seq;
|
||||
|
||||
*seq_other= NULL;
|
||||
|
||||
for(seq= ed->seqbasep->first; seq; seq= seq->next) {
|
||||
if(seq->flag & SELECT && (seq != (*seq_act))) {
|
||||
if(*seq_other) {
|
||||
return 0;
|
||||
}
|
||||
else {
|
||||
*seq_other= seq;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return (*seq_other != NULL);
|
||||
}
|
||||
}
|
||||
|
||||
/* api like funcs for adding */
|
||||
|
||||
void seq_load_apply(Scene *scene, Sequence *seq, SeqLoadInfo *seq_load)
|
||||
@ -3861,7 +3918,7 @@ void seq_load_apply(Scene *scene, Sequence *seq, SeqLoadInfo *seq_load)
|
||||
|
||||
if(seq_load->flag & SEQ_LOAD_REPLACE_SEL) {
|
||||
seq_load->flag |= SELECT;
|
||||
active_seq_set(scene, seq);
|
||||
seq_active_set(scene, seq);
|
||||
}
|
||||
|
||||
if(seq_load->flag & SEQ_LOAD_SOUND_CACHE) {
|
||||
@ -3934,7 +3991,7 @@ Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
|
||||
|
||||
AUD_SoundInfo info;
|
||||
|
||||
sound = sound_new_file(CTX_data_main(C), seq_load->path);
|
||||
sound = sound_new_file(CTX_data_main(C), seq_load->path); /* handles relative paths */
|
||||
|
||||
if (sound==NULL || sound->playback_handle == NULL) {
|
||||
//if(op)
|
||||
@ -3982,6 +4039,7 @@ Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
|
||||
Sequence *sequencer_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C); /* only for sound */
|
||||
char path[sizeof(seq_load->path)];
|
||||
|
||||
Sequence *seq, *soundseq; /* generic strip vars */
|
||||
Strip *strip;
|
||||
@ -3989,7 +4047,10 @@ Sequence *sequencer_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
|
||||
|
||||
struct anim *an;
|
||||
|
||||
an = openanim(seq_load->path, IB_rect);
|
||||
BLI_strncpy(path, seq_load->path, sizeof(path));
|
||||
BLI_path_abs(path, G.sce);
|
||||
|
||||
an = openanim(path, IB_rect);
|
||||
|
||||
if(an==NULL)
|
||||
return NULL;
|
||||
@ -4029,3 +4090,131 @@ Sequence *sequencer_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
|
||||
|
||||
return seq;
|
||||
}
|
||||
|
||||
|
||||
static Sequence *seq_dupli(struct Scene *scene, Sequence *seq, int dupe_flag)
|
||||
{
|
||||
Sequence *seqn = MEM_dupallocN(seq);
|
||||
|
||||
seq->tmp = seqn;
|
||||
seqn->strip= MEM_dupallocN(seq->strip);
|
||||
|
||||
// XXX: add F-Curve duplication stuff?
|
||||
|
||||
seqn->strip->tstripdata = 0;
|
||||
seqn->strip->tstripdata_startstill = 0;
|
||||
seqn->strip->tstripdata_endstill = 0;
|
||||
seqn->strip->ibuf_startstill = 0;
|
||||
seqn->strip->ibuf_endstill = 0;
|
||||
|
||||
if (seq->strip->crop) {
|
||||
seqn->strip->crop = MEM_dupallocN(seq->strip->crop);
|
||||
}
|
||||
|
||||
if (seq->strip->transform) {
|
||||
seqn->strip->transform = MEM_dupallocN(seq->strip->transform);
|
||||
}
|
||||
|
||||
if (seq->strip->proxy) {
|
||||
seqn->strip->proxy = MEM_dupallocN(seq->strip->proxy);
|
||||
}
|
||||
|
||||
if (seq->strip->color_balance) {
|
||||
seqn->strip->color_balance
|
||||
= MEM_dupallocN(seq->strip->color_balance);
|
||||
}
|
||||
|
||||
if(seq->type==SEQ_META) {
|
||||
seqn->strip->stripdata = 0;
|
||||
|
||||
seqn->seqbase.first= seqn->seqbase.last= 0;
|
||||
/* WATCH OUT!!! - This metastrip is not recursively duplicated here - do this after!!! */
|
||||
/* - seq_dupli_recursive(&seq->seqbase,&seqn->seqbase);*/
|
||||
} else if(seq->type == SEQ_SCENE) {
|
||||
seqn->strip->stripdata = 0;
|
||||
if(seq->scene_sound)
|
||||
seqn->scene_sound = sound_scene_add_scene_sound(scene, seqn, seq->startdisp, seq->enddisp, seq->startofs + seq->anim_startofs);
|
||||
} else if(seq->type == SEQ_MOVIE) {
|
||||
seqn->strip->stripdata =
|
||||
MEM_dupallocN(seq->strip->stripdata);
|
||||
seqn->anim= 0;
|
||||
} else if(seq->type == SEQ_SOUND) {
|
||||
seqn->strip->stripdata =
|
||||
MEM_dupallocN(seq->strip->stripdata);
|
||||
if(seq->scene_sound)
|
||||
seqn->scene_sound = sound_add_scene_sound(scene, seqn, seq->startdisp, seq->enddisp, seq->startofs + seq->anim_startofs);
|
||||
|
||||
seqn->sound->id.us++;
|
||||
} else if(seq->type == SEQ_IMAGE) {
|
||||
seqn->strip->stripdata =
|
||||
MEM_dupallocN(seq->strip->stripdata);
|
||||
} else if(seq->type >= SEQ_EFFECT) {
|
||||
if(seq->seq1 && seq->seq1->tmp) seqn->seq1= seq->seq1->tmp;
|
||||
if(seq->seq2 && seq->seq2->tmp) seqn->seq2= seq->seq2->tmp;
|
||||
if(seq->seq3 && seq->seq3->tmp) seqn->seq3= seq->seq3->tmp;
|
||||
|
||||
if (seq->type & SEQ_EFFECT) {
|
||||
struct SeqEffectHandle sh;
|
||||
sh = get_sequence_effect(seq);
|
||||
if(sh.copy)
|
||||
sh.copy(seq, seqn);
|
||||
}
|
||||
|
||||
seqn->strip->stripdata = 0;
|
||||
|
||||
} else {
|
||||
fprintf(stderr, "Aiiiiekkk! sequence type not "
|
||||
"handled in duplicate!\nExpect a crash"
|
||||
" now...\n");
|
||||
}
|
||||
|
||||
if(dupe_flag & SEQ_DUPE_UNIQUE_NAME)
|
||||
seqbase_unique_name_recursive(&scene->ed->seqbase, seqn);
|
||||
|
||||
return seqn;
|
||||
}
|
||||
|
||||
Sequence * seq_dupli_recursive(struct Scene *scene, Sequence * seq, int dupe_flag)
|
||||
{
|
||||
Sequence * seqn = seq_dupli(scene, seq, dupe_flag);
|
||||
if (seq->type == SEQ_META) {
|
||||
Sequence *s;
|
||||
for(s= seq->seqbase.first; s; s = s->next) {
|
||||
Sequence *n = seq_dupli_recursive(scene, s, dupe_flag);
|
||||
if (n) {
|
||||
BLI_addtail(&seqn->seqbase, n);
|
||||
}
|
||||
}
|
||||
}
|
||||
return seqn;
|
||||
}
|
||||
|
||||
void seqbase_dupli_recursive(Scene *scene, ListBase *nseqbase, ListBase *seqbase, int dupe_flag)
|
||||
{
|
||||
Sequence *seq;
|
||||
Sequence *seqn = 0;
|
||||
Sequence *last_seq = seq_active_get(scene);
|
||||
|
||||
for(seq= seqbase->first; seq; seq= seq->next) {
|
||||
seq->tmp= NULL;
|
||||
if(seq->flag & SELECT) {
|
||||
seqn = seq_dupli(scene, seq, dupe_flag);
|
||||
if (seqn) { /*should never fail */
|
||||
if(dupe_flag & SEQ_DUPE_CONTEXT) {
|
||||
seq->flag &= ~SEQ_ALLSEL;
|
||||
seqn->flag &= ~(SEQ_LEFTSEL+SEQ_RIGHTSEL+SEQ_LOCK);
|
||||
}
|
||||
|
||||
BLI_addtail(nseqbase, seqn);
|
||||
if(seq->type==SEQ_META)
|
||||
seqbase_dupli_recursive(scene, &seqn->seqbase, &seq->seqbase, dupe_flag);
|
||||
|
||||
if(dupe_flag & SEQ_DUPE_CONTEXT) {
|
||||
if (seq == last_seq) {
|
||||
seq_active_set(scene, seqn);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -509,6 +509,27 @@ void default_tex(Tex *tex)
|
||||
tex->preview = NULL;
|
||||
}
|
||||
|
||||
void tex_set_type(Tex *tex, int type)
|
||||
{
|
||||
switch(type) {
|
||||
|
||||
case TEX_VOXELDATA:
|
||||
if (tex->vd == NULL)
|
||||
tex->vd = BKE_add_voxeldata();
|
||||
break;
|
||||
case TEX_POINTDENSITY:
|
||||
if (tex->pd == NULL)
|
||||
tex->pd = BKE_add_pointdensity();
|
||||
break;
|
||||
case TEX_ENVMAP:
|
||||
if (tex->env == NULL)
|
||||
tex->env = BKE_add_envmap();
|
||||
break;
|
||||
}
|
||||
|
||||
tex->type = type;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------------- */
|
||||
|
||||
Tex *add_texture(const char *name)
|
||||
|
30
source/blender/blenlib/BLI_cpu.h
Normal file
30
source/blender/blenlib/BLI_cpu.h
Normal file
@ -0,0 +1,30 @@
|
||||
/*
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
* ***** 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.
|
||||
*
|
||||
* ***** END GPL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#ifndef BLI_CPU_H
|
||||
#define BLI_CPU_H
|
||||
|
||||
int BLI_cpu_support_sse2(void);
|
||||
|
||||
#endif
|
||||
|
@ -47,11 +47,14 @@ typedef struct LinkNode {
|
||||
int BLI_linklist_length (struct LinkNode *list);
|
||||
int BLI_linklist_index (struct LinkNode *list, void *ptr);
|
||||
|
||||
struct LinkNode *BLI_linklist_find (struct LinkNode *list, int index);
|
||||
|
||||
void BLI_linklist_reverse (struct LinkNode **listp);
|
||||
|
||||
void BLI_linklist_prepend (struct LinkNode **listp, void *ptr);
|
||||
void BLI_linklist_append (struct LinkNode **listp, void *ptr);
|
||||
void BLI_linklist_prepend_arena (struct LinkNode **listp, void *ptr, struct MemArena *ma);
|
||||
void BLI_linklist_insert_after (struct LinkNode **listp, void *ptr);
|
||||
|
||||
void BLI_linklist_free (struct LinkNode *list, LinkNodeFreeFP freefunc);
|
||||
void BLI_linklist_apply (struct LinkNode *list, LinkNodeApplyFP applyfunc, void *userdata);
|
||||
|
@ -115,6 +115,9 @@ extern "C" {
|
||||
#ifndef fmodf
|
||||
#define fmodf(a, b) ((float)fmod(a, b))
|
||||
#endif
|
||||
#ifndef hypotf
|
||||
#define hypotf(a, b) ((float)hypot(a, b))
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
#ifndef FREE_WINDOWS
|
||||
|
@ -38,11 +38,14 @@ extern "C" {
|
||||
#ifdef BLI_MATH_INLINE
|
||||
#ifdef _MSC_VER
|
||||
#define MINLINE static __forceinline
|
||||
#define MALWAYS_INLINE MINLINE
|
||||
#else
|
||||
#define MINLINE static inline
|
||||
#define MALWAYS_INLINE static __attribute__((always_inline))
|
||||
#endif
|
||||
#else
|
||||
#define MINLINE
|
||||
#define MALWAYS_INLINE
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
@ -122,6 +122,9 @@ float determinant_m3(
|
||||
float g, float h, float i);
|
||||
float determinant_m4(float A[4][4]);
|
||||
|
||||
void svd_m4(float U[4][4], float s[4], float V[4][4], float A[4][4]);
|
||||
void pseudoinverse_m4_m4(float Ainv[4][4], float A[4][4], float epsilon);
|
||||
|
||||
/****************************** Transformations ******************************/
|
||||
|
||||
void scale_m3_fl(float R[3][3], float scale);
|
||||
|
@ -114,6 +114,12 @@ void BLI_pbvh_get_grid_updates(PBVH *bvh, int clear, void ***gridfaces, int *tot
|
||||
void BLI_pbvh_grids_update(PBVH *bvh, struct DMGridData **grids,
|
||||
struct DMGridAdjacency *gridadj, void **gridfaces);
|
||||
|
||||
/* vertex deformer */
|
||||
float (*BLI_pbvh_get_vertCos(struct PBVH *pbvh))[3];
|
||||
void BLI_pbvh_apply_vertCos(struct PBVH *pbvh, float (*vertCos)[3]);
|
||||
int BLI_pbvh_isDeformed(struct PBVH *pbvh);
|
||||
|
||||
|
||||
/* Vertex Iterator */
|
||||
|
||||
/* this iterator has quite a lot of code, but it's designed to:
|
||||
|
@ -45,18 +45,28 @@ int BLI_linklist_length(LinkNode *list) {
|
||||
}
|
||||
}
|
||||
|
||||
int BLI_linklist_index(struct LinkNode *list, void *ptr)
|
||||
int BLI_linklist_index(LinkNode *list, void *ptr)
|
||||
{
|
||||
int index;
|
||||
|
||||
for (index = 0; list; list= list->next, index++) {
|
||||
for (index = 0; list; list= list->next, index++)
|
||||
if (list->link == ptr)
|
||||
return index;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
LinkNode *BLI_linklist_find(LinkNode *list, int index)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; list; list= list->next, i++)
|
||||
if (i == index)
|
||||
return list;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void BLI_linklist_reverse(LinkNode **listp) {
|
||||
LinkNode *rhead= NULL, *cur= *listp;
|
||||
|
||||
@ -105,6 +115,22 @@ void BLI_linklist_prepend_arena(LinkNode **listp, void *ptr, MemArena *ma) {
|
||||
*listp= nlink;
|
||||
}
|
||||
|
||||
void BLI_linklist_insert_after(LinkNode **listp, void *ptr) {
|
||||
LinkNode *nlink= MEM_mallocN(sizeof(*nlink), "nlink");
|
||||
LinkNode *node = *listp;
|
||||
|
||||
nlink->link = ptr;
|
||||
|
||||
if(node) {
|
||||
nlink->next = node->next;
|
||||
node->next = nlink;
|
||||
}
|
||||
else {
|
||||
nlink->next = NULL;
|
||||
*listp = nlink;
|
||||
}
|
||||
}
|
||||
|
||||
void BLI_linklist_free(LinkNode *list, LinkNodeFreeFP freefunc) {
|
||||
while (list) {
|
||||
LinkNode *next= list->next;
|
||||
|
57
source/blender/blenlib/intern/cpu.c
Normal file
57
source/blender/blenlib/intern/cpu.c
Normal file
@ -0,0 +1,57 @@
|
||||
/**
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
* ***** 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.
|
||||
*
|
||||
* ***** END GPL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include "BLI_cpu.h"
|
||||
|
||||
int BLI_cpu_support_sse2(void)
|
||||
{
|
||||
#if defined(__x86_64__) || defined(_M_X64)
|
||||
/* x86_64 always has SSE2 instructions */
|
||||
return 1;
|
||||
#elif defined(__GNUC__) && defined(i386)
|
||||
/* for GCC x86 we check cpuid */
|
||||
unsigned int d;
|
||||
__asm__(
|
||||
"pushl %%ebx\n\t"
|
||||
"cpuid\n\t"
|
||||
"popl %%ebx\n\t"
|
||||
: "=d"(d)
|
||||
: "a"(1));
|
||||
return (d & 0x04000000) != 0;
|
||||
#elif (defined(_MSC_VER) && defined(_M_IX86))
|
||||
/* also check cpuid for MSVC x86 */
|
||||
unsigned int d;
|
||||
__asm {
|
||||
xor eax, eax
|
||||
inc eax
|
||||
push ebx
|
||||
cpuid
|
||||
pop ebx
|
||||
mov d, edx
|
||||
}
|
||||
return (d & 0x04000000) != 0;
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -1149,3 +1149,458 @@ void print_m4(char *str, float m[][4])
|
||||
printf("%f %f %f %f\n",m[0][3],m[1][3],m[2][3],m[3][3]);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
/*********************************** SVD ************************************
|
||||
* from TNT matrix library
|
||||
|
||||
* Compute the Single Value Decomposition of an arbitrary matrix A
|
||||
* That is compute the 3 matrices U,W,V with U column orthogonal (m,n)
|
||||
* ,W a diagonal matrix and V an orthogonal square matrix s.t.
|
||||
* A = U.W.Vt. From this decomposition it is trivial to compute the
|
||||
* (pseudo-inverse) of A as Ainv = V.Winv.tranpose(U).
|
||||
*/
|
||||
|
||||
void svd_m4(float U[4][4], float s[4], float V[4][4], float A_[4][4])
|
||||
{
|
||||
float A[4][4];
|
||||
float work1[4], work2[4];
|
||||
int m = 4;
|
||||
int n = 4;
|
||||
int maxiter = 200;
|
||||
int nu = minf(m,n);
|
||||
|
||||
float *work = work1;
|
||||
float *e = work2;
|
||||
float eps;
|
||||
|
||||
int i=0, j=0, k=0, p, pp, iter;
|
||||
|
||||
// Reduce A to bidiagonal form, storing the diagonal elements
|
||||
// in s and the super-diagonal elements in e.
|
||||
|
||||
int nct = minf(m-1,n);
|
||||
int nrt = maxf(0,minf(n-2,m));
|
||||
|
||||
copy_m4_m4(A, A_);
|
||||
zero_m4(U);
|
||||
zero_v4(s);
|
||||
|
||||
for (k = 0; k < maxf(nct,nrt); k++) {
|
||||
if (k < nct) {
|
||||
|
||||
// Compute the transformation for the k-th column and
|
||||
// place the k-th diagonal in s[k].
|
||||
// Compute 2-norm of k-th column without under/overflow.
|
||||
s[k] = 0;
|
||||
for (i = k; i < m; i++) {
|
||||
s[k] = hypotf(s[k],A[i][k]);
|
||||
}
|
||||
if (s[k] != 0.0f) {
|
||||
float invsk;
|
||||
if (A[k][k] < 0.0f) {
|
||||
s[k] = -s[k];
|
||||
}
|
||||
invsk = 1.0f/s[k];
|
||||
for (i = k; i < m; i++) {
|
||||
A[i][k] *= invsk;
|
||||
}
|
||||
A[k][k] += 1.0f;
|
||||
}
|
||||
s[k] = -s[k];
|
||||
}
|
||||
for (j = k+1; j < n; j++) {
|
||||
if ((k < nct) && (s[k] != 0.0f)) {
|
||||
|
||||
// Apply the transformation.
|
||||
|
||||
float t = 0;
|
||||
for (i = k; i < m; i++) {
|
||||
t += A[i][k]*A[i][j];
|
||||
}
|
||||
t = -t/A[k][k];
|
||||
for (i = k; i < m; i++) {
|
||||
A[i][j] += t*A[i][k];
|
||||
}
|
||||
}
|
||||
|
||||
// Place the k-th row of A into e for the
|
||||
// subsequent calculation of the row transformation.
|
||||
|
||||
e[j] = A[k][j];
|
||||
}
|
||||
if (k < nct) {
|
||||
|
||||
// Place the transformation in U for subsequent back
|
||||
// multiplication.
|
||||
|
||||
for (i = k; i < m; i++)
|
||||
U[i][k] = A[i][k];
|
||||
}
|
||||
if (k < nrt) {
|
||||
|
||||
// Compute the k-th row transformation and place the
|
||||
// k-th super-diagonal in e[k].
|
||||
// Compute 2-norm without under/overflow.
|
||||
e[k] = 0;
|
||||
for (i = k+1; i < n; i++) {
|
||||
e[k] = hypotf(e[k],e[i]);
|
||||
}
|
||||
if (e[k] != 0.0f) {
|
||||
float invek;
|
||||
if (e[k+1] < 0.0f) {
|
||||
e[k] = -e[k];
|
||||
}
|
||||
invek = 1.0f/e[k];
|
||||
for (i = k+1; i < n; i++) {
|
||||
e[i] *= invek;
|
||||
}
|
||||
e[k+1] += 1.0f;
|
||||
}
|
||||
e[k] = -e[k];
|
||||
if ((k+1 < m) & (e[k] != 0.0f)) {
|
||||
float invek1;
|
||||
|
||||
// Apply the transformation.
|
||||
|
||||
for (i = k+1; i < m; i++) {
|
||||
work[i] = 0.0f;
|
||||
}
|
||||
for (j = k+1; j < n; j++) {
|
||||
for (i = k+1; i < m; i++) {
|
||||
work[i] += e[j]*A[i][j];
|
||||
}
|
||||
}
|
||||
invek1 = 1.0f/e[k+1];
|
||||
for (j = k+1; j < n; j++) {
|
||||
float t = -e[j]*invek1;
|
||||
for (i = k+1; i < m; i++) {
|
||||
A[i][j] += t*work[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Place the transformation in V for subsequent
|
||||
// back multiplication.
|
||||
|
||||
for (i = k+1; i < n; i++)
|
||||
V[i][k] = e[i];
|
||||
}
|
||||
}
|
||||
|
||||
// Set up the final bidiagonal matrix or order p.
|
||||
|
||||
p = minf(n,m+1);
|
||||
if (nct < n) {
|
||||
s[nct] = A[nct][nct];
|
||||
}
|
||||
if (m < p) {
|
||||
s[p-1] = 0.0f;
|
||||
}
|
||||
if (nrt+1 < p) {
|
||||
e[nrt] = A[nrt][p-1];
|
||||
}
|
||||
e[p-1] = 0.0f;
|
||||
|
||||
// If required, generate U.
|
||||
|
||||
for (j = nct; j < nu; j++) {
|
||||
for (i = 0; i < m; i++) {
|
||||
U[i][j] = 0.0f;
|
||||
}
|
||||
U[j][j] = 1.0f;
|
||||
}
|
||||
for (k = nct-1; k >= 0; k--) {
|
||||
if (s[k] != 0.0f) {
|
||||
for (j = k+1; j < nu; j++) {
|
||||
float t = 0;
|
||||
for (i = k; i < m; i++) {
|
||||
t += U[i][k]*U[i][j];
|
||||
}
|
||||
t = -t/U[k][k];
|
||||
for (i = k; i < m; i++) {
|
||||
U[i][j] += t*U[i][k];
|
||||
}
|
||||
}
|
||||
for (i = k; i < m; i++ ) {
|
||||
U[i][k] = -U[i][k];
|
||||
}
|
||||
U[k][k] = 1.0f + U[k][k];
|
||||
for (i = 0; i < k-1; i++) {
|
||||
U[i][k] = 0.0f;
|
||||
}
|
||||
} else {
|
||||
for (i = 0; i < m; i++) {
|
||||
U[i][k] = 0.0f;
|
||||
}
|
||||
U[k][k] = 1.0f;
|
||||
}
|
||||
}
|
||||
|
||||
// If required, generate V.
|
||||
|
||||
for (k = n-1; k >= 0; k--) {
|
||||
if ((k < nrt) & (e[k] != 0.0f)) {
|
||||
for (j = k+1; j < nu; j++) {
|
||||
float t = 0;
|
||||
for (i = k+1; i < n; i++) {
|
||||
t += V[i][k]*V[i][j];
|
||||
}
|
||||
t = -t/V[k+1][k];
|
||||
for (i = k+1; i < n; i++) {
|
||||
V[i][j] += t*V[i][k];
|
||||
}
|
||||
}
|
||||
}
|
||||
for (i = 0; i < n; i++) {
|
||||
V[i][k] = 0.0f;
|
||||
}
|
||||
V[k][k] = 1.0f;
|
||||
}
|
||||
|
||||
// Main iteration loop for the singular values.
|
||||
|
||||
pp = p-1;
|
||||
iter = 0;
|
||||
eps = powf(2.0f,-52.0f);
|
||||
while (p > 0) {
|
||||
int kase=0;
|
||||
k=0;
|
||||
|
||||
// Test for maximum iterations to avoid infinite loop
|
||||
if(maxiter == 0)
|
||||
break;
|
||||
maxiter--;
|
||||
|
||||
// This section of the program inspects for
|
||||
// negligible elements in the s and e arrays. On
|
||||
// completion the variables kase and k are set as follows.
|
||||
|
||||
// kase = 1 if s(p) and e[k-1] are negligible and k<p
|
||||
// kase = 2 if s(k) is negligible and k<p
|
||||
// kase = 3 if e[k-1] is negligible, k<p, and
|
||||
// s(k), ..., s(p) are not negligible (qr step).
|
||||
// kase = 4 if e(p-1) is negligible (convergence).
|
||||
|
||||
for (k = p-2; k >= -1; k--) {
|
||||
if (k == -1) {
|
||||
break;
|
||||
}
|
||||
if (fabsf(e[k]) <= eps*(fabsf(s[k]) + fabsf(s[k+1]))) {
|
||||
e[k] = 0.0f;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (k == p-2) {
|
||||
kase = 4;
|
||||
} else {
|
||||
int ks;
|
||||
for (ks = p-1; ks >= k; ks--) {
|
||||
float t;
|
||||
if (ks == k) {
|
||||
break;
|
||||
}
|
||||
t = (ks != p ? fabsf(e[ks]) : 0.f) +
|
||||
(ks != k+1 ? fabsf(e[ks-1]) : 0.0f);
|
||||
if (fabsf(s[ks]) <= eps*t) {
|
||||
s[ks] = 0.0f;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (ks == k) {
|
||||
kase = 3;
|
||||
} else if (ks == p-1) {
|
||||
kase = 1;
|
||||
} else {
|
||||
kase = 2;
|
||||
k = ks;
|
||||
}
|
||||
}
|
||||
k++;
|
||||
|
||||
// Perform the task indicated by kase.
|
||||
|
||||
switch (kase) {
|
||||
|
||||
// Deflate negligible s(p).
|
||||
|
||||
case 1: {
|
||||
float f = e[p-2];
|
||||
e[p-2] = 0.0f;
|
||||
for (j = p-2; j >= k; j--) {
|
||||
float t = hypotf(s[j],f);
|
||||
float invt = 1.0f/t;
|
||||
float cs = s[j]*invt;
|
||||
float sn = f*invt;
|
||||
s[j] = t;
|
||||
if (j != k) {
|
||||
f = -sn*e[j-1];
|
||||
e[j-1] = cs*e[j-1];
|
||||
}
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
t = cs*V[i][j] + sn*V[i][p-1];
|
||||
V[i][p-1] = -sn*V[i][j] + cs*V[i][p-1];
|
||||
V[i][j] = t;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
// Split at negligible s(k).
|
||||
|
||||
case 2: {
|
||||
float f = e[k-1];
|
||||
e[k-1] = 0.0f;
|
||||
for (j = k; j < p; j++) {
|
||||
float t = hypotf(s[j],f);
|
||||
float invt = 1.0f/t;
|
||||
float cs = s[j]*invt;
|
||||
float sn = f*invt;
|
||||
s[j] = t;
|
||||
f = -sn*e[j];
|
||||
e[j] = cs*e[j];
|
||||
|
||||
for (i = 0; i < m; i++) {
|
||||
t = cs*U[i][j] + sn*U[i][k-1];
|
||||
U[i][k-1] = -sn*U[i][j] + cs*U[i][k-1];
|
||||
U[i][j] = t;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
// Perform one qr step.
|
||||
|
||||
case 3: {
|
||||
|
||||
// Calculate the shift.
|
||||
|
||||
float scale = maxf(maxf(maxf(maxf(
|
||||
fabsf(s[p-1]),fabsf(s[p-2])),fabsf(e[p-2])),
|
||||
fabsf(s[k])),fabsf(e[k]));
|
||||
float invscale = 1.0f/scale;
|
||||
float sp = s[p-1]*invscale;
|
||||
float spm1 = s[p-2]*invscale;
|
||||
float epm1 = e[p-2]*invscale;
|
||||
float sk = s[k]*invscale;
|
||||
float ek = e[k]*invscale;
|
||||
float b = ((spm1 + sp)*(spm1 - sp) + epm1*epm1)*0.5f;
|
||||
float c = (sp*epm1)*(sp*epm1);
|
||||
float shift = 0.0f;
|
||||
float f, g;
|
||||
if ((b != 0.0f) || (c != 0.0f)) {
|
||||
shift = sqrtf(b*b + c);
|
||||
if (b < 0.0f) {
|
||||
shift = -shift;
|
||||
}
|
||||
shift = c/(b + shift);
|
||||
}
|
||||
f = (sk + sp)*(sk - sp) + shift;
|
||||
g = sk*ek;
|
||||
|
||||
// Chase zeros.
|
||||
|
||||
for (j = k; j < p-1; j++) {
|
||||
float t = hypotf(f,g);
|
||||
/* division by zero checks added to avoid NaN (brecht) */
|
||||
float cs = (t == 0.0f)? 0.0f: f/t;
|
||||
float sn = (t == 0.0f)? 0.0f: g/t;
|
||||
if (j != k) {
|
||||
e[j-1] = t;
|
||||
}
|
||||
f = cs*s[j] + sn*e[j];
|
||||
e[j] = cs*e[j] - sn*s[j];
|
||||
g = sn*s[j+1];
|
||||
s[j+1] = cs*s[j+1];
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
t = cs*V[i][j] + sn*V[i][j+1];
|
||||
V[i][j+1] = -sn*V[i][j] + cs*V[i][j+1];
|
||||
V[i][j] = t;
|
||||
}
|
||||
|
||||
t = hypotf(f,g);
|
||||
/* division by zero checks added to avoid NaN (brecht) */
|
||||
cs = (t == 0.0f)? 0.0f: f/t;
|
||||
sn = (t == 0.0f)? 0.0f: g/t;
|
||||
s[j] = t;
|
||||
f = cs*e[j] + sn*s[j+1];
|
||||
s[j+1] = -sn*e[j] + cs*s[j+1];
|
||||
g = sn*e[j+1];
|
||||
e[j+1] = cs*e[j+1];
|
||||
if (j < m-1) {
|
||||
for (i = 0; i < m; i++) {
|
||||
t = cs*U[i][j] + sn*U[i][j+1];
|
||||
U[i][j+1] = -sn*U[i][j] + cs*U[i][j+1];
|
||||
U[i][j] = t;
|
||||
}
|
||||
}
|
||||
}
|
||||
e[p-2] = f;
|
||||
iter = iter + 1;
|
||||
}
|
||||
break;
|
||||
|
||||
// Convergence.
|
||||
|
||||
case 4: {
|
||||
|
||||
// Make the singular values positive.
|
||||
|
||||
if (s[k] <= 0.0f) {
|
||||
s[k] = (s[k] < 0.0f ? -s[k] : 0.0f);
|
||||
|
||||
for (i = 0; i <= pp; i++)
|
||||
V[i][k] = -V[i][k];
|
||||
}
|
||||
|
||||
// Order the singular values.
|
||||
|
||||
while (k < pp) {
|
||||
float t;
|
||||
if (s[k] >= s[k+1]) {
|
||||
break;
|
||||
}
|
||||
t = s[k];
|
||||
s[k] = s[k+1];
|
||||
s[k+1] = t;
|
||||
if (k < n-1) {
|
||||
for (i = 0; i < n; i++) {
|
||||
t = V[i][k+1]; V[i][k+1] = V[i][k]; V[i][k] = t;
|
||||
}
|
||||
}
|
||||
if (k < m-1) {
|
||||
for (i = 0; i < m; i++) {
|
||||
t = U[i][k+1]; U[i][k+1] = U[i][k]; U[i][k] = t;
|
||||
}
|
||||
}
|
||||
k++;
|
||||
}
|
||||
iter = 0;
|
||||
p--;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void pseudoinverse_m4_m4(float Ainv[4][4], float A[4][4], float epsilon)
|
||||
{
|
||||
/* compute moon-penrose pseudo inverse of matrix, singular values
|
||||
below epsilon are ignored for stability (truncated SVD) */
|
||||
float V[4][4], W[4], Wm[4][4], U[4][4];
|
||||
int i;
|
||||
|
||||
transpose_m4(A);
|
||||
svd_m4(V, W, U, A);
|
||||
transpose_m4(U);
|
||||
transpose_m4(V);
|
||||
|
||||
zero_m4(Wm);
|
||||
for(i=0; i<4; i++)
|
||||
Wm[i][i]= (W[i] < epsilon)? 0.0f: 1.0f/W[i];
|
||||
|
||||
transpose_m4(V);
|
||||
|
||||
mul_serie_m4(Ainv, U, Wm, V, 0, 0, 0, 0, 0);
|
||||
}
|
||||
|
@ -199,8 +199,15 @@ float hashvectf[768]= {
|
||||
/* IMPROVED PERLIN NOISE */
|
||||
/**************************/
|
||||
|
||||
#define lerp(t, a, b) ((a)+(t)*((b)-(a)))
|
||||
#define npfade(t) ((t)*(t)*(t)*((t)*((t)*6-15)+10))
|
||||
static float lerp(float t, float a, float b)
|
||||
{
|
||||
return (a+t*(b-a));
|
||||
}
|
||||
|
||||
static float npfade(float t)
|
||||
{
|
||||
return (t*t*t*(t*(t*6.0f-15.0f)+10.0f));
|
||||
}
|
||||
|
||||
static float grad(int hash, float x, float y, float z)
|
||||
{
|
||||
|
@ -29,6 +29,7 @@
|
||||
#include "BLI_pbvh.h"
|
||||
|
||||
#include "BKE_DerivedMesh.h"
|
||||
#include "BKE_mesh.h" /* for mesh_calc_normals */
|
||||
|
||||
#include "gpu_buffers.h"
|
||||
|
||||
@ -120,6 +121,9 @@ struct PBVH {
|
||||
#ifdef PERFCNTRS
|
||||
int perf_modified;
|
||||
#endif
|
||||
|
||||
/* flag are verts/faces deformed */
|
||||
int deformed;
|
||||
};
|
||||
|
||||
#define STACK_FIXED_DEPTH 100
|
||||
@ -576,6 +580,15 @@ void BLI_pbvh_free(PBVH *bvh)
|
||||
}
|
||||
}
|
||||
|
||||
if (bvh->deformed) {
|
||||
if (bvh->verts) {
|
||||
/* if pbvh was deformed, new memory was allocated for verts/faces -- free it */
|
||||
|
||||
MEM_freeN(bvh->verts);
|
||||
MEM_freeN(bvh->faces);
|
||||
}
|
||||
}
|
||||
|
||||
MEM_freeN(bvh->nodes);
|
||||
MEM_freeN(bvh->prim_indices);
|
||||
MEM_freeN(bvh);
|
||||
@ -1330,3 +1343,55 @@ void BLI_pbvh_grids_update(PBVH *bvh, DMGridData **grids, DMGridAdjacency *grida
|
||||
bvh->gridfaces= gridfaces;
|
||||
}
|
||||
|
||||
float (*BLI_pbvh_get_vertCos(PBVH *pbvh))[3]
|
||||
{
|
||||
int a;
|
||||
float (*vertCos)[3]= NULL;
|
||||
|
||||
if (pbvh->verts) {
|
||||
float *co;
|
||||
MVert *mvert= pbvh->verts;
|
||||
|
||||
vertCos= MEM_callocN(3*pbvh->totvert*sizeof(float), "BLI_pbvh_get_vertCoords");
|
||||
co= (float*)vertCos;
|
||||
|
||||
for (a= 0; a<pbvh->totvert; a++, mvert++, co+= 3) {
|
||||
copy_v3_v3(co, mvert->co);
|
||||
}
|
||||
}
|
||||
|
||||
return vertCos;
|
||||
}
|
||||
|
||||
void BLI_pbvh_apply_vertCos(PBVH *pbvh, float (*vertCos)[3])
|
||||
{
|
||||
int a;
|
||||
|
||||
if (!pbvh->deformed) {
|
||||
if (pbvh->verts) {
|
||||
/* if pbvh is not already deformed, verts/faces points to the */
|
||||
/* original data and applying new coords to this arrays would lead to */
|
||||
/* unneeded deformation -- duplicate verts/faces to avoid this */
|
||||
|
||||
pbvh->verts= MEM_dupallocN(pbvh->verts);
|
||||
pbvh->faces= MEM_dupallocN(pbvh->faces);
|
||||
|
||||
pbvh->deformed= 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (pbvh->verts) {
|
||||
/* copy new verts coords */
|
||||
for (a= 0; a < pbvh->totvert; ++a) {
|
||||
copy_v3_v3(pbvh->verts[a].co, vertCos[a]);
|
||||
}
|
||||
|
||||
/* coordinates are new -- normals should also be updated */
|
||||
mesh_calc_normals(pbvh->verts, pbvh->totvert, pbvh->faces, pbvh->totprim, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
int BLI_pbvh_isDeformed(PBVH *pbvh)
|
||||
{
|
||||
return pbvh->deformed;
|
||||
}
|
||||
|
@ -158,20 +158,20 @@ void BLI_init_threads(ListBase *threadbase, void *(*do_thread)(void *), int tot)
|
||||
tslot->do_thread= do_thread;
|
||||
tslot->avail= 1;
|
||||
}
|
||||
|
||||
if(thread_levels == 0) {
|
||||
MEM_set_lock_callback(BLI_lock_malloc_thread, BLI_unlock_malloc_thread);
|
||||
}
|
||||
|
||||
if(thread_levels == 0) {
|
||||
MEM_set_lock_callback(BLI_lock_malloc_thread, BLI_unlock_malloc_thread);
|
||||
|
||||
#if defined(__APPLE__) && (PARALLEL == 1) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 2)
|
||||
/* workaround for Apple gcc 4.2.1 omp vs background thread bug,
|
||||
we copy gomp thread local storage pointer to setting it again
|
||||
inside the thread that we start */
|
||||
thread_tls_data = pthread_getspecific(gomp_tls_key);
|
||||
/* workaround for Apple gcc 4.2.1 omp vs background thread bug,
|
||||
we copy gomp thread local storage pointer to setting it again
|
||||
inside the thread that we start */
|
||||
thread_tls_data = pthread_getspecific(gomp_tls_key);
|
||||
#endif
|
||||
}
|
||||
|
||||
thread_levels++;
|
||||
}
|
||||
|
||||
thread_levels++;
|
||||
}
|
||||
|
||||
/* amount of available threads */
|
||||
@ -287,11 +287,11 @@ void BLI_end_threads(ListBase *threadbase)
|
||||
}
|
||||
}
|
||||
BLI_freelistN(threadbase);
|
||||
|
||||
thread_levels--;
|
||||
if(thread_levels==0)
|
||||
MEM_set_lock_callback(NULL, NULL);
|
||||
}
|
||||
|
||||
thread_levels--;
|
||||
if(thread_levels==0)
|
||||
MEM_set_lock_callback(NULL, NULL);
|
||||
}
|
||||
|
||||
/* System Information */
|
||||
|
@ -138,7 +138,7 @@
|
||||
#include "BKE_sequencer.h"
|
||||
#include "BKE_texture.h" // for open_plugin_tex
|
||||
#include "BKE_utildefines.h" // SWITCH_INT DATA ENDB DNA1 O_BINARY GLOB USER TEST REND
|
||||
|
||||
#include "BKE_ipo.h"
|
||||
#include "BKE_sound.h"
|
||||
|
||||
//XXX #include "BIF_butspace.h" // badlevel, for do_versions, patching event codes
|
||||
@ -5173,6 +5173,10 @@ static void direct_link_screen(FileData *fd, bScreen *sc)
|
||||
}
|
||||
snode->nodetree= snode->edittree= NULL;
|
||||
}
|
||||
else if(sl->spacetype==SPACE_TIME) {
|
||||
SpaceTime *stime= (SpaceTime *)sl;
|
||||
stime->caches.first= stime->caches.last= NULL;
|
||||
}
|
||||
else if(sl->spacetype==SPACE_LOGIC) {
|
||||
SpaceLogic *slogic= (SpaceLogic *)sl;
|
||||
|
||||
@ -9758,11 +9762,6 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
|
||||
do_versions_gpencil_2_50(main, screen);
|
||||
}
|
||||
|
||||
/* old Animation System (using IPO's) needs to be converted to the new Animato system
|
||||
* (NOTE: conversion code in blenkernel/intern/ipo.c for now)
|
||||
*/
|
||||
//do_versions_ipos_to_animato(main);
|
||||
|
||||
/* shader, composit and texture node trees have id.name empty, put something in
|
||||
* to have them show in RNA viewer and accessible otherwise.
|
||||
*/
|
||||
@ -10886,14 +10885,21 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
|
||||
SpaceLink *sl;
|
||||
for (sl= sa->spacedata.first; sl; sl= sl->next) {
|
||||
if (sl->spacetype == SPACE_NODE) {
|
||||
SpaceNode *snode;
|
||||
|
||||
snode= (SpaceNode *)sl;
|
||||
SpaceNode *snode= (SpaceNode *)sl;
|
||||
|
||||
if (snode->v2d.minzoom > 0.09f)
|
||||
snode->v2d.minzoom= 0.09f;
|
||||
if (snode->v2d.maxzoom < 2.31f)
|
||||
snode->v2d.maxzoom= 2.31f;
|
||||
}
|
||||
else if (sl->spacetype == SPACE_TIME) {
|
||||
SpaceTime *stime= (SpaceTime *)sl;
|
||||
|
||||
/* enable all cache display */
|
||||
stime->cache_display |= TIME_CACHE_DISPLAY;
|
||||
stime->cache_display |= (TIME_CACHE_SOFTBODY|TIME_CACHE_PARTICLES);
|
||||
stime->cache_display |= (TIME_CACHE_CLOTH|TIME_CACHE_SMOKE);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -10954,6 +10960,14 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
|
||||
/* don't forget to set version number in blender.c! */
|
||||
}
|
||||
|
||||
static void do_versions_after_linking(FileData *fd, Library *lib, Main *main)
|
||||
{
|
||||
/* old Animation System (using IPO's) needs to be converted to the new Animato system
|
||||
*/
|
||||
if(main->versionfile < 250)
|
||||
do_versions_ipos_to_animato(main);
|
||||
}
|
||||
|
||||
static void lib_link_all(FileData *fd, Main *main)
|
||||
{
|
||||
oldnewmap_sort(fd);
|
||||
@ -11100,6 +11114,7 @@ BlendFileData *blo_read_file_internal(FileData *fd, const char *filename)
|
||||
blo_join_main(&fd->mainlist);
|
||||
|
||||
lib_link_all(fd, bfd->main);
|
||||
do_versions_after_linking(fd, NULL, bfd->main);
|
||||
lib_verify_nodetree(bfd->main, 1);
|
||||
fix_relpaths_library(fd->relabase, bfd->main); /* make all relative paths, relative to the open blend file */
|
||||
|
||||
|
@ -1543,7 +1543,7 @@ private:
|
||||
vert += 3;
|
||||
}
|
||||
|
||||
filldisplist(&dispbase, &dispbase);
|
||||
filldisplist(&dispbase, &dispbase, 0);
|
||||
|
||||
int tottri = 0;
|
||||
dl= (DispList*)dispbase.first;
|
||||
|
@ -27,7 +27,6 @@ SET(INC
|
||||
../../blenlib
|
||||
../../makesdna
|
||||
../../makesrna
|
||||
../../render/extern/include
|
||||
../../windowmanager
|
||||
../../../../intern/guardedalloc
|
||||
../../../../intern/opennl/extern
|
||||
|
@ -50,7 +50,6 @@ CPPFLAGS += -I../../imbuf
|
||||
CPPFLAGS += -I../../python
|
||||
CPPFLAGS += -I../../gpu
|
||||
CPPFLAGS += -I../../makesrna
|
||||
CPPFLAGS += -I../../render/extern/include
|
||||
CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
|
||||
|
||||
# own include
|
||||
|
@ -5,7 +5,6 @@ sources = env.Glob('*.c')
|
||||
|
||||
incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../imbuf'
|
||||
incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include'
|
||||
incs += ' ../../render/extern/include'
|
||||
incs += ' ../../gpu ../../makesrna #/intern/opennl/extern'
|
||||
|
||||
if env['OURPLATFORM'] == 'linux2':
|
||||
|
@ -130,6 +130,7 @@ void SKETCH_OT_draw_stroke(struct wmOperatorType *ot);
|
||||
void SKETCH_OT_draw_preview(struct wmOperatorType *ot);
|
||||
void SKETCH_OT_finish_stroke(struct wmOperatorType *ot);
|
||||
void SKETCH_OT_cancel_stroke(struct wmOperatorType *ot);
|
||||
void SKETCH_OT_convert(struct wmOperatorType *ot);
|
||||
void SKETCH_OT_select(struct wmOperatorType *ot);
|
||||
|
||||
/* ******************************************************* */
|
||||
|
@ -96,6 +96,7 @@ void ED_operatortypes_armature(void)
|
||||
WM_operatortype_append(SKETCH_OT_draw_preview);
|
||||
WM_operatortype_append(SKETCH_OT_finish_stroke);
|
||||
WM_operatortype_append(SKETCH_OT_cancel_stroke);
|
||||
WM_operatortype_append(SKETCH_OT_convert);
|
||||
WM_operatortype_append(SKETCH_OT_select);
|
||||
|
||||
/* POSE */
|
||||
@ -190,14 +191,15 @@ void ED_keymap_armature(wmKeyConfig *keyconf)
|
||||
WM_keymap_add_item(keymap, "SKETCH_OT_delete", XKEY, KM_PRESS, 0, 0);
|
||||
WM_keymap_add_item(keymap, "SKETCH_OT_delete", DELKEY, KM_PRESS, 0, 0);
|
||||
WM_keymap_add_item(keymap, "SKETCH_OT_delete", BACKSPACEKEY, KM_PRESS, 0, 0);
|
||||
WM_keymap_add_item(keymap, "SKETCH_OT_finish_stroke", SELECTMOUSE, KM_PRESS, 0, 0);
|
||||
WM_keymap_add_item(keymap, "SKETCH_OT_finish_stroke", RIGHTMOUSE, KM_PRESS, 0, 0);
|
||||
WM_keymap_add_item(keymap, "SKETCH_OT_cancel_stroke", ESCKEY, KM_PRESS, 0, 0);
|
||||
WM_keymap_add_item(keymap, "SKETCH_OT_select", SELECTMOUSE, KM_PRESS, 0, 0);
|
||||
// Already part of view3d select
|
||||
//WM_keymap_add_item(keymap, "SKETCH_OT_select", SELECTMOUSE, KM_PRESS, 0, 0);
|
||||
|
||||
/* sketch poll checks mode */
|
||||
WM_keymap_add_item(keymap, "SKETCH_OT_gesture", ACTIONMOUSE, KM_PRESS, KM_SHIFT, 0);
|
||||
WM_keymap_add_item(keymap, "SKETCH_OT_draw_stroke", ACTIONMOUSE, KM_PRESS, 0, 0);
|
||||
kmi = WM_keymap_add_item(keymap, "SKETCH_OT_draw_stroke", ACTIONMOUSE, KM_PRESS, KM_CTRL, 0);
|
||||
WM_keymap_add_item(keymap, "SKETCH_OT_gesture", LEFTMOUSE, KM_PRESS, KM_SHIFT, 0);
|
||||
WM_keymap_add_item(keymap, "SKETCH_OT_draw_stroke", LEFTMOUSE, KM_PRESS, 0, 0);
|
||||
kmi = WM_keymap_add_item(keymap, "SKETCH_OT_draw_stroke", LEFTMOUSE, KM_PRESS, KM_CTRL, 0);
|
||||
RNA_boolean_set(kmi->ptr, "snap", 1);
|
||||
WM_keymap_add_item(keymap, "SKETCH_OT_draw_preview", MOUSEMOVE, KM_ANY, 0, 0);
|
||||
kmi = WM_keymap_add_item(keymap, "SKETCH_OT_draw_preview", MOUSEMOVE, KM_ANY, KM_CTRL, 0);
|
||||
|
@ -2154,7 +2154,7 @@ void sk_applyGesture(bContext *C, SK_Sketch *sketch)
|
||||
/********************************************/
|
||||
|
||||
|
||||
void sk_selectStroke(bContext *C, SK_Sketch *sketch, short mval[2], int extend)
|
||||
int sk_selectStroke(bContext *C, SK_Sketch *sketch, short mval[2], int extend)
|
||||
{
|
||||
ViewContext vc;
|
||||
rcti rect;
|
||||
@ -2199,7 +2199,10 @@ void sk_selectStroke(bContext *C, SK_Sketch *sketch, short mval[2], int extend)
|
||||
|
||||
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void sk_queueRedrawSketch(SK_Sketch *sketch)
|
||||
@ -2301,7 +2304,7 @@ void sk_drawSketch(Scene *scene, View3D *v3d, SK_Sketch *sketch, int with_names)
|
||||
}
|
||||
}
|
||||
|
||||
#if 1
|
||||
#if 0
|
||||
if (sketch->depth_peels.first != NULL)
|
||||
{
|
||||
float colors[8][3] = {
|
||||
@ -2471,7 +2474,8 @@ void BIF_sk_selectStroke(bContext *C, short mval[2], short extend)
|
||||
|
||||
if (sketch != NULL && ts->bone_sketching & BONE_SKETCHING)
|
||||
{
|
||||
sk_selectStroke(C, sketch, mval, extend);
|
||||
if (sk_selectStroke(C, sketch, mval, extend))
|
||||
ED_area_tag_redraw(CTX_wm_area(C));
|
||||
}
|
||||
}
|
||||
|
||||
@ -2558,6 +2562,17 @@ SK_Sketch* viewcontextSketch(ViewContext *vc, int create)
|
||||
return sketch;
|
||||
}
|
||||
|
||||
static int sketch_convert(bContext *C, wmOperator *op, wmEvent *event)
|
||||
{
|
||||
SK_Sketch *sketch = contextSketch(C, 0);
|
||||
if (sketch != NULL)
|
||||
{
|
||||
sk_convert(C, sketch);
|
||||
ED_area_tag_redraw(CTX_wm_area(C));
|
||||
}
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
static int sketch_cancel(bContext *C, wmOperator *op, wmEvent *event)
|
||||
{
|
||||
SK_Sketch *sketch = contextSketch(C, 0);
|
||||
@ -2590,8 +2605,8 @@ static int sketch_select(bContext *C, wmOperator *op, wmEvent *event)
|
||||
if (sketch)
|
||||
{
|
||||
short extend = 0;
|
||||
sk_selectStroke(C, sketch, event->mval, extend);
|
||||
ED_area_tag_redraw(CTX_wm_area(C));
|
||||
if (sk_selectStroke(C, sketch, event->mval, extend))
|
||||
ED_area_tag_redraw(CTX_wm_area(C));
|
||||
}
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
@ -2859,6 +2874,21 @@ void SKETCH_OT_cancel_stroke(wmOperatorType *ot)
|
||||
// ot->flag= OPTYPE_UNDO;
|
||||
}
|
||||
|
||||
void SKETCH_OT_convert(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name= "convert";
|
||||
ot->idname= "SKETCH_OT_convert";
|
||||
|
||||
/* api callbacks */
|
||||
ot->invoke= sketch_convert;
|
||||
|
||||
ot->poll= ED_operator_sketch_full_mode;
|
||||
|
||||
/* flags */
|
||||
ot->flag= OPTYPE_UNDO;
|
||||
}
|
||||
|
||||
void SKETCH_OT_finish_stroke(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
|
@ -52,8 +52,6 @@
|
||||
#include "BLI_polardecomp.h"
|
||||
#endif
|
||||
|
||||
#include "RE_raytrace.h"
|
||||
|
||||
#include "ONL_opennl.h"
|
||||
|
||||
#include "BLO_sys_types.h" // for intptr_t support
|
||||
@ -107,8 +105,7 @@ struct LaplacianSystem {
|
||||
float *p; /* values from all p vectors */
|
||||
float *mindist; /* minimum distance to a bone for all vertices */
|
||||
|
||||
RayObject *raytree; /* ray tracing acceleration structure */
|
||||
RayFace *faces; /* faces to add to the ray tracing struture */
|
||||
BVHTree *bvhtree; /* ray tracing acceleration structure */
|
||||
MFace **vface; /* a face that the vertex belongs to */
|
||||
} heat;
|
||||
|
||||
@ -396,29 +393,65 @@ float laplacian_system_get_solution(int v)
|
||||
#define WEIGHT_LIMIT_END 0.025f
|
||||
#define DISTANCE_EPSILON 1e-4f
|
||||
|
||||
typedef struct BVHCallbackUserData {
|
||||
float start[3];
|
||||
float vec[3];
|
||||
LaplacianSystem *sys;
|
||||
} BVHCallbackUserData;
|
||||
|
||||
static void bvh_callback(void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit)
|
||||
{
|
||||
BVHCallbackUserData *data = (struct BVHCallbackUserData*)userdata;
|
||||
MFace *mf = data->sys->heat.mface + index;
|
||||
float (*verts)[3] = data->sys->heat.verts;
|
||||
float lambda, uv[2], n[3], dir[3];
|
||||
|
||||
mul_v3_v3fl(dir, data->vec, hit->dist);
|
||||
|
||||
if(isect_ray_tri_v3(data->start, dir, verts[mf->v1], verts[mf->v2], verts[mf->v3], &lambda, uv)) {
|
||||
normal_tri_v3(n, verts[mf->v1], verts[mf->v2], verts[mf->v3]);
|
||||
if(lambda < 1.0f && dot_v3v3(n, data->vec) < -1e-5f) {
|
||||
hit->index = index;
|
||||
hit->dist *= lambda;
|
||||
}
|
||||
}
|
||||
|
||||
mul_v3_v3fl(dir, data->vec, hit->dist);
|
||||
|
||||
if(isect_ray_tri_v3(data->start, dir, verts[mf->v1], verts[mf->v3], verts[mf->v4], &lambda, uv)) {
|
||||
normal_tri_v3(n, verts[mf->v1], verts[mf->v3], verts[mf->v4]);
|
||||
if(lambda < 1.0f && dot_v3v3(n, data->vec) < -1e-5f) {
|
||||
hit->index = index;
|
||||
hit->dist *= lambda;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Raytracing for vertex to bone/vertex visibility */
|
||||
static void heat_ray_tree_create(LaplacianSystem *sys)
|
||||
{
|
||||
MFace *mface = sys->heat.mface;
|
||||
float (*verts)[3] = sys->heat.verts;
|
||||
int totface = sys->heat.totface;
|
||||
int totvert = sys->heat.totvert;
|
||||
int a;
|
||||
|
||||
sys->heat.raytree = RE_rayobject_vbvh_create(totface);
|
||||
sys->heat.faces = MEM_callocN(sizeof(RayFace)*totface, "Heat RayFaces");
|
||||
sys->heat.bvhtree = BLI_bvhtree_new(totface, 0.0f, 4, 6);
|
||||
sys->heat.vface = MEM_callocN(sizeof(MFace*)*totvert, "HeatVFaces");
|
||||
|
||||
for(a=0; a<totface; a++) {
|
||||
|
||||
MFace *mf = mface+a;
|
||||
RayFace *rayface = sys->heat.faces+a;
|
||||
float bb[6];
|
||||
|
||||
RayObject *obj = RE_rayface_from_coords(
|
||||
rayface, &sys->heat, mf,
|
||||
sys->heat.verts[mf->v1], sys->heat.verts[mf->v2],
|
||||
sys->heat.verts[mf->v3], mf->v4 ? sys->heat.verts[mf->v4] : 0
|
||||
);
|
||||
RE_rayobject_add(sys->heat.raytree, obj);
|
||||
INIT_MINMAX(bb, bb+3);
|
||||
DO_MINMAX(verts[mf->v1], bb, bb+3);
|
||||
DO_MINMAX(verts[mf->v2], bb, bb+3);
|
||||
DO_MINMAX(verts[mf->v3], bb, bb+3);
|
||||
if(mf->v4) {
|
||||
DO_MINMAX(verts[mf->v4], bb, bb+3);
|
||||
}
|
||||
|
||||
BLI_bvhtree_insert(sys->heat.bvhtree, a, bb, 2);
|
||||
|
||||
//Setup inverse pointers to use on isect.orig
|
||||
sys->heat.vface[mf->v1]= mf;
|
||||
@ -426,12 +459,14 @@ static void heat_ray_tree_create(LaplacianSystem *sys)
|
||||
sys->heat.vface[mf->v3]= mf;
|
||||
if(mf->v4) sys->heat.vface[mf->v4]= mf;
|
||||
}
|
||||
RE_rayobject_done(sys->heat.raytree);
|
||||
|
||||
BLI_bvhtree_balance(sys->heat.bvhtree);
|
||||
}
|
||||
|
||||
static int heat_ray_source_visible(LaplacianSystem *sys, int vertex, int source)
|
||||
{
|
||||
Isect isec;
|
||||
BVHTreeRayHit hit;
|
||||
BVHCallbackUserData data;
|
||||
MFace *mface;
|
||||
float end[3];
|
||||
int visible;
|
||||
@ -440,27 +475,24 @@ static int heat_ray_source_visible(LaplacianSystem *sys, int vertex, int source)
|
||||
if(!mface)
|
||||
return 1;
|
||||
|
||||
/* setup isec */
|
||||
memset(&isec, 0, sizeof(isec));
|
||||
isec.mode= RE_RAY_SHADOW;
|
||||
isec.lay= -1;
|
||||
isec.orig.ob = &sys->heat;
|
||||
isec.orig.face = mface;
|
||||
isec.skip = RE_SKIP_CULLFACE;
|
||||
|
||||
copy_v3_v3(isec.start, sys->heat.verts[vertex]);
|
||||
data.sys= sys;
|
||||
copy_v3_v3(data.start, sys->heat.verts[vertex]);
|
||||
|
||||
if(sys->heat.root) /* bone */
|
||||
closest_to_line_segment_v3(end, isec.start,
|
||||
closest_to_line_segment_v3(end, data.start,
|
||||
sys->heat.root[source], sys->heat.tip[source]);
|
||||
else /* vertex */
|
||||
copy_v3_v3(end, sys->heat.source[source]);
|
||||
|
||||
sub_v3_v3v3(isec.vec, end, isec.start);
|
||||
isec.labda = 1.0f - 1e-5;
|
||||
madd_v3_v3v3fl(isec.start, isec.start, isec.vec, 1e-5);
|
||||
sub_v3_v3v3(data.vec, end, data.start);
|
||||
madd_v3_v3v3fl(data.start, data.start, data.vec, 1e-5);
|
||||
mul_v3_fl(data.vec, 1.0f - 2e-5);
|
||||
|
||||
visible= !RE_rayobject_raycast(sys->heat.raytree, &isec);
|
||||
/* pass normalized vec + distance to bvh */
|
||||
hit.index = -1;
|
||||
hit.dist = normalize_v3(data.vec);
|
||||
|
||||
visible= BLI_bvhtree_ray_cast(sys->heat.bvhtree, data.start, data.vec, 0.0f, &hit, bvh_callback, (void*)&data) == -1;
|
||||
|
||||
return visible;
|
||||
}
|
||||
@ -587,9 +619,8 @@ static void heat_laplacian_create(LaplacianSystem *sys)
|
||||
|
||||
static void heat_system_free(LaplacianSystem *sys)
|
||||
{
|
||||
RE_rayobject_free(sys->heat.raytree);
|
||||
BLI_bvhtree_free(sys->heat.bvhtree);
|
||||
MEM_freeN(sys->heat.vface);
|
||||
MEM_freeN(sys->heat.faces);
|
||||
|
||||
MEM_freeN(sys->heat.mindist);
|
||||
MEM_freeN(sys->heat.H);
|
||||
@ -1050,11 +1081,19 @@ typedef struct MeshDeformBind {
|
||||
|
||||
/* direct solver */
|
||||
int *varidx;
|
||||
|
||||
/* raytrace */
|
||||
RayObject *raytree;
|
||||
} MeshDeformBind;
|
||||
|
||||
typedef struct MeshDeformIsect {
|
||||
float start[3];
|
||||
float vec[3];
|
||||
float labda;
|
||||
|
||||
void *face;
|
||||
int isect;
|
||||
float u, v;
|
||||
|
||||
} MeshDeformIsect;
|
||||
|
||||
/* ray intersection */
|
||||
|
||||
/* our own triangle intersection, so we can fully control the epsilons and
|
||||
@ -1117,63 +1156,7 @@ static int meshdeform_tri_intersect(float orig[3], float end[3], float vert0[3],
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* blender's raytracer is not use now, even though it is much faster. it can
|
||||
* give problems with rays falling through, so we use our own intersection
|
||||
* function above with tweaked epsilons */
|
||||
|
||||
#if 0
|
||||
static MeshDeformBind *MESHDEFORM_BIND = NULL;
|
||||
|
||||
static void meshdeform_ray_coords_func(RayFace *face, float **v1, float **v2, float **v3, float **v4)
|
||||
{
|
||||
MFace *mface= (MFace*)face;
|
||||
float (*cagecos)[3]= MESHDEFORM_BIND->cagecos;
|
||||
|
||||
*v1= cagecos[mface->v1];
|
||||
*v2= cagecos[mface->v2];
|
||||
*v3= cagecos[mface->v3];
|
||||
*v4= (mface->v4)? cagecos[mface->v4]: NULL;
|
||||
}
|
||||
|
||||
static int meshdeform_ray_check_func(Isect *is, RayFace *face)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void meshdeform_ray_tree_create(MeshDeformBind *mdb)
|
||||
{
|
||||
MFace *mface;
|
||||
float min[3], max[3];
|
||||
int a, totface;
|
||||
|
||||
/* create a raytrace tree from the mesh */
|
||||
INIT_MINMAX(min, max);
|
||||
|
||||
for(a=0; a<mdb->totcagevert; a++)
|
||||
DO_MINMAX(mdb->cagecos[a], min, max)
|
||||
|
||||
MESHDEFORM_BIND= mdb;
|
||||
|
||||
mface= mdb->cagedm->getFaceArray(mdb->cagedm);
|
||||
totface= mdb->cagedm->getNumFaces(mdb->cagedm);
|
||||
|
||||
mdb->raytree= RE_ray_tree_create(64, totface, min, max,
|
||||
meshdeform_ray_coords_func, meshdeform_ray_check_func);
|
||||
|
||||
for(a=0; a<totface; a++, mface++)
|
||||
RE_ray_tree_add_face(mdb->raytree, mface);
|
||||
|
||||
RE_ray_tree_done(mdb->raytree);
|
||||
}
|
||||
|
||||
static void meshdeform_ray_tree_free(MeshDeformBind *mdb)
|
||||
{
|
||||
MESHDEFORM_BIND= NULL;
|
||||
RE_ray_tree_free(mdb->raytree);
|
||||
}
|
||||
#endif
|
||||
|
||||
static int meshdeform_intersect(MeshDeformBind *mdb, Isect *isec)
|
||||
static int meshdeform_intersect(MeshDeformBind *mdb, MeshDeformIsect *isec)
|
||||
{
|
||||
MFace *mface;
|
||||
float face[4][3], co[3], uvw[3], len, nor[3], end[3];
|
||||
@ -1212,7 +1195,7 @@ static int meshdeform_intersect(MeshDeformBind *mdb, Isect *isec)
|
||||
len= len_v3v3(isec->start, co)/len_v3v3(isec->start, end);
|
||||
if(len < isec->labda) {
|
||||
isec->labda= len;
|
||||
isec->hit.face = mface;
|
||||
isec->face = mface;
|
||||
isec->isect= (INPR(isec->vec, nor) <= 0.0f);
|
||||
is= 1;
|
||||
}
|
||||
@ -1225,7 +1208,7 @@ static int meshdeform_intersect(MeshDeformBind *mdb, Isect *isec)
|
||||
static MDefBoundIsect *meshdeform_ray_tree_intersect(MeshDeformBind *mdb, float *co1, float *co2)
|
||||
{
|
||||
MDefBoundIsect *isect;
|
||||
Isect isec;
|
||||
MeshDeformIsect isec;
|
||||
float (*cagecos)[3];
|
||||
MFace *mface;
|
||||
float vert[4][3], len, end[3];
|
||||
@ -1233,21 +1216,15 @@ static MDefBoundIsect *meshdeform_ray_tree_intersect(MeshDeformBind *mdb, float
|
||||
|
||||
/* setup isec */
|
||||
memset(&isec, 0, sizeof(isec));
|
||||
isec.mode= RE_RAY_MIRROR; /* we want the closest intersection */
|
||||
isec.lay= -1;
|
||||
isec.labda= 1e10f;
|
||||
|
||||
VECADD(isec.start, co1, epsilon);
|
||||
VECADD(end, co2, epsilon);
|
||||
sub_v3_v3v3(isec.vec, end, isec.start);
|
||||
|
||||
#if 0
|
||||
/*if(RE_ray_tree_intersect(mdb->raytree, &isec)) {*/
|
||||
#endif
|
||||
|
||||
if(meshdeform_intersect(mdb, &isec)) {
|
||||
len= isec.labda;
|
||||
mface=(MFace*)isec.hit.face;
|
||||
mface=(MFace*)isec.face;
|
||||
|
||||
/* create MDefBoundIsect */
|
||||
isect= BLI_memarena_alloc(mdb->memarena, sizeof(*isect));
|
||||
@ -1790,11 +1767,6 @@ static void harmonic_coordinates_bind(Scene *scene, MeshDeformModifierData *mmd,
|
||||
|
||||
progress_bar(0, "Setting up mesh deform system");
|
||||
|
||||
#if 0
|
||||
/* create ray tree */
|
||||
meshdeform_ray_tree_create(mdb);
|
||||
#endif
|
||||
|
||||
totinside= 0;
|
||||
for(a=0; a<mdb->totvert; a++) {
|
||||
copy_v3_v3(vec, mdb->vertexcos[a]);
|
||||
@ -1817,11 +1789,6 @@ static void harmonic_coordinates_bind(Scene *scene, MeshDeformModifierData *mmd,
|
||||
for(x=0; x<mdb->size; x++)
|
||||
meshdeform_add_intersections(mdb, x, y, z);
|
||||
|
||||
#if 0
|
||||
/* free ray tree */
|
||||
meshdeform_ray_tree_free(mdb);
|
||||
#endif
|
||||
|
||||
/* compute exterior and interior tags */
|
||||
meshdeform_bind_floodfill(mdb);
|
||||
|
||||
|
@ -66,6 +66,9 @@ void FONT_OT_change_spacing(struct wmOperatorType *ot);
|
||||
void FONT_OT_open(struct wmOperatorType *ot);
|
||||
void FONT_OT_unlink(struct wmOperatorType *ot);
|
||||
|
||||
void FONT_OT_textbox_add(struct wmOperatorType *ot);
|
||||
void FONT_OT_textbox_remove(struct wmOperatorType *ot);
|
||||
|
||||
/* editcurve.c */
|
||||
void CURVE_OT_hide(struct wmOperatorType *ot);
|
||||
void CURVE_OT_reveal(struct wmOperatorType *ot);
|
||||
|
@ -81,6 +81,9 @@ void ED_operatortypes_curve(void)
|
||||
|
||||
WM_operatortype_append(FONT_OT_open);
|
||||
WM_operatortype_append(FONT_OT_unlink);
|
||||
|
||||
WM_operatortype_append(FONT_OT_textbox_add);
|
||||
WM_operatortype_append(FONT_OT_textbox_remove);
|
||||
|
||||
WM_operatortype_append(CURVE_OT_hide);
|
||||
WM_operatortype_append(CURVE_OT_reveal);
|
||||
|
@ -5256,54 +5256,62 @@ Nurb *add_nurbs_primitive(bContext *C, float mat[4][4], int type, int newname)
|
||||
return nu;
|
||||
}
|
||||
|
||||
static int curve_prim_add(bContext *C, wmOperator *op, int type){
|
||||
static int curvesurf_prim_add(bContext *C, wmOperator *op, int type, int isSurf) {
|
||||
|
||||
Object *obedit= CTX_data_edit_object(C);
|
||||
ListBase *editnurb;
|
||||
Nurb *nu;
|
||||
int newob= 0;//, type= RNA_enum_get(op->ptr, "type");
|
||||
int newob= 0;
|
||||
int enter_editmode;
|
||||
unsigned int layer;
|
||||
float loc[3], rot[3];
|
||||
float mat[4][4];
|
||||
|
||||
//object_add_generic_invoke_options(C, op); // XXX these props don't get set right when only exec() is called
|
||||
|
||||
if(!ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer))
|
||||
return OPERATOR_CANCELLED;
|
||||
|
||||
|
||||
if(obedit==NULL || obedit->type!=OB_CURVE) {
|
||||
Curve *cu;
|
||||
obedit= ED_object_add_type(C, OB_CURVE, loc, rot, TRUE, layer);
|
||||
newob = 1;
|
||||
if (!isSurf) { /* adding curve */
|
||||
if(obedit==NULL || obedit->type!=OB_CURVE) {
|
||||
Curve *cu;
|
||||
obedit= ED_object_add_type(C, OB_CURVE, loc, rot, TRUE, layer);
|
||||
newob = 1;
|
||||
|
||||
cu= (Curve*)obedit->data;
|
||||
cu->flag |= CU_DEFORM_FILL;
|
||||
if(type & CU_PRIM_PATH)
|
||||
cu->flag |= CU_PATH|CU_3D;
|
||||
cu= (Curve*)obedit->data;
|
||||
cu->flag |= CU_DEFORM_FILL;
|
||||
if(type & CU_PRIM_PATH)
|
||||
cu->flag |= CU_PATH|CU_3D;
|
||||
} else DAG_id_flush_update(&obedit->id, OB_RECALC_DATA);
|
||||
} else { /* adding surface */
|
||||
if(obedit==NULL || obedit->type!=OB_SURF) {
|
||||
obedit= ED_object_add_type(C, OB_SURF, loc, rot, TRUE, layer);
|
||||
newob = 1;
|
||||
} else DAG_id_flush_update(&obedit->id, OB_RECALC_DATA);
|
||||
}
|
||||
else if(obedit==NULL || obedit->type!=OB_SURF) {
|
||||
obedit= ED_object_add_type(C, OB_SURF, loc, rot, TRUE, layer);
|
||||
newob = 1;
|
||||
}
|
||||
else DAG_id_flush_update(&obedit->id, OB_RECALC_DATA);
|
||||
|
||||
|
||||
|
||||
ED_object_new_primitive_matrix(C, obedit, loc, rot, mat);
|
||||
|
||||
|
||||
nu= add_nurbs_primitive(C, mat, type, newob);
|
||||
editnurb= curve_get_editcurve(obedit);
|
||||
BLI_addtail(editnurb, nu);
|
||||
|
||||
|
||||
/* userdef */
|
||||
if (newob && !enter_editmode) {
|
||||
ED_object_exit_editmode(C, EM_FREEDATA);
|
||||
}
|
||||
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, obedit);
|
||||
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
static int curve_prim_add(bContext *C, wmOperator *op, int type) {
|
||||
return curvesurf_prim_add(C, op, type, 0);
|
||||
}
|
||||
|
||||
static int surf_prim_add(bContext *C, wmOperator *op, int type) {
|
||||
return curvesurf_prim_add(C, op, type, 1);
|
||||
}
|
||||
|
||||
/* ******************** Curves ******************* */
|
||||
|
||||
static int add_primitive_bezier_exec(bContext *C, wmOperator *op)
|
||||
@ -5424,7 +5432,7 @@ void CURVE_OT_primitive_nurbs_path_add(wmOperatorType *ot)
|
||||
/* **************** NURBS surfaces ********************** */
|
||||
static int add_primitive_nurbs_surface_curve_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
return curve_prim_add(C, op, CU_PRIM_CURVE|CU_NURBS);
|
||||
return surf_prim_add(C, op, CU_PRIM_CURVE|CU_NURBS);
|
||||
}
|
||||
|
||||
void SURFACE_OT_primitive_nurbs_surface_curve_add(wmOperatorType *ot)
|
||||
@ -5447,7 +5455,7 @@ void SURFACE_OT_primitive_nurbs_surface_curve_add(wmOperatorType *ot)
|
||||
|
||||
static int add_primitive_nurbs_surface_circle_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
return curve_prim_add(C, op, CU_PRIM_CIRCLE|CU_NURBS);
|
||||
return surf_prim_add(C, op, CU_PRIM_CIRCLE|CU_NURBS);
|
||||
}
|
||||
|
||||
void SURFACE_OT_primitive_nurbs_surface_circle_add(wmOperatorType *ot)
|
||||
@ -5470,7 +5478,7 @@ void SURFACE_OT_primitive_nurbs_surface_circle_add(wmOperatorType *ot)
|
||||
|
||||
static int add_primitive_nurbs_surface_surface_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
return curve_prim_add(C, op, CU_PRIM_PATCH|CU_NURBS);
|
||||
return surf_prim_add(C, op, CU_PRIM_PATCH|CU_NURBS);
|
||||
}
|
||||
|
||||
void SURFACE_OT_primitive_nurbs_surface_surface_add(wmOperatorType *ot)
|
||||
@ -5493,7 +5501,7 @@ void SURFACE_OT_primitive_nurbs_surface_surface_add(wmOperatorType *ot)
|
||||
|
||||
static int add_primitive_nurbs_surface_tube_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
return curve_prim_add(C, op, CU_PRIM_TUBE|CU_NURBS);
|
||||
return surf_prim_add(C, op, CU_PRIM_TUBE|CU_NURBS);
|
||||
}
|
||||
|
||||
void SURFACE_OT_primitive_nurbs_surface_tube_add(wmOperatorType *ot)
|
||||
@ -5516,7 +5524,7 @@ void SURFACE_OT_primitive_nurbs_surface_tube_add(wmOperatorType *ot)
|
||||
|
||||
static int add_primitive_nurbs_surface_sphere_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
return curve_prim_add(C, op, CU_PRIM_SPHERE|CU_NURBS);
|
||||
return surf_prim_add(C, op, CU_PRIM_SPHERE|CU_NURBS);
|
||||
}
|
||||
|
||||
void SURFACE_OT_primitive_nurbs_surface_sphere_add(wmOperatorType *ot)
|
||||
@ -5539,7 +5547,7 @@ void SURFACE_OT_primitive_nurbs_surface_sphere_add(wmOperatorType *ot)
|
||||
|
||||
static int add_primitive_nurbs_surface_donut_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
return curve_prim_add(C, op, CU_PRIM_DONUT|CU_NURBS);
|
||||
return surf_prim_add(C, op, CU_PRIM_DONUT|CU_NURBS);
|
||||
}
|
||||
|
||||
void SURFACE_OT_primitive_nurbs_surface_donut_add(wmOperatorType *ot)
|
||||
|
@ -1363,6 +1363,99 @@ void FONT_OT_text_insert(wmOperatorType *ot)
|
||||
RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");
|
||||
}
|
||||
|
||||
|
||||
/*********************** textbox add operator *************************/
|
||||
static int textbox_poll(bContext *C)
|
||||
{
|
||||
Object *ob = CTX_data_active_object(C);
|
||||
|
||||
if (!ED_operator_object_active_editable(C) ) return 0;
|
||||
if (ob->type != OB_FONT) return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int textbox_add_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Object *obedit= CTX_data_active_object(C);
|
||||
Curve *cu= obedit->data;
|
||||
int i;
|
||||
|
||||
if (cu->totbox < 256) {
|
||||
for (i = cu->totbox; i>cu->actbox; i--) cu->tb[i]= cu->tb[i-1];
|
||||
cu->tb[cu->actbox]= cu->tb[cu->actbox-1];
|
||||
cu->actbox++;
|
||||
cu->totbox++;
|
||||
}
|
||||
|
||||
WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
void FONT_OT_textbox_add(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name= "Add Textbox";
|
||||
ot->description= "Add a new text box";
|
||||
ot->idname= "FONT_OT_textbox_add";
|
||||
|
||||
/* api callbacks */
|
||||
ot->exec= textbox_add_exec;
|
||||
ot->poll= textbox_poll;
|
||||
|
||||
/* flags */
|
||||
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*********************** textbox remove operator *************************/
|
||||
|
||||
|
||||
|
||||
static int textbox_remove_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Object *obedit= CTX_data_active_object(C);
|
||||
Curve *cu= obedit->data;
|
||||
int i;
|
||||
int index = RNA_int_get(op->ptr, "index");
|
||||
|
||||
|
||||
if (cu->totbox > 1) {
|
||||
for (i = index; i < cu->totbox; i++) cu->tb[i]= cu->tb[i+1];
|
||||
cu->totbox--;
|
||||
if (cu->actbox >= index)
|
||||
cu->actbox--;
|
||||
}
|
||||
|
||||
WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
void FONT_OT_textbox_remove(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name= "Remove Textbox";
|
||||
ot->description= "Remove the textbox";
|
||||
ot->idname= "FONT_OT_textbox_remove";
|
||||
|
||||
/* api callbacks */
|
||||
ot->exec= textbox_remove_exec;
|
||||
ot->poll= textbox_poll;
|
||||
|
||||
/* flags */
|
||||
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
|
||||
RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "The current text box.", 0, INT_MAX);
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
/***************** editmode enter/exit ********************/
|
||||
|
||||
void make_editText(Object *obedit)
|
||||
|
@ -1481,6 +1481,7 @@ static int gpencil_draw_modal (bContext *C, wmOperator *op, wmEvent *event)
|
||||
|
||||
/* moving mouse - assumed that mouse button is down if in painting status */
|
||||
case MOUSEMOVE:
|
||||
case INBETWEEN_MOUSEMOVE:
|
||||
/* check if we're currently painting */
|
||||
if (p->status == GP_STATUS_PAINTING) {
|
||||
/* handle drawing event */
|
||||
|
@ -55,6 +55,7 @@ void ED_region_set(const struct bContext *C, struct ARegion *ar);
|
||||
void ED_region_init(struct bContext *C, struct ARegion *ar);
|
||||
void ED_region_tag_redraw(struct ARegion *ar);
|
||||
void ED_region_tag_redraw_partial(struct ARegion *ar, struct rcti *rct);
|
||||
void ED_region_tag_redraw_overlay(struct ARegion *ar);
|
||||
void ED_region_panels_init(struct wmWindowManager *wm, struct ARegion *ar);
|
||||
void ED_region_panels(const struct bContext *C, struct ARegion *ar, int vertical, char *context, int contextnr);
|
||||
void ED_region_header_init(struct ARegion *ar);
|
||||
@ -97,8 +98,8 @@ void ED_screen_set_scene(struct bContext *C, struct Scene *scene);
|
||||
void ED_screen_delete_scene(struct bContext *C, struct Scene *scene);
|
||||
void ED_screen_set_subwinactive(struct wmWindow *win, struct wmEvent *event);
|
||||
void ED_screen_exit(struct bContext *C, struct wmWindow *window, struct bScreen *screen);
|
||||
void ED_screen_animation_timer(struct bContext *C, int redraws, int sync, int enable);
|
||||
void ED_screen_animation_timer_update(struct bScreen *screen, int redraws);
|
||||
void ED_screen_animation_timer(struct bContext *C, int redraws, int refresh, int sync, int enable);
|
||||
void ED_screen_animation_timer_update(struct bScreen *screen, int redraws, int refresh);
|
||||
int ED_screen_full_newspace(struct bContext *C, ScrArea *sa, int type);
|
||||
void ED_screen_full_prevspace(struct bContext *C, ScrArea *sa);
|
||||
void ED_screen_full_restore(struct bContext *C, ScrArea *sa);
|
||||
|
@ -35,6 +35,7 @@
|
||||
typedef struct ScreenAnimData {
|
||||
ARegion *ar; /* do not read from this, only for comparing if region exists */
|
||||
short redraws;
|
||||
short refresh;
|
||||
short flag; /* flags for playback */
|
||||
int sfra; /* frame that playback was started from */
|
||||
} ScreenAnimData;
|
||||
|
@ -186,7 +186,7 @@ static void draw_triangulated(short mcords[][2], short tot)
|
||||
}
|
||||
|
||||
/* do the fill */
|
||||
filldisplist(&lb, &lb);
|
||||
filldisplist(&lb, &lb, 0);
|
||||
|
||||
/* do the draw */
|
||||
dl= lb.first; /* filldisplist adds in head of list */
|
||||
|
@ -490,74 +490,6 @@ void OBJECT_OT_camera_add(wmOperatorType *ot)
|
||||
|
||||
/* ***************** add primitives *************** */
|
||||
|
||||
static EnumPropertyItem prop_surface_types[]= {
|
||||
{CU_PRIM_CURVE|CU_NURBS, "NURBS_CURVE", ICON_SURFACE_NCURVE, "NURBS Curve", ""},
|
||||
{CU_PRIM_CIRCLE|CU_NURBS, "NURBS_CIRCLE", ICON_SURFACE_NCIRCLE, "NURBS Circle", ""},
|
||||
{CU_PRIM_PATCH|CU_NURBS, "NURBS_SURFACE", ICON_SURFACE_NSURFACE, "NURBS Surface", ""},
|
||||
{CU_PRIM_TUBE|CU_NURBS, "NURBS_TUBE", ICON_SURFACE_NTUBE, "NURBS Tube", ""},
|
||||
{CU_PRIM_SPHERE|CU_NURBS, "NURBS_SPHERE", ICON_SURFACE_NSPHERE, "NURBS Sphere", ""},
|
||||
{CU_PRIM_DONUT|CU_NURBS, "NURBS_DONUT", ICON_SURFACE_NDONUT, "NURBS Donut", ""},
|
||||
{0, NULL, 0, NULL, NULL}
|
||||
};
|
||||
|
||||
static int object_add_surface_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Object *obedit= CTX_data_edit_object(C);
|
||||
ListBase *editnurb;
|
||||
Nurb *nu;
|
||||
int newob= 0;
|
||||
int enter_editmode;
|
||||
unsigned int layer;
|
||||
float loc[3], rot[3];
|
||||
float mat[4][4];
|
||||
|
||||
object_add_generic_invoke_options(C, op); // XXX these props don't get set right when only exec() is called
|
||||
|
||||
if(!ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer))
|
||||
return OPERATOR_CANCELLED;
|
||||
|
||||
if(obedit==NULL || obedit->type!=OB_SURF) {
|
||||
obedit= ED_object_add_type(C, OB_SURF, loc, rot, TRUE, layer);
|
||||
newob = 1;
|
||||
}
|
||||
else DAG_id_flush_update(&obedit->id, OB_RECALC_DATA);
|
||||
|
||||
ED_object_new_primitive_matrix(C, obedit, loc, rot, mat);
|
||||
|
||||
nu= add_nurbs_primitive(C, mat, RNA_enum_get(op->ptr, "type"), newob);
|
||||
editnurb= curve_get_editcurve(obedit);
|
||||
BLI_addtail(editnurb, nu);
|
||||
|
||||
/* userdef */
|
||||
if (newob && !enter_editmode) {
|
||||
ED_object_exit_editmode(C, EM_FREEDATA);
|
||||
}
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, obedit);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
void OBJECT_OT_surface_add(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name= "Add Surface";
|
||||
ot->description = "Add a surface object to the scene";
|
||||
ot->idname= "OBJECT_OT_surface_add";
|
||||
|
||||
/* api callbacks */
|
||||
ot->invoke= WM_menu_invoke;
|
||||
ot->exec= object_add_surface_exec;
|
||||
|
||||
ot->poll= ED_operator_scene_editable;
|
||||
|
||||
/* flags */
|
||||
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
|
||||
ot->prop= RNA_def_enum(ot->srna, "type", prop_surface_types, 0, "Primitive", "");
|
||||
ED_object_add_generic_props(ot, TRUE);
|
||||
}
|
||||
|
||||
static EnumPropertyItem prop_metaball_types[]= {
|
||||
{MB_BALL, "MBALL_BALL", ICON_META_BALL, "Meta Ball", ""},
|
||||
{MB_TUBE, "MBALL_TUBE", ICON_META_TUBE, "Meta Tube", ""},
|
||||
|
@ -69,7 +69,9 @@ static int particle_system_add_exec(bContext *C, wmOperator *op)
|
||||
return OPERATOR_CANCELLED;
|
||||
|
||||
object_add_particle_system(scene, ob, NULL);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE, ob);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_POINTCACHE, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
@ -107,7 +109,8 @@ static int particle_system_remove_exec(bContext *C, wmOperator *op)
|
||||
if(scene->basact && scene->basact->object==ob)
|
||||
WM_event_add_notifier(C, NC_SCENE|ND_MODE|NS_MODE_OBJECT, NULL);
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE, ob);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_POINTCACHE, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
@ -166,7 +169,7 @@ static int new_particle_settings_exec(bContext *C, wmOperator *op)
|
||||
DAG_scene_sort(scene);
|
||||
DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
@ -214,7 +217,7 @@ static int new_particle_target_exec(bContext *C, wmOperator *op)
|
||||
DAG_scene_sort(scene);
|
||||
DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
@ -262,7 +265,7 @@ static int remove_particle_target_exec(bContext *C, wmOperator *op)
|
||||
DAG_scene_sort(scene);
|
||||
DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
@ -300,7 +303,7 @@ static int target_move_up_exec(bContext *C, wmOperator *op)
|
||||
BLI_insertlink(&psys->targets, pt->prev->prev, pt);
|
||||
|
||||
DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE, ob);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -338,7 +341,7 @@ static int target_move_down_exec(bContext *C, wmOperator *op)
|
||||
BLI_insertlink(&psys->targets, pt->next, pt);
|
||||
|
||||
DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE, ob);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -376,7 +379,7 @@ static int dupliob_move_up_exec(bContext *C, wmOperator *op)
|
||||
BLI_remlink(&part->dupliweights, dw);
|
||||
BLI_insertlink(&part->dupliweights, dw->prev->prev, dw);
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, NULL);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE, NULL);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -415,7 +418,7 @@ static int copy_particle_dupliob_exec(bContext *C, wmOperator *op)
|
||||
dw->flag |= PART_DUPLIW_CURRENT;
|
||||
BLI_addhead(&part->dupliweights, dw);
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, NULL);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE, NULL);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -461,7 +464,7 @@ static int remove_particle_dupliob_exec(bContext *C, wmOperator *op)
|
||||
if(dw)
|
||||
dw->flag |= PART_DUPLIW_CURRENT;
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, NULL);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE, NULL);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
@ -498,7 +501,7 @@ static int dupliob_move_down_exec(bContext *C, wmOperator *op)
|
||||
BLI_remlink(&part->dupliweights, dw);
|
||||
BLI_insertlink(&part->dupliweights, dw->next, dw);
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, NULL);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE, NULL);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -590,7 +593,7 @@ static int disconnect_hair_exec(bContext *C, wmOperator *op)
|
||||
disconnect_hair(scene, ob, psys);
|
||||
}
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
@ -729,7 +732,7 @@ static int connect_hair_exec(bContext *C, wmOperator *op)
|
||||
connect_hair(scene, ob, psys);
|
||||
}
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
@ -115,6 +115,7 @@ static int ptcache_bake_all_exec(bContext *C, wmOperator *op)
|
||||
BKE_ptcache_make_cache(&baker);
|
||||
|
||||
WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_POINTCACHE, NULL);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
@ -133,6 +134,8 @@ static int ptcache_free_bake_all_exec(bContext *C, wmOperator *op)
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_POINTCACHE, base->object);
|
||||
}
|
||||
|
||||
WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
|
||||
@ -211,6 +214,7 @@ static int ptcache_bake_exec(bContext *C, wmOperator *op)
|
||||
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;
|
||||
}
|
||||
@ -218,6 +222,7 @@ static int ptcache_free_bake_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
PointerRNA ptr= CTX_data_pointer_get_type(C, "point_cache", &RNA_PointCache);
|
||||
PointCache *cache= ptr.data;
|
||||
Object *ob= ptr.id.data;
|
||||
|
||||
if(cache->edit) {
|
||||
if(!cache->edit->edited || 1) {// XXX okee("Lose changes done in particle mode?")) {
|
||||
@ -228,6 +233,8 @@ static int ptcache_free_bake_exec(bContext *C, wmOperator *op)
|
||||
}
|
||||
else
|
||||
cache->flag &= ~PTCACHE_BAKED;
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_POINTCACHE, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
@ -235,8 +242,11 @@ static int ptcache_bake_from_cache_exec(bContext *C, wmOperator *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;
|
||||
}
|
||||
@ -303,6 +313,7 @@ static int ptcache_add_new_exec(bContext *C, wmOperator *op)
|
||||
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;
|
||||
}
|
||||
@ -331,6 +342,8 @@ static int ptcache_remove_exec(bContext *C, wmOperator *op)
|
||||
}
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_POINTCACHE, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
@ -221,7 +221,7 @@ void screen_set_image_output(bContext *C, int mx, int my)
|
||||
sa= CTX_wm_area(C);
|
||||
}
|
||||
else if(scene->r.displaymode==R_OUTPUT_SCREEN) {
|
||||
if (CTX_wm_area(C)->spacetype == SPACE_IMAGE)
|
||||
if (CTX_wm_area(C) && CTX_wm_area(C)->spacetype == SPACE_IMAGE)
|
||||
area_was_image = 1;
|
||||
|
||||
/* this function returns with changed context */
|
||||
|
@ -60,6 +60,7 @@
|
||||
|
||||
#include "ED_screen.h"
|
||||
#include "ED_view3d.h"
|
||||
#include "ED_image.h"
|
||||
|
||||
#include "RE_pipeline.h"
|
||||
#include "IMB_imbuf_types.h"
|
||||
@ -304,6 +305,10 @@ static int screen_opengl_render_anim_step(bContext *C, wmOperator *op)
|
||||
int ok= 0;
|
||||
int view_context = (oglrender->v3d != NULL);
|
||||
|
||||
/* update animated image textures for gpu, etc,
|
||||
* call before scene_update_for_newframe so modifiers with textuers dont lag 1 frame */
|
||||
ED_image_update_frame(C);
|
||||
|
||||
/* go to next frame */
|
||||
while(CFRA<oglrender->nfra) {
|
||||
unsigned int lay= screen_opengl_layers(oglrender);
|
||||
|
@ -372,6 +372,12 @@ void ED_region_tag_redraw(ARegion *ar)
|
||||
}
|
||||
}
|
||||
|
||||
void ED_region_tag_redraw_overlay(ARegion *ar)
|
||||
{
|
||||
if(ar)
|
||||
ar->do_draw_overlay= RGN_DRAW;
|
||||
}
|
||||
|
||||
void ED_region_tag_redraw_partial(ARegion *ar, rcti *rct)
|
||||
{
|
||||
if(ar) {
|
||||
|
@ -1651,7 +1651,7 @@ void ED_refresh_viewport_fps(bContext *C)
|
||||
/* redraws: uses defines from stime->redraws
|
||||
* enable: 1 - forward on, -1 - backwards on, 0 - off
|
||||
*/
|
||||
void ED_screen_animation_timer(bContext *C, int redraws, int sync, int enable)
|
||||
void ED_screen_animation_timer(bContext *C, int redraws, int refresh, int sync, int enable)
|
||||
{
|
||||
bScreen *screen= CTX_wm_screen(C);
|
||||
wmWindowManager *wm= CTX_wm_manager(C);
|
||||
@ -1669,6 +1669,7 @@ void ED_screen_animation_timer(bContext *C, int redraws, int sync, int enable)
|
||||
sad->ar= CTX_wm_region(C);
|
||||
sad->sfra = scene->r.cfra;
|
||||
sad->redraws= redraws;
|
||||
sad->refresh= refresh;
|
||||
sad->flag |= (enable < 0)? ANIMPLAY_FLAG_REVERSE: 0;
|
||||
sad->flag |= (sync == 0)? ANIMPLAY_FLAG_NO_SYNC: (sync == 1)? ANIMPLAY_FLAG_SYNC: 0;
|
||||
screen->animtimer->customdata= sad;
|
||||
@ -1702,13 +1703,14 @@ static ARegion *time_top_left_3dwindow(bScreen *screen)
|
||||
return aret;
|
||||
}
|
||||
|
||||
void ED_screen_animation_timer_update(bScreen *screen, int redraws)
|
||||
void ED_screen_animation_timer_update(bScreen *screen, int redraws, int refresh)
|
||||
{
|
||||
if(screen && screen->animtimer) {
|
||||
wmTimer *wt= screen->animtimer;
|
||||
ScreenAnimData *sad= wt->customdata;
|
||||
|
||||
sad->redraws= redraws;
|
||||
sad->refresh= refresh;
|
||||
sad->ar= NULL;
|
||||
if(redraws & TIME_REGION)
|
||||
sad->ar= time_top_left_3dwindow(screen);
|
||||
@ -1735,6 +1737,10 @@ void ED_update_for_newframe(const bContext *C, int mute)
|
||||
|
||||
//extern void audiostream_scrub(unsigned int frame); /* seqaudio.c */
|
||||
|
||||
/* update animated image textures for gpu, etc,
|
||||
* call before scene_update_for_newframe so modifiers with textuers dont lag 1 frame */
|
||||
ED_image_update_frame(C);
|
||||
|
||||
/* this function applies the changes too */
|
||||
/* XXX future: do all windows */
|
||||
scene_update_for_newframe(scene, BKE_screen_visible_layers(screen, scene)); /* BKE_scene.h */
|
||||
@ -1752,9 +1758,6 @@ void ED_update_for_newframe(const bContext *C, int mute)
|
||||
if(scene->use_nodes && scene->nodetree)
|
||||
ntreeCompositTagAnimated(scene->nodetree);
|
||||
|
||||
/* update animated image textures for gpu, etc */
|
||||
ED_image_update_frame(C);
|
||||
|
||||
/* update animated texture nodes */
|
||||
{
|
||||
Tex *tex;
|
||||
|
@ -2359,6 +2359,18 @@ void SCREEN_OT_header_toolbox(wmOperatorType *ot)
|
||||
|
||||
/* ****************** anim player, with timer ***************** */
|
||||
|
||||
static int match_area_with_refresh(int spacetype, int refresh)
|
||||
{
|
||||
switch (spacetype) {
|
||||
case SPACE_TIME:
|
||||
if (refresh & SPACE_TIME)
|
||||
return 1;
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int match_region_with_redraws(int spacetype, int regiontype, int redraws)
|
||||
{
|
||||
if(regiontype==RGN_TYPE_WINDOW) {
|
||||
@ -2505,6 +2517,9 @@ static int screen_animation_step(bContext *C, wmOperator *op, wmEvent *event)
|
||||
if(match_region_with_redraws(sa->spacetype, ar->regiontype, sad->redraws))
|
||||
ED_region_tag_redraw(ar);
|
||||
}
|
||||
|
||||
if (match_area_with_refresh(sa->spacetype, sad->refresh))
|
||||
ED_area_tag_refresh(sa);
|
||||
}
|
||||
|
||||
/* update frame rate info too
|
||||
@ -2548,11 +2563,12 @@ int ED_screen_animation_play(bContext *C, int sync, int mode)
|
||||
|
||||
if(screen->animtimer) {
|
||||
/* stop playback now */
|
||||
ED_screen_animation_timer(C, 0, 0, 0);
|
||||
ED_screen_animation_timer(C, 0, 0, 0, 0);
|
||||
sound_stop_scene(scene);
|
||||
}
|
||||
else {
|
||||
ScrArea *sa= CTX_wm_area(C);
|
||||
int refresh= SPACE_TIME;
|
||||
|
||||
if(mode == 1) // XXX only play audio forwards!?
|
||||
sound_play_scene(scene);
|
||||
@ -2561,10 +2577,10 @@ int ED_screen_animation_play(bContext *C, int sync, int mode)
|
||||
if ((sa) && (sa->spacetype == SPACE_TIME)) {
|
||||
SpaceTime *stime= (SpaceTime *)sa->spacedata.first;
|
||||
|
||||
ED_screen_animation_timer(C, stime->redraws, sync, mode);
|
||||
ED_screen_animation_timer(C, stime->redraws, refresh, sync, mode);
|
||||
|
||||
/* update region if TIME_REGION was set, to leftmost 3d window */
|
||||
ED_screen_animation_timer_update(screen, stime->redraws);
|
||||
ED_screen_animation_timer_update(screen, stime->redraws, refresh);
|
||||
}
|
||||
else {
|
||||
int redraws = TIME_REGION|TIME_ALL_3D_WIN;
|
||||
@ -2574,7 +2590,7 @@ int ED_screen_animation_play(bContext *C, int sync, int mode)
|
||||
redraws |= TIME_SEQ;
|
||||
}
|
||||
|
||||
ED_screen_animation_timer(C, redraws, sync, mode);
|
||||
ED_screen_animation_timer(C, redraws, refresh, sync, mode);
|
||||
|
||||
if(screen->animtimer) {
|
||||
wmTimer *wt= screen->animtimer;
|
||||
|
@ -4872,6 +4872,7 @@ static int paint_modal(bContext *C, wmOperator *op, wmEvent *event)
|
||||
paint_exit(C, op);
|
||||
return OPERATOR_FINISHED;
|
||||
case MOUSEMOVE:
|
||||
case INBETWEEN_MOUSEMOVE:
|
||||
paint_apply_event(C, op, event);
|
||||
break;
|
||||
case TIMER:
|
||||
|
@ -275,7 +275,7 @@ int paint_stroke_modal(bContext *C, wmOperator *op, wmEvent *event)
|
||||
MEM_freeN(stroke);
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
else if(first || event->type == MOUSEMOVE || (event->type == TIMER && (event->customdata == stroke->timer))) {
|
||||
else if(first || ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE) || (event->type == TIMER && (event->customdata == stroke->timer))) {
|
||||
if(stroke->stroke_started) {
|
||||
if(paint_smooth_stroke(stroke, mouse, event)) {
|
||||
if(paint_space_stroke_enabled(stroke->brush)) {
|
||||
|
@ -91,6 +91,11 @@
|
||||
/* Number of vertices to average in order to determine the flatten distance */
|
||||
#define FLATTEN_SAMPLE_SIZE 10
|
||||
|
||||
/* ==== FORWARD DEFINITIONS =====
|
||||
*
|
||||
*/
|
||||
static void sculpt_vertcos_to_key(Object *ob, KeyBlock *kb, float (*vertCos)[3]);
|
||||
|
||||
/* ===== STRUCTS =====
|
||||
*
|
||||
*/
|
||||
@ -275,6 +280,9 @@ typedef struct SculptUndoNode {
|
||||
|
||||
/* layer brush */
|
||||
float *layer_disp;
|
||||
|
||||
/* shape keys */
|
||||
char *shapeName[32]; /* keep size in sync with keyblock dna */
|
||||
} SculptUndoNode;
|
||||
|
||||
static void update_cb(PBVHNode *node, void *data)
|
||||
@ -326,16 +334,53 @@ static void sculpt_undo_restore(bContext *C, ListBase *lb)
|
||||
continue;
|
||||
|
||||
if(unode->maxvert) {
|
||||
char *shapeName= (char*)unode->shapeName;
|
||||
|
||||
/* regular mesh restore */
|
||||
if(ss->totvert != unode->maxvert)
|
||||
continue;
|
||||
|
||||
if (ss->kb && strcmp(ss->kb->name, shapeName)) {
|
||||
/* shape key has been changed before calling undo operator */
|
||||
|
||||
Key *key= ob_get_key(ob);
|
||||
KeyBlock *kb= key_get_named_keyblock(key, shapeName);
|
||||
|
||||
if (kb) {
|
||||
ob->shapenr= BLI_findindex(&key->block, kb) + 1;
|
||||
ob->shapeflag|= OB_SHAPE_LOCK;
|
||||
|
||||
sculpt_update_mesh_elements(scene, ob, 0);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_DATA, ob);
|
||||
} else {
|
||||
/* key has been removed -- skip this undo node */
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
index= unode->index;
|
||||
mvert= ss->mvert;
|
||||
|
||||
for(i=0; i<unode->totvert; i++) {
|
||||
swap_v3_v3(mvert[index[i]].co, unode->co[i]);
|
||||
mvert[index[i]].flag |= ME_VERT_PBVH_UPDATE;
|
||||
if (ss->kb) {
|
||||
float (*vertCos)[3];
|
||||
vertCos= key_to_vertcos(ob, ss->kb);
|
||||
|
||||
for(i=0; i<unode->totvert; i++)
|
||||
swap_v3_v3(vertCos[index[i]], unode->co[i]);
|
||||
|
||||
/* propagate new coords to keyblock */
|
||||
sculpt_vertcos_to_key(ob, ss->kb, vertCos);
|
||||
|
||||
/* pbvh uses it's own mvert array, so coords should be */
|
||||
/* propagated to pbvh here */
|
||||
BLI_pbvh_apply_vertCos(ss->pbvh, vertCos);
|
||||
|
||||
MEM_freeN(vertCos);
|
||||
} else {
|
||||
for(i=0; i<unode->totvert; i++) {
|
||||
swap_v3_v3(mvert[index[i]].co, unode->co[i]);
|
||||
mvert[index[i]].flag |= ME_VERT_PBVH_UPDATE;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(unode->maxgrid && dm->getGridData) {
|
||||
@ -365,9 +410,6 @@ static void sculpt_undo_restore(bContext *C, ListBase *lb)
|
||||
}
|
||||
|
||||
if(update) {
|
||||
if(ss->kb) sculpt_mesh_to_key(ss->ob, ss->kb);
|
||||
if(ss->refkb) sculpt_key_to_mesh(ss->refkb, ob);
|
||||
|
||||
/* we update all nodes still, should be more clever, but also
|
||||
needs to work correct when exiting/entering sculpt mode and
|
||||
the nodes get recreated, though in that case it could do all */
|
||||
@ -377,7 +419,7 @@ static void sculpt_undo_restore(bContext *C, ListBase *lb)
|
||||
if((mmd=sculpt_multires_active(scene, ob)))
|
||||
multires_mark_as_modified(ob);
|
||||
|
||||
if(sculpt_modifiers_active(scene, ob))
|
||||
if(ss->modifiers_active || ((Mesh*)ob->data)->id.us > 1)
|
||||
DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
|
||||
}
|
||||
}
|
||||
@ -475,7 +517,11 @@ static SculptUndoNode *sculpt_undo_push_node(SculptSession *ss, PBVHNode *node)
|
||||
|
||||
if(unode->grids)
|
||||
memcpy(unode->grids, grids, sizeof(int)*totgrid);
|
||||
|
||||
|
||||
/* store active shape key */
|
||||
if(ss->kb) BLI_strncpy((char*)unode->shapeName, ss->kb->name, sizeof(ss->kb->name));
|
||||
else unode->shapeName[0]= '\0';
|
||||
|
||||
return unode;
|
||||
}
|
||||
|
||||
@ -1367,6 +1413,68 @@ static void do_flatten_clay_brush(Sculpt *sd, SculptSession *ss, PBVHNode **node
|
||||
}
|
||||
}
|
||||
|
||||
static void sculpt_vertcos_to_key(Object *ob, KeyBlock *kb, float (*vertCos)[3])
|
||||
{
|
||||
Mesh *me= (Mesh*)ob->data;
|
||||
float (*ofs)[3]= NULL;
|
||||
int a, is_basis= 0;
|
||||
KeyBlock *currkey;
|
||||
|
||||
/* for relative keys editing of base should update other keys */
|
||||
if (me->key->type == KEY_RELATIVE)
|
||||
for (currkey = me->key->block.first; currkey; currkey= currkey->next)
|
||||
if(ob->shapenr-1 == currkey->relative) {
|
||||
is_basis= 1;
|
||||
break;
|
||||
}
|
||||
|
||||
if (is_basis) {
|
||||
ofs= key_to_vertcos(ob, kb);
|
||||
|
||||
/* calculate key coord offsets (from previous location) */
|
||||
for (a= 0; a < me->totvert; a++) {
|
||||
VECSUB(ofs[a], vertCos[a], ofs[a]);
|
||||
}
|
||||
|
||||
/* apply offsets on other keys */
|
||||
currkey = me->key->block.first;
|
||||
while (currkey) {
|
||||
int apply_offset = ((currkey != kb) && (ob->shapenr-1 == currkey->relative));
|
||||
|
||||
if (apply_offset)
|
||||
offset_to_key(ob, currkey, ofs);
|
||||
|
||||
currkey= currkey->next;
|
||||
}
|
||||
|
||||
MEM_freeN(ofs);
|
||||
}
|
||||
|
||||
/* modifying of basis key should update mesh */
|
||||
if (kb == me->key->refkey) {
|
||||
MVert *mvert= me->mvert;
|
||||
|
||||
for (a= 0; a < me->totvert; a++, mvert++)
|
||||
VECCOPY(mvert->co, vertCos[a]);
|
||||
|
||||
mesh_calc_normals(me->mvert, me->totvert, me->mface, me->totface, NULL);
|
||||
}
|
||||
|
||||
/* apply new coords on active key block */
|
||||
vertcos_to_key(ob, kb, vertCos);
|
||||
}
|
||||
|
||||
/* copy the modified vertices from bvh to the active key */
|
||||
static void sculpt_update_keyblock(SculptSession *ss)
|
||||
{
|
||||
float (*vertCos)[3]= BLI_pbvh_get_vertCos(ss->pbvh);
|
||||
|
||||
if (vertCos) {
|
||||
sculpt_vertcos_to_key(ss->ob, ss->kb, vertCos);
|
||||
MEM_freeN(vertCos);
|
||||
}
|
||||
}
|
||||
|
||||
static void do_brush_action(Sculpt *sd, SculptSession *ss, StrokeCache *cache)
|
||||
{
|
||||
SculptSearchSphereData data;
|
||||
@ -1424,13 +1532,15 @@ static void do_brush_action(Sculpt *sd, SculptSession *ss, StrokeCache *cache)
|
||||
do_flatten_clay_brush(sd, ss, nodes, totnode, 1);
|
||||
break;
|
||||
}
|
||||
|
||||
/* copy the modified vertices from mesh to the active key */
|
||||
if(ss->kb) mesh_to_key(ss->ob->data, ss->kb);
|
||||
|
||||
|
||||
/* optimization: we could avoid copying new coords to keyblock at each */
|
||||
/* stroke step if there are no modifiers due to pbvh is used for displaying */
|
||||
/* so to increase speed we'll copy new coords to keyblock when stroke is done */
|
||||
if(ss->kb && ss->modifiers_active) sculpt_update_keyblock(ss);
|
||||
|
||||
if(nodes)
|
||||
MEM_freeN(nodes);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Flip all the editdata across the axis/axes specified by symm. Used to
|
||||
@ -1506,40 +1616,18 @@ struct MultiresModifierData *sculpt_multires_active(Scene *scene, Object *ob)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void sculpt_key_to_mesh(KeyBlock *kb, Object *ob)
|
||||
{
|
||||
Mesh *me= ob->data;
|
||||
|
||||
key_to_mesh(kb, me);
|
||||
mesh_calc_normals(me->mvert, me->totvert, me->mface, me->totface, NULL);
|
||||
}
|
||||
|
||||
void sculpt_mesh_to_key(Object *ob, KeyBlock *kb)
|
||||
{
|
||||
Mesh *me= ob->data;
|
||||
|
||||
mesh_to_key(me, kb);
|
||||
}
|
||||
|
||||
void sculpt_update_mesh_elements(Scene *scene, Object *ob, int need_fmap)
|
||||
{
|
||||
DerivedMesh *dm = mesh_get_derived_final(scene, ob, 0);
|
||||
DerivedMesh *dm = mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH);
|
||||
SculptSession *ss = ob->sculpt;
|
||||
MultiresModifierData *mmd= sculpt_multires_active(scene, ob);
|
||||
|
||||
ss->ob= ob;
|
||||
|
||||
if((ob->shapeflag & OB_SHAPE_LOCK) && !mmd) {
|
||||
ss->kb= ob_get_keyblock(ob);
|
||||
ss->refkb= ob_get_reference_keyblock(ob);
|
||||
}
|
||||
else {
|
||||
ss->kb= NULL;
|
||||
ss->refkb= NULL;
|
||||
}
|
||||
ss->modifiers_active= sculpt_modifiers_active(scene, ob);
|
||||
|
||||
/* need to make PBVH with shape key coordinates */
|
||||
if(ss->kb) sculpt_key_to_mesh(ss->kb, ss->ob);
|
||||
if((ob->shapeflag & OB_SHAPE_LOCK) && !mmd) ss->kb= ob_get_keyblock(ob);
|
||||
else ss->kb= NULL;
|
||||
|
||||
if(mmd) {
|
||||
ss->multires = mmd;
|
||||
@ -1561,6 +1649,17 @@ void sculpt_update_mesh_elements(Scene *scene, Object *ob, int need_fmap)
|
||||
|
||||
ss->pbvh = dm->getPBVH(ob, dm);
|
||||
ss->fmap = (need_fmap && dm->getFaceMap)? dm->getFaceMap(ob, dm): NULL;
|
||||
|
||||
/* if pbvh is deformed, key block is already applied to it */
|
||||
if (ss->kb && !BLI_pbvh_isDeformed(ss->pbvh)) {
|
||||
float (*vertCos)[3]= key_to_vertcos(ob, ss->kb);
|
||||
|
||||
if (vertCos) {
|
||||
/* apply shape keys coordinates to PBVH */
|
||||
BLI_pbvh_apply_vertCos(ss->pbvh, vertCos);
|
||||
MEM_freeN(vertCos);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int sculpt_mode_poll(bContext *C)
|
||||
@ -1815,9 +1914,7 @@ static void sculpt_update_cache_variants(Sculpt *sd, SculptSession *ss, struct P
|
||||
|
||||
static void sculpt_stroke_modifiers_check(bContext *C, SculptSession *ss)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
|
||||
if(sculpt_modifiers_active(scene, ss->ob)) {
|
||||
if(ss->modifiers_active) {
|
||||
Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
|
||||
Brush *brush = paint_brush(&sd->paint);
|
||||
|
||||
@ -1995,7 +2092,6 @@ static void sculpt_restore_mesh(Sculpt *sd, SculptSession *ss)
|
||||
|
||||
static void sculpt_flush_update(bContext *C)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
Object *ob = CTX_data_active_object(C);
|
||||
SculptSession *ss = ob->sculpt;
|
||||
ARegion *ar = CTX_wm_region(C);
|
||||
@ -2005,7 +2101,7 @@ static void sculpt_flush_update(bContext *C)
|
||||
if(mmd)
|
||||
multires_mark_as_modified(ob);
|
||||
|
||||
if(sculpt_modifiers_active(scene, ob)) {
|
||||
if(ss->modifiers_active) {
|
||||
DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
|
||||
ED_region_tag_redraw(ar);
|
||||
}
|
||||
@ -2089,10 +2185,13 @@ static void sculpt_stroke_done(bContext *C, struct PaintStroke *stroke)
|
||||
|
||||
BLI_pbvh_update(ss->pbvh, PBVH_UpdateOriginalBB, NULL);
|
||||
|
||||
if(ss->refkb) sculpt_key_to_mesh(ss->refkb, ob);
|
||||
/* optimization: if there is locked key and active modifiers present in */
|
||||
/* the stack, keyblock is updating at each step. otherwise we could update */
|
||||
/* keyblock only when stroke is finished */
|
||||
if(ss->kb && !ss->modifiers_active) sculpt_update_keyblock(ss);
|
||||
|
||||
ss->partial_redraw = 0;
|
||||
|
||||
|
||||
/* try to avoid calling this, only for e.g. linked duplicates now */
|
||||
if(((Mesh*)ob->data)->id.us > 1)
|
||||
DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
|
||||
@ -2225,9 +2324,6 @@ static void sculpt_init_session(Scene *scene, Object *ob)
|
||||
ob->sculpt = MEM_callocN(sizeof(SculptSession), "sculpt session");
|
||||
|
||||
sculpt_update_mesh_elements(scene, ob, 0);
|
||||
|
||||
if(ob->sculpt->refkb)
|
||||
sculpt_key_to_mesh(ob->sculpt->refkb, ob);
|
||||
}
|
||||
|
||||
static int sculpt_toggle_mode(bContext *C, wmOperator *op)
|
||||
|
@ -58,8 +58,6 @@ void sculpt(Sculpt *sd);
|
||||
|
||||
int sculpt_poll(struct bContext *C);
|
||||
void sculpt_update_mesh_elements(struct Scene *scene, struct Object *ob, int need_fmap);
|
||||
void sculpt_key_to_mesh(struct KeyBlock *kb, struct Object *ob);
|
||||
void sculpt_mesh_to_key(struct Object *ob, struct KeyBlock *kb);
|
||||
|
||||
/* Stroke */
|
||||
struct SculptStroke *sculpt_stroke_new(const int max);
|
||||
|
@ -30,6 +30,7 @@
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
#include "DNA_userdef_types.h"
|
||||
|
||||
#include "BKE_context.h"
|
||||
|
||||
@ -129,6 +130,10 @@ static int file_browse_invoke(bContext *C, wmOperator *op, wmEvent *event)
|
||||
RNA_string_set(op->ptr, "filepath", str);
|
||||
MEM_freeN(str);
|
||||
|
||||
if(RNA_struct_find_property(op->ptr, "relative_path"))
|
||||
if(!RNA_property_is_set(op->ptr, "relative_path"))
|
||||
RNA_boolean_set(op->ptr, "relative_path", U.flag & USER_RELPATHS);
|
||||
|
||||
WM_event_add_fileselect(C, op);
|
||||
|
||||
return OPERATOR_RUNNING_MODAL;
|
||||
@ -147,6 +152,6 @@ void BUTTONS_OT_file_browse(wmOperatorType *ot)
|
||||
ot->cancel= file_browse_cancel;
|
||||
|
||||
/* properties */
|
||||
WM_operator_properties_filesel(ot, 0, FILE_SPECIAL, FILE_OPENFILE, 0);
|
||||
WM_operator_properties_filesel(ot, 0, FILE_SPECIAL, FILE_OPENFILE, FILE_RELPATH);
|
||||
}
|
||||
|
||||
|
@ -545,7 +545,7 @@ void FILE_OT_cancel(struct wmOperatorType *ot)
|
||||
int file_exec(bContext *C, wmOperator *exec_op)
|
||||
{
|
||||
SpaceFile *sfile= CTX_wm_space_file(C);
|
||||
char name[FILE_MAX];
|
||||
char filepath[FILE_MAX];
|
||||
|
||||
if(sfile->op) {
|
||||
wmOperator *op= sfile->op;
|
||||
@ -567,16 +567,23 @@ int file_exec(bContext *C, wmOperator *exec_op)
|
||||
}
|
||||
|
||||
sfile->op = NULL;
|
||||
RNA_string_set(op->ptr, "filename", sfile->params->file);
|
||||
BLI_strncpy(name, sfile->params->dir, sizeof(name));
|
||||
RNA_string_set(op->ptr, "directory", name);
|
||||
strcat(name, sfile->params->file); // XXX unsafe
|
||||
|
||||
if(RNA_struct_find_property(op->ptr, "relative_path"))
|
||||
if(RNA_boolean_get(op->ptr, "relative_path"))
|
||||
BLI_path_rel(name, G.sce);
|
||||
BLI_join_dirfile(filepath, sfile->params->dir, sfile->params->file);
|
||||
if(RNA_struct_find_property(op->ptr, "relative_path")) {
|
||||
if(RNA_boolean_get(op->ptr, "relative_path")) {
|
||||
BLI_path_rel(filepath, G.sce);
|
||||
}
|
||||
}
|
||||
|
||||
RNA_string_set(op->ptr, "filepath", name);
|
||||
if(RNA_struct_find_property(op->ptr, "filename")) {
|
||||
RNA_string_set(op->ptr, "filename", sfile->params->file);
|
||||
}
|
||||
if(RNA_struct_find_property(op->ptr, "directory")) {
|
||||
RNA_string_set(op->ptr, "directory", sfile->params->dir);
|
||||
}
|
||||
if(RNA_struct_find_property(op->ptr, "filepath")) {
|
||||
RNA_string_set(op->ptr, "filepath", filepath);
|
||||
}
|
||||
|
||||
/* some ops have multiple files to select */
|
||||
{
|
||||
@ -612,8 +619,8 @@ int file_exec(bContext *C, wmOperator *exec_op)
|
||||
folderlist_free(sfile->folders_next);
|
||||
|
||||
fsmenu_insert_entry(fsmenu_get(), FS_CATEGORY_RECENT, sfile->params->dir,0, 1);
|
||||
BLI_make_file_string(G.sce, name, BLI_gethome(), ".Bfs");
|
||||
fsmenu_write_file(fsmenu_get(), name);
|
||||
BLI_make_file_string(G.sce, filepath, BLI_gethome(), ".Bfs");
|
||||
fsmenu_write_file(fsmenu_get(), filepath);
|
||||
WM_event_fileselect_event(C, op, EVT_FILESELECT_EXEC);
|
||||
|
||||
ED_fileselect_clear(C, sfile);
|
||||
|
@ -780,7 +780,6 @@ static int replace_exec(bContext *C, wmOperator *op)
|
||||
static int replace_invoke(bContext *C, wmOperator *op, wmEvent *event)
|
||||
{
|
||||
SpaceImage *sima= CTX_wm_space_image(C);
|
||||
char *path= (sima->image)? sima->image->name: U.textudir;
|
||||
|
||||
if(!sima->image)
|
||||
return OPERATOR_CANCELLED;
|
||||
@ -788,7 +787,10 @@ static int replace_invoke(bContext *C, wmOperator *op, wmEvent *event)
|
||||
if(RNA_property_is_set(op->ptr, "filepath"))
|
||||
return replace_exec(C, op);
|
||||
|
||||
image_filesel(C, op, path);
|
||||
if(!RNA_property_is_set(op->ptr, "relative_path"))
|
||||
RNA_boolean_set(op->ptr, "relative_path", (strncmp(sima->image->name, "//", 2))==0);
|
||||
|
||||
image_filesel(C, op, sima->image->name);
|
||||
|
||||
return OPERATOR_RUNNING_MODAL;
|
||||
}
|
||||
@ -808,7 +810,7 @@ void IMAGE_OT_replace(wmOperatorType *ot)
|
||||
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
|
||||
/* properties */
|
||||
WM_operator_properties_filesel(ot, FOLDERFILE|IMAGEFILE|MOVIEFILE, FILE_SPECIAL, FILE_OPENFILE, 0); //XXX TODO, relative_path
|
||||
WM_operator_properties_filesel(ot, FOLDERFILE|IMAGEFILE|MOVIEFILE, FILE_SPECIAL, FILE_OPENFILE, FILE_RELPATH);
|
||||
}
|
||||
|
||||
/******************** save image as operator ********************/
|
||||
|
@ -3172,9 +3172,9 @@ static int is_sensor_linked(uiBlock *block, bSensor *sens)
|
||||
|
||||
/* Sensors code */
|
||||
|
||||
static void draw_sensor_header(uiLayout *layout, PointerRNA *ptr)
|
||||
static void draw_sensor_header(uiLayout *layout, PointerRNA *ptr, PointerRNA *logic_ptr)
|
||||
{
|
||||
uiLayout *box, *row;
|
||||
uiLayout *box, *row, *subrow;
|
||||
|
||||
box= uiLayoutBox(layout);
|
||||
row= uiLayoutRow(box, 0);
|
||||
@ -3182,6 +3182,12 @@ static void draw_sensor_header(uiLayout *layout, PointerRNA *ptr)
|
||||
uiItemR(row, ptr, "expanded", UI_ITEM_R_NO_BG, "", 0);
|
||||
uiItemR(row, ptr, "type", 0, "", 0);
|
||||
uiItemR(row, ptr, "name", 0, "", 0);
|
||||
|
||||
subrow= uiLayoutRow(row, 0);
|
||||
uiLayoutSetActive(subrow, (RNA_boolean_get(logic_ptr, "sensors_show_active_states")
|
||||
&& RNA_boolean_get(ptr, "expanded") || RNA_boolean_get(ptr, "pinned")));
|
||||
uiItemR(subrow, ptr, "pinned", UI_ITEM_R_NO_BG, "", 0);
|
||||
|
||||
uiItemO(row, "", ICON_X, "LOGIC_OT_sensor_remove");
|
||||
}
|
||||
|
||||
@ -3584,9 +3590,9 @@ void draw_brick_controller(uiLayout *layout, PointerRNA *ptr)
|
||||
}
|
||||
|
||||
/* Actuator code */
|
||||
static void draw_actuator_header(uiLayout *layout, PointerRNA *ptr)
|
||||
static void draw_actuator_header(uiLayout *layout, PointerRNA *ptr, PointerRNA *logic_ptr)
|
||||
{
|
||||
uiLayout *box, *row;
|
||||
uiLayout *box, *row, *subrow;
|
||||
|
||||
box= uiLayoutBox(layout);
|
||||
row= uiLayoutRow(box, 0);
|
||||
@ -3594,6 +3600,12 @@ static void draw_actuator_header(uiLayout *layout, PointerRNA *ptr)
|
||||
uiItemR(row, ptr, "expanded", UI_ITEM_R_NO_BG, "", 0);
|
||||
uiItemR(row, ptr, "type", 0, "", 0);
|
||||
uiItemR(row, ptr, "name", 0, "", 0);
|
||||
|
||||
subrow= uiLayoutRow(row, 0);
|
||||
uiLayoutSetActive(subrow, (RNA_boolean_get(logic_ptr, "actuators_show_active_states")
|
||||
&& RNA_boolean_get(ptr, "expanded") || RNA_boolean_get(ptr, "pinned")));
|
||||
uiItemR(subrow, ptr, "pinned", UI_ITEM_R_NO_BG, "", 0);
|
||||
|
||||
uiItemO(row, "", ICON_X, "LOGIC_OT_actuator_remove");
|
||||
}
|
||||
|
||||
@ -4351,7 +4363,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
|
||||
PointerRNA logic_ptr, settings_ptr;
|
||||
|
||||
uiLayout *layout, *row, *split, *subsplit, *box, *col;
|
||||
uiLayout *layout, *row, *box;
|
||||
uiBlock *block;
|
||||
uiBut *but;
|
||||
char name[32];
|
||||
@ -4367,13 +4379,17 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
block= uiBeginBlock(C, ar, name, UI_EMBOSS);
|
||||
uiBlockSetHandleFunc(block, do_logic_buts, NULL);
|
||||
|
||||
/* clean ACT_LINKED and ACT_VISIBLE of all potentially visible actuators so that
|
||||
we can determine which is actually linked/visible */
|
||||
/* loop over all objects and set visible/linked flags for the logic bricks */
|
||||
for(a=0; a<count; a++) {
|
||||
bActuator *act;
|
||||
bSensor *sens;
|
||||
bController *cont;
|
||||
int iact;
|
||||
short flag;
|
||||
|
||||
ob= (Object *)idar[a];
|
||||
|
||||
/* clean ACT_LINKED and ACT_VISIBLE of all potentially visible actuators so that we can determine which is actually linked/visible */
|
||||
act = ob->actuators.first;
|
||||
while(act) {
|
||||
act->flag &= ~(ACT_LINKED|ACT_VISIBLE);
|
||||
@ -4385,6 +4401,23 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
sens->flag &= ~(SENS_VISIBLE);
|
||||
sens = sens->next;
|
||||
}
|
||||
|
||||
/* mark the linked and visible actuators */
|
||||
cont= ob->controllers.first;
|
||||
while(cont) {
|
||||
flag = ACT_LINKED;
|
||||
|
||||
/* this controller is visible, mark all its actuator */
|
||||
if ((ob->scaflag & OB_ALLSTATE) || (ob->state & cont->state_mask))
|
||||
flag |= ACT_VISIBLE;
|
||||
|
||||
for (iact=0; iact<cont->totlinks; iact++) {
|
||||
act = cont->links[iact];
|
||||
if (act)
|
||||
act->flag |= flag;
|
||||
}
|
||||
cont = cont->next;
|
||||
}
|
||||
}
|
||||
|
||||
/* ****************** Controllers ****************** */
|
||||
@ -4393,7 +4426,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, U.uistyles.first);
|
||||
row = uiLayoutRow(layout, 1);
|
||||
|
||||
uiDefBlockBut(block, controller_menu, NULL, "Controllers", xco-10, yco, 70, UI_UNIT_Y, ""); /* replace this with uiLayout stuff later */
|
||||
uiDefBlockBut(block, controller_menu, NULL, "Controllers", xco-10, yco, 300, UI_UNIT_Y, ""); /* replace this with uiLayout stuff later */
|
||||
|
||||
uiItemR(row, &logic_ptr, "controllers_show_selected_objects", 0, "Sel", 0);
|
||||
uiItemR(row, &logic_ptr, "controllers_show_active_objects", 0, "Act", 0);
|
||||
@ -4406,6 +4439,9 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
int iact;
|
||||
|
||||
ob= (Object *)idar[a];
|
||||
|
||||
/* only draw the controller common header if "visible" */
|
||||
if( (ob->scavisflag & OB_VIS_CONT) == 0) continue;
|
||||
|
||||
/* Drawing the Controller Header common to all Selected Objects */
|
||||
|
||||
@ -4442,7 +4478,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
|
||||
/* End of Drawing the Controller Header common to all Selected Objects */
|
||||
|
||||
if (!(ob->scavisflag & OB_VIS_CONT) || !(ob->scaflag & OB_SHOWCONT)) continue;
|
||||
if ((ob->scaflag & OB_SHOWCONT) == 0) continue;
|
||||
|
||||
|
||||
uiItemS(layout);
|
||||
@ -4452,16 +4488,6 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
|
||||
if (!(ob->scaflag & OB_ALLSTATE) && !(ob->state & cont->state_mask))
|
||||
continue;
|
||||
//if (!(cont->state_mask & (1<<stbit)))
|
||||
// continue;
|
||||
|
||||
/* this controller is visible, mark all its actuator */
|
||||
/* XXX: perhaps move this to a preprocessing stage if possible? */
|
||||
for (iact=0; iact<cont->totlinks; iact++) {
|
||||
bActuator *act = cont->links[iact];
|
||||
if (act)
|
||||
act->flag |= ACT_VISIBLE;
|
||||
}
|
||||
|
||||
/* use two nested splits to align inlinks/links properly */
|
||||
split = uiLayoutSplit(layout, 0.05, 0);
|
||||
@ -4501,7 +4527,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, U.uistyles.first);
|
||||
row = uiLayoutRow(layout, 1);
|
||||
|
||||
uiDefBlockBut(block, sensor_menu, NULL, "Sensors", xco-10, yco, 70, UI_UNIT_Y, ""); /* replace this with uiLayout stuff later */
|
||||
uiDefBlockBut(block, sensor_menu, NULL, "Sensors", xco-10, yco, 300, UI_UNIT_Y, ""); /* replace this with uiLayout stuff later */
|
||||
|
||||
uiItemR(row, &logic_ptr, "sensors_show_selected_objects", 0, "Sel", 0);
|
||||
uiItemR(row, &logic_ptr, "sensors_show_active_objects", 0, "Act", 0);
|
||||
@ -4514,11 +4540,14 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
|
||||
ob= (Object *)idar[a];
|
||||
|
||||
/* only draw the sensor common header if "visible" */
|
||||
if((ob->scavisflag & OB_VIS_SENS) == 0) continue;
|
||||
|
||||
row = uiLayoutRow(layout, 1);
|
||||
uiDefButBitS(block, TOG, OB_SHOWSENS, B_REDR, ob->id.name+2,(short)(xco-10), yco, (short)(width-30), UI_UNIT_Y, &ob->scaflag, 0, 31, 0, 0, "Object name, click to show/hide sensors");
|
||||
uiItemMenuEnumO(row, "LOGIC_OT_sensor_add", "type", "Add Sensor", 0);
|
||||
|
||||
if (!(ob->scavisflag & OB_VIS_SENS) || !(ob->scaflag & OB_SHOWSENS)) continue;
|
||||
if ((ob->scaflag & OB_SHOWSENS) == 0) continue;
|
||||
|
||||
uiItemS(layout);
|
||||
|
||||
@ -4526,7 +4555,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
RNA_pointer_create((ID *)ob, &RNA_Sensor, sens, &ptr);
|
||||
|
||||
if ((ob->scaflag & OB_ALLSTATE) ||
|
||||
(slogic->scaflag & BUTS_SENS_STATE) ||
|
||||
!(slogic->scaflag & BUTS_SENS_STATE) ||
|
||||
(sens->totlinks == 0) || /* always display sensor without links so that is can be edited */
|
||||
(sens->flag & SENS_PIN && slogic->scaflag & BUTS_SENS_STATE) || /* states can hide some sensors, pinned sensors ignore the visible state */
|
||||
(is_sensor_linked(block, sens))
|
||||
@ -4539,7 +4568,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
uiLayoutSetContextPointer(col, "sensor", &ptr);
|
||||
|
||||
/* should make UI template for sensor header.. function will do for now */
|
||||
draw_sensor_header(col, &ptr);
|
||||
draw_sensor_header(col, &ptr, &logic_ptr);
|
||||
|
||||
/* draw the brick contents */
|
||||
draw_brick_sensor(col, &ptr, C);
|
||||
@ -4560,7 +4589,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, U.uistyles.first);
|
||||
row = uiLayoutRow(layout, 1);
|
||||
|
||||
uiDefBlockBut(block, sensor_menu, NULL, "Actuators", xco-10, yco, 70, UI_UNIT_Y, ""); /* replace this with uiLayout stuff later */
|
||||
uiDefBlockBut(block, actuator_menu, NULL, "Actuators", xco-10, yco, 300, UI_UNIT_Y, ""); /* replace this with uiLayout stuff later */
|
||||
|
||||
uiItemR(row, &logic_ptr, "actuators_show_selected_objects", 0, "Sel", 0);
|
||||
uiItemR(row, &logic_ptr, "actuators_show_active_objects", 0, "Act", 0);
|
||||
@ -4573,11 +4602,14 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
|
||||
ob= (Object *)idar[a];
|
||||
|
||||
/* only draw the actuator common header if "visible" */
|
||||
if( (ob->scavisflag & OB_VIS_ACT) == 0) continue;
|
||||
|
||||
row = uiLayoutRow(layout, 1);
|
||||
uiDefButBitS(block, TOG, OB_SHOWACT, B_REDR, ob->id.name+2,(short)(xco-10), yco, (short)(width-30), UI_UNIT_Y, &ob->scaflag, 0, 31, 0, 0, "Object name, click to show/hide actuators");
|
||||
uiItemMenuEnumO(row, "LOGIC_OT_actuator_add", "type", "Add Actuator", 0);
|
||||
|
||||
if (!(ob->scavisflag & OB_VIS_ACT) || !(ob->scaflag & OB_SHOWACT)) continue;
|
||||
if ((ob->scaflag & OB_SHOWACT) == 0) continue;
|
||||
|
||||
uiItemS(layout);
|
||||
|
||||
@ -4586,7 +4618,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
RNA_pointer_create((ID *)ob, &RNA_Actuator, act, &ptr);
|
||||
|
||||
if ((ob->scaflag & OB_ALLSTATE) ||
|
||||
(slogic->scaflag & BUTS_ACT_STATE) ||
|
||||
!(slogic->scaflag & BUTS_ACT_STATE) ||
|
||||
!(act->flag & ACT_LINKED) || /* always display actuators without links so that is can be edited */
|
||||
(act->flag & ACT_VISIBLE) || /* this actuator has visible connection, display it */
|
||||
(act->flag & ACT_PIN && slogic->scaflag & BUTS_ACT_STATE) /* states can hide some sensors, pinned sensors ignore the visible state */
|
||||
@ -4604,7 +4636,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
|
||||
uiLayoutSetContextPointer(col, "actuator", &ptr);
|
||||
|
||||
/* should make UI template for actuator header.. function will do for now */
|
||||
draw_actuator_header(col, &ptr);
|
||||
draw_actuator_header(col, &ptr, &logic_ptr);
|
||||
|
||||
/* draw the brick contents */
|
||||
draw_brick_actuator(col, &ptr, C);
|
||||
|
@ -1927,7 +1927,8 @@ static int tree_element_active_material(bContext *C, Scene *scene, SpaceOops *so
|
||||
|
||||
/* we search for the object parent */
|
||||
ob= (Object *)outliner_search_back(soops, te, ID_OB);
|
||||
if(ob==NULL || ob!=OBACT) return 0; // just paranoia
|
||||
// note: ob->matbits can be NULL when a local object points to a library mesh.
|
||||
if(ob==NULL || ob!=OBACT || ob->matbits==NULL) return 0; // just paranoia
|
||||
|
||||
/* searching in ob mat array? */
|
||||
tes= te->parent;
|
||||
|
@ -43,6 +43,7 @@
|
||||
|
||||
|
||||
#include "DNA_scene_types.h"
|
||||
#include "DNA_userdef_types.h"
|
||||
|
||||
#include "BKE_context.h"
|
||||
#include "BKE_global.h"
|
||||
@ -203,7 +204,7 @@ static int sequencer_add_scene_strip_exec(bContext *C, wmOperator *op)
|
||||
|
||||
if (RNA_boolean_get(op->ptr, "replace_sel")) {
|
||||
deselect_all_seq(scene);
|
||||
active_seq_set(scene, seq);
|
||||
seq_active_set(scene, seq);
|
||||
seq->flag |= SELECT;
|
||||
}
|
||||
|
||||
@ -313,6 +314,9 @@ static int sequencer_add_movie_strip_invoke(bContext *C, wmOperator *op, wmEvent
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
if(!RNA_property_is_set(op->ptr, "relative_path"))
|
||||
RNA_boolean_set(op->ptr, "relative_path", U.flag & USER_RELPATHS);
|
||||
|
||||
sequencer_generic_invoke_xy__internal(C, op, event, 0);
|
||||
return WM_operator_filesel(C, op, event);
|
||||
//return sequencer_add_movie_strip_exec(C, op);
|
||||
@ -336,7 +340,7 @@ void SEQUENCER_OT_movie_strip_add(struct wmOperatorType *ot)
|
||||
/* flags */
|
||||
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
|
||||
WM_operator_properties_filesel(ot, FOLDERFILE|MOVIEFILE, FILE_SPECIAL, FILE_OPENFILE, 0); //XXX TODO, relative_path
|
||||
WM_operator_properties_filesel(ot, FOLDERFILE|MOVIEFILE, FILE_SPECIAL, FILE_OPENFILE, FILE_RELPATH);
|
||||
sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME|SEQPROP_FILES);
|
||||
RNA_def_boolean(ot->srna, "sound", TRUE, "Sound", "Load sound with the movie");
|
||||
}
|
||||
@ -355,6 +359,9 @@ static int sequencer_add_sound_strip_invoke(bContext *C, wmOperator *op, wmEvent
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
if(!RNA_property_is_set(op->ptr, "relative_path"))
|
||||
RNA_boolean_set(op->ptr, "relative_path", U.flag & USER_RELPATHS);
|
||||
|
||||
sequencer_generic_invoke_xy__internal(C, op, event, 0);
|
||||
return WM_operator_filesel(C, op, event);
|
||||
//return sequencer_add_sound_strip_exec(C, op);
|
||||
@ -378,7 +385,7 @@ void SEQUENCER_OT_sound_strip_add(struct wmOperatorType *ot)
|
||||
/* flags */
|
||||
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
|
||||
WM_operator_properties_filesel(ot, FOLDERFILE|SOUNDFILE, FILE_SPECIAL, FILE_OPENFILE, 0); //XXX TODO, relative_path
|
||||
WM_operator_properties_filesel(ot, FOLDERFILE|SOUNDFILE, FILE_SPECIAL, FILE_OPENFILE, FILE_RELPATH);
|
||||
sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME|SEQPROP_FILES);
|
||||
RNA_def_boolean(ot->srna, "cache", FALSE, "Cache", "Cache the sound in memory.");
|
||||
}
|
||||
@ -446,6 +453,9 @@ static int sequencer_add_image_strip_invoke(bContext *C, wmOperator *op, wmEvent
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
if(!RNA_property_is_set(op->ptr, "relative_path"))
|
||||
RNA_boolean_set(op->ptr, "relative_path", U.flag & USER_RELPATHS);
|
||||
|
||||
sequencer_generic_invoke_xy__internal(C, op, event, SEQPROP_ENDFRAME);
|
||||
return WM_operator_filesel(C, op, event);
|
||||
//return sequencer_add_image_strip_exec(C, op);
|
||||
@ -469,7 +479,7 @@ void SEQUENCER_OT_image_strip_add(struct wmOperatorType *ot)
|
||||
/* flags */
|
||||
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
|
||||
WM_operator_properties_filesel(ot, FOLDERFILE|IMAGEFILE, FILE_SPECIAL, FILE_OPENFILE, 0); //XXX TODO, relative_path
|
||||
WM_operator_properties_filesel(ot, FOLDERFILE|IMAGEFILE, FILE_SPECIAL, FILE_OPENFILE, FILE_RELPATH);
|
||||
sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME|SEQPROP_ENDFRAME|SEQPROP_FILES);
|
||||
}
|
||||
|
||||
@ -572,7 +582,7 @@ static int sequencer_add_effect_strip_exec(bContext *C, wmOperator *op)
|
||||
|
||||
if (RNA_boolean_get(op->ptr, "replace_sel")) {
|
||||
deselect_all_seq(scene);
|
||||
active_seq_set(scene, seq);
|
||||
seq_active_set(scene, seq);
|
||||
seq->flag |= SELECT;
|
||||
}
|
||||
|
||||
@ -593,6 +603,10 @@ static int sequencer_add_effect_strip_invoke(bContext *C, wmOperator *op, wmEven
|
||||
sequencer_generic_invoke_xy__internal(C, op, event, SEQPROP_ENDFRAME);
|
||||
|
||||
if (RNA_property_is_set(op->ptr, "type") && RNA_enum_get(op->ptr, "type")==SEQ_PLUGIN) {
|
||||
|
||||
if(!RNA_property_is_set(op->ptr, "relative_path"))
|
||||
RNA_boolean_set(op->ptr, "relative_path", U.flag & USER_RELPATHS);
|
||||
|
||||
/* only plugins need the file selector */
|
||||
return WM_operator_filesel(C, op, event);
|
||||
}
|
||||
@ -617,7 +631,7 @@ void SEQUENCER_OT_effect_strip_add(struct wmOperatorType *ot)
|
||||
/* flags */
|
||||
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
|
||||
WM_operator_properties_filesel(ot, 0, FILE_SPECIAL, FILE_OPENFILE, 0); //XXX TODO, relative_path
|
||||
WM_operator_properties_filesel(ot, 0, FILE_SPECIAL, FILE_OPENFILE, FILE_RELPATH);
|
||||
sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME|SEQPROP_ENDFRAME);
|
||||
RNA_def_enum(ot->srna, "type", sequencer_prop_effect_types, SEQ_CROSS, "Type", "Sequencer effect type");
|
||||
RNA_def_float_vector(ot->srna, "color", 3, NULL, 0.0f, 1.0f, "Color", "Initialize the strip with this color (only used when type='COLOR')", 0.0f, 1.0f);
|
||||
|
@ -900,7 +900,7 @@ static void draw_seq_strips(const bContext *C, Editing *ed, ARegion *ar)
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
SpaceSeq *sseq= CTX_wm_space_seq(C);
|
||||
View2D *v2d= &ar->v2d;
|
||||
Sequence *last_seq = active_seq_get(scene);
|
||||
Sequence *last_seq = seq_active_get(scene);
|
||||
int sel = 0, j;
|
||||
float pixelx = (v2d->cur.xmax - v2d->cur.xmin)/(v2d->mask.xmax - v2d->mask.xmin);
|
||||
|
||||
|
@ -75,10 +75,6 @@
|
||||
/* own include */
|
||||
#include "sequencer_intern.h"
|
||||
|
||||
/* XXX */
|
||||
//static Sequence *_last_seq=0;
|
||||
//static int _last_seq_init=0;
|
||||
/* XXX */
|
||||
static void error(const char *dummy) {}
|
||||
static void waitcursor(int val) {}
|
||||
static void activate_fileselect(int d1, char *d2, char *d3, void *d4) {}
|
||||
@ -167,7 +163,7 @@ static void change_plugin_seq(Scene *scene, char *str) /* called from fileselect
|
||||
{
|
||||
Editing *ed= seq_give_editing(scene, FALSE);
|
||||
struct SeqEffectHandle sh;
|
||||
Sequence *last_seq= active_seq_get(scene);
|
||||
Sequence *last_seq= seq_active_get(scene);
|
||||
|
||||
if(last_seq && last_seq->type != SEQ_PLUGIN) return;
|
||||
|
||||
@ -393,7 +389,7 @@ void deselect_all_seq(Scene *scene)
|
||||
if(ed==NULL) return;
|
||||
|
||||
SEQP_BEGIN(ed, seq) {
|
||||
seq->flag &= SEQ_DESEL;
|
||||
seq->flag &= ~SEQ_ALLSEL;
|
||||
}
|
||||
SEQ_END
|
||||
|
||||
@ -406,9 +402,9 @@ void recurs_sel_seq(Sequence *seqm)
|
||||
seq= seqm->seqbase.first;
|
||||
while(seq) {
|
||||
|
||||
if(seqm->flag & (SEQ_LEFTSEL+SEQ_RIGHTSEL)) seq->flag &= SEQ_DESEL;
|
||||
if(seqm->flag & (SEQ_LEFTSEL+SEQ_RIGHTSEL)) seq->flag &= ~SEQ_ALLSEL;
|
||||
else if(seqm->flag & SELECT) seq->flag |= SELECT;
|
||||
else seq->flag &= SEQ_DESEL;
|
||||
else seq->flag &= ~SEQ_ALLSEL;
|
||||
|
||||
if(seq->seqbase.first) recurs_sel_seq(seq);
|
||||
|
||||
@ -441,7 +437,7 @@ static void reload_sound_strip(Scene *scene, char *name)
|
||||
Editing *ed;
|
||||
Sequence *seq, *seqact;
|
||||
SpaceFile *sfile;
|
||||
Sequence *last_seq= active_seq_get(scene);
|
||||
Sequence *last_seq= seq_active_get(scene);
|
||||
|
||||
ed= scene->ed;
|
||||
|
||||
@ -483,7 +479,7 @@ static void reload_image_strip(Scene *scene, char *name)
|
||||
Editing *ed= seq_give_editing(scene, FALSE);
|
||||
Sequence *seq=NULL, *seqact;
|
||||
SpaceFile *sfile=NULL;
|
||||
Sequence *last_seq= active_seq_get(scene);
|
||||
Sequence *last_seq= seq_active_get(scene);
|
||||
|
||||
|
||||
|
||||
@ -519,7 +515,7 @@ static void reload_image_strip(Scene *scene, char *name)
|
||||
void change_sequence(Scene *scene)
|
||||
{
|
||||
Editing *ed= seq_give_editing(scene, FALSE);
|
||||
Sequence *last_seq= active_seq_get(scene);
|
||||
Sequence *last_seq= seq_active_get(scene);
|
||||
Scene *sce;
|
||||
short event;
|
||||
|
||||
@ -621,7 +617,7 @@ int seq_effect_find_selected(Scene *scene, Sequence *activeseq, int type, Sequen
|
||||
*error_str= NULL;
|
||||
|
||||
if (!activeseq)
|
||||
seq2= active_seq_get(scene);
|
||||
seq2= seq_active_get(scene);
|
||||
|
||||
for(seq=ed->seqbasep->first; seq; seq=seq->next) {
|
||||
if(seq->flag & SELECT) {
|
||||
@ -684,7 +680,7 @@ int seq_effect_find_selected(Scene *scene, Sequence *activeseq, int type, Sequen
|
||||
void reassign_inputs_seq_effect(Scene *scene)
|
||||
{
|
||||
Editing *ed= seq_give_editing(scene, FALSE);
|
||||
Sequence *seq1, *seq2, *seq3, *last_seq = active_seq_get(scene);
|
||||
Sequence *seq1, *seq2, *seq3, *last_seq = seq_active_get(scene);
|
||||
char *error_msg;
|
||||
|
||||
if(last_seq==0 || !(last_seq->type & SEQ_EFFECT)) return;
|
||||
@ -753,7 +749,7 @@ static Sequence *del_seq_find_replace_recurs(Scene *scene, Sequence *seq)
|
||||
static void recurs_del_seq_flag(Scene *scene, ListBase *lb, short flag, short deleteall)
|
||||
{
|
||||
Sequence *seq, *seqn;
|
||||
Sequence *last_seq = active_seq_get(scene);
|
||||
Sequence *last_seq = seq_active_get(scene);
|
||||
|
||||
seq= lb->first;
|
||||
while(seq) {
|
||||
@ -763,7 +759,7 @@ static void recurs_del_seq_flag(Scene *scene, ListBase *lb, short flag, short de
|
||||
seq->sound->id.us--;
|
||||
|
||||
BLI_remlink(lb, seq);
|
||||
if(seq==last_seq) active_seq_set(scene, NULL);
|
||||
if(seq==last_seq) seq_active_set(scene, NULL);
|
||||
if(seq->type==SEQ_META) recurs_del_seq_flag(scene, &seq->seqbase, flag, 1);
|
||||
if(seq->ipo) seq->ipo->id.us--;
|
||||
seq_free_sequence(scene, seq);
|
||||
@ -772,132 +768,6 @@ static void recurs_del_seq_flag(Scene *scene, ListBase *lb, short flag, short de
|
||||
}
|
||||
}
|
||||
|
||||
static Sequence *dupli_seq(struct Scene *scene, Sequence *seq)
|
||||
{
|
||||
Sequence *seqn = MEM_dupallocN(seq);
|
||||
|
||||
seq->tmp = seqn;
|
||||
seqn->strip= MEM_dupallocN(seq->strip);
|
||||
|
||||
// XXX: add F-Curve duplication stuff?
|
||||
|
||||
seqn->strip->tstripdata = 0;
|
||||
seqn->strip->tstripdata_startstill = 0;
|
||||
seqn->strip->tstripdata_endstill = 0;
|
||||
seqn->strip->ibuf_startstill = 0;
|
||||
seqn->strip->ibuf_endstill = 0;
|
||||
|
||||
if (seq->strip->crop) {
|
||||
seqn->strip->crop = MEM_dupallocN(seq->strip->crop);
|
||||
}
|
||||
|
||||
if (seq->strip->transform) {
|
||||
seqn->strip->transform = MEM_dupallocN(seq->strip->transform);
|
||||
}
|
||||
|
||||
if (seq->strip->proxy) {
|
||||
seqn->strip->proxy = MEM_dupallocN(seq->strip->proxy);
|
||||
}
|
||||
|
||||
if (seq->strip->color_balance) {
|
||||
seqn->strip->color_balance
|
||||
= MEM_dupallocN(seq->strip->color_balance);
|
||||
}
|
||||
|
||||
if(seq->type==SEQ_META) {
|
||||
seqn->strip->stripdata = 0;
|
||||
|
||||
seqn->seqbase.first= seqn->seqbase.last= 0;
|
||||
/* WATCH OUT!!! - This metastrip is not recursively duplicated here - do this after!!! */
|
||||
/* - recurs_dupli_seq(&seq->seqbase,&seqn->seqbase);*/
|
||||
} else if(seq->type == SEQ_SCENE) {
|
||||
seqn->strip->stripdata = 0;
|
||||
if(seq->scene_sound)
|
||||
seqn->scene_sound = sound_scene_add_scene_sound(scene, seqn, seq->startdisp, seq->enddisp, seq->startofs + seq->anim_startofs);
|
||||
} else if(seq->type == SEQ_MOVIE) {
|
||||
seqn->strip->stripdata =
|
||||
MEM_dupallocN(seq->strip->stripdata);
|
||||
seqn->anim= 0;
|
||||
} else if(seq->type == SEQ_SOUND) {
|
||||
seqn->strip->stripdata =
|
||||
MEM_dupallocN(seq->strip->stripdata);
|
||||
if(seq->scene_sound)
|
||||
seqn->scene_sound = sound_add_scene_sound(scene, seqn, seq->startdisp, seq->enddisp, seq->startofs + seq->anim_startofs);
|
||||
|
||||
seqn->sound->id.us++;
|
||||
} else if(seq->type == SEQ_IMAGE) {
|
||||
seqn->strip->stripdata =
|
||||
MEM_dupallocN(seq->strip->stripdata);
|
||||
} else if(seq->type >= SEQ_EFFECT) {
|
||||
if(seq->seq1 && seq->seq1->tmp) seqn->seq1= seq->seq1->tmp;
|
||||
if(seq->seq2 && seq->seq2->tmp) seqn->seq2= seq->seq2->tmp;
|
||||
if(seq->seq3 && seq->seq3->tmp) seqn->seq3= seq->seq3->tmp;
|
||||
|
||||
if (seq->type & SEQ_EFFECT) {
|
||||
struct SeqEffectHandle sh;
|
||||
sh = get_sequence_effect(seq);
|
||||
if(sh.copy)
|
||||
sh.copy(seq, seqn);
|
||||
}
|
||||
|
||||
seqn->strip->stripdata = 0;
|
||||
|
||||
} else {
|
||||
fprintf(stderr, "Aiiiiekkk! sequence type not "
|
||||
"handled in duplicate!\nExpect a crash"
|
||||
" now...\n");
|
||||
}
|
||||
|
||||
seqbase_unique_name_recursive(&scene->ed->seqbase, seqn);
|
||||
|
||||
return seqn;
|
||||
}
|
||||
|
||||
static Sequence * deep_dupli_seq(struct Scene *scene, Sequence * seq)
|
||||
{
|
||||
Sequence * seqn = dupli_seq(scene, seq);
|
||||
if (seq->type == SEQ_META) {
|
||||
Sequence * s;
|
||||
for(s= seq->seqbase.first; s; s = s->next) {
|
||||
Sequence * n = deep_dupli_seq(scene, s);
|
||||
if (n) {
|
||||
BLI_addtail(&seqn->seqbase, n);
|
||||
}
|
||||
}
|
||||
}
|
||||
return seqn;
|
||||
}
|
||||
|
||||
|
||||
static void recurs_dupli_seq(Scene *scene, ListBase *old, ListBase *new, int do_context)
|
||||
{
|
||||
Sequence *seq;
|
||||
Sequence *seqn = 0;
|
||||
Sequence *last_seq = active_seq_get(scene);
|
||||
|
||||
for(seq= old->first; seq; seq= seq->next) {
|
||||
seq->tmp= NULL;
|
||||
if(seq->flag & SELECT) {
|
||||
seqn = dupli_seq(scene, seq);
|
||||
if (seqn) { /*should never fail */
|
||||
if(do_context) {
|
||||
seq->flag &= SEQ_DESEL;
|
||||
seqn->flag &= ~(SEQ_LEFTSEL+SEQ_RIGHTSEL+SEQ_LOCK);
|
||||
}
|
||||
|
||||
BLI_addtail(new, seqn);
|
||||
if(seq->type==SEQ_META)
|
||||
recurs_dupli_seq(scene, &seq->seqbase,&seqn->seqbase, do_context);
|
||||
|
||||
if(do_context) {
|
||||
if (seq == last_seq) {
|
||||
active_seq_set(scene, seqn);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static Sequence *cut_seq_hard(Scene *scene, Sequence * seq, int cutframe)
|
||||
{
|
||||
@ -951,7 +821,7 @@ static Sequence *cut_seq_hard(Scene *scene, Sequence * seq, int cutframe)
|
||||
|
||||
if (!skip_dup) {
|
||||
/* Duplicate AFTER the first change */
|
||||
seqn = deep_dupli_seq(scene, seq);
|
||||
seqn = seq_dupli_recursive(scene, seq, SEQ_DUPE_UNIQUE_NAME);
|
||||
}
|
||||
|
||||
if (seqn) {
|
||||
@ -1040,7 +910,7 @@ static Sequence *cut_seq_soft(Scene *scene, Sequence * seq, int cutframe)
|
||||
|
||||
if (!skip_dup) {
|
||||
/* Duplicate AFTER the first change */
|
||||
seqn = deep_dupli_seq(scene, seq);
|
||||
seqn = seq_dupli_recursive(scene, seq, SEQ_DUPE_UNIQUE_NAME);
|
||||
}
|
||||
|
||||
if (seqn) {
|
||||
@ -1190,7 +1060,7 @@ void set_filter_seq(Scene *scene)
|
||||
|
||||
void seq_remap_paths(Scene *scene)
|
||||
{
|
||||
Sequence *seq, *last_seq = active_seq_get(scene);
|
||||
Sequence *seq, *last_seq = seq_active_get(scene);
|
||||
Editing *ed= seq_give_editing(scene, FALSE);
|
||||
char from[FILE_MAX], to[FILE_MAX], stripped[FILE_MAX];
|
||||
|
||||
@ -1625,11 +1495,11 @@ static int sequencer_cut_exec(bContext *C, wmOperator *op)
|
||||
SEQP_BEGIN(ed, seq) {
|
||||
if (cut_side==SEQ_SIDE_LEFT) {
|
||||
if ( seq->startdisp >= cut_frame ) {
|
||||
seq->flag &= SEQ_DESEL;
|
||||
seq->flag &= ~SEQ_ALLSEL;
|
||||
}
|
||||
} else {
|
||||
if ( seq->enddisp <= cut_frame ) {
|
||||
seq->flag &= SEQ_DESEL;
|
||||
seq->flag &= ~SEQ_ALLSEL;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1691,17 +1561,17 @@ static int sequencer_add_duplicate_exec(bContext *C, wmOperator *op)
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
Editing *ed= seq_give_editing(scene, FALSE);
|
||||
|
||||
ListBase new= {NULL, NULL};
|
||||
ListBase nseqbase= {NULL, NULL};
|
||||
|
||||
if(ed==NULL)
|
||||
return OPERATOR_CANCELLED;
|
||||
|
||||
recurs_dupli_seq(scene, ed->seqbasep, &new, TRUE);
|
||||
seqbase_dupli_recursive(scene, &nseqbase, ed->seqbasep, SEQ_DUPE_UNIQUE_NAME|SEQ_DUPE_CONTEXT);
|
||||
|
||||
if(new.first) {
|
||||
Sequence * seq= new.first;
|
||||
/* rely on the new list being added at the end */
|
||||
addlisttolist(ed->seqbasep, &new);
|
||||
if(nseqbase.first) {
|
||||
Sequence * seq= nseqbase.first;
|
||||
/* rely on the nseqbase list being added at the end */
|
||||
addlisttolist(ed->seqbasep, &nseqbase);
|
||||
|
||||
for( ; seq; seq= seq->next)
|
||||
seqbase_unique_name_recursive(&ed->seqbase, seq);
|
||||
@ -1751,7 +1621,7 @@ static int sequencer_delete_exec(bContext *C, wmOperator *op)
|
||||
MetaStack *ms;
|
||||
int nothingSelected = TRUE;
|
||||
|
||||
seq=active_seq_get(scene);
|
||||
seq=seq_active_get(scene);
|
||||
if (seq && seq->flag & SELECT) { /* avoid a loop since this is likely to be selected */
|
||||
nothingSelected = FALSE;
|
||||
} else {
|
||||
@ -1918,7 +1788,7 @@ static int sequencer_meta_toggle_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
Editing *ed= seq_give_editing(scene, FALSE);
|
||||
Sequence *last_seq= active_seq_get(scene);
|
||||
Sequence *last_seq= seq_active_get(scene);
|
||||
MetaStack *ms;
|
||||
|
||||
if(last_seq && last_seq->type==SEQ_META && last_seq->flag & SELECT) {
|
||||
@ -1930,7 +1800,7 @@ static int sequencer_meta_toggle_exec(bContext *C, wmOperator *op)
|
||||
|
||||
ed->seqbasep= &last_seq->seqbase;
|
||||
|
||||
active_seq_set(scene, NULL);
|
||||
seq_active_set(scene, NULL);
|
||||
|
||||
}
|
||||
else {
|
||||
@ -1950,7 +1820,7 @@ static int sequencer_meta_toggle_exec(bContext *C, wmOperator *op)
|
||||
for(seq= ed->seqbasep->first; seq; seq= seq->next)
|
||||
calc_sequence(scene, seq);
|
||||
|
||||
active_seq_set(scene, ms->parseq);
|
||||
seq_active_set(scene, ms->parseq);
|
||||
|
||||
ms->parseq->flag |= SELECT;
|
||||
recurs_sel_seq(ms->parseq);
|
||||
@ -2020,7 +1890,7 @@ static int sequencer_meta_make_exec(bContext *C, wmOperator *op)
|
||||
seqm->strip->len= seqm->len;
|
||||
seqm->strip->us= 1;
|
||||
|
||||
active_seq_set(scene, seqm);
|
||||
seq_active_set(scene, seqm);
|
||||
|
||||
if( seq_test_overlap(ed->seqbasep, seqm) ) shuffle_seq(ed->seqbasep, seqm, scene);
|
||||
|
||||
@ -2065,7 +1935,7 @@ static int sequencer_meta_separate_exec(bContext *C, wmOperator *op)
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
Editing *ed= seq_give_editing(scene, FALSE);
|
||||
|
||||
Sequence *seq, *last_seq = active_seq_get(scene); /* last_seq checks ed==NULL */
|
||||
Sequence *seq, *last_seq = seq_active_get(scene); /* last_seq checks ed==NULL */
|
||||
|
||||
if(last_seq==NULL || last_seq->type!=SEQ_META)
|
||||
return OPERATOR_CANCELLED;
|
||||
@ -2521,7 +2391,7 @@ static int sequencer_swap_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
Editing *ed= seq_give_editing(scene, FALSE);
|
||||
Sequence *active_seq = active_seq_get(scene);
|
||||
Sequence *active_seq = seq_active_get(scene);
|
||||
Sequence *seq, *iseq;
|
||||
int side= RNA_enum_get(op->ptr, "side");
|
||||
|
||||
@ -2597,7 +2467,7 @@ static int sequencer_rendersize_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
int retval = OPERATOR_CANCELLED;
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
Sequence *active_seq = active_seq_get(scene);
|
||||
Sequence *active_seq = seq_active_get(scene);
|
||||
|
||||
if(active_seq==NULL)
|
||||
return OPERATOR_CANCELLED;
|
||||
@ -2670,7 +2540,7 @@ static int sequencer_copy_exec(bContext *C, wmOperator *op)
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
recurs_dupli_seq(scene, ed->seqbasep, &seqbase_clipboard, FALSE);
|
||||
seqbase_dupli_recursive(scene, &seqbase_clipboard, ed->seqbasep, SEQ_DUPE_UNIQUE_NAME);
|
||||
seqbase_clipboard_frame= scene->r.cfra;
|
||||
|
||||
/* Need to remove anything that references the current scene */
|
||||
@ -2717,23 +2587,23 @@ static int sequencer_paste_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
Editing *ed= seq_give_editing(scene, TRUE); /* create if needed */
|
||||
ListBase new = {NULL, NULL};
|
||||
ListBase nseqbase = {NULL, NULL};
|
||||
int ofs;
|
||||
Sequence *iseq;
|
||||
|
||||
deselect_all_seq(scene);
|
||||
ofs = scene->r.cfra - seqbase_clipboard_frame;
|
||||
|
||||
recurs_dupli_seq(scene, &seqbase_clipboard, &new, FALSE);
|
||||
seqbase_dupli_recursive(scene, &nseqbase, &seqbase_clipboard, SEQ_DUPE_UNIQUE_NAME);
|
||||
|
||||
/* transform pasted strips before adding */
|
||||
if(ofs) {
|
||||
for(iseq= new.first; iseq; iseq= iseq->next) {
|
||||
for(iseq= nseqbase.first; iseq; iseq= iseq->next) {
|
||||
seq_offset(scene, iseq, ofs);
|
||||
}
|
||||
}
|
||||
|
||||
addlisttolist(ed->seqbasep, &new);
|
||||
addlisttolist(ed->seqbasep, &nseqbase);
|
||||
|
||||
WM_event_add_notifier(C, NC_SCENE|ND_SEQUENCER, scene);
|
||||
|
||||
@ -2756,3 +2626,45 @@ void SEQUENCER_OT_paste(wmOperatorType *ot)
|
||||
|
||||
/* properties */
|
||||
}
|
||||
|
||||
static int sequencer_swap_data_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
Sequence *seq_act;
|
||||
Sequence *seq_other;
|
||||
|
||||
if(seq_active_pair_get(scene, &seq_act, &seq_other) == 0) {
|
||||
BKE_report(op->reports, RPT_ERROR, "Must select 2 strips");
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
if(seq_swap(seq_act, seq_other) == 0) {
|
||||
BKE_report(op->reports, RPT_ERROR, "Strips were not compatible");
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
calc_sequence(scene, seq_act);
|
||||
calc_sequence(scene, seq_other);
|
||||
|
||||
WM_event_add_notifier(C, NC_SCENE|ND_SEQUENCER, scene);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
void SEQUENCER_OT_swap_data(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name= "Sequencer Swap Data";
|
||||
ot->idname= "SEQUENCER_OT_swap_data";
|
||||
ot->description="Swap 2 sequencer strips";
|
||||
|
||||
/* api callbacks */
|
||||
ot->exec= sequencer_swap_data_exec;
|
||||
ot->poll= ED_operator_sequencer_active;
|
||||
|
||||
/* flags */
|
||||
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
|
||||
/* properties */
|
||||
}
|
||||
|
||||
|
@ -95,6 +95,7 @@ void SEQUENCER_OT_snap(struct wmOperatorType *ot);
|
||||
void SEQUENCER_OT_previous_edit(struct wmOperatorType *ot);
|
||||
void SEQUENCER_OT_next_edit(struct wmOperatorType *ot);
|
||||
void SEQUENCER_OT_swap(struct wmOperatorType *ot);
|
||||
void SEQUENCER_OT_swap_data(struct wmOperatorType *ot);
|
||||
void SEQUENCER_OT_rendersize(struct wmOperatorType *ot);
|
||||
|
||||
void SEQUENCER_OT_view_toggle(struct wmOperatorType *ot);
|
||||
@ -145,8 +146,6 @@ enum {
|
||||
};
|
||||
|
||||
/* defines used internally */
|
||||
#define SEQ_ALLSEL (SELECT+SEQ_LEFTSEL+SEQ_RIGHTSEL)
|
||||
#define SEQ_DESEL ~SEQ_ALLSEL
|
||||
#define SCE_MARKERS 0 // XXX - dummy
|
||||
|
||||
/* sequencer_ops.c */
|
||||
|
@ -73,6 +73,7 @@ void sequencer_operatortypes(void)
|
||||
WM_operatortype_append(SEQUENCER_OT_next_edit);
|
||||
WM_operatortype_append(SEQUENCER_OT_previous_edit);
|
||||
WM_operatortype_append(SEQUENCER_OT_swap);
|
||||
WM_operatortype_append(SEQUENCER_OT_swap_data);
|
||||
WM_operatortype_append(SEQUENCER_OT_rendersize);
|
||||
|
||||
WM_operatortype_append(SEQUENCER_OT_view_all);
|
||||
|
@ -166,7 +166,7 @@ void select_single_seq(Scene *scene, Sequence *seq, int deselect_all) /* BRING B
|
||||
|
||||
if(deselect_all)
|
||||
deselect_all_seq(scene);
|
||||
active_seq_set(scene, seq);
|
||||
seq_active_set(scene, seq);
|
||||
|
||||
if((seq->type==SEQ_IMAGE) || (seq->type==SEQ_MOVIE)) {
|
||||
if(seq->strip)
|
||||
@ -185,7 +185,7 @@ void select_single_seq(Scene *scene, Sequence *seq, int deselect_all) /* BRING B
|
||||
|
||||
void select_neighbor_from_last(Scene *scene, int lr)
|
||||
{
|
||||
Sequence *seq= active_seq_get(scene);
|
||||
Sequence *seq= seq_active_get(scene);
|
||||
Sequence *neighbor;
|
||||
int change = 0;
|
||||
if (seq) {
|
||||
@ -231,7 +231,7 @@ static int sequencer_deselect_exec(bContext *C, wmOperator *op)
|
||||
|
||||
for(seq= ed->seqbasep->first; seq; seq=seq->next) {
|
||||
if (desel) {
|
||||
seq->flag &= SEQ_DESEL;
|
||||
seq->flag &= ~SEQ_ALLSEL;
|
||||
}
|
||||
else {
|
||||
seq->flag &= ~(SEQ_LEFTSEL+SEQ_RIGHTSEL);
|
||||
@ -269,7 +269,7 @@ static int sequencer_select_inverse_exec(bContext *C, wmOperator *op)
|
||||
|
||||
for(seq= ed->seqbasep->first; seq; seq=seq->next) {
|
||||
if (seq->flag & SELECT) {
|
||||
seq->flag &= SEQ_DESEL;
|
||||
seq->flag &= ~SEQ_ALLSEL;
|
||||
}
|
||||
else {
|
||||
seq->flag &= ~(SEQ_LEFTSEL+SEQ_RIGHTSEL);
|
||||
@ -392,7 +392,7 @@ static int sequencer_select_invoke(bContext *C, wmOperator *op, wmEvent *event)
|
||||
deselect_all_seq(scene);
|
||||
|
||||
if(seq) {
|
||||
active_seq_set(scene, seq);
|
||||
seq_active_set(scene, seq);
|
||||
|
||||
if ((seq->type == SEQ_IMAGE) || (seq->type == SEQ_MOVIE)) {
|
||||
if(seq->strip) {
|
||||
@ -409,7 +409,7 @@ static int sequencer_select_invoke(bContext *C, wmOperator *op, wmEvent *event)
|
||||
switch(hand) {
|
||||
case SEQ_SIDE_NONE:
|
||||
if (linked_handle==0)
|
||||
seq->flag &= SEQ_DESEL;
|
||||
seq->flag &= ~SEQ_ALLSEL;
|
||||
break;
|
||||
case SEQ_SIDE_LEFT:
|
||||
seq->flag ^= SEQ_LEFTSEL;
|
||||
@ -794,7 +794,7 @@ static int sequencer_select_active_side_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
Editing *ed= seq_give_editing(scene, 0);
|
||||
Sequence *seq_act= active_seq_get(scene);
|
||||
Sequence *seq_act= seq_active_get(scene);
|
||||
|
||||
if (ed==NULL || seq_act==NULL)
|
||||
return OPERATOR_CANCELLED;
|
||||
@ -860,7 +860,7 @@ static int sequencer_borderselect_exec(bContext *C, wmOperator *op)
|
||||
|
||||
if(BLI_isect_rctf(&rq, &rectf, 0)) {
|
||||
if(selecting) seq->flag |= SELECT;
|
||||
else seq->flag &= SEQ_DESEL;
|
||||
else seq->flag &= ~SEQ_ALLSEL;
|
||||
recurs_sel_seq(seq);
|
||||
}
|
||||
}
|
||||
|
@ -31,6 +31,7 @@
|
||||
|
||||
#include "DNA_object_types.h"
|
||||
#include "DNA_scene_types.h"
|
||||
#include "DNA_particle_types.h"
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
@ -40,6 +41,7 @@
|
||||
#include "BKE_context.h"
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_screen.h"
|
||||
#include "BKE_pointcache.h"
|
||||
#include "BKE_utildefines.h"
|
||||
|
||||
#include "ED_anim_api.h"
|
||||
@ -84,6 +86,174 @@ static void time_draw_sfra_efra(const bContext *C, SpaceTime *stime, ARegion *ar
|
||||
fdrawline((float)PEFRA, v2d->cur.ymin, (float)PEFRA, v2d->cur.ymax);
|
||||
}
|
||||
|
||||
#define CACHE_DRAW_HEIGHT 3.0f
|
||||
|
||||
static void time_draw_cache(const bContext *C, SpaceTime *stime, ARegion *ar)
|
||||
{
|
||||
SpaceTimeCache *stc;
|
||||
float yoffs=0.f;
|
||||
|
||||
if (!(stime->cache_display & TIME_CACHE_DISPLAY))
|
||||
return;
|
||||
|
||||
for (stc= stime->caches.first; stc; stc=stc->next) {
|
||||
float col[4];
|
||||
|
||||
if (!stc->array || !stc->ok)
|
||||
continue;
|
||||
|
||||
glPushMatrix();
|
||||
glTranslatef(0.0, (float)V2D_SCROLL_HEIGHT+yoffs, 0.0);
|
||||
glScalef(1.0, CACHE_DRAW_HEIGHT, 0.0);
|
||||
|
||||
switch(stc->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_PARTICLES:
|
||||
col[0] = 1.0; col[1] = 0.1; 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;
|
||||
}
|
||||
glColor4fv(col);
|
||||
|
||||
glEnable(GL_BLEND);
|
||||
|
||||
glRectf((float)stc->startframe, 0.0, (float)stc->endframe, 1.0);
|
||||
|
||||
col[3] = 0.4;
|
||||
if (stc->flag & PTCACHE_BAKED) {
|
||||
col[0] -= 0.4; col[1] -= 0.4; col[2] -= 0.4;
|
||||
}
|
||||
glColor4fv(col);
|
||||
|
||||
glEnableClientState(GL_VERTEX_ARRAY);
|
||||
glVertexPointer(2, GL_FLOAT, 0, stc->array);
|
||||
glDrawArrays(GL_QUADS, 0, stc->len);
|
||||
glDisableClientState(GL_VERTEX_ARRAY);
|
||||
|
||||
glDisable(GL_BLEND);
|
||||
|
||||
glPopMatrix();
|
||||
|
||||
yoffs += CACHE_DRAW_HEIGHT;
|
||||
}
|
||||
}
|
||||
|
||||
static void time_cache_free(SpaceTime *stime)
|
||||
{
|
||||
SpaceTimeCache *stc;
|
||||
|
||||
for (stc= stime->caches.first; stc; stc=stc->next) {
|
||||
if (stc->array) {
|
||||
MEM_freeN(stc->array);
|
||||
stc->array = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
BLI_freelistN(&stime->caches);
|
||||
}
|
||||
|
||||
static void time_cache_refresh(const bContext *C, SpaceTime *stime, ARegion *ar)
|
||||
{
|
||||
Object *ob = CTX_data_active_object(C);
|
||||
PTCacheID *pid;
|
||||
ListBase pidlist;
|
||||
|
||||
time_cache_free(stime);
|
||||
|
||||
if (!(stime->cache_display & TIME_CACHE_DISPLAY) || (!ob))
|
||||
return;
|
||||
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, NULL, 0);
|
||||
|
||||
/* iterate over pointcaches on the active object,
|
||||
* add spacetimecache and vertex array for each */
|
||||
for(pid=pidlist.first; pid; pid=pid->next) {
|
||||
SpaceTimeCache *stc;
|
||||
float *fp, *array;
|
||||
int i, len;
|
||||
|
||||
switch(pid->type) {
|
||||
case PTCACHE_TYPE_SOFTBODY:
|
||||
if (!(stime->cache_display & TIME_CACHE_SOFTBODY)) continue;
|
||||
break;
|
||||
case PTCACHE_TYPE_PARTICLES:
|
||||
if (!(stime->cache_display & TIME_CACHE_PARTICLES)) 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;
|
||||
}
|
||||
|
||||
stc= MEM_callocN(sizeof(SpaceTimeCache), "spacetimecache");
|
||||
|
||||
stc->type = pid->type;
|
||||
|
||||
if (pid->cache->flag & PTCACHE_BAKED)
|
||||
stc->flag |= PTCACHE_BAKED;
|
||||
if (pid->cache->flag & PTCACHE_DISK_CACHE)
|
||||
stc->flag |= PTCACHE_DISK_CACHE;
|
||||
|
||||
/* first allocate with maximum number of frames needed */
|
||||
BKE_ptcache_id_time(pid, CTX_data_scene(C), 0, &stc->startframe, &stc->endframe, NULL);
|
||||
len = (stc->endframe - stc->startframe + 1)*4;
|
||||
fp = array = MEM_callocN(len*2*sizeof(float), "temporary timeline cache array");
|
||||
|
||||
/* fill the vertex array with a quad for each cached frame */
|
||||
for (i=stc->startframe; i<=stc->endframe; i++) {
|
||||
|
||||
if (BKE_ptcache_id_exist(pid, i)) {
|
||||
fp[0] = (float)i;
|
||||
fp[1] = 0.0;
|
||||
fp+=2;
|
||||
|
||||
fp[0] = (float)i;
|
||||
fp[1] = 1.0;
|
||||
fp+=2;
|
||||
|
||||
fp[0] = (float)(i+1);
|
||||
fp[1] = 1.0;
|
||||
fp+=2;
|
||||
|
||||
fp[0] = (float)(i+1);
|
||||
fp[1] = 0.0;
|
||||
fp+=2;
|
||||
}
|
||||
}
|
||||
/* update with final number of frames */
|
||||
stc->len = (i-stc->startframe)*4;
|
||||
stc->array = MEM_mallocN(stc->len*2*sizeof(float), "SpaceTimeCache array");
|
||||
memcpy(stc->array, array, stc->len*2*sizeof(float));
|
||||
|
||||
MEM_freeN(array);
|
||||
array = NULL;
|
||||
|
||||
stc->ok = 1;
|
||||
|
||||
BLI_addtail(&stime->caches, stc);
|
||||
}
|
||||
|
||||
/* todo: sort time->caches list for consistent order */
|
||||
// ...
|
||||
|
||||
BLI_freelistN(&pidlist);
|
||||
}
|
||||
|
||||
/* helper function - find actkeycolumn that occurs on cframe, or the nearest one if not found */
|
||||
static ActKeyColumn *time_cfra_find_ak (ActKeyColumn *ak, float cframe)
|
||||
{
|
||||
@ -206,6 +376,52 @@ static void time_draw_keyframes(const bContext *C, SpaceTime *stime, ARegion *ar
|
||||
|
||||
/* ---------------- */
|
||||
|
||||
static void time_refresh(const bContext *C, ScrArea *sa)
|
||||
{
|
||||
SpaceTime *stime = (SpaceTime *)sa->spacedata.first;
|
||||
ARegion *ar;
|
||||
|
||||
/* find the main timeline region and refresh cache display*/
|
||||
for (ar= sa->regionbase.first; ar; ar= ar->next) {
|
||||
if (ar->regiontype==RGN_TYPE_WINDOW) {
|
||||
time_cache_refresh(C, stime, ar);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* editor level listener */
|
||||
static void time_listener(ScrArea *sa, wmNotifier *wmn)
|
||||
{
|
||||
|
||||
/* mainly for updating cache display */
|
||||
switch (wmn->category) {
|
||||
case NC_OBJECT:
|
||||
switch (wmn->data) {
|
||||
case ND_POINTCACHE:
|
||||
ED_area_tag_refresh(sa);
|
||||
ED_area_tag_redraw(sa);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case NC_SCENE:
|
||||
switch (wmn->data) {
|
||||
case ND_OB_ACTIVE:
|
||||
case ND_FRAME:
|
||||
ED_area_tag_refresh(sa);
|
||||
break;
|
||||
}
|
||||
case NC_SPACE:
|
||||
switch (wmn->data) {
|
||||
case ND_SPACE_CHANGED:
|
||||
ED_area_tag_refresh(sa);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------- */
|
||||
|
||||
/* add handlers, stuff you only do once or on area/region changes */
|
||||
static void time_main_area_init(wmWindowManager *wm, ARegion *ar)
|
||||
{
|
||||
@ -235,7 +451,7 @@ static void time_main_area_draw(const bContext *C, ARegion *ar)
|
||||
|
||||
/* start and end frame */
|
||||
time_draw_sfra_efra(C, stime, ar);
|
||||
|
||||
|
||||
/* grid */
|
||||
unit= (stime->flag & TIME_DRAWFRAMES)? V2D_UNIT_FRAMES: V2D_UNIT_SECONDS;
|
||||
grid= UI_view2d_grid_calc(C, v2d, unit, V2D_GRID_CLAMP, V2D_ARG_DUMMY, V2D_ARG_DUMMY, ar->winx, ar->winy);
|
||||
@ -254,6 +470,9 @@ static void time_main_area_draw(const bContext *C, ARegion *ar)
|
||||
UI_view2d_view_orthoSpecial(C, v2d, 1);
|
||||
draw_markers_time(C, 0);
|
||||
|
||||
/* caches */
|
||||
time_draw_cache(C, stime, ar);
|
||||
|
||||
/* reset view matrix */
|
||||
UI_view2d_view_restore(C);
|
||||
|
||||
@ -277,7 +496,6 @@ static void time_main_area_listener(ARegion *ar, wmNotifier *wmn)
|
||||
break;
|
||||
|
||||
case NC_SCENE:
|
||||
/* any scene change for now */
|
||||
ED_region_tag_redraw(ar);
|
||||
break;
|
||||
|
||||
@ -377,13 +595,23 @@ static SpaceLink *time_new(const bContext *C)
|
||||
/* not spacelink itself */
|
||||
static void time_free(SpaceLink *sl)
|
||||
{
|
||||
SpaceTime *stime= (SpaceTime *)sl;
|
||||
|
||||
time_cache_free(stime);
|
||||
}
|
||||
/* spacetype; init callback in ED_area_initialize() */
|
||||
/* init is called to (re)initialize an existing editor (file read, screen changes) */
|
||||
/* validate spacedata, add own area level handlers */
|
||||
static void time_init(wmWindowManager *wm, ScrArea *sa)
|
||||
{
|
||||
SpaceTime *stime= (SpaceTime *)sa->spacedata.first;
|
||||
|
||||
time_cache_free(stime);
|
||||
|
||||
/* enable all cache display */
|
||||
stime->cache_display |= TIME_CACHE_DISPLAY;
|
||||
stime->cache_display |= (TIME_CACHE_SOFTBODY|TIME_CACHE_PARTICLES);
|
||||
stime->cache_display |= (TIME_CACHE_CLOTH|TIME_CACHE_SMOKE);
|
||||
}
|
||||
|
||||
static SpaceLink *time_duplicate(SpaceLink *sl)
|
||||
@ -391,6 +619,8 @@ static SpaceLink *time_duplicate(SpaceLink *sl)
|
||||
SpaceTime *stime= (SpaceTime *)sl;
|
||||
SpaceTime *stimen= MEM_dupallocN(stime);
|
||||
|
||||
time_cache_free(stimen);
|
||||
|
||||
return (SpaceLink *)stimen;
|
||||
}
|
||||
|
||||
@ -410,6 +640,8 @@ void ED_spacetype_time(void)
|
||||
st->duplicate= time_duplicate;
|
||||
st->operatortypes= time_operatortypes;
|
||||
st->keymap= NULL;
|
||||
st->listener= time_listener;
|
||||
st->refresh= time_refresh;
|
||||
|
||||
/* regions: main window */
|
||||
art= MEM_callocN(sizeof(ARegionType), "spacetype time region");
|
||||
|
@ -430,7 +430,7 @@ static int draw_tface__set_draw(MTFace *tface, MCol *mcol, int matnr)
|
||||
} else if (tface && tface->mode&TF_OBCOL) {
|
||||
return 2; /* Don't set color */
|
||||
} else if (!mcol) {
|
||||
return 2; /* Don't set color */
|
||||
return 1; /* Don't set color */
|
||||
} else {
|
||||
return 1; /* Set color from mcol */
|
||||
}
|
||||
@ -465,9 +465,9 @@ static void add_tface_color_layer(DerivedMesh *dm)
|
||||
}
|
||||
} else if (tface && tface->mode&TF_OBCOL) {
|
||||
for(j=0;j<4;j++) {
|
||||
finalCol[i*4+j].r = Gtexdraw.obcol[0];
|
||||
finalCol[i*4+j].g = Gtexdraw.obcol[1];
|
||||
finalCol[i*4+j].b = Gtexdraw.obcol[2];
|
||||
finalCol[i*4+j].r = FTOCHAR(Gtexdraw.obcol[0]);
|
||||
finalCol[i*4+j].g = FTOCHAR(Gtexdraw.obcol[1]);
|
||||
finalCol[i*4+j].b = FTOCHAR(Gtexdraw.obcol[2]);
|
||||
}
|
||||
} else if (!mcol) {
|
||||
if (tface) {
|
||||
@ -486,9 +486,9 @@ static void add_tface_color_layer(DerivedMesh *dm)
|
||||
else copy_v3_v3(col, &ma->r);
|
||||
|
||||
for(j=0;j<4;j++) {
|
||||
finalCol[i*4+j].b = col[2];
|
||||
finalCol[i*4+j].g = col[1];
|
||||
finalCol[i*4+j].r = col[0];
|
||||
finalCol[i*4+j].b = FTOCHAR(col[2]);
|
||||
finalCol[i*4+j].g = FTOCHAR(col[1]);
|
||||
finalCol[i*4+j].r = FTOCHAR(col[0]);
|
||||
}
|
||||
}
|
||||
else
|
||||
@ -535,7 +535,7 @@ static int draw_em_tf_mapped__set_draw(void *userData, int index)
|
||||
mcol = CustomData_em_get(&em->fdata, efa->data, CD_MCOL);
|
||||
matnr = efa->mat_nr;
|
||||
|
||||
return draw_tface__set_draw(tface, mcol, matnr);
|
||||
return draw_tface__set_draw_legacy(tface, mcol, matnr);
|
||||
}
|
||||
|
||||
static int wpaint__setSolidDrawOptions(void *userData, int index, int *drawSmooth_r)
|
||||
|
@ -3927,6 +3927,20 @@ static void draw_new_particle_system(Scene *scene, View3D *v3d, RegionView3D *rv
|
||||
cd2=cdata2=0;
|
||||
|
||||
glLineWidth(1.0f);
|
||||
|
||||
if((part->draw & PART_DRAW_NUM) && (v3d->flag2 & V3D_RENDER_OVERRIDE)==0){
|
||||
cache=psys->pathcache;
|
||||
|
||||
for(a=0, pa=psys->particles; a<totpart; a++, pa++){
|
||||
float vec_txt[3];
|
||||
val[0]= '\0';
|
||||
|
||||
sprintf(val, "%i", a);
|
||||
/* use worldspace beause object matrix is alredy applied */
|
||||
mul_v3_m4v3(vec_txt, ob->imat, cache[a]->co);
|
||||
view3d_cached_text_draw_add(vec_txt[0], vec_txt[1], vec_txt[2], val, 10, V3D_CACHE_TEXT_WORLDSPACE);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(pdd && ELEM(draw_as, 0, PART_DRAW_CIRC)==0){
|
||||
glDisableClientState(GL_COLOR_ARRAY);
|
||||
|
@ -587,7 +587,7 @@ static void view3d_main_area_listener(ARegion *ar, wmNotifier *wmn)
|
||||
break;
|
||||
case NC_BRUSH:
|
||||
if(wmn->action == NA_EDITED)
|
||||
ED_region_tag_redraw(ar);
|
||||
ED_region_tag_redraw_overlay(ar);
|
||||
break;
|
||||
case NC_MATERIAL:
|
||||
switch(wmn->data) {
|
||||
|
@ -1242,7 +1242,17 @@ static int viewhome_exec(bContext *C, wmOperator *op) /* was view3d_home() in 2.
|
||||
minmax_object(base->object, min, max);
|
||||
}
|
||||
}
|
||||
if(!onedone) return OPERATOR_FINISHED; /* TODO - should this be cancel? */
|
||||
if(!onedone) {
|
||||
ED_region_tag_redraw(ar);
|
||||
/* TODO - should this be cancel?
|
||||
* I think no, because we always move the cursor, with or without
|
||||
* object, but in this case there is no change in the scene,
|
||||
* only the cursor so I choice a ED_region_tag like
|
||||
* smooth_view do for the center_cursor.
|
||||
* See bug #22640
|
||||
*/
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
afm[0]= (max[0]-min[0]);
|
||||
afm[1]= (max[1]-min[1]);
|
||||
|
@ -392,6 +392,7 @@ void Transform_Properties(struct wmOperatorType *ot, int flags)
|
||||
{
|
||||
prop= RNA_def_property(ot->srna, "axis", PROP_FLOAT, PROP_DIRECTION);
|
||||
RNA_def_property_array(prop, 3);
|
||||
/* Make this not hidden when there's a nice axis selection widget */
|
||||
RNA_def_property_flag(prop, PROP_HIDDEN);
|
||||
RNA_def_property_ui_text(prop, "Axis", "The axis around which the transformation occurs");
|
||||
|
||||
@ -400,9 +401,7 @@ void Transform_Properties(struct wmOperatorType *ot, int flags)
|
||||
if (flags & P_CONSTRAINT)
|
||||
{
|
||||
prop= RNA_def_boolean_vector(ot->srna, "constraint_axis", 3, NULL, "Constraint Axis", "");
|
||||
RNA_def_property_flag(prop, PROP_HIDDEN);
|
||||
prop= RNA_def_property(ot->srna, "constraint_orientation", PROP_ENUM, PROP_NONE);
|
||||
RNA_def_property_flag(prop, PROP_HIDDEN);
|
||||
RNA_def_property_ui_text(prop, "Orientation", "Transformation orientation");
|
||||
RNA_def_enum_funcs(prop, rna_TransformOrientation_itemf);
|
||||
|
||||
|
@ -589,9 +589,9 @@ static int startffmpeg(struct anim * anim) {
|
||||
anim->duration = pFormatCtx->duration * pCodecCtx->frame_rate
|
||||
/ pCodecCtx->frame_rate_base / AV_TIME_BASE;
|
||||
#else
|
||||
anim->duration = pFormatCtx->duration
|
||||
anim->duration = ceil(pFormatCtx->duration
|
||||
* av_q2d(pFormatCtx->streams[videoStream]->r_frame_rate)
|
||||
/ AV_TIME_BASE;
|
||||
/ AV_TIME_BASE);
|
||||
|
||||
#endif
|
||||
anim->params = 0;
|
||||
|
@ -592,8 +592,10 @@ struct ImBuf *imb_loadtarga(unsigned char *mem, int mem_size, int flags)
|
||||
if (flags & IB_test) return (ibuf);
|
||||
|
||||
if (tga.imgtyp != 1 && tga.imgtyp != 9) { /* happens sometimes (beuh) */
|
||||
MEM_freeN(cmap);
|
||||
cmap= NULL;
|
||||
if(cmap) {
|
||||
MEM_freeN(cmap);
|
||||
cmap= NULL;
|
||||
}
|
||||
}
|
||||
|
||||
switch(tga.imgtyp){
|
||||
|
@ -152,7 +152,9 @@ typedef struct ARegion {
|
||||
short sizex, sizey; /* current split size in pixels (if zero it uses regiontype) */
|
||||
|
||||
short do_draw; /* private, cached notifier events */
|
||||
short do_draw_overlay; /* private, cached notifier events */
|
||||
short swap; /* private, indicator to survive swap-exchange */
|
||||
short pad[3];
|
||||
|
||||
struct ARegionType *type; /* callbacks for this region type */
|
||||
|
||||
|
@ -276,6 +276,9 @@ typedef struct SpeedControlVars {
|
||||
#define SEQ_USE_PROXY_CUSTOM_FILE 2097152
|
||||
#define SEQ_USE_EFFECT_DEFAULT_FADE 4194304
|
||||
|
||||
/* convenience define for all selection flags */
|
||||
#define SEQ_ALLSEL (SELECT+SEQ_LEFTSEL+SEQ_RIGHTSEL)
|
||||
|
||||
/* deprecated, dont use a flag anymore*/
|
||||
/*#define SEQ_ACTIVE 1048576*/
|
||||
|
||||
|
@ -346,6 +346,17 @@ typedef struct SpaceScript {
|
||||
void *but_refs;
|
||||
} SpaceScript;
|
||||
|
||||
typedef struct SpaceTimeCache {
|
||||
struct SpaceTimeCache *next, *prev;
|
||||
int type;
|
||||
int flag;
|
||||
|
||||
float *array;
|
||||
int len;
|
||||
int startframe, endframe;
|
||||
int ok;
|
||||
} SpaceTimeCache;
|
||||
|
||||
typedef struct SpaceTime {
|
||||
SpaceLink *next, *prev;
|
||||
ListBase regionbase; /* storage of regions for inactive spaces */
|
||||
@ -354,6 +365,9 @@ typedef struct SpaceTime {
|
||||
|
||||
View2D v2d; /* deprecated, copied to region */
|
||||
|
||||
ListBase caches;
|
||||
int cache_display, pad;
|
||||
|
||||
int flag, redraws;
|
||||
|
||||
} SpaceTime;
|
||||
@ -860,6 +874,13 @@ enum {
|
||||
#define TIME_CONTINUE_PHYSICS 128
|
||||
#define TIME_NODES 256
|
||||
|
||||
/* time->cache */
|
||||
#define TIME_CACHE_DISPLAY 1
|
||||
#define TIME_CACHE_SOFTBODY 2
|
||||
#define TIME_CACHE_PARTICLES 4
|
||||
#define TIME_CACHE_CLOTH 8
|
||||
#define TIME_CACHE_SMOKE 16
|
||||
|
||||
/* sseq->mainb */
|
||||
#define SEQ_DRAW_SEQUENCE 0
|
||||
#define SEQ_DRAW_IMG_IMBUF 1
|
||||
|
@ -2275,7 +2275,7 @@ RNAProcessItem PROCESS_ITEMS[]= {
|
||||
{"rna_screen.c", NULL, RNA_def_screen},
|
||||
{"rna_sculpt_paint.c", NULL, RNA_def_sculpt_paint},
|
||||
{"rna_sensor.c", NULL, RNA_def_sensor},
|
||||
{"rna_sequencer.c", NULL, RNA_def_sequencer},
|
||||
{"rna_sequencer.c", "rna_sequencer_api.c", RNA_def_sequencer},
|
||||
{"rna_smoke.c", NULL, RNA_def_smoke},
|
||||
{"rna_space.c", NULL, RNA_def_space},
|
||||
{"rna_test.c", NULL, RNA_def_test},
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user