sandey/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

style cleanup: blenkernel

Browse Source
This commit is contained in:
Campbell Barton 2012-05-06 17:22:54 +00:00
parent 1118b3fe3f
commit ffed654ff2
19 changed files with 4438 additions and 4442 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

718
source/blender/blenkernel/intern/anim.c
View File

File diff suppressed because it is too large Load Diff

244
source/blender/blenkernel/intern/blender.c
View File

@ -95,7 +95,7 @@ Global G;
UserDef U;
/* ListBase = {NULL, NULL}; */
char versionstr[48]= "";
char versionstr[48] = "";
/* ********** free ********** */
@ -104,9 +104,9 @@ void free_blender(void)
{
/* samples are in a global list..., also sets G.main->sound->sample NULL */
free_main(G.main);
G.main= NULL;
G.main = NULL;
BKE_spacetypes_free(); /* after free main, it uses space callbacks */
BKE_spacetypes_free(); /* after free main, it uses space callbacks */
IMB_exit();
@ -122,18 +122,18 @@ void initglobals(void)
{
memset(&G, 0, sizeof(Global));
U.savetime= 1;
U.savetime = 1;
G.main= MEM_callocN(sizeof(Main), "initglobals");
G.main = MEM_callocN(sizeof(Main), "initglobals");
strcpy(G.ima, "//");
if (BLENDER_SUBVERSION)
BLI_snprintf(versionstr, sizeof(versionstr), "v%d.%02d.%d", BLENDER_VERSION/100, BLENDER_VERSION%100, BLENDER_SUBVERSION);
BLI_snprintf(versionstr, sizeof(versionstr), "v%d.%02d.%d", BLENDER_VERSION / 100, BLENDER_VERSION % 100, BLENDER_SUBVERSION);
else
BLI_snprintf(versionstr, sizeof(versionstr), "v%d.%02d", BLENDER_VERSION/100, BLENDER_VERSION%100);
BLI_snprintf(versionstr, sizeof(versionstr), "v%d.%02d", BLENDER_VERSION / 100, BLENDER_VERSION % 100);
#ifdef _WIN32 // FULLSCREEN
#ifdef _WIN32 // FULLSCREEN
G.windowstate = G_WINDOWSTATE_USERDEF;
#endif
@ -154,11 +154,11 @@ static void clear_global(void)
{
// extern short winqueue_break; /* screen.c */
free_main(G.main); /* free all lib data */
free_main(G.main); /* free all lib data */
// free_vertexpaint();
G.main= NULL;
G.main = NULL;
}
static int clean_paths_visit_cb(void *UNUSED(userdata), char *path_dst, const char *path_src)
@ -175,7 +175,7 @@ static void clean_paths(Main *main)
BLI_bpath_traverse_main(main, clean_paths_visit_cb, BLI_BPATH_TRAVERSE_SKIP_MULTIFILE, NULL);
for (scene= main->scene.first; scene; scene= scene->id.next) {
for (scene = main->scene.first; scene; scene = scene->id.next) {
BLI_clean(scene->r.pic);
}
}
@ -188,17 +188,17 @@ static void clean_paths(Main *main)
static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath)
{
bScreen *curscreen= NULL;
Scene *curscene= NULL;
bScreen *curscreen = NULL;
Scene *curscene = NULL;
int recover;
char mode;
/* 'u' = undo save, 'n' = no UI load */
if (bfd->main->screen.first==NULL) mode= 'u';
else if (G.fileflags & G_FILE_NO_UI) mode= 'n';
else mode= 0;
if (bfd->main->screen.first == NULL) mode = 'u';
else if (G.fileflags & G_FILE_NO_UI) mode = 'n';
else mode = 0;
recover= (G.fileflags & G_FILE_RECOVER);
recover = (G.fileflags & G_FILE_RECOVER);
/* Free all render results, without this stale data gets displayed after loading files */
if (mode != 'u') {
@ -222,12 +222,12 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath
SWAP(ListBase, G.main->script, bfd->main->script);
/* we re-use current screen */
curscreen= CTX_wm_screen(C);
curscreen = CTX_wm_screen(C);
/* but use new Scene pointer */
curscene= bfd->curscene;
if (curscene==NULL) curscene= bfd->main->scene.first;
curscene = bfd->curscene;
if (curscene == NULL) curscene = bfd->main->scene.first;
/* and we enforce curscene to be in current screen */
if (curscreen) curscreen->scene= curscene; /* can run in bgmode */
if (curscreen) curscreen->scene = curscene; /* can run in bgmode */
/* clear_global will free G.main, here we can still restore pointers */
lib_link_screen_restore(bfd->main, curscreen, curscene);
@ -240,7 +240,7 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath
/* clear old property update cache, in case some old references are left dangling */
RNA_property_update_cache_free();
G.main= bfd->main;
G.main = bfd->main;
CTX_data_main_set(C, G.main);
@ -251,7 +251,7 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath
/* only here free userdef themes... */
BKE_userdef_free();
U= *bfd->user;
U = *bfd->user;
MEM_freeN(bfd->user);
}
@ -261,9 +261,9 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath
CTX_data_scene_set(C, curscene);
}
else {
G.winpos= bfd->winpos;
G.displaymode= bfd->displaymode;
G.fileflags= bfd->fileflags;
G.winpos = bfd->winpos;
G.displaymode = bfd->displaymode;
G.fileflags = bfd->fileflags;
CTX_wm_manager_set(C, bfd->main->wm.first);
CTX_wm_screen_set(C, bfd->curscreen);
CTX_data_scene_set(C, bfd->curscreen->scene);
@ -273,20 +273,20 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath
}
/* this can happen when active scene was lib-linked, and doesn't exist anymore */
if (CTX_data_scene(C)==NULL) {
if (CTX_data_scene(C) == NULL) {
CTX_data_scene_set(C, bfd->main->scene.first);
CTX_wm_screen(C)->scene= CTX_data_scene(C);
curscene= CTX_data_scene(C);
CTX_wm_screen(C)->scene = CTX_data_scene(C);
curscene = CTX_data_scene(C);
}
/* special cases, override loaded flags: */
if (G.f != bfd->globalf) {
const int flags_keep = (G_SWAP_EXCHANGE | G_SCRIPT_AUTOEXEC | G_SCRIPT_OVERRIDE_PREF);
bfd->globalf= (bfd->globalf & ~flags_keep) | (G.f & flags_keep);
bfd->globalf = (bfd->globalf & ~flags_keep) | (G.f & flags_keep);
}
G.f= bfd->globalf;
G.f = bfd->globalf;
if (!G.background) {
//setscreen(G.curscreen);
@ -300,12 +300,12 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath
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 */
filepath= bfd->filename;
filepath = bfd->filename;
}
#if 0
else if (!G.relbase_valid) {
/* otherwise, use an empty string as filename, rather than <memory2> */
filepath="";
filepath = "";
}
#endif
@ -324,8 +324,8 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath
static int handle_subversion_warning(Main *main, ReportList *reports)
{
if (main->minversionfile > BLENDER_VERSION ||
(main->minversionfile == BLENDER_VERSION &&
main->minsubversionfile > BLENDER_SUBVERSION)) {
(main->minversionfile == BLENDER_VERSION &&
main->minsubversionfile > BLENDER_SUBVERSION)) {
BKE_reportf(reports, RPT_ERROR, "File written by newer Blender binary: %d.%d , expect loss of data!", main->minversionfile, main->minsubversionfile);
}
@ -348,8 +348,8 @@ void BKE_userdef_free(void)
wmKeyMapItem *kmi;
wmKeyMapDiffItem *kmdi;
for (km=U.user_keymaps.first; km; km=km->next) {
for (kmdi=km->diff_items.first; kmdi; kmdi=kmdi->next) {
for (km = U.user_keymaps.first; km; km = km->next) {
for (kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) {
if (kmdi->add_item) {
keymap_item_free(kmdi->add_item);
MEM_freeN(kmdi->add_item);
@ -360,7 +360,7 @@ void BKE_userdef_free(void)
}
}
for (kmi=km->items.first; kmi; kmi=kmi->next)
for (kmi = km->items.first; kmi; kmi = kmi->next)
keymap_item_free(kmi);
BLI_freelistN(&km->diff_items);
@ -377,41 +377,41 @@ void BKE_userdef_free(void)
int BKE_read_file(bContext *C, const char *filepath, ReportList *reports)
{
BlendFileData *bfd;
int retval= BKE_READ_FILE_OK;
int retval = BKE_READ_FILE_OK;
if (strstr(filepath, BLENDER_STARTUP_FILE)==NULL) /* don't print user-pref loading */
if (strstr(filepath, BLENDER_STARTUP_FILE) == NULL) /* don't print user-pref loading */
printf("read blend: %s\n", filepath);
bfd= BLO_read_from_file(filepath, reports);
bfd = BLO_read_from_file(filepath, reports);
if (bfd) {
if (bfd->user) retval= BKE_READ_FILE_OK_USERPREFS;
if (bfd->user) retval = BKE_READ_FILE_OK_USERPREFS;
if (0==handle_subversion_warning(bfd->main, reports)) {
if (0 == handle_subversion_warning(bfd->main, reports)) {
free_main(bfd->main);
MEM_freeN(bfd);
bfd= NULL;
retval= BKE_READ_FILE_FAIL;
bfd = NULL;
retval = BKE_READ_FILE_FAIL;
}
else
setup_app_data(C, bfd, filepath); // frees BFD
setup_app_data(C, bfd, filepath); // frees BFD
}
else
BKE_reports_prependf(reports, "Loading %s failed: ", filepath);
return (bfd?retval:BKE_READ_FILE_FAIL);
return (bfd ? retval : BKE_READ_FILE_FAIL);
}
int BKE_read_file_from_memory(bContext *C, char* filebuf, int filelength, ReportList *reports)
int BKE_read_file_from_memory(bContext *C, char *filebuf, int filelength, ReportList *reports)
{
BlendFileData *bfd;
bfd= BLO_read_from_memory(filebuf, filelength, reports);
bfd = BLO_read_from_memory(filebuf, filelength, reports);
if (bfd)
setup_app_data(C, bfd, "<memory2>");
else
BKE_reports_prepend(reports, "Loading failed: ");
return (bfd?1:0);
return (bfd ? 1 : 0);
}
/* memfile is the undo buffer */
@ -419,13 +419,13 @@ int BKE_read_file_from_memfile(bContext *C, MemFile *memfile, ReportList *report
{
BlendFileData *bfd;
bfd= BLO_read_from_memfile(CTX_data_main(C), G.main->name, memfile, reports);
bfd = BLO_read_from_memfile(CTX_data_main(C), G.main->name, memfile, reports);
if (bfd)
setup_app_data(C, bfd, "<memory1>");
else
BKE_reports_prepend(reports, "Loading failed: ");
return (bfd?1:0);
return (bfd ? 1 : 0);
}
@ -435,7 +435,7 @@ static void (*blender_test_break_cb)(void) = NULL;
void set_blender_test_break_cb(void (*func)(void) )
{
blender_test_break_cb= func;
blender_test_break_cb = func;
}
@ -446,15 +446,15 @@ int blender_test_break(void)
blender_test_break_cb();
}
return (G.afbreek==1);
return (G.afbreek == 1);
}
/* ***************** GLOBAL UNDO *************** */
#define UNDO_DISK 0
#define UNDO_DISK 0
#define MAXUNDONAME 64
#define MAXUNDONAME 64
typedef struct UndoElem {
struct UndoElem *next, *prev;
char str[FILE_MAX];
@ -463,31 +463,31 @@ typedef struct UndoElem {
uintptr_t undosize;
} UndoElem;
static ListBase undobase={NULL, NULL};
static UndoElem *curundo= NULL;
static ListBase undobase = {NULL, NULL};
static UndoElem *curundo = NULL;
static int read_undosave(bContext *C, UndoElem *uel)
{
char mainstr[sizeof(G.main->name)];
int success=0, fileflags;
int success = 0, fileflags;
/* This is needed so undoing/redoing doesn't crash with threaded previews going */
WM_jobs_stop_all(CTX_wm_manager(C));
BLI_strncpy(mainstr, G.main->name, sizeof(mainstr)); /* temporal store */
BLI_strncpy(mainstr, G.main->name, sizeof(mainstr)); /* temporal store */
fileflags= G.fileflags;
fileflags = G.fileflags;
G.fileflags |= G_FILE_NO_UI;
if (UNDO_DISK)
success= (BKE_read_file(C, uel->str, NULL) != BKE_READ_FILE_FAIL);
success = (BKE_read_file(C, uel->str, NULL) != BKE_READ_FILE_FAIL);
else
success= BKE_read_file_from_memfile(C, &uel->memfile, NULL);
success = BKE_read_file_from_memfile(C, &uel->memfile, NULL);
/* restore */
BLI_strncpy(G.main->name, mainstr, sizeof(G.main->name)); /* restore */
G.fileflags= fileflags;
G.fileflags = fileflags;
if (success) {
/* important not to update time here, else non keyed tranforms are lost */
@ -504,33 +504,33 @@ void BKE_write_undo(bContext *C, const char *name)
int nr /*, success */ /* UNUSED */;
UndoElem *uel;
if ( (U.uiflag & USER_GLOBALUNDO)==0) return;
if ( U.undosteps==0) return;
if ( (U.uiflag & USER_GLOBALUNDO) == 0) return;
if (U.undosteps == 0) return;
/* remove all undos after (also when curundo==NULL) */
while (undobase.last != curundo) {
uel= undobase.last;
uel = undobase.last;
BLI_remlink(&undobase, uel);
BLO_free_memfile(&uel->memfile);
MEM_freeN(uel);
}
/* make new */
curundo= uel= MEM_callocN(sizeof(UndoElem), "undo file");
curundo = uel = MEM_callocN(sizeof(UndoElem), "undo file");
BLI_strncpy(uel->name, name, sizeof(uel->name));
BLI_addtail(&undobase, uel);
/* and limit amount to the maximum */
nr= 0;
uel= undobase.last;
nr = 0;
uel = undobase.last;
while (uel) {
nr++;
if (nr==U.undosteps) break;
uel= uel->prev;
if (nr == U.undosteps) break;
uel = uel->prev;
}
if (uel) {
while (undobase.first!=uel) {
UndoElem *first= undobase.first;
while (undobase.first != uel) {
UndoElem *first = undobase.first;
BLI_remlink(&undobase, first);
/* the merge is because of compression */
BLO_merge_memfile(&first->memfile, &first->next->memfile);
@ -541,14 +541,14 @@ void BKE_write_undo(bContext *C, const char *name)
/* disk save version */
if (UNDO_DISK) {
static int counter= 0;
static int counter = 0;
char filepath[FILE_MAX];
char numstr[32];
int fileflags = G.fileflags & ~(G_FILE_HISTORY); /* don't do file history on undo */
/* calculate current filepath */
counter++;
counter= counter % U.undosteps;
counter = counter % U.undosteps;
BLI_snprintf(numstr, sizeof(numstr), "%d.blend", counter);
BLI_make_file_string("/", filepath, BLI_temporary_dir(), numstr);
@ -558,34 +558,34 @@ void BKE_write_undo(bContext *C, const char *name)
BLI_strncpy(curundo->str, filepath, sizeof(curundo->str));
}
else {
MemFile *prevfile=NULL;
MemFile *prevfile = NULL;
if (curundo->prev) prevfile= &(curundo->prev->memfile);
if (curundo->prev) prevfile = &(curundo->prev->memfile);
memused= MEM_get_memory_in_use();
memused = MEM_get_memory_in_use();
/* success= */ /* UNUSED */ BLO_write_file_mem(CTX_data_main(C), prevfile, &curundo->memfile, G.fileflags);
curundo->undosize= MEM_get_memory_in_use() - memused;
curundo->undosize = MEM_get_memory_in_use() - memused;
}
if (U.undomemory != 0) {
/* limit to maximum memory (afterwards, we can't know in advance) */
totmem= 0;
maxmem= ((uintptr_t)U.undomemory)*1024*1024;
totmem = 0;
maxmem = ((uintptr_t)U.undomemory) * 1024 * 1024;
/* keep at least two (original + other) */
uel= undobase.last;
uel = undobase.last;
while (uel && uel->prev) {
totmem+= uel->undosize;
if (totmem>maxmem) break;
uel= uel->prev;
totmem += uel->undosize;
if (totmem > maxmem) break;
uel = uel->prev;
}
if (uel) {
if (uel->prev && uel->prev->prev)
uel= uel->prev;
uel = uel->prev;
while (undobase.first!=uel) {
UndoElem *first= undobase.first;
while (undobase.first != uel) {
UndoElem *first = undobase.first;
BLI_remlink(&undobase, first);
/* the merge is because of compression */
BLO_merge_memfile(&first->memfile, &first->next->memfile);
@ -599,25 +599,25 @@ void BKE_write_undo(bContext *C, const char *name)
void BKE_undo_step(bContext *C, int step)
{
if (step==0) {
if (step == 0) {
read_undosave(C, curundo);
}
else if (step==1) {
else if (step == 1) {
/* curundo should never be NULL, after restart or load file it should call undo_save */
if (curundo==NULL || curundo->prev==NULL) ; // XXX error("No undo available");
if (curundo == NULL || curundo->prev == NULL) ; // XXX error("No undo available");
else {
if (G.debug & G_DEBUG) printf("undo %s\n", curundo->name);
curundo= curundo->prev;
curundo = curundo->prev;
read_undosave(C, curundo);
}
}
else {
/* curundo has to remain current situation! */
if (curundo==NULL || curundo->next==NULL) ; // XXX error("No redo available");
if (curundo == NULL || curundo->next == NULL) ; // XXX error("No redo available");
else {
read_undosave(C, curundo->next);
curundo= curundo->next;
curundo = curundo->next;
if (G.debug & G_DEBUG) printf("redo %s\n", curundo->name);
}
}
@ -627,30 +627,30 @@ void BKE_reset_undo(void)
{
UndoElem *uel;
uel= undobase.first;
uel = undobase.first;
while (uel) {
BLO_free_memfile(&uel->memfile);
uel= uel->next;
uel = uel->next;
}
BLI_freelistN(&undobase);
curundo= NULL;
curundo = NULL;
}
/* based on index nr it does a restore */
void BKE_undo_number(bContext *C, int nr)
{
curundo= BLI_findlink(&undobase, nr);
curundo = BLI_findlink(&undobase, nr);
BKE_undo_step(C, 0);
}
/* go back to the last occurance of name in stack */
void BKE_undo_name(bContext *C, const char *name)
{
UndoElem *uel= BLI_rfindstring(&undobase, name, offsetof(UndoElem, name));
UndoElem *uel = BLI_rfindstring(&undobase, name, offsetof(UndoElem, name));
if (uel && uel->prev) {
curundo= uel->prev;
curundo = uel->prev;
BKE_undo_step(C, 0);
}
}
@ -659,7 +659,7 @@ void BKE_undo_name(bContext *C, const char *name)
int BKE_undo_valid(const char *name)
{
if (name) {
UndoElem *uel= BLI_rfindstring(&undobase, name, offsetof(UndoElem, name));
UndoElem *uel = BLI_rfindstring(&undobase, name, offsetof(UndoElem, name));
return uel && uel->prev;
}
@ -670,13 +670,13 @@ int BKE_undo_valid(const char *name)
/* if active pointer, set it to 1 if true */
const char *BKE_undo_get_name(int nr, int *active)
{
UndoElem *uel= BLI_findlink(&undobase, nr);
UndoElem *uel = BLI_findlink(&undobase, nr);
if (active) *active= 0;
if (active) *active = 0;
if (uel) {
if (active && uel==curundo)
*active= 1;
if (active && uel == curundo)
*active = 1;
return uel->name;
}
return NULL;
@ -685,23 +685,23 @@ const char *BKE_undo_get_name(int nr, int *active)
char *BKE_undo_menu_string(void)
{
UndoElem *uel;
DynStr *ds= BLI_dynstr_new();
DynStr *ds = BLI_dynstr_new();
char *menu;
BLI_dynstr_append(ds, "Global Undo History %t");
for (uel= undobase.first; uel; uel= uel->next) {
for (uel = undobase.first; uel; uel = uel->next) {
BLI_dynstr_append(ds, "|");
BLI_dynstr_append(ds, uel->name);
}
menu= BLI_dynstr_get_cstring(ds);
menu = BLI_dynstr_get_cstring(ds);
BLI_dynstr_free(ds);
return menu;
}
/* saves quit.blend */
/* saves quit.blend */
void BKE_undo_save_quit(void)
{
UndoElem *uel;
@ -709,16 +709,16 @@ void BKE_undo_save_quit(void)
int file;
char str[FILE_MAX];
if ( (U.uiflag & USER_GLOBALUNDO)==0) return;
if ( (U.uiflag & USER_GLOBALUNDO) == 0) return;
uel= curundo;
if (uel==NULL) {
uel = curundo;
if (uel == NULL) {
printf("No undo buffer to save recovery file\n");
return;
}
/* no undo state to save */
if (undobase.first==undobase.last) return;
if (undobase.first == undobase.last) return;
BLI_make_file_string("/", str, BLI_temporary_dir(), "quit.blend");
@ -728,28 +728,28 @@ void BKE_undo_save_quit(void)
return;
}
chunk= uel->memfile.chunks.first;
chunk = uel->memfile.chunks.first;
while (chunk) {
if ( write(file, chunk->buf, chunk->size) != chunk->size) break;
chunk= chunk->next;
if (write(file, chunk->buf, chunk->size) != chunk->size) break;
chunk = chunk->next;
}
close(file);
if (chunk) ; //XXX error("Unable to save %s, internal error", str);
if (chunk) ; //XXX error("Unable to save %s, internal error", str);
else printf("Saved session recovery to %s\n", str);
}
/* sets curscene */
Main *BKE_undo_get_main(Scene **scene)
{
Main *mainp= NULL;
BlendFileData *bfd= BLO_read_from_memfile(G.main, G.main->name, &curundo->memfile, NULL);
Main *mainp = NULL;
BlendFileData *bfd = BLO_read_from_memfile(G.main, G.main->name, &curundo->memfile, NULL);
if (bfd) {
mainp= bfd->main;
mainp = bfd->main;
if (scene)
*scene= bfd->curscene;
*scene = bfd->curscene;
MEM_freeN(bfd);
}

115
source/blender/blenkernel/intern/bvhutils.c
View File

@ -101,11 +101,11 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f
sub_v3_v3v3(e1, v2, v0);
A00 = dot_v3v3(e0, e0);
A01 = dot_v3v3(e0, e1 );
A11 = dot_v3v3(e1, e1 );
B0 = dot_v3v3(diff, e0 );
B1 = dot_v3v3(diff, e1 );
C = dot_v3v3(diff, diff );
A01 = dot_v3v3(e0, e1);
A11 = dot_v3v3(e1, e1);
B0 = dot_v3v3(diff, e0);
B1 = dot_v3v3(diff, e1);
C = dot_v3v3(diff, diff);
Det = fabs(A00 * A11 - A01 * A01);
S = A01 * B1 - A11 * B0;
T = A01 * B0 - A00 * B1;
@ -122,7 +122,7 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f
}
else {
if (fabsf(A00) > FLT_EPSILON)
S = -B0/A00;
S = -B0 / A00;
else
S = 0.0f;
sqrDist = B0 * S + C;
@ -195,7 +195,7 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f
}
}
else { /* Region 0 */
// Minimum at interior lv
/* Minimum at interior lv */
float invDet;
if (fabsf(Det) > FLT_EPSILON)
invDet = 1.0f / Det;
@ -203,8 +203,8 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f
invDet = 0.0f;
S *= invDet;
T *= invDet;
sqrDist = S * ( A00 * S + A01 * T + 2.0f * B0) +
T * ( A01 * S + A11 * T + 2.0f * B1 ) + C;
sqrDist = S * (A00 * S + A01 * T + 2.0f * B0) +
T * (A01 * S + A11 * T + 2.0f * B1) + C;
}
}
else {
@ -213,10 +213,10 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f
if (S < 0.0f) { /* Region 2 */
tmp0 = A01 + B0;
tmp1 = A11 + B1;
if ( tmp1 > tmp0 ) {
if (tmp1 > tmp0) {
numer = tmp1 - tmp0;
denom = A00 - 2.0f * A01 + A11;
if ( numer >= denom ) {
if (numer >= denom) {
S = 1.0f;
T = 0.0f;
sqrDist = A00 + 2.0f * B0 + C;
@ -228,14 +228,14 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f
else
S = 0.0f;
T = 1.0f - S;
sqrDist = S * ( A00 * S + A01 * T + 2.0f * B0 ) +
T * ( A01 * S + A11 * T + 2.0f * B1 ) + C;
sqrDist = S * (A00 * S + A01 * T + 2.0f * B0) +
T * (A01 * S + A11 * T + 2.0f * B1) + C;
le = 2;
}
}
else {
S = 0.0f;
if ( tmp1 <= 0.0f ) {
if (tmp1 <= 0.0f) {
T = 1.0f;
sqrDist = A11 + 2.0f * B1 + C;
lv = 2;
@ -258,10 +258,10 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f
else if (T < 0.0f) { /* Region 6 */
tmp0 = A01 + B1;
tmp1 = A00 + B0;
if ( tmp1 > tmp0 ) {
if (tmp1 > tmp0) {
numer = tmp1 - tmp0;
denom = A00 - 2.0f * A01 + A11;
if ( numer >= denom ) {
if (numer >= denom) {
T = 1.0f;
S = 0.0f;
sqrDist = A11 + 2.0f * B1 + C;
@ -273,8 +273,8 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f
else
T = 0.0f;
S = 1.0f - T;
sqrDist = S * ( A00 * S + A01 * T + 2.0f * B0 ) +
T * ( A01 * S + A11 * T + 2.0f * B1 ) + C;
sqrDist = S * (A00 * S + A01 * T + 2.0f * B0) +
T * (A01 * S + A11 * T + 2.0f * B1) + C;
le = 2;
}
}
@ -302,7 +302,7 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f
}
else { /* Region 1 */
numer = A11 + B1 - A01 - B0;
if ( numer <= 0.0f ) {
if (numer <= 0.0f) {
S = 0.0f;
T = 1.0f;
sqrDist = A11 + 2.0f * B1 + C;
@ -310,7 +310,7 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f
}
else {
denom = A00 - 2.0f * A01 + A11;
if ( numer >= denom ) {
if (numer >= denom) {
S = 1.0f;
T = 0.0f;
sqrDist = A00 + 2.0f * B0 + C;
@ -322,8 +322,8 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f
else
S = 0.0f;
T = 1.0f - S;
sqrDist = S * ( A00 * S + A01 * T + 2.0f * B0 ) +
T * ( A01 * S + A11 * T + 2.0f * B1 ) + C;
sqrDist = S * (A00 * S + A01 * T + 2.0f * B0) +
T * (A01 * S + A11 * T + 2.0f * B1) + C;
le = 2;
}
}
@ -331,7 +331,7 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f
}
// Account for numerical round-off error
if ( sqrDist < FLT_EPSILON )
if (sqrDist < FLT_EPSILON)
sqrDist = 0.0f;
{
@ -362,19 +362,18 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f
// userdata must be a BVHMeshCallbackUserdata built from the same mesh as the tree.
static void mesh_faces_nearest_point(void *userdata, int index, const float co[3], BVHTreeNearest *nearest)
{
const BVHTreeFromMesh *data = (BVHTreeFromMesh*) userdata;
MVert *vert = data->vert;
const BVHTreeFromMesh *data = (BVHTreeFromMesh *) userdata;
MVert *vert = data->vert;
MFace *face = data->face + index;
float *t0, *t1, *t2, *t3;
t0 = vert[ face->v1 ].co;
t1 = vert[ face->v2 ].co;
t2 = vert[ face->v3 ].co;
t3 = face->v4 ? vert[ face->v4].co : NULL;
t0 = vert[face->v1].co;
t1 = vert[face->v2].co;
t2 = vert[face->v3].co;
t3 = face->v4 ? vert[face->v4].co : NULL;
do
{
do {
float nearest_tmp[3], dist;
int vertex, edge;
@ -397,8 +396,8 @@ static void mesh_faces_nearest_point(void *userdata, int index, const float co[3
// userdata must be a BVHMeshCallbackUserdata built from the same mesh as the tree.
static void mesh_faces_spherecast(void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit)
{
const BVHTreeFromMesh *data = (BVHTreeFromMesh*) userdata;
MVert *vert = data->vert;
const BVHTreeFromMesh *data = (BVHTreeFromMesh *) userdata;
MVert *vert = data->vert;
MFace *face = data->face + index;
float *t0, *t1, *t2, *t3;
@ -408,8 +407,7 @@ static void mesh_faces_spherecast(void *userdata, int index, const BVHTreeRay *r
t3 = face->v4 ? vert[face->v4].co : NULL;
do
{
do {
float dist;
if (data->sphere_radius == 0.0f)
dist = bvhtree_ray_tri_intersection(ray, hit->dist, t0, t1, t2);
@ -435,14 +433,14 @@ static void mesh_faces_spherecast(void *userdata, int index, const BVHTreeRay *r
// userdata must be a BVHMeshCallbackUserdata built from the same mesh as the tree.
static void mesh_edges_nearest_point(void *userdata, int index, const float co[3], BVHTreeNearest *nearest)
{
const BVHTreeFromMesh *data = (BVHTreeFromMesh*) userdata;
MVert *vert = data->vert;
const BVHTreeFromMesh *data = (BVHTreeFromMesh *) userdata;
MVert *vert = data->vert;
MEdge *edge = data->edge + index;
float nearest_tmp[3], dist;
float *t0, *t1;
t0 = vert[ edge->v1 ].co;
t1 = vert[ edge->v2 ].co;
t0 = vert[edge->v1].co;
t1 = vert[edge->v2].co;
closest_to_line_segment_v3(nearest_tmp, co, t0, t1);
dist = len_squared_v3v3(nearest_tmp, co);
@ -460,15 +458,15 @@ static void mesh_edges_nearest_point(void *userdata, int index, const float co[3
* BVH builders
*/
// Builds a bvh tree.. where nodes are the vertexs of the given mesh
BVHTree* bvhtree_from_mesh_verts(BVHTreeFromMesh *data, DerivedMesh *mesh, float epsilon, int tree_type, int axis)
BVHTree *bvhtree_from_mesh_verts(BVHTreeFromMesh *data, DerivedMesh *mesh, float epsilon, int tree_type, int axis)
{
BVHTree *tree = bvhcache_find(&mesh->bvhCache, BVHTREE_FROM_VERTICES);
//Not in cache
if (tree == NULL) {
int i;
int numVerts= mesh->getNumVerts(mesh);
MVert *vert = mesh->getVertDataArray(mesh, CD_MVERT);
int numVerts = mesh->getNumVerts(mesh);
MVert *vert = mesh->getVertDataArray(mesh, CD_MVERT);
if (vert != NULL) {
tree = BLI_bvhtree_new(numVerts, epsilon, tree_type, axis);
@ -514,14 +512,14 @@ BVHTree* bvhtree_from_mesh_verts(BVHTreeFromMesh *data, DerivedMesh *mesh, float
}
// Builds a bvh tree.. where nodes are the faces of the given mesh.
BVHTree* bvhtree_from_mesh_faces(BVHTreeFromMesh *data, DerivedMesh *mesh, float epsilon, int tree_type, int axis)
BVHTree *bvhtree_from_mesh_faces(BVHTreeFromMesh *data, DerivedMesh *mesh, float epsilon, int tree_type, int axis)
{
BVHTree *tree = bvhcache_find(&mesh->bvhCache, BVHTREE_FROM_FACES);
//Not in cache
if (tree == NULL) {
int i;
int numFaces= mesh->getNumTessFaces(mesh);
int numFaces = mesh->getNumTessFaces(mesh);
/* BMESH specific check that we have tessfaces,
* we _could_ tessellate here but rather not - campbell
@ -534,7 +532,7 @@ BVHTree* bvhtree_from_mesh_faces(BVHTreeFromMesh *data, DerivedMesh *mesh, float
/* Create a bvh-tree of the given target */
tree = BLI_bvhtree_new(numFaces, epsilon, tree_type, axis);
if (tree != NULL) {
BMEditMesh *em= data->em_evil;
BMEditMesh *em = data->em_evil;
if (em) {
/* data->em_evil is only set for snapping, and only for the mesh of the object
* which is currently open in edit mode. When set, the bvhtree should not contain
@ -594,17 +592,17 @@ BVHTree* bvhtree_from_mesh_faces(BVHTreeFromMesh *data, DerivedMesh *mesh, float
}
}
else {
MVert *vert = mesh->getVertDataArray(mesh, CD_MVERT);
MVert *vert = mesh->getVertDataArray(mesh, CD_MVERT);
MFace *face = mesh->getTessFaceDataArray(mesh, CD_MFACE);
if (vert != NULL && face != NULL) {
for (i = 0; i < numFaces; i++) {
float co[4][3];
copy_v3_v3(co[0], vert[ face[i].v1 ].co);
copy_v3_v3(co[1], vert[ face[i].v2 ].co);
copy_v3_v3(co[2], vert[ face[i].v3 ].co);
copy_v3_v3(co[0], vert[face[i].v1].co);
copy_v3_v3(co[1], vert[face[i].v2].co);
copy_v3_v3(co[2], vert[face[i].v3].co);
if (face[i].v4)
copy_v3_v3(co[3], vert[ face[i].v4 ].co);
copy_v3_v3(co[3], vert[face[i].v4].co);
BLI_bvhtree_insert(tree, i, co[0], face[i].v4 ? 4 : 3);
}
@ -644,15 +642,15 @@ BVHTree* bvhtree_from_mesh_faces(BVHTreeFromMesh *data, DerivedMesh *mesh, float
}
// Builds a bvh tree.. where nodes are the faces of the given mesh.
BVHTree* bvhtree_from_mesh_edges(BVHTreeFromMesh *data, DerivedMesh *mesh, float epsilon, int tree_type, int axis)
BVHTree *bvhtree_from_mesh_edges(BVHTreeFromMesh *data, DerivedMesh *mesh, float epsilon, int tree_type, int axis)
{
BVHTree *tree = bvhcache_find(&mesh->bvhCache, BVHTREE_FROM_EDGES);
//Not in cache
if (tree == NULL) {
int i;
int numEdges= mesh->getNumEdges(mesh);
MVert *vert = mesh->getVertDataArray(mesh, CD_MVERT);
int numEdges = mesh->getNumEdges(mesh);
MVert *vert = mesh->getVertDataArray(mesh, CD_MVERT);
MEdge *edge = mesh->getEdgeDataArray(mesh, CD_MEDGE);
if (vert != NULL && edge != NULL) {
@ -661,8 +659,8 @@ BVHTree* bvhtree_from_mesh_edges(BVHTreeFromMesh *data, DerivedMesh *mesh, float
if (tree != NULL) {
for (i = 0; i < numEdges; i++) {
float co[4][3];
copy_v3_v3(co[0], vert[ edge[i].v1 ].co);
copy_v3_v3(co[1], vert[ edge[i].v2 ].co);
copy_v3_v3(co[0], vert[edge[i].v1].co);
copy_v3_v3(co[1], vert[edge[i].v2].co);
BLI_bvhtree_insert(tree, i, co[0], 2);
}
@ -712,8 +710,7 @@ void free_bvhtree_from_mesh(struct BVHTreeFromMesh *data)
/* BVHCache */
typedef struct BVHCacheItem
{
typedef struct BVHCacheItem {
int type;
BVHTree *tree;
@ -721,8 +718,8 @@ typedef struct BVHCacheItem
static void bvhcacheitem_set_if_match(void *_cached, void *_search)
{
BVHCacheItem * cached = (BVHCacheItem *)_cached;
BVHCacheItem * search = (BVHCacheItem *)_search;
BVHCacheItem *cached = (BVHCacheItem *)_cached;
BVHCacheItem *search = (BVHCacheItem *)_search;
if (search->type == cached->type) {
search->tree = cached->tree;

498
source/blender/blenkernel/intern/cdderivedmesh.c
View File

File diff suppressed because it is too large Load Diff

726
source/blender/blenkernel/intern/colortools.c
View File

File diff suppressed because it is too large Load Diff

1648
source/blender/blenkernel/intern/constraint.c
View File

File diff suppressed because it is too large Load Diff

236
source/blender/blenkernel/intern/context.c
View File

@ -92,14 +92,14 @@ bContext *CTX_create(void)
{
bContext *C;
C= MEM_callocN(sizeof(bContext), "bContext");
C = MEM_callocN(sizeof(bContext), "bContext");
return C;
}
bContext *CTX_copy(const bContext *C)
{
bContext *newC= MEM_dupallocN((void*)C);
bContext *newC = MEM_dupallocN((void *)C);
return newC;
}
@ -118,23 +118,23 @@ bContextStore *CTX_store_add(ListBase *contexts, const char *name, PointerRNA *p
/* ensure we have a context to put the entry in, if it was already used
* we have to copy the context to ensure */
ctx= contexts->last;
ctx = contexts->last;
if (!ctx || ctx->used) {
if (ctx) {
lastctx= ctx;
ctx= MEM_dupallocN(lastctx);
lastctx = ctx;
ctx = MEM_dupallocN(lastctx);
BLI_duplicatelist(&ctx->entries, &lastctx->entries);
}
else
ctx= MEM_callocN(sizeof(bContextStore), "bContextStore");
ctx = MEM_callocN(sizeof(bContextStore), "bContextStore");
BLI_addtail(contexts, ctx);
}
entry= MEM_callocN(sizeof(bContextStoreEntry), "bContextStoreEntry");
entry = MEM_callocN(sizeof(bContextStoreEntry), "bContextStoreEntry");
BLI_strncpy(entry->name, name, sizeof(entry->name));
entry->ptr= *ptr;
entry->ptr = *ptr;
BLI_addtail(&ctx->entries, entry);
@ -148,22 +148,22 @@ bContextStore *CTX_store_add_all(ListBase *contexts, bContextStore *context)
/* ensure we have a context to put the entries in, if it was already used
* we have to copy the context to ensure */
ctx= contexts->last;
ctx = contexts->last;
if (!ctx || ctx->used) {
if (ctx) {
lastctx= ctx;
ctx= MEM_dupallocN(lastctx);
lastctx = ctx;
ctx = MEM_dupallocN(lastctx);
BLI_duplicatelist(&ctx->entries, &lastctx->entries);
}
else
ctx= MEM_callocN(sizeof(bContextStore), "bContextStore");
ctx = MEM_callocN(sizeof(bContextStore), "bContextStore");
BLI_addtail(contexts, ctx);
}
for (tentry= context->entries.first; tentry; tentry= tentry->next) {
entry= MEM_dupallocN(tentry);
for (tentry = context->entries.first; tentry; tentry = tentry->next) {
entry = MEM_dupallocN(tentry);
BLI_addtail(&ctx->entries, entry);
}
@ -172,14 +172,14 @@ bContextStore *CTX_store_add_all(ListBase *contexts, bContextStore *context)
void CTX_store_set(bContext *C, bContextStore *store)
{
C->wm.store= store;
C->wm.store = store;
}
bContextStore *CTX_store_copy(bContextStore *store)
{
bContextStore *ctx;
ctx= MEM_dupallocN(store);
ctx = MEM_dupallocN(store);
BLI_duplicatelist(&ctx->entries, &store->entries);
return ctx;
@ -195,7 +195,7 @@ void CTX_store_free_list(ListBase *contexts)
{
bContextStore *ctx;
while ((ctx= contexts->first)) {
while ((ctx = contexts->first)) {
BLI_remlink(contexts, ctx);
CTX_store_free(ctx);
}
@ -209,7 +209,7 @@ int CTX_py_init_get(bContext *C)
}
void CTX_py_init_set(bContext *C, int value)
{
C->data.py_init= value;
C->data.py_init = value;
}
void *CTX_py_dict_get(const bContext *C)
@ -218,7 +218,7 @@ void *CTX_py_dict_get(const bContext *C)
}
void CTX_py_dict_set(bContext *C, void *value)
{
C->data.py_context= value;
C->data.py_context = value;
}
/* data context utility functions */
@ -237,8 +237,8 @@ static void *ctx_wm_python_context_get(const bContext *C, const char *member, vo
if (C && CTX_py_dict_get(C)) {
memset(&result, 0, sizeof(bContextDataResult));
BPY_context_member_get((bContext*)C, member, &result);
if(result.ptr.data)
BPY_context_member_get((bContext *)C, member, &result);
if (result.ptr.data)
return result.ptr.data;
}
#endif
@ -251,8 +251,8 @@ static int ctx_data_get(bContext *C, const char *member, bContextDataResult *res
bScreen *sc;
ScrArea *sa;
ARegion *ar;
int done= 0, recursion= C->data.recursion;
int ret= 0;
int done = 0, recursion = C->data.recursion;
int ret = 0;
memset(result, 0, sizeof(bContextDataResult));
#ifdef WITH_PYTHON
@ -271,42 +271,42 @@ static int ctx_data_get(bContext *C, const char *member, bContextDataResult *res
* Values in order of importance
* (0, -1, 1) - Where 1 is highest priority
* */
if (done!=1 && recursion < 1 && C->wm.store) {
if (done != 1 && recursion < 1 && C->wm.store) {
bContextStoreEntry *entry;
C->data.recursion= 1;
C->data.recursion = 1;
entry= BLI_rfindstring(&C->wm.store->entries, member, offsetof(bContextStoreEntry, name));
entry = BLI_rfindstring(&C->wm.store->entries, member, offsetof(bContextStoreEntry, name));
if (entry) {
result->ptr= entry->ptr;
done= 1;
result->ptr = entry->ptr;
done = 1;
}
}
if (done!=1 && recursion < 2 && (ar=CTX_wm_region(C))) {
C->data.recursion= 2;
if (done != 1 && recursion < 2 && (ar = CTX_wm_region(C))) {
C->data.recursion = 2;
if (ar->type && ar->type->context) {
ret = ar->type->context(C, member, result);
if (ret) done= -(-ret | -done);
if (ret) done = -(-ret | -done);
}
}
if (done!=1 && recursion < 3 && (sa=CTX_wm_area(C))) {
C->data.recursion= 3;
if (done != 1 && recursion < 3 && (sa = CTX_wm_area(C))) {
C->data.recursion = 3;
if (sa->type && sa->type->context) {
ret = sa->type->context(C, member, result);
if (ret) done= -(-ret | -done);
if (ret) done = -(-ret | -done);
}
}
if (done!=1 && recursion < 4 && (sc=CTX_wm_screen(C))) {
bContextDataCallback cb= sc->context;
C->data.recursion= 4;
if (done != 1 && recursion < 4 && (sc = CTX_wm_screen(C))) {
bContextDataCallback cb = sc->context;
C->data.recursion = 4;
if (cb) {
ret = cb(C, member, result);
if (ret) done= -(-ret | -done);
if (ret) done = -(-ret | -done);
}
}
C->data.recursion= recursion;
C->data.recursion = recursion;
return done;
}
@ -315,7 +315,7 @@ static void *ctx_data_pointer_get(const bContext *C, const char *member)
{
bContextDataResult result;
if (C && ctx_data_get((bContext*)C, member, &result)==1)
if (C && ctx_data_get((bContext *)C, member, &result) == 1)
return result.ptr.data;
return NULL;
@ -327,15 +327,15 @@ static int ctx_data_pointer_verify(const bContext *C, const char *member, void *
/* if context is NULL, pointer must be NULL too and that is a valid return */
if (C == NULL) {
*pointer= NULL;
*pointer = NULL;
return 1;
}
else if (ctx_data_get((bContext*)C, member, &result)==1) {
*pointer= result.ptr.data;
else if (ctx_data_get((bContext *)C, member, &result) == 1) {
*pointer = result.ptr.data;
return 1;
}
else {
*pointer= NULL;
*pointer = NULL;
return 0;
}
}
@ -344,13 +344,13 @@ static int ctx_data_collection_get(const bContext *C, const char *member, ListBa
{
bContextDataResult result;
if (ctx_data_get((bContext*)C, member, &result)==1) {
*list= result.list;
if (ctx_data_get((bContext *)C, member, &result) == 1) {
*list = result.list;
return 1;
}
list->first= NULL;
list->last= NULL;
list->first = NULL;
list->last = NULL;
return 0;
}
@ -359,7 +359,7 @@ PointerRNA CTX_data_pointer_get(const bContext *C, const char *member)
{
bContextDataResult result;
if (ctx_data_get((bContext*)C, member, &result)==1)
if (ctx_data_get((bContext *)C, member, &result) == 1)
return result.ptr;
else
return PointerRNA_NULL;
@ -379,11 +379,11 @@ ListBase CTX_data_collection_get(const bContext *C, const char *member)
{
bContextDataResult result;
if (ctx_data_get((bContext*)C, member, &result)==1) {
if (ctx_data_get((bContext *)C, member, &result) == 1) {
return result.list;
}
else {
ListBase list= {NULL, NULL};
ListBase list = {NULL, NULL};
return list;
}
}
@ -392,17 +392,17 @@ ListBase CTX_data_collection_get(const bContext *C, const char *member)
int CTX_data_get(const bContext *C, const char *member, PointerRNA *r_ptr, ListBase *r_lb, short *r_type)
{
bContextDataResult result;
int ret= ctx_data_get((bContext*)C, member, &result);
int ret = ctx_data_get((bContext *)C, member, &result);
if (ret==1) {
*r_ptr= result.ptr;
*r_lb= result.list;
*r_type= result.type;
if (ret == 1) {
*r_ptr = result.ptr;
*r_lb = result.list;
*r_type = result.type;
}
else {
memset(r_ptr, 0, sizeof(*r_ptr));
memset(r_lb, 0, sizeof(*r_lb));
*r_type= 0;
*r_type = 0;
}
return ret;
@ -418,8 +418,8 @@ static void data_dir_add(ListBase *lb, const char *member)
if (BLI_findstring(lb, member, offsetof(LinkData, data)))
return;
link= MEM_callocN(sizeof(LinkData), "LinkData");
link->data= (void*)member;
link = MEM_callocN(sizeof(LinkData), "LinkData");
link->data = (void *)member;
BLI_addtail(lb, link);
}
@ -437,32 +437,32 @@ ListBase CTX_data_dir_get(const bContext *C)
if (C->wm.store) {
bContextStoreEntry *entry;
for (entry=C->wm.store->entries.first; entry; entry=entry->next)
for (entry = C->wm.store->entries.first; entry; entry = entry->next)
data_dir_add(&lb, entry->name);
}
if ((ar=CTX_wm_region(C)) && ar->type && ar->type->context) {
if ((ar = CTX_wm_region(C)) && ar->type && ar->type->context) {
memset(&result, 0, sizeof(result));
ar->type->context(C, "", &result);
if (result.dir)
for (a=0; result.dir[a]; a++)
for (a = 0; result.dir[a]; a++)
data_dir_add(&lb, result.dir[a]);
}
if ((sa=CTX_wm_area(C)) && sa->type && sa->type->context) {
if ((sa = CTX_wm_area(C)) && sa->type && sa->type->context) {
memset(&result, 0, sizeof(result));
sa->type->context(C, "", &result);
if (result.dir)
for (a=0; result.dir[a]; a++)
for (a = 0; result.dir[a]; a++)
data_dir_add(&lb, result.dir[a]);
}
if ((sc=CTX_wm_screen(C)) && sc->context) {
bContextDataCallback cb= sc->context;
if ((sc = CTX_wm_screen(C)) && sc->context) {
bContextDataCallback cb = sc->context;
memset(&result, 0, sizeof(result));
cb(C, "", &result);
if (result.dir)
for (a=0; result.dir[a]; a++)
for (a = 0; result.dir[a]; a++)
data_dir_add(&lb, result.dir[a]);
}
@ -493,7 +493,7 @@ void CTX_data_id_list_add(bContextDataResult *result, ID *id)
{
CollectionPointerLink *link;
link= MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_id_list_add");
link = MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_id_list_add");
RNA_id_pointer_create(id, &link->ptr);
BLI_addtail(&result->list, link);
@ -503,18 +503,18 @@ void CTX_data_list_add(bContextDataResult *result, ID *id, StructRNA *type, void
{
CollectionPointerLink *link;
link= MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_list_add");
link = MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_list_add");
RNA_pointer_create(id, type, data, &link->ptr);
BLI_addtail(&result->list, link);
}
int ctx_data_list_count(const bContext *C, int (*func)(const bContext*, ListBase*))
int ctx_data_list_count(const bContext *C, int (*func)(const bContext *, ListBase *))
{
ListBase list;
if (func(C, &list)) {
int tot= BLI_countlist(&list);
int tot = BLI_countlist(&list);
BLI_freelistN(&list);
return tot;
}
@ -524,12 +524,12 @@ int ctx_data_list_count(const bContext *C, int (*func)(const bContext*, ListBase
void CTX_data_dir_set(bContextDataResult *result, const char **dir)
{
result->dir= dir;
result->dir = dir;
}
void CTX_data_type_set(bContextDataResult *result, short type)
{
result->type= type;
result->type = type;
}
short CTX_data_type_get(bContextDataResult *result)
@ -564,7 +564,7 @@ ScrArea *CTX_wm_area(const bContext *C)
SpaceLink *CTX_wm_space_data(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
return (sa)? sa->spacedata.first: NULL;
return (sa) ? sa->spacedata.first : NULL;
}
ARegion *CTX_wm_region(const bContext *C)
@ -575,7 +575,7 @@ ARegion *CTX_wm_region(const bContext *C)
void *CTX_wm_region_data(const bContext *C)
{
ARegion *ar = CTX_wm_region(C);
return (ar)? ar->regiondata: NULL;
return (ar) ? ar->regiondata : NULL;
}
struct ARegion *CTX_wm_menu(const bContext *C)
@ -594,7 +594,7 @@ struct ReportList *CTX_wm_reports(const bContext *C)
View3D *CTX_wm_view3d(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_VIEW3D)
if (sa && sa->spacetype == SPACE_VIEW3D)
return sa->spacedata.first;
return NULL;
}
@ -604,7 +604,7 @@ RegionView3D *CTX_wm_region_view3d(const bContext *C)
ScrArea *sa = CTX_wm_area(C);
ARegion *ar = CTX_wm_region(C);
if (sa && sa->spacetype==SPACE_VIEW3D)
if (sa && sa->spacetype == SPACE_VIEW3D)
if (ar)
return ar->regiondata;
return NULL;
@ -613,7 +613,7 @@ RegionView3D *CTX_wm_region_view3d(const bContext *C)
struct SpaceText *CTX_wm_space_text(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_TEXT)
if (sa && sa->spacetype == SPACE_TEXT)
return sa->spacedata.first;
return NULL;
}
@ -621,7 +621,7 @@ struct SpaceText *CTX_wm_space_text(const bContext *C)
struct SpaceConsole *CTX_wm_space_console(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_CONSOLE)
if (sa && sa->spacetype == SPACE_CONSOLE)
return sa->spacedata.first;
return NULL;
}
@ -629,7 +629,7 @@ struct SpaceConsole *CTX_wm_space_console(const bContext *C)
struct SpaceImage *CTX_wm_space_image(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_IMAGE)
if (sa && sa->spacetype == SPACE_IMAGE)
return sa->spacedata.first;
return NULL;
}
@ -637,7 +637,7 @@ struct SpaceImage *CTX_wm_space_image(const bContext *C)
struct SpaceButs *CTX_wm_space_buts(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_BUTS)
if (sa && sa->spacetype == SPACE_BUTS)
return sa->spacedata.first;
return NULL;
}
@ -645,7 +645,7 @@ struct SpaceButs *CTX_wm_space_buts(const bContext *C)
struct SpaceFile *CTX_wm_space_file(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_FILE)
if (sa && sa->spacetype == SPACE_FILE)
return sa->spacedata.first;
return NULL;
}
@ -653,7 +653,7 @@ struct SpaceFile *CTX_wm_space_file(const bContext *C)
struct SpaceSeq *CTX_wm_space_seq(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_SEQ)
if (sa && sa->spacetype == SPACE_SEQ)
return sa->spacedata.first;
return NULL;
}
@ -661,7 +661,7 @@ struct SpaceSeq *CTX_wm_space_seq(const bContext *C)
struct SpaceOops *CTX_wm_space_outliner(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_OUTLINER)
if (sa && sa->spacetype == SPACE_OUTLINER)
return sa->spacedata.first;
return NULL;
}
@ -669,7 +669,7 @@ struct SpaceOops *CTX_wm_space_outliner(const bContext *C)
struct SpaceNla *CTX_wm_space_nla(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_NLA)
if (sa && sa->spacetype == SPACE_NLA)
return sa->spacedata.first;
return NULL;
}
@ -677,7 +677,7 @@ struct SpaceNla *CTX_wm_space_nla(const bContext *C)
struct SpaceTime *CTX_wm_space_time(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_TIME)
if (sa && sa->spacetype == SPACE_TIME)
return sa->spacedata.first;
return NULL;
}
@ -685,7 +685,7 @@ struct SpaceTime *CTX_wm_space_time(const bContext *C)
struct SpaceNode *CTX_wm_space_node(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_NODE)
if (sa && sa->spacetype == SPACE_NODE)
return sa->spacedata.first;
return NULL;
}
@ -693,7 +693,7 @@ struct SpaceNode *CTX_wm_space_node(const bContext *C)
struct SpaceLogic *CTX_wm_space_logic(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_LOGIC)
if (sa && sa->spacetype == SPACE_LOGIC)
return sa->spacedata.first;
return NULL;
}
@ -701,7 +701,7 @@ struct SpaceLogic *CTX_wm_space_logic(const bContext *C)
struct SpaceIpo *CTX_wm_space_graph(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_IPO)
if (sa && sa->spacetype == SPACE_IPO)
return sa->spacedata.first;
return NULL;
}
@ -709,7 +709,7 @@ struct SpaceIpo *CTX_wm_space_graph(const bContext *C)
struct SpaceAction *CTX_wm_space_action(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_ACTION)
if (sa && sa->spacetype == SPACE_ACTION)
return sa->spacedata.first;
return NULL;
}
@ -717,7 +717,7 @@ struct SpaceAction *CTX_wm_space_action(const bContext *C)
struct SpaceInfo *CTX_wm_space_info(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_INFO)
if (sa && sa->spacetype == SPACE_INFO)
return sa->spacedata.first;
return NULL;
}
@ -725,7 +725,7 @@ struct SpaceInfo *CTX_wm_space_info(const bContext *C)
struct SpaceUserPref *CTX_wm_space_userpref(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_USERPREF)
if (sa && sa->spacetype == SPACE_USERPREF)
return sa->spacedata.first;
return NULL;
}
@ -733,58 +733,58 @@ struct SpaceUserPref *CTX_wm_space_userpref(const bContext *C)
struct SpaceClip *CTX_wm_space_clip(const bContext *C)
{
ScrArea *sa = CTX_wm_area(C);
if (sa && sa->spacetype==SPACE_CLIP)
if (sa && sa->spacetype == SPACE_CLIP)
return sa->spacedata.first;
return NULL;
}
void CTX_wm_manager_set(bContext *C, wmWindowManager *wm)
{
C->wm.manager= wm;
C->wm.window= NULL;
C->wm.screen= NULL;
C->wm.area= NULL;
C->wm.region= NULL;
C->wm.manager = wm;
C->wm.window = NULL;
C->wm.screen = NULL;
C->wm.area = NULL;
C->wm.region = NULL;
}
void CTX_wm_window_set(bContext *C, wmWindow *win)
{
C->wm.window= win;
C->wm.screen= (win)? win->screen: NULL;
C->wm.window = win;
C->wm.screen = (win) ? win->screen : NULL;
if (C->wm.screen)
C->data.scene= C->wm.screen->scene;
C->wm.area= NULL;
C->wm.region= NULL;
C->data.scene = C->wm.screen->scene;
C->wm.area = NULL;
C->wm.region = NULL;
}
void CTX_wm_screen_set(bContext *C, bScreen *screen)
{
C->wm.screen= screen;
C->wm.screen = screen;
if (C->wm.screen)
C->data.scene= C->wm.screen->scene;
C->wm.area= NULL;
C->wm.region= NULL;
C->data.scene = C->wm.screen->scene;
C->wm.area = NULL;
C->wm.region = NULL;
}
void CTX_wm_area_set(bContext *C, ScrArea *area)
{
C->wm.area= area;
C->wm.region= NULL;
C->wm.area = area;
C->wm.region = NULL;
}
void CTX_wm_region_set(bContext *C, ARegion *region)
{
C->wm.region= region;
C->wm.region = region;
}
void CTX_wm_menu_set(bContext *C, ARegion *menu)
{
C->wm.menu= menu;
C->wm.menu = menu;
}
void CTX_wm_operator_poll_msg_set(bContext *C, const char *msg)
{
C->wm.operator_poll_msg= msg;
C->wm.operator_poll_msg = msg;
}
const char *CTX_wm_operator_poll_msg_get(bContext *C)
@ -798,7 +798,7 @@ Main *CTX_data_main(const bContext *C)
{
Main *bmain;
if (ctx_data_pointer_verify(C, "blend_data", (void*)&bmain))
if (ctx_data_pointer_verify(C, "blend_data", (void *)&bmain))
return bmain;
else
return C->data.main;
@ -806,14 +806,14 @@ Main *CTX_data_main(const bContext *C)
void CTX_data_main_set(bContext *C, Main *bmain)
{
C->data.main= bmain;
C->data.main = bmain;
}
Scene *CTX_data_scene(const bContext *C)
{
Scene *scene;
if (ctx_data_pointer_verify(C, "scene", (void*)&scene))
if (ctx_data_pointer_verify(C, "scene", (void *)&scene))
return scene;
else
return C->data.scene;
@ -821,7 +821,7 @@ Scene *CTX_data_scene(const bContext *C)
int CTX_data_mode_enum(const bContext *C)
{
Object *obedit= CTX_data_edit_object(C);
Object *obedit = CTX_data_edit_object(C);
if (obedit) {
switch (obedit->type) {
@ -846,7 +846,7 @@ int CTX_data_mode_enum(const bContext *C)
if (ob) {
if (ob->mode & OB_MODE_POSE) return CTX_MODE_POSE;
else if (ob->mode & OB_MODE_SCULPT) return CTX_MODE_SCULPT;
else if (ob->mode & OB_MODE_SCULPT) return CTX_MODE_SCULPT;
else if (ob->mode & OB_MODE_WEIGHT_PAINT) return CTX_MODE_PAINT_WEIGHT;
else if (ob->mode & OB_MODE_VERTEX_PAINT) return CTX_MODE_PAINT_VERTEX;
else if (ob->mode & OB_MODE_TEXTURE_PAINT) return CTX_MODE_PAINT_TEXTURE;
@ -884,7 +884,7 @@ const char *CTX_data_mode_string(const bContext *C)
void CTX_data_scene_set(bContext *C, Scene *scene)
{
C->data.scene= scene;
C->data.scene = scene;
}
ToolSettings *CTX_data_tool_settings(const bContext *C)

898
source/blender/blenkernel/intern/depsgraph.c
View File

File diff suppressed because it is too large Load Diff

828
source/blender/blenkernel/intern/displist.c
View File

File diff suppressed because it is too large Load Diff

802
source/blender/blenkernel/intern/fcurve.c
View File

File diff suppressed because it is too large Load Diff

450
source/blender/blenkernel/intern/fmodifier.c
View File

File diff suppressed because it is too large Load Diff

134
source/blender/blenkernel/intern/idprop.c
View File

@ -47,16 +47,16 @@ static char idp_size_table[] = {
1, /*strings*/
sizeof(int),
sizeof(float),
sizeof(float)*3, /*Vector type, deprecated*/
sizeof(float)*16, /*Matrix type, deprecated*/
sizeof(float) * 3, /*Vector type, deprecated*/
sizeof(float) * 16, /*Matrix type, deprecated*/
0, /*arrays don't have a fixed size*/
sizeof(ListBase), /*Group type*/
sizeof(void*),
sizeof(void *),
sizeof(double)
};
/* ------------Property Array Type ----------- */
#define GETPROP(prop, i) (((IDProperty*)(prop)->data.pointer)+(i))
#define GETPROP(prop, i) (((IDProperty *)(prop)->data.pointer) + (i))
/* --------- property array type -------------*/
@ -78,10 +78,10 @@ IDProperty *IDP_CopyIDPArray(IDProperty *array)
IDProperty *narray = MEM_mallocN(sizeof(IDProperty), "IDP_CopyIDPArray"), *tmp;
int i;
*narray= *array;
*narray = *array;
narray->data.pointer = MEM_dupallocN(array->data.pointer);
for (i=0; i<narray->len; i++) {
for (i = 0; i < narray->len; i++) {
/* ok, the copy functions always allocate a new structure,
* which doesn't work here. instead, simply copy the
* contents of the new structure into the array cell,
@ -100,7 +100,7 @@ void IDP_FreeIDPArray(IDProperty *prop)
{
int i;
for (i=0; i<prop->len; i++)
for (i = 0; i < prop->len; i++)
IDP_FreeProperty(GETPROP(prop, i));
if (prop->data.pointer)
@ -124,22 +124,22 @@ IDProperty *IDP_GetIndexArray(IDProperty *prop, int index)
IDProperty *IDP_AppendArray(IDProperty *prop, IDProperty *item)
{
IDP_ResizeIDPArray(prop, prop->len+1);
IDP_SetIndexArray(prop, prop->len-1, item);
IDP_ResizeIDPArray(prop, prop->len + 1);
IDP_SetIndexArray(prop, prop->len - 1, item);
return item;
}
void IDP_ResizeIDPArray(IDProperty *prop, int newlen)
{
void *newarr;
int newsize=newlen;
int newsize = newlen;
/*first check if the array buffer size has room*/
/*if newlen is 200 chars less then totallen, reallocate anyway*/
if (newlen <= prop->totallen && prop->totallen - newlen < 200) {
int i;
for (i=newlen; i<prop->len; i++)
for (i = newlen; i < prop->len; i++)
IDP_FreeProperty(GETPROP(prop, i));
prop->len = newlen;
@ -156,18 +156,18 @@ void IDP_ResizeIDPArray(IDProperty *prop, int newlen)
*/
newsize = (newsize >> 3) + (newsize < 9 ? 3 : 6) + newsize;
newarr = MEM_callocN(sizeof(IDProperty)*newsize, "idproperty array resized");
newarr = MEM_callocN(sizeof(IDProperty) * newsize, "idproperty array resized");
if (newlen >= prop->len) {
/* newlen is bigger*/
memcpy(newarr, prop->data.pointer, prop->len*sizeof(IDProperty));
memcpy(newarr, prop->data.pointer, prop->len * sizeof(IDProperty));
}
else {
int i;
/* newlen is smaller*/
for (i=newlen; i<prop->len; i++) {
for (i = newlen; i < prop->len; i++) {
IDP_FreeProperty(GETPROP(prop, i));
}
memcpy(newarr, prop->data.pointer, newlen*sizeof(IDProperty));
memcpy(newarr, prop->data.pointer, newlen * sizeof(IDProperty));
}
if (prop->data.pointer)
@ -185,21 +185,21 @@ static void idp_resize_group_array(IDProperty *prop, int newlen, void *newarr)
if (newlen >= prop->len) {
/* bigger */
IDProperty **array= newarr;
IDProperty **array = newarr;
IDPropertyTemplate val;
int a;
for (a=prop->len; a<newlen; a++) {
for (a = prop->len; a < newlen; a++) {
val.i = 0; /* silence MSVC warning about uninitialized var when debugging */
array[a]= IDP_New(IDP_GROUP, &val, "IDP_ResizeArray group");
array[a] = IDP_New(IDP_GROUP, &val, "IDP_ResizeArray group");
}
}
else {
/* smaller */
IDProperty **array= prop->data.pointer;
IDProperty **array = prop->data.pointer;
int a;
for (a=newlen; a<prop->len; a++) {
for (a = newlen; a < prop->len; a++) {
IDP_FreeProperty(array[a]);
MEM_freeN(array[a]);
}
@ -210,7 +210,7 @@ static void idp_resize_group_array(IDProperty *prop, int newlen, void *newarr)
void IDP_ResizeArray(IDProperty *prop, int newlen)
{
void *newarr;
int newsize=newlen;
int newsize = newlen;
/*first check if the array buffer size has room*/
/*if newlen is 200 chars less then totallen, reallocate anyway*/
@ -230,16 +230,16 @@ void IDP_ResizeArray(IDProperty *prop, int newlen)
*/
newsize = (newsize >> 3) + (newsize < 9 ? 3 : 6) + newsize;
newarr = MEM_callocN(idp_size_table[(int)prop->subtype]*newsize, "idproperty array resized");
newarr = MEM_callocN(idp_size_table[(int)prop->subtype] * newsize, "idproperty array resized");
if (newlen >= prop->len) {
/* newlen is bigger*/
memcpy(newarr, prop->data.pointer, prop->len*idp_size_table[(int)prop->subtype]);
memcpy(newarr, prop->data.pointer, prop->len * idp_size_table[(int)prop->subtype]);
idp_resize_group_array(prop, newlen, newarr);
}
else {
/* newlen is smaller*/
idp_resize_group_array(prop, newlen, newarr);
memcpy(newarr, prop->data.pointer, newlen*idp_size_table[(int)prop->subtype]);
memcpy(newarr, prop->data.pointer, newlen * idp_size_table[(int)prop->subtype]);
}
MEM_freeN(prop->data.pointer);
@ -257,8 +257,8 @@ void IDP_FreeArray(IDProperty *prop)
}
static IDProperty *idp_generic_copy(IDProperty *prop)
{
static IDProperty *idp_generic_copy(IDProperty *prop)
{
IDProperty *newp = MEM_callocN(sizeof(IDProperty), "IDProperty array dup");
BLI_strncpy(newp->name, prop->name, MAX_IDPROP_NAME);
@ -268,7 +268,7 @@ void IDP_FreeArray(IDProperty *prop)
newp->data.val2 = prop->data.val2;
return newp;
}
}
static IDProperty *IDP_CopyArray(IDProperty *prop)
{
@ -278,11 +278,11 @@ static IDProperty *IDP_CopyArray(IDProperty *prop)
newp->data.pointer = MEM_dupallocN(prop->data.pointer);
if (prop->type == IDP_GROUP) {
IDProperty **array= newp->data.pointer;
IDProperty **array = newp->data.pointer;
int a;
for (a=0; a<prop->len; a++)
array[a]= IDP_CopyProperty(array[a]);
for (a = 0; a < prop->len; a++)
array[a] = IDP_CopyProperty(array[a]);
}
}
newp->len = prop->len;
@ -294,12 +294,12 @@ static IDProperty *IDP_CopyArray(IDProperty *prop)
/*taken from readfile.c*/
#define SWITCH_LONGINT(a) { \
char s_i, *p_i; \
p_i= (char *)&(a); \
s_i=p_i[0]; p_i[0]=p_i[7]; p_i[7]=s_i; \
s_i=p_i[1]; p_i[1]=p_i[6]; p_i[6]=s_i; \
s_i=p_i[2]; p_i[2]=p_i[5]; p_i[5]=s_i; \
s_i=p_i[3]; p_i[3]=p_i[4]; p_i[4]=s_i; }
char s_i, *p_i; \
p_i = (char *)& (a); \
s_i = p_i[0]; p_i[0] = p_i[7]; p_i[7] = s_i; \
s_i = p_i[1]; p_i[1] = p_i[6]; p_i[6] = s_i; \
s_i = p_i[2]; p_i[2] = p_i[5]; p_i[5] = s_i; \
s_i = p_i[3]; p_i[3] = p_i[4]; p_i[4] = s_i; }
@ -350,7 +350,7 @@ void IDP_AssignString(IDProperty *prop, const char *st, int maxlen)
int stlen = strlen(st);
if (maxlen > 0 && maxlen < stlen)
stlen= maxlen;
stlen = maxlen;
if (prop->subtype == IDP_STRING_SUB_BYTE) {
IDP_ResizeArray(prop, stlen);
@ -396,14 +396,14 @@ void IDP_FreeString(IDProperty *prop)
void IDP_LinkID(IDProperty *prop, ID *id)
{
if (prop->data.pointer) ((ID*)prop->data.pointer)->us--;
if (prop->data.pointer) ((ID *)prop->data.pointer)->us--;
prop->data.pointer = id;
id_us_plus(id);
}
void IDP_UnlinkID(IDProperty *prop)
{
((ID*)prop->data.pointer)->us--;
((ID *)prop->data.pointer)->us--;
}
/*-------- Group Functions -------*/
@ -414,7 +414,7 @@ static IDProperty *IDP_CopyGroup(IDProperty *prop)
IDProperty *newp = idp_generic_copy(prop), *link;
newp->len = prop->len;
for (link=prop->data.group.first; link; link=link->next) {
for (link = prop->data.group.first; link; link = link->next) {
BLI_addtail(&newp->data.group, IDP_CopyProperty(link));
}
@ -426,22 +426,22 @@ static IDProperty *IDP_CopyGroup(IDProperty *prop)
void IDP_SyncGroupValues(IDProperty *dest, IDProperty *src)
{
IDProperty *other, *prop;
for (prop=src->data.group.first; prop; prop=prop->next) {
other= BLI_findstring(&dest->data.group, prop->name, offsetof(IDProperty, name));
if (other && prop->type==other->type) {
for (prop = src->data.group.first; prop; prop = prop->next) {
other = BLI_findstring(&dest->data.group, prop->name, offsetof(IDProperty, name));
if (other && prop->type == other->type) {
switch (prop->type) {
case IDP_INT:
case IDP_FLOAT:
case IDP_DOUBLE:
other->data= prop->data;
other->data = prop->data;
break;
case IDP_GROUP:
IDP_SyncGroupValues(other, prop);
break;
default:
{
IDProperty *tmp= other;
IDProperty *copy= IDP_CopyProperty(prop);
IDProperty *tmp = other;
IDProperty *copy = IDP_CopyProperty(prop);
BLI_insertlinkafter(&dest->data.group, other, copy);
BLI_remlink(&dest->data.group, tmp);
@ -460,8 +460,8 @@ void IDP_SyncGroupValues(IDProperty *dest, IDProperty *src)
void IDP_ReplaceGroupInGroup(IDProperty *dest, IDProperty *src)
{
IDProperty *loop, *prop;
for (prop=src->data.group.first; prop; prop=prop->next) {
for (loop=dest->data.group.first; loop; loop=loop->next) {
for (prop = src->data.group.first; prop; prop = prop->next) {
for (loop = dest->data.group.first; loop; loop = loop->next) {
if (strcmp(loop->name, prop->name) == 0) {
IDProperty *copy = IDP_CopyProperty(prop);
@ -489,7 +489,7 @@ void IDP_ReplaceGroupInGroup(IDProperty *dest, IDProperty *src)
void IDP_ReplaceInGroup(IDProperty *group, IDProperty *prop)
{
IDProperty *loop;
if ((loop= IDP_GetPropertyFromGroup(group, prop->name))) {
if ((loop = IDP_GetPropertyFromGroup(group, prop->name))) {
BLI_insertlink(&group->data.group, loop, prop);
BLI_remlink(&group->data.group, loop);
@ -539,7 +539,7 @@ IDProperty *IDP_GetPropertyFromGroup(IDProperty *prop, const char *name)
IDProperty *IDP_GetPropertyTypeFromGroup(IDProperty *prop, const char *name, const char type)
{
IDProperty *idprop= IDP_GetPropertyFromGroup(prop, name);
IDProperty *idprop = IDP_GetPropertyFromGroup(prop, name);
return (idprop && idprop->type == type) ? idprop : NULL;
}
@ -553,20 +553,20 @@ void *IDP_GetGroupIterator(IDProperty *prop)
IDPIter *iter = MEM_callocN(sizeof(IDPIter), "IDPIter");
iter->next = prop->data.group.first;
iter->parent = prop;
return (void*) iter;
return (void *) iter;
}
IDProperty *IDP_GroupIterNext(void *vself)
{
IDPIter *self = (IDPIter*) vself;
Link *next = (Link*) self->next;
IDPIter *self = (IDPIter *) vself;
Link *next = (Link *) self->next;
if (self->next == NULL) {
MEM_freeN(self);
return NULL;
}
self->next = next->next;
return (void*) next;
return (void *) next;
}
void IDP_FreeIterBeforeEnd(void *vself)
@ -581,7 +581,7 @@ void IDP_FreeIterBeforeEnd(void *vself)
static void IDP_FreeGroup(IDProperty *prop)
{
IDProperty *loop;
for (loop=prop->data.group.first; loop; loop=loop->next) {
for (loop = prop->data.group.first; loop; loop = loop->next) {
IDP_FreeProperty(loop);
}
BLI_freelistN(&prop->data.group);
@ -635,7 +635,7 @@ int IDP_EqualsProperties(IDProperty *prop1, IDProperty *prop2)
return ((prop1->len == prop2->len) && strncmp(IDP_String(prop1), IDP_String(prop2), prop1->len) == 0);
else if (prop1->type == IDP_ARRAY) {
if (prop1->len == prop2->len && prop1->subtype == prop2->subtype)
return memcmp(IDP_Array(prop1), IDP_Array(prop2), idp_size_table[(int)prop1->subtype]*prop1->len);
return memcmp(IDP_Array(prop1), IDP_Array(prop2), idp_size_table[(int)prop1->subtype] * prop1->len);
else
return 0;
}
@ -645,8 +645,8 @@ int IDP_EqualsProperties(IDProperty *prop1, IDProperty *prop2)
if (BLI_countlist(&prop1->data.group) != BLI_countlist(&prop2->data.group))
return 0;
for (link1=prop1->data.group.first; link1; link1=link1->next) {
link2= IDP_GetPropertyFromGroup(prop2, link1->name);
for (link1 = prop1->data.group.first; link1; link1 = link1->next) {
link2 = IDP_GetPropertyFromGroup(prop2, link1->name);
if (!IDP_EqualsProperties(link1, link2))
return 0;
@ -655,14 +655,14 @@ int IDP_EqualsProperties(IDProperty *prop1, IDProperty *prop2)
return 1;
}
else if (prop1->type == IDP_IDPARRAY) {
IDProperty *array1= IDP_IDPArray(prop1);
IDProperty *array2= IDP_IDPArray(prop2);
IDProperty *array1 = IDP_IDPArray(prop1);
IDProperty *array2 = IDP_IDPArray(prop2);
int i;
if (prop1->len != prop2->len)
return 0;
for (i=0; i<prop1->len; i++)
for (i = 0; i < prop1->len; i++)
if (!IDP_EqualsProperties(&array1[i], &array2[i]))
return 0;
}
@ -673,7 +673,7 @@ int IDP_EqualsProperties(IDProperty *prop1, IDProperty *prop2)
/* 'val' is never NULL, don't check */
IDProperty *IDP_New(const int type, const IDPropertyTemplate *val, const char *name)
{
IDProperty *prop=NULL;
IDProperty *prop = NULL;
switch (type) {
case IDP_INT:
@ -682,11 +682,11 @@ IDProperty *IDP_New(const int type, const IDPropertyTemplate *val, const char *n
break;
case IDP_FLOAT:
prop = MEM_callocN(sizeof(IDProperty), "IDProperty float");
*(float*)&prop->data.val = val->f;
*(float *)&prop->data.val = val->f;
break;
case IDP_DOUBLE:
prop = MEM_callocN(sizeof(IDProperty), "IDProperty float");
*(double*)&prop->data.val = val->d;
*(double *)&prop->data.val = val->d;
break;
case IDP_ARRAY:
{
@ -699,7 +699,7 @@ IDProperty *IDP_New(const int type, const IDPropertyTemplate *val, const char *n
prop = MEM_callocN(sizeof(IDProperty), "IDProperty array");
prop->subtype = val->array.type;
if (val->array.len)
prop->data.pointer = MEM_callocN(idp_size_table[val->array.type]*val->array.len, "id property array");
prop->data.pointer = MEM_callocN(idp_size_table[val->array.type] * val->array.len, "id property array");
prop->len = prop->totallen = val->array.len;
break;
}
@ -724,7 +724,7 @@ IDProperty *IDP_New(const int type, const IDPropertyTemplate *val, const char *n
prop->len = prop->totallen = val->string.len;
memcpy(prop->data.pointer, st, val->string.len);
}
prop->subtype= IDP_STRING_SUB_BYTE;
prop->subtype = IDP_STRING_SUB_BYTE;
}
else {
if (st == NULL) {
@ -738,7 +738,7 @@ IDProperty *IDP_New(const int type, const IDPropertyTemplate *val, const char *n
prop->len = prop->totallen = stlen;
memcpy(prop->data.pointer, st, stlen);
}
prop->subtype= IDP_STRING_SUB_UTF8;
prop->subtype = IDP_STRING_SUB_UTF8;
}
break;
}

214
source/blender/blenkernel/intern/image_gen.c
View File

@ -39,10 +39,10 @@ void BKE_image_buf_fill_color(unsigned char *rect, float *rect_float, int width,
/* blank image */
if (rect_float) {
for (y= 0; y<height; y++) {
for (x= 0; x<width; x++) {
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
copy_v4_v4(rect_float, color);
rect_float+= 4;
rect_float += 4;
}
}
}
@ -52,14 +52,14 @@ void BKE_image_buf_fill_color(unsigned char *rect, float *rect_float, int width,
rgba_float_to_uchar(ccol, color);
for (y= 0; y<height; y++) {
for (x= 0; x<width; x++) {
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
rect[0]= ccol[0];
rect[1]= ccol[1];
rect[2]= ccol[2];
rect[3]= ccol[3];
rect+= 4;
rect[0] = ccol[0];
rect[1] = ccol[1];
rect[2] = ccol[2];
rect[3] = ccol[3];
rect += 4;
}
}
}
@ -71,84 +71,84 @@ void BKE_image_buf_fill_checker(unsigned char *rect, float *rect_float, int widt
/* these two passes could be combined into one, but it's more readable and
* easy to tweak like this, speed isn't really that much of an issue in this situation... */
int checkerwidth= 32, dark= 1;
int checkerwidth = 32, dark = 1;
int x, y;
unsigned char *rect_orig= rect;
float *rect_float_orig= rect_float;
unsigned char *rect_orig = rect;
float *rect_float_orig = rect_float;
float h=0.0, hoffs=0.0, hue=0.0, s=0.9, v=0.9, r, g, b;
float h = 0.0, hoffs = 0.0, hue = 0.0, s = 0.9, v = 0.9, r, g, b;
/* checkers */
for (y= 0; y<height; y++) {
dark= powf(-1.0f, floorf(y / checkerwidth));
for (y = 0; y < height; y++) {
dark = powf(-1.0f, floorf(y / checkerwidth));
for (x= 0; x<width; x++) {
if (x % checkerwidth == 0) dark= -dark;
for (x = 0; x < width; x++) {
if (x % checkerwidth == 0) dark = -dark;
if (rect_float) {
if (dark > 0) {
rect_float[0]= rect_float[1]= rect_float[2]= 0.25f;
rect_float[3]= 1.0f;
rect_float[0] = rect_float[1] = rect_float[2] = 0.25f;
rect_float[3] = 1.0f;
}
else {
rect_float[0]= rect_float[1]= rect_float[2]= 0.58f;
rect_float[3]= 1.0f;
rect_float[0] = rect_float[1] = rect_float[2] = 0.58f;
rect_float[3] = 1.0f;
}
rect_float+= 4;
rect_float += 4;
}
else {
if (dark > 0) {
rect[0]= rect[1]= rect[2]= 64;
rect[3]= 255;
rect[0] = rect[1] = rect[2] = 64;
rect[3] = 255;
}
else {
rect[0]= rect[1]= rect[2]= 150;
rect[3]= 255;
rect[0] = rect[1] = rect[2] = 150;
rect[3] = 255;
}
rect+= 4;
rect += 4;
}
}
}
rect= rect_orig;
rect_float= rect_float_orig;
rect = rect_orig;
rect_float = rect_float_orig;
/* 2nd pass, colored + */
for (y= 0; y<height; y++) {
hoffs= 0.125f * floorf(y / checkerwidth);
for (y = 0; y < height; y++) {
hoffs = 0.125f * floorf(y / checkerwidth);
for (x= 0; x<width; x++) {
h= 0.125f * floorf(x / checkerwidth);
for (x = 0; x < width; x++) {
h = 0.125f * floorf(x / checkerwidth);
if ((fabs((x % checkerwidth) - (checkerwidth / 2)) < 4) &&
(fabs((y % checkerwidth) - (checkerwidth / 2)) < 4)) {
(fabs((y % checkerwidth) - (checkerwidth / 2)) < 4)) {
if ((fabs((x % checkerwidth) - (checkerwidth / 2)) < 1) ||
(fabs((y % checkerwidth) - (checkerwidth / 2)) < 1)) {
(fabs((y % checkerwidth) - (checkerwidth / 2)) < 1)) {
hue= fmodf(fabs(h-hoffs), 1.0f);
hue = fmodf(fabs(h - hoffs), 1.0f);
hsv_to_rgb(hue, s, v, &r, &g, &b);
if (rect) {
rect[0]= (char)(r * 255.0f);
rect[1]= (char)(g * 255.0f);
rect[2]= (char)(b * 255.0f);
rect[3]= 255;
rect[0] = (char)(r * 255.0f);
rect[1] = (char)(g * 255.0f);
rect[2] = (char)(b * 255.0f);
rect[3] = 255;
}
if (rect_float) {
rect_float[0]= r;
rect_float[1]= g;
rect_float[2]= b;
rect_float[3]= 1.0f;
rect_float[0] = r;
rect_float[1] = g;
rect_float[2] = b;
rect_float[3] = 1.0f;
}
}
}
if (rect_float) rect_float+= 4;
if (rect) rect+= 4;
if (rect_float) rect_float += 4;
if (rect) rect += 4;
}
}
}
@ -156,7 +156,7 @@ void BKE_image_buf_fill_checker(unsigned char *rect, float *rect_float, int widt
/* Utility functions for BKE_image_buf_fill_checker_color */
#define BLEND_FLOAT(real, add) (real+add <= 1.0f) ? (real+add) : 1.0f
#define BLEND_FLOAT(real, add) (real + add <= 1.0f) ? (real + add) : 1.0f
#define BLEND_CHAR(real, add) ((real + (char)(add * 255.0f)) <= 255) ? (real + (char)(add * 255.0f)) : 255
static void checker_board_color_fill(unsigned char *rect, float *rect_float, int width, int height)
@ -164,32 +164,32 @@ static void checker_board_color_fill(unsigned char *rect, float *rect_float, int
int hue_step, y, x;
float hue, val, sat, r, g, b;
sat= 1.0;
sat = 1.0;
hue_step= power_of_2_max_i(width / 8);
if (hue_step < 8) hue_step= 8;
hue_step = power_of_2_max_i(width / 8);
if (hue_step < 8) hue_step = 8;
for (y= 0; y < height; y++) {
for (y = 0; y < height; y++) {
val= 0.1 + (y * (0.4 / height)); /* use a number lower then 1.0 else its too bright */
for (x= 0; x < width; x++) {
hue= (float)((double)(x/hue_step) * 1.0 / width * hue_step);
val = 0.1 + (y * (0.4 / height)); /* use a number lower then 1.0 else its too bright */
for (x = 0; x < width; x++) {
hue = (float)((double)(x / hue_step) * 1.0 / width * hue_step);
hsv_to_rgb(hue, sat, val, &r, &g, &b);
if (rect) {
rect[0]= (char)(r * 255.0f);
rect[1]= (char)(g * 255.0f);
rect[2]= (char)(b * 255.0f);
rect[3]= 255;
rect[0] = (char)(r * 255.0f);
rect[1] = (char)(g * 255.0f);
rect[2] = (char)(b * 255.0f);
rect[3] = 255;
rect += 4;
}
if (rect_float) {
rect_float[0]= r;
rect_float[1]= g;
rect_float[2]= b;
rect_float[3]= 1.0f;
rect_float[0] = r;
rect_float[1] = g;
rect_float[2] = b;
rect_float[3] = 1.0f;
rect_float += 4;
}
@ -200,42 +200,42 @@ static void checker_board_color_fill(unsigned char *rect, float *rect_float, int
static void checker_board_color_tint(unsigned char *rect, float *rect_float, int width, int height, int size, float blend)
{
int x, y;
float blend_half= blend * 0.5f;
float blend_half = blend * 0.5f;
for (y= 0; y < height; y++) {
for (x= 0; x < width; x++) {
if (((y / size) % 2 == 1 && (x / size) % 2 == 1 ) || ( (y / size) % 2 == 0 && (x / size) % 2 == 0 )) {
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
if (((y / size) % 2 == 1 && (x / size) % 2 == 1) || ( (y / size) % 2 == 0 && (x / size) % 2 == 0)) {
if (rect) {
rect[0]= (char)BLEND_CHAR(rect[0], blend);
rect[1]= (char)BLEND_CHAR(rect[1], blend);
rect[2]= (char)BLEND_CHAR(rect[2], blend);
rect[3]= 255;
rect[0] = (char)BLEND_CHAR(rect[0], blend);
rect[1] = (char)BLEND_CHAR(rect[1], blend);
rect[2] = (char)BLEND_CHAR(rect[2], blend);
rect[3] = 255;
rect += 4;
}
if (rect_float) {
rect_float[0]= BLEND_FLOAT(rect_float[0], blend);
rect_float[1]= BLEND_FLOAT(rect_float[1], blend);
rect_float[2]= BLEND_FLOAT(rect_float[2], blend);
rect_float[3]= 1.0f;
rect_float[0] = BLEND_FLOAT(rect_float[0], blend);
rect_float[1] = BLEND_FLOAT(rect_float[1], blend);
rect_float[2] = BLEND_FLOAT(rect_float[2], blend);
rect_float[3] = 1.0f;
rect_float += 4;
}
}
else {
if (rect) {
rect[0]= (char)BLEND_CHAR(rect[0], blend_half);
rect[1]= (char)BLEND_CHAR(rect[1], blend_half);
rect[2]= (char)BLEND_CHAR(rect[2], blend_half);
rect[3]= 255;
rect[0] = (char)BLEND_CHAR(rect[0], blend_half);
rect[1] = (char)BLEND_CHAR(rect[1], blend_half);
rect[2] = (char)BLEND_CHAR(rect[2], blend_half);
rect[3] = 255;
rect += 4;
}
if (rect_float) {
rect_float[0]= BLEND_FLOAT(rect_float[0], blend_half);
rect_float[1]= BLEND_FLOAT(rect_float[1], blend_half);
rect_float[2]= BLEND_FLOAT(rect_float[2], blend_half);
rect_float[3]= 1.0f;
rect_float[0] = BLEND_FLOAT(rect_float[0], blend_half);
rect_float[1] = BLEND_FLOAT(rect_float[1], blend_half);
rect_float[2] = BLEND_FLOAT(rect_float[2], blend_half);
rect_float[3] = 1.0f;
rect_float += 4;
}
@ -248,22 +248,22 @@ static void checker_board_color_tint(unsigned char *rect, float *rect_float, int
static void checker_board_grid_fill(unsigned char *rect, float *rect_float, int width, int height, float blend)
{
int x, y;
for (y= 0; y < height; y++) {
for (x= 0; x < width; x++) {
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
if (((y % 32) == 0) || ((x % 32) == 0) || x == 0) {
if (rect) {
rect[0]= BLEND_CHAR(rect[0], blend);
rect[1]= BLEND_CHAR(rect[1], blend);
rect[2]= BLEND_CHAR(rect[2], blend);
rect[3]= 255;
rect[0] = BLEND_CHAR(rect[0], blend);
rect[1] = BLEND_CHAR(rect[1], blend);
rect[2] = BLEND_CHAR(rect[2], blend);
rect[3] = 255;
rect += 4;
}
if (rect_float) {
rect_float[0]= BLEND_FLOAT(rect_float[0], blend);
rect_float[1]= BLEND_FLOAT(rect_float[1], blend);
rect_float[2]= BLEND_FLOAT(rect_float[2], blend);
rect_float[3]= 1.0f;
rect_float[0] = BLEND_FLOAT(rect_float[0], blend);
rect_float[1] = BLEND_FLOAT(rect_float[1], blend);
rect_float[2] = BLEND_FLOAT(rect_float[2], blend);
rect_float[3] = 1.0f;
rect_float += 4;
}
@ -282,17 +282,17 @@ static void checker_board_text(unsigned char *rect, float *rect_float, int width
{
int x, y;
int pen_x, pen_y;
char text[3]= {'A', '1', '\0'};
const int mono= blf_mono_font;
char text[3] = {'A', '1', '\0'};
const int mono = blf_mono_font;
BLF_size(mono, 54, 72); /* hard coded size! */
BLF_buffer(mono, rect_float, rect, width, height, 4);
for (y= 0; y < height; y+=step) {
text[1]= '1';
for (y = 0; y < height; y += step) {
text[1] = '1';
for (x= 0; x < width; x+=step) {
for (x = 0; x < width; x += step) {
/* hard coded offset */
pen_x = x + 33;
pen_y = y + 44;
@ -300,22 +300,22 @@ static void checker_board_text(unsigned char *rect, float *rect_float, int width
/* terribly crappy outline font! */
BLF_buffer_col(mono, 1.0, 1.0, 1.0, 1.0);
BLF_position(mono, pen_x-outline, pen_y, 0.0);
BLF_position(mono, pen_x - outline, pen_y, 0.0);
BLF_draw_buffer(mono, text);
BLF_position(mono, pen_x+outline, pen_y, 0.0);
BLF_position(mono, pen_x + outline, pen_y, 0.0);
BLF_draw_buffer(mono, text);
BLF_position(mono, pen_x, pen_y-outline, 0.0);
BLF_position(mono, pen_x, pen_y - outline, 0.0);
BLF_draw_buffer(mono, text);
BLF_position(mono, pen_x, pen_y+outline, 0.0);
BLF_position(mono, pen_x, pen_y + outline, 0.0);
BLF_draw_buffer(mono, text);
BLF_position(mono, pen_x-outline, pen_y-outline, 0.0);
BLF_position(mono, pen_x - outline, pen_y - outline, 0.0);
BLF_draw_buffer(mono, text);
BLF_position(mono, pen_x+outline, pen_y+outline, 0.0);
BLF_position(mono, pen_x + outline, pen_y + outline, 0.0);
BLF_draw_buffer(mono, text);
BLF_position(mono, pen_x-outline, pen_y+outline, 0.0);
BLF_position(mono, pen_x - outline, pen_y + outline, 0.0);
BLF_draw_buffer(mono, text);
BLF_position(mono, pen_x+outline, pen_y-outline, 0.0);
BLF_position(mono, pen_x + outline, pen_y - outline, 0.0);
BLF_draw_buffer(mono, text);
BLF_buffer_col(mono, 0.0, 0.0, 0.0, 1.0);
@ -338,7 +338,7 @@ void BKE_image_buf_fill_checker_color(unsigned char *rect, float *rect_float, in
checker_board_color_tint(rect, rect_float, width, height, 4, 0.05f);
checker_board_color_tint(rect, rect_float, width, height, 32, 0.07f);
checker_board_color_tint(rect, rect_float, width, height, 128, 0.15f);
checker_board_grid_fill(rect, rect_float, width, height, 1.0f/4.0f);
checker_board_grid_fill(rect, rect_float, width, height, 1.0f / 4.0f);
checker_board_text(rect, rect_float, width, height, 128, 2);
}

505
source/blender/blenkernel/intern/library.c
View File

File diff suppressed because it is too large Load Diff

116
source/blender/blenkernel/intern/modifier.c
View File

@ -68,12 +68,12 @@
ModifierTypeInfo *modifierType_getInfo(ModifierType type)
{
static ModifierTypeInfo *types[NUM_MODIFIER_TYPES]= {NULL};
static ModifierTypeInfo *types[NUM_MODIFIER_TYPES] = {NULL};
static int types_init = 1;
if (types_init) {
modifier_type_init(types); /* MOD_utils.c */
types_init= 0;
types_init = 0;
}
/* type unsigned, no need to check < 0 */
@ -97,7 +97,7 @@ ModifierData *modifier_new(int type)
md->type = type;
md->mode = eModifierMode_Realtime
| eModifierMode_Render | eModifierMode_Expanded;
| eModifierMode_Render | eModifierMode_Expanded;
if (mti->flags & eModifierTypeFlag_EnableInEditmode)
md->mode |= eModifierMode_Editmode;
@ -137,8 +137,8 @@ int modifier_supportsMapping(ModifierData *md)
{
ModifierTypeInfo *mti = modifierType_getInfo(md->type);
return (mti->type==eModifierTypeType_OnlyDeform ||
(mti->flags & eModifierTypeFlag_SupportsMapping));
return (mti->type == eModifierTypeType_OnlyDeform ||
(mti->flags & eModifierTypeFlag_SupportsMapping));
}
int modifier_isPreview(ModifierData *md)
@ -158,8 +158,8 @@ ModifierData *modifiers_findByType(Object *ob, ModifierType type)
{
ModifierData *md = ob->modifiers.first;
for (; md; md=md->next)
if (md->type==type)
for (; md; md = md->next)
if (md->type == type)
break;
return md;
@ -175,7 +175,7 @@ void modifiers_clearErrors(Object *ob)
ModifierData *md = ob->modifiers.first;
/* int qRedraw = 0; */
for (; md; md=md->next) {
for (; md; md = md->next) {
if (md->error) {
MEM_freeN(md->error);
md->error = NULL;
@ -186,11 +186,11 @@ void modifiers_clearErrors(Object *ob)
}
void modifiers_foreachObjectLink(Object *ob, ObjectWalkFunc walk,
void *userData)
void *userData)
{
ModifierData *md = ob->modifiers.first;
for (; md; md=md->next) {
for (; md; md = md->next) {
ModifierTypeInfo *mti = modifierType_getInfo(md->type);
if (mti->foreachObjectLink)
@ -202,7 +202,7 @@ void modifiers_foreachIDLink(Object *ob, IDWalkFunc walk, void *userData)
{
ModifierData *md = ob->modifiers.first;
for (; md; md=md->next) {
for (; md; md = md->next) {
ModifierTypeInfo *mti = modifierType_getInfo(md->type);
if (mti->foreachIDLink) mti->foreachIDLink(md, ob, walk, userData);
@ -218,7 +218,7 @@ void modifiers_foreachTexLink(Object *ob, TexWalkFunc walk, void *userData)
{
ModifierData *md = ob->modifiers.first;
for (; md; md=md->next) {
for (; md; md = md->next) {
ModifierTypeInfo *mti = modifierType_getInfo(md->type);
if (mti->foreachTexLink)
@ -240,12 +240,12 @@ int modifier_couldBeCage(struct Scene *scene, ModifierData *md)
{
ModifierTypeInfo *mti = modifierType_getInfo(md->type);
md->scene= scene;
md->scene = scene;
return ( (md->mode & eModifierMode_Realtime) &&
(md->mode & eModifierMode_Editmode) &&
(!mti->isDisabled || !mti->isDisabled(md, 0)) &&
modifier_supportsMapping(md));
return ((md->mode & eModifierMode_Realtime) &&
(md->mode & eModifierMode_Editmode) &&
(!mti->isDisabled || !mti->isDisabled(md, 0)) &&
modifier_supportsMapping(md));
}
int modifier_sameTopology(ModifierData *md)
@ -269,7 +269,7 @@ void modifier_setError(ModifierData *md, const char *format, ...)
va_start(ap, format);
vsnprintf(buffer, sizeof(buffer), format, ap);
va_end(ap);
buffer[sizeof(buffer) - 1]= '\0';
buffer[sizeof(buffer) - 1] = '\0';
if (md->error)
MEM_freeN(md->error);
@ -287,19 +287,19 @@ void modifier_setError(ModifierData *md, const char *format, ...)
*/
int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *lastPossibleCageIndex_r, int virtual_)
{
ModifierData *md = (virtual_)? modifiers_getVirtualModifierList(ob): ob->modifiers.first;
ModifierData *md = (virtual_) ? modifiers_getVirtualModifierList(ob) : ob->modifiers.first;
int i, cageIndex = -1;
if (lastPossibleCageIndex_r) {
/* ensure the value is initialized */
*lastPossibleCageIndex_r= -1;
*lastPossibleCageIndex_r = -1;
}
/* Find the last modifier acting on the cage. */
for (i=0; md; i++, md=md->next) {
for (i = 0; md; i++, md = md->next) {
ModifierTypeInfo *mti = modifierType_getInfo(md->type);
md->scene= scene;
md->scene = scene;
if (!(md->mode & eModifierMode_Realtime)) continue;
if (!(md->mode & eModifierMode_Editmode)) continue;
@ -344,7 +344,7 @@ int modifier_isEnabled(struct Scene *scene, ModifierData *md, int required_mode)
{
ModifierTypeInfo *mti = modifierType_getInfo(md->type);
md->scene= scene;
md->scene = scene;
if ((md->mode & required_mode) != required_mode) return 0;
if (mti->isDisabled && mti->isDisabled(md, required_mode == eModifierMode_Render)) return 0;
@ -396,7 +396,7 @@ CDMaskLink *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierDat
}
/* reverse the list so it's in the correct order */
BLI_linklist_reverse((LinkNode**)&dataMasks);
BLI_linklist_reverse((LinkNode **)&dataMasks);
return dataMasks;
}
@ -431,19 +431,19 @@ ModifierData *modifiers_getVirtualModifierList(Object *ob)
if (init) {
md = modifier_new(eModifierType_Armature);
amd = *((ArmatureModifierData*) md);
amd = *((ArmatureModifierData *) md);
modifier_free(md);
md = modifier_new(eModifierType_Curve);
cmd = *((CurveModifierData*) md);
cmd = *((CurveModifierData *) md);
modifier_free(md);
md = modifier_new(eModifierType_Lattice);
lmd = *((LatticeModifierData*) md);
lmd = *((LatticeModifierData *) md);
modifier_free(md);
md = modifier_new(eModifierType_ShapeKey);
smd = *((ShapeKeyModifierData*) md);
smd = *((ShapeKeyModifierData *) md);
modifier_free(md);
amd.modifier.mode |= eModifierMode_Virtual;
@ -457,19 +457,19 @@ ModifierData *modifiers_getVirtualModifierList(Object *ob)
md = ob->modifiers.first;
if (ob->parent) {
if (ob->parent->type==OB_ARMATURE && ob->partype==PARSKEL) {
if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
amd.object = ob->parent;
amd.modifier.next = md;
amd.deformflag= ((bArmature *)(ob->parent->data))->deformflag;
amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
md = &amd.modifier;
}
else if (ob->parent->type==OB_CURVE && ob->partype==PARSKEL) {
else if (ob->parent->type == OB_CURVE && ob->partype == PARSKEL) {
cmd.object = ob->parent;
cmd.defaxis = ob->trackflag + 1;
cmd.modifier.next = md;
md = &cmd.modifier;
}
else if (ob->parent->type==OB_LATTICE && ob->partype==PARSKEL) {
else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
lmd.object = ob->parent;
lmd.modifier.next = md;
md = &lmd.modifier;
@ -479,9 +479,9 @@ ModifierData *modifiers_getVirtualModifierList(Object *ob)
/* shape key modifier, not yet for curves */
if (ELEM(ob->type, OB_MESH, OB_LATTICE) && ob_get_key(ob)) {
if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE))
smd.modifier.mode |= eModifierMode_Editmode|eModifierMode_OnCage;
smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
else
smd.modifier.mode &= ~eModifierMode_Editmode|eModifierMode_OnCage;
smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage;
smd.modifier.next = md;
md = &smd.modifier;
@ -496,12 +496,12 @@ ModifierData *modifiers_getVirtualModifierList(Object *ob)
Object *modifiers_isDeformedByArmature(Object *ob)
{
ModifierData *md = modifiers_getVirtualModifierList(ob);
ArmatureModifierData *amd= NULL;
ArmatureModifierData *amd = NULL;
/* return the first selected armature, this lets us use multiple armatures */
for (; md; md=md->next) {
if (md->type==eModifierType_Armature) {
amd = (ArmatureModifierData*) md;
for (; md; md = md->next) {
if (md->type == eModifierType_Armature) {
amd = (ArmatureModifierData *) md;
if (amd->object && (amd->object->flag & SELECT))
return amd->object;
}
@ -520,12 +520,12 @@ Object *modifiers_isDeformedByArmature(Object *ob)
Object *modifiers_isDeformedByLattice(Object *ob)
{
ModifierData *md = modifiers_getVirtualModifierList(ob);
LatticeModifierData *lmd= NULL;
LatticeModifierData *lmd = NULL;
/* return the first selected lattice, this lets us use multiple lattices */
for (; md; md=md->next) {
if (md->type==eModifierType_Lattice) {
lmd = (LatticeModifierData*) md;
for (; md; md = md->next) {
if (md->type == eModifierType_Lattice) {
lmd = (LatticeModifierData *) md;
if (lmd->object && (lmd->object->flag & SELECT))
return lmd->object;
}
@ -543,10 +543,10 @@ int modifiers_usesArmature(Object *ob, bArmature *arm)
{
ModifierData *md = modifiers_getVirtualModifierList(ob);
for (; md; md=md->next) {
if (md->type==eModifierType_Armature) {
ArmatureModifierData *amd = (ArmatureModifierData*) md;
if (amd->object && amd->object->data==arm)
for (; md; md = md->next) {
if (md->type == eModifierType_Armature) {
ArmatureModifierData *amd = (ArmatureModifierData *) md;
if (amd->object && amd->object->data == arm)
return 1;
}
}
@ -556,9 +556,9 @@ int modifiers_usesArmature(Object *ob, bArmature *arm)
int modifier_isCorrectableDeformed(ModifierData *md)
{
if (md->type==eModifierType_Armature)
if (md->type == eModifierType_Armature)
return 1;
if (md->type==eModifierType_ShapeKey)
if (md->type == eModifierType_ShapeKey)
return 1;
return 0;
@ -568,11 +568,11 @@ int modifiers_isCorrectableDeformed(Object *ob)
{
ModifierData *md = modifiers_getVirtualModifierList(ob);
for (; md; md=md->next) {
if (ob->mode==OB_MODE_EDIT && (md->mode & eModifierMode_Editmode)==0);
for (; md; md = md->next) {
if (ob->mode == OB_MODE_EDIT && (md->mode & eModifierMode_Editmode) == 0) ;
else
if (modifier_isCorrectableDeformed(md))
return 1;
if (modifier_isCorrectableDeformed(md))
return 1;
}
return 0;
}
@ -593,22 +593,22 @@ int modifiers_isPreview(Object *ob)
int modifiers_indexInObject(Object *ob, ModifierData *md_seek)
{
int i= 0;
int i = 0;
ModifierData *md;
for (md=ob->modifiers.first; (md && md_seek!=md); md=md->next, i++);
if (!md) return -1; /* modifier isn't in the object */
for (md = ob->modifiers.first; (md && md_seek != md); md = md->next, i++) ;
if (!md) return -1; /* modifier isn't in the object */
return i;
}
void modifier_freeTemporaryData(ModifierData *md)
{
if (md->type == eModifierType_Armature) {
ArmatureModifierData *amd= (ArmatureModifierData*)md;
ArmatureModifierData *amd = (ArmatureModifierData *)md;
if (amd->prevCos) {
MEM_freeN(amd->prevCos);
amd->prevCos= NULL;
amd->prevCos = NULL;
}
}
}
@ -625,7 +625,7 @@ void test_object_modifiers(Object *ob)
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Multires) {
MultiresModifierData *mmd = (MultiresModifierData*)md;
MultiresModifierData *mmd = (MultiresModifierData *)md;
multiresModifier_set_levels_from_disps(mmd, ob);
}

486
source/blender/blenkernel/intern/multires.c
View File

File diff suppressed because it is too large Load Diff

70
source/blender/blenkernel/intern/packedFile.c
View File

@ -73,17 +73,17 @@ int seekPackedFile(PackedFile *pf, int offset, int whence)
if (pf) {
oldseek = pf->seek;
switch (whence) {
case SEEK_CUR:
seek = oldseek + offset;
break;
case SEEK_END:
seek = pf->size + offset;
break;
case SEEK_SET:
seek = offset;
break;
default:
oldseek = -1;
case SEEK_CUR:
seek = oldseek + offset;
break;
case SEEK_END:
seek = pf->size + offset;
break;
case SEEK_SET:
seek = offset;
break;
default:
oldseek = -1;
}
if (seek < 0) {
seek = 0;
@ -133,15 +133,15 @@ int countPackedFiles(Main *bmain)
int count = 0;
// let's check if there are packed files...
for (ima=bmain->image.first; ima; ima=ima->id.next)
for (ima = bmain->image.first; ima; ima = ima->id.next)
if (ima->packedfile)
count++;
for (vf=bmain->vfont.first; vf; vf=vf->id.next)
for (vf = bmain->vfont.first; vf; vf = vf->id.next)
if (vf->packedfile)
count++;
for (sound=bmain->sound.first; sound; sound=sound->id.next)
for (sound = bmain->sound.first; sound; sound = sound->id.next)
if (sound->packedfile)
count++;
@ -176,7 +176,7 @@ PackedFile *newPackedFile(ReportList *reports, const char *filename, const char
/* render result has no filename and can be ignored
* any other files with no name can be ignored too */
if (filename[0]=='\0')
if (filename[0] == '\0')
return NULL;
//XXX waitcursor(1);
@ -189,7 +189,7 @@ PackedFile *newPackedFile(ReportList *reports, const char *filename, const char
// open the file
// and create a PackedFile structure
file= BLI_open(name, O_BINARY|O_RDONLY, 0);
file = BLI_open(name, O_BINARY | O_RDONLY, 0);
if (file <= 0) {
BKE_reportf(reports, RPT_ERROR, "Unable to pack file, source path not found: \"%s\"", name);
}
@ -222,23 +222,23 @@ void packAll(Main *bmain, ReportList *reports)
VFont *vf;
bSound *sound;
for (ima=bmain->image.first; ima; ima=ima->id.next) {
if (ima->packedfile == NULL && ima->id.lib==NULL) {
if (ima->source==IMA_SRC_FILE) {
for (ima = bmain->image.first; ima; ima = ima->id.next) {
if (ima->packedfile == NULL && ima->id.lib == NULL) {
if (ima->source == IMA_SRC_FILE) {
ima->packedfile = newPackedFile(reports, ima->name, ID_BLEND_PATH(bmain, &ima->id));
}
else if (ELEM(ima->source, IMA_SRC_SEQUENCE, IMA_SRC_MOVIE)) {
BKE_reportf(reports, RPT_WARNING, "Image '%s' skipped, movies and image sequences not supported.", ima->id.name+2);
BKE_reportf(reports, RPT_WARNING, "Image '%s' skipped, movies and image sequences not supported.", ima->id.name + 2);
}
}
}
for (vf=bmain->vfont.first; vf; vf=vf->id.next)
if (vf->packedfile == NULL && vf->id.lib==NULL && strcmp(vf->name, FO_BUILTIN_NAME) != 0)
for (vf = bmain->vfont.first; vf; vf = vf->id.next)
if (vf->packedfile == NULL && vf->id.lib == NULL && strcmp(vf->name, FO_BUILTIN_NAME) != 0)
vf->packedfile = newPackedFile(reports, vf->name, bmain->name);
for (sound=bmain->sound.first; sound; sound=sound->id.next)
if (sound->packedfile == NULL && sound->id.lib==NULL)
for (sound = bmain->sound.first; sound; sound = sound->id.next)
if (sound->packedfile == NULL && sound->id.lib == NULL)
sound->packedfile = newPackedFile(reports, sound->name, bmain->name);
}
@ -257,12 +257,12 @@ static char *find_new_name(char *name)
if (fop_exists(name)) {
for (number = 1; number <= 999; number++) {
BLI_snprintf(tempname, sizeof(tempname), "%s.%03d", name, number);
if (! fop_exists(tempname)) {
if (!fop_exists(tempname)) {
break;
}
}
}
len= strlen(tempname) + 1;
len = strlen(tempname) + 1;
newname = MEM_mallocN(len, "find_new_name");
memcpy(newname, tempname, len * sizeof(char));
return newname;
@ -275,7 +275,7 @@ int writePackedFile(ReportList *reports, const char *filename, PackedFile *pf, i
int ret_value = RET_OK;
char name[FILE_MAX];
char tempname[FILE_MAX];
/* void *data; */
/* void *data; */
if (guimode) {} //XXX waitcursor(1);
@ -285,7 +285,7 @@ int writePackedFile(ReportList *reports, const char *filename, PackedFile *pf, i
if (BLI_exists(name)) {
for (number = 1; number <= 999; number++) {
BLI_snprintf(tempname, sizeof(tempname), "%s.%03d_", name, number);
if (! BLI_exists(tempname)) {
if (!BLI_exists(tempname)) {
if (BLI_copy(name, tempname) == RET_OK) {
remove_tmp = TRUE;
}
@ -409,7 +409,7 @@ char *unpackFile(ReportList *reports, const char *abs_name, const char *local_na
case PF_KEEP:
break;
case PF_REMOVE:
temp= abs_name;
temp = abs_name;
break;
case PF_USE_LOCAL:
// if file exists use it
@ -417,7 +417,7 @@ char *unpackFile(ReportList *reports, const char *abs_name, const char *local_na
temp = local_name;
break;
}
// else fall through and create it
// else fall through and create it
case PF_WRITE_LOCAL:
if (writePackedFile(reports, local_name, pf, 1) == RET_OK) {
temp = local_name;
@ -429,7 +429,7 @@ char *unpackFile(ReportList *reports, const char *abs_name, const char *local_na
temp = abs_name;
break;
}
// else fall through and create it
// else fall through and create it
case PF_WRITE_ORIGINAL:
if (writePackedFile(reports, abs_name, pf, 1) == RET_OK) {
temp = abs_name;
@ -441,7 +441,7 @@ char *unpackFile(ReportList *reports, const char *abs_name, const char *local_na
}
if (temp) {
newname= BLI_strdup(temp);
newname = BLI_strdup(temp);
}
}
@ -533,15 +533,15 @@ void unpackAll(Main *bmain, ReportList *reports, int how)
VFont *vf;
bSound *sound;
for (ima=bmain->image.first; ima; ima=ima->id.next)
for (ima = bmain->image.first; ima; ima = ima->id.next)
if (ima->packedfile)
unpackImage(reports, ima, how);
for (vf=bmain->vfont.first; vf; vf=vf->id.next)
for (vf = bmain->vfont.first; vf; vf = vf->id.next)
if (vf->packedfile)
unpackVFont(reports, vf, how);
for (sound=bmain->sound.first; sound; sound=sound->id.next)
for (sound = bmain->sound.first; sound; sound = sound->id.next)
if (sound->packedfile)
unpackSound(bmain, reports, sound, how);
}

178
source/blender/blenkernel/intern/property.c
View File

@ -57,7 +57,7 @@ void free_properties(ListBase *lb)
{
bProperty *prop;
while ( (prop= lb->first) ) {
while ( (prop = lb->first) ) {
BLI_remlink(lb, prop);
free_property(prop);
}
@ -67,11 +67,11 @@ bProperty *copy_property(bProperty *prop)
{
bProperty *propn;
propn= MEM_dupallocN(prop);
propn = MEM_dupallocN(prop);
if (prop->poin && prop->poin != &prop->data) {
propn->poin= MEM_dupallocN(prop->poin);
propn->poin = MEM_dupallocN(prop->poin);
}
else propn->poin= &propn->data;
else propn->poin = &propn->data;
return propn;
}
@ -80,11 +80,11 @@ void copy_properties(ListBase *lbn, ListBase *lbo)
{
bProperty *prop, *propn;
free_properties(lbn); /* in case we are copying to an object with props */
prop= lbo->first;
prop = lbo->first;
while (prop) {
propn= copy_property(prop);
propn = copy_property(prop);
BLI_addtail(lbn, propn);
prop= prop->next;
prop = prop->next;
}
@ -95,20 +95,20 @@ void init_property(bProperty *prop)
/* also use when property changes type */
if (prop->poin && prop->poin != &prop->data) MEM_freeN(prop->poin);
prop->poin= NULL;
prop->poin = NULL;
prop->data= 0;
prop->data = 0;
switch (prop->type) {
case GPROP_BOOL:
case GPROP_INT:
case GPROP_FLOAT:
case GPROP_TIME:
prop->poin= &prop->data;
break;
case GPROP_STRING:
prop->poin= MEM_callocN(MAX_PROPSTRING, "property string");
break;
case GPROP_BOOL:
case GPROP_INT:
case GPROP_FLOAT:
case GPROP_TIME:
prop->poin = &prop->data;
break;
case GPROP_STRING:
prop->poin = MEM_callocN(MAX_PROPSTRING, "property string");
break;
}
}
@ -117,8 +117,8 @@ bProperty *new_property(int type)
{
bProperty *prop;
prop= MEM_callocN(sizeof(bProperty), "property");
prop->type= type;
prop = MEM_callocN(sizeof(bProperty), "property");
prop->type = type;
init_property(prop);
@ -131,8 +131,8 @@ bProperty *new_property(int type)
static bProperty *get_property__internal(bProperty *first, bProperty *self, const char *name)
{
bProperty *p;
for (p= first; p; p= p->next) {
if (p!=self && (strcmp(p->name, name)==0))
for (p = first; p; p = p->next) {
if (p != self && (strcmp(p->name, name) == 0))
return p;
}
return NULL;
@ -142,10 +142,10 @@ void unique_property(bProperty *first, bProperty *prop, int force)
bProperty *p;
/* set the first if its not set */
if (first==NULL) {
first= prop;
if (first == NULL) {
first = prop;
while (first->prev) {
first= first->prev;
first = first->prev;
}
}
@ -162,14 +162,14 @@ void unique_property(bProperty *first, bProperty *prop, int force)
char new_name[sizeof(prop->name)];
char base_name[sizeof(prop->name)];
char num[sizeof(prop->name)];
int i= 0;
int i = 0;
/* strip numbers */
BLI_strncpy(base_name, prop->name, sizeof(base_name));
for (i= strlen(base_name)-1; (i>=0 && isdigit(base_name[i])); i--) {
base_name[i]= '\0';
for (i = strlen(base_name) - 1; (i >= 0 && isdigit(base_name[i])); i--) {
base_name[i] = '\0';
}
i= 0;
i = 0;
do { /* ensure we have enough chars for the new number in the name */
BLI_snprintf(num, sizeof(num), "%d", i++);
@ -190,7 +190,7 @@ bProperty *get_ob_property(Object *ob, const char *name)
void set_ob_property(Object *ob, bProperty *propc)
{
bProperty *prop;
prop= get_ob_property(ob, propc->name);
prop = get_ob_property(ob, propc->name);
if (prop) {
free_property(prop);
BLI_remlink(&ob->prop, prop);
@ -207,32 +207,32 @@ int compare_property(bProperty *prop, const char *str)
float fvalue, ftest;
switch (prop->type) {
case GPROP_BOOL:
if (BLI_strcasecmp(str, "true")==0) {
if (prop->data==1) return 0;
else return 1;
}
else if (BLI_strcasecmp(str, "false")==0) {
if (prop->data==0) return 0;
else return 1;
}
case GPROP_BOOL:
if (BLI_strcasecmp(str, "true") == 0) {
if (prop->data == 1) return 0;
else return 1;
}
else if (BLI_strcasecmp(str, "false") == 0) {
if (prop->data == 0) return 0;
else return 1;
}
/* no break, do GPROP_int too! */
case GPROP_INT:
return prop->data - atoi(str);
case GPROP_INT:
return prop->data - atoi(str);
case GPROP_FLOAT:
case GPROP_TIME:
// WARNING: untested for GPROP_TIME
// function isn't used currently
fvalue= *((float *)&prop->data);
ftest= (float)atof(str);
if ( fvalue > ftest) return 1;
else if ( fvalue < ftest) return -1;
return 0;
case GPROP_FLOAT:
case GPROP_TIME:
// WARNING: untested for GPROP_TIME
// function isn't used currently
fvalue = *((float *)&prop->data);
ftest = (float)atof(str);
if (fvalue > ftest) return 1;
else if (fvalue < ftest) return -1;
return 0;
case GPROP_STRING:
return strcmp(prop->poin, str);
case GPROP_STRING:
return strcmp(prop->poin, str);
}
return 0;
@ -243,21 +243,21 @@ void set_property(bProperty *prop, const char *str)
// extern int Gdfra; /* sector.c */
switch (prop->type) {
case GPROP_BOOL:
if (BLI_strcasecmp(str, "true")==0) prop->data= 1;
else if (BLI_strcasecmp(str, "false")==0) prop->data= 0;
else prop->data= (atoi(str)!=0);
break;
case GPROP_INT:
prop->data= atoi(str);
break;
case GPROP_FLOAT:
case GPROP_TIME:
*((float *)&prop->data)= (float)atof(str);
break;
case GPROP_STRING:
strcpy(prop->poin, str); /* TODO - check size? */
break;
case GPROP_BOOL:
if (BLI_strcasecmp(str, "true") == 0) prop->data = 1;
else if (BLI_strcasecmp(str, "false") == 0) prop->data = 0;
else prop->data = (atoi(str) != 0);
break;
case GPROP_INT:
prop->data = atoi(str);
break;
case GPROP_FLOAT:
case GPROP_TIME:
*((float *)&prop->data) = (float)atof(str);
break;
case GPROP_STRING:
strcpy(prop->poin, str); /* TODO - check size? */
break;
}
}
@ -267,17 +267,17 @@ void add_property(bProperty *prop, const char *str)
// extern int Gdfra; /* sector.c */
switch (prop->type) {
case GPROP_BOOL:
case GPROP_INT:
prop->data+= atoi(str);
break;
case GPROP_FLOAT:
case GPROP_TIME:
*((float *)&prop->data)+= (float)atof(str);
break;
case GPROP_STRING:
/* strcpy(prop->poin, str); */
break;
case GPROP_BOOL:
case GPROP_INT:
prop->data += atoi(str);
break;
case GPROP_FLOAT:
case GPROP_TIME:
*((float *)&prop->data) += (float)atof(str);
break;
case GPROP_STRING:
/* strcpy(prop->poin, str); */
break;
}
}
@ -289,17 +289,17 @@ void set_property_valstr(bProperty *prop, char *str)
if (str == NULL) return;
switch (prop->type) {
case GPROP_BOOL:
case GPROP_INT:
sprintf(str, "%d", prop->data);
break;
case GPROP_FLOAT:
case GPROP_TIME:
sprintf(str, "%f", *((float *)&prop->data));
break;
case GPROP_STRING:
BLI_strncpy(str, prop->poin, MAX_PROPSTRING);
break;
case GPROP_BOOL:
case GPROP_INT:
sprintf(str, "%d", prop->data);
break;
case GPROP_FLOAT:
case GPROP_TIME:
sprintf(str, "%f", *((float *)&prop->data));
break;
case GPROP_STRING:
BLI_strncpy(str, prop->poin, MAX_PROPSTRING);
break;
}
}

14
source/blender/blenkernel/intern/texture.c
View File

@ -1492,7 +1492,7 @@ void BKE_free_pointdensity(PointDensity *pd)
/* ------------------------------------------------------------------------- */
void BKE_free_voxeldatadata(struct VoxelData *vd)
void BKE_free_voxeldatadata(VoxelData *vd)
{
if (vd->dataset) {
MEM_freeN(vd->dataset);
@ -1501,17 +1501,17 @@ void BKE_free_voxeldatadata(struct VoxelData *vd)
}
void BKE_free_voxeldata(struct VoxelData *vd)
void BKE_free_voxeldata(VoxelData *vd)
{
BKE_free_voxeldatadata(vd);
MEM_freeN(vd);
}
struct VoxelData *BKE_add_voxeldata(void)
VoxelData *BKE_add_voxeldata(void)
{
VoxelData *vd;
vd = MEM_callocN(sizeof(struct VoxelData), "voxeldata");
vd = MEM_callocN(sizeof(VoxelData), "voxeldata");
vd->dataset = NULL;
vd->resol[0] = vd->resol[1] = vd->resol[2] = 1;
vd->interp_type = TEX_VD_LINEAR;
@ -1525,7 +1525,7 @@ struct VoxelData *BKE_add_voxeldata(void)
return vd;
}
struct VoxelData *BKE_copy_voxeldata(struct VoxelData *vd)
VoxelData *BKE_copy_voxeldata(VoxelData *vd)
{
VoxelData *vdn;
@ -1537,7 +1537,7 @@ struct VoxelData *BKE_copy_voxeldata(struct VoxelData *vd)
/* ------------------------------------------------------------------------- */
struct OceanTex *BKE_add_oceantex(void)
OceanTex *BKE_add_oceantex(void)
{
OceanTex *ot;
@ -1548,7 +1548,7 @@ struct OceanTex *BKE_add_oceantex(void)
return ot;
}
struct OceanTex *BKE_copy_oceantex(struct OceanTex *ot)
OceanTex *BKE_copy_oceantex(struct OceanTex *ot)
{
OceanTex *otn = MEM_dupallocN(ot);