diff options
author | Joshua Leung <aligorith@gmail.com> | 2009-01-29 12:40:49 +0300 |
---|---|---|
committer | Joshua Leung <aligorith@gmail.com> | 2009-01-29 12:40:49 +0300 |
commit | 595983cd287c2910728022c01727a4db1d15ab23 (patch) | |
tree | f24da3cf0a6d3567c5ecc83d75ae46744858b688 /source/blender | |
parent | ca36e04362d1140fdc61bc052dd7b3dcc81545a0 (diff) |
Animato: Added base-code for converting the ugly old bitflag settings
Only object layers have been done for now. The implementation of this should provide a good indicator for how this should be done. Unforunately, the code for animating layer visibility is not that straightforward, since scene->base->layer (not set) settings need to be synchronised with the object->layer (set by Animato) settings.
Diffstat (limited to 'source/blender')
-rw-r--r-- | source/blender/blenkernel/BKE_fcurve.h | 1 | ||||
-rw-r--r-- | source/blender/blenkernel/intern/fcurve.c | 20 | ||||
-rw-r--r-- | source/blender/blenkernel/intern/ipo.c | 229 |
3 files changed, 200 insertions, 50 deletions
diff --git a/source/blender/blenkernel/BKE_fcurve.h b/source/blender/blenkernel/BKE_fcurve.h index bed909fd040..87c230eec91 100644 --- a/source/blender/blenkernel/BKE_fcurve.h +++ b/source/blender/blenkernel/BKE_fcurve.h @@ -25,6 +25,7 @@ void bezt_add_to_cfra_elem(ListBase *lb, struct BezTriple *bezt); /* ************** F-Curve Drivers ***************** */ void fcurve_free_driver(struct FCurve *fcu); +struct ChannelDriver *fcurve_copy_driver(struct ChannelDriver *driver); /* ************** F-Curve Modifiers *************** */ diff --git a/source/blender/blenkernel/intern/fcurve.c b/source/blender/blenkernel/intern/fcurve.c index bb627039639..bfc193254fe 100644 --- a/source/blender/blenkernel/intern/fcurve.c +++ b/source/blender/blenkernel/intern/fcurve.c @@ -106,7 +106,7 @@ FCurve *copy_fcurve (FCurve *fcu) fcu_d->rna_path= MEM_dupallocN(fcu_d->rna_path); /* copy driver */ - //fcurve_copy_driver(); + fcu_d->driver= fcurve_copy_driver(fcu_d->driver); /* copy modifiers */ fcurve_copy_modifiers(&fcu_d->modifiers, &fcu->modifiers); @@ -438,6 +438,24 @@ void fcurve_free_driver(FCurve *fcu) fcu->driver= NULL; } +/* This makes a copy of the given driver */ +ChannelDriver *fcurve_copy_driver (ChannelDriver *driver) +{ + ChannelDriver *ndriver; + + /* sanity checks */ + if (driver == NULL) + return NULL; + + /* copy all data */ + ndriver= MEM_dupallocN(driver); + ndriver->rna_path= MEM_dupallocN(ndriver->rna_path); + ndriver->rna_path2= MEM_dupallocN(ndriver->rna_path2); + + /* return the new driver */ + return ndriver; +} + /* Driver Evaluation -------------------------- */ /* Helper function to obtain a value using RNA from the specified source (for evaluating drivers) diff --git a/source/blender/blenkernel/intern/ipo.c b/source/blender/blenkernel/intern/ipo.c index 371d44cff2a..01ccf65bb46 100644 --- a/source/blender/blenkernel/intern/ipo.c +++ b/source/blender/blenkernel/intern/ipo.c @@ -115,6 +115,73 @@ void free_ipo (Ipo *ipo) /* *************************************************** */ /* ADRCODE to RNA-Path Conversion Code - Special (Bitflags) */ +/* Mapping Table for bitflag <-> RNA path */ +typedef struct AdrBit2Path { + int bit; + char *path; + int array_index; +} AdrBit2Path; + +/* ----------------- */ +/* Mapping Tables to use bits <-> RNA paths */ + +/* Object layers */ +static AdrBit2Path ob_layer_bits[]= { + {(1<<0), "layer", 0}, + {(1<<1), "layer", 1}, + {(1<<2), "layer", 2}, + {(1<<3), "layer", 3}, + {(1<<4), "layer", 4}, + {(1<<5), "layer", 5}, + {(1<<6), "layer", 6}, + {(1<<7), "layer", 7}, + {(1<<8), "layer", 8}, + {(1<<9), "layer", 9}, + {(1<<10), "layer", 10}, + {(1<<11), "layer", 11}, + {(1<<12), "layer", 12}, + {(1<<13), "layer", 13}, + {(1<<14), "layer", 14}, + {(1<<15), "layer", 15}, + {(1<<16), "layer", 16}, + {(1<<17), "layer", 17}, + {(1<<18), "layer", 18}, + {(1<<19), "layer", 19}, + {(1<<20), "layer", 20} +}; + +/* ----------------- */ + +/* This function checks if a Blocktype+Adrcode combo, returning a mapping table */ +static AdrBit2Path *adrcode_bitmaps_to_paths (int blocktype, int adrcode, int *tot) +{ + /* Object layers */ + if ((blocktype == ID_OB) && (adrcode == OB_LAY)) { + *tot= sizeof(ob_layer_bits)/sizeof(AdrBit2Path); + return ob_layer_bits; + } + else if ((blocktype == ID_MA) && (adrcode == MA_MODE)) { + // XXX to be added... + } + // XXX TODO: add other types... + + /* Normal curve */ + return NULL; +} + +/* This function makes a copy of a path stored in AdrBit2Path entry, and makes a guardedalloc copy */ +static char *adrcode_bitmap_path_copy (const char *abp_path) +{ + char *path; + int len; + + /* copy the path */ + len= strlen(abp_path) + 1; // XXX is this safe? + path= MEM_callocN(len, "Bitflag IPO-Curve RNA-Path"); + memcpy(path, abp_path, len); + + return path; +} /* *************************************************** */ /* ADRCODE to RNA-Path Conversion Code - Standard */ @@ -167,10 +234,6 @@ static char *ob_adrcodes_to_paths (int adrcode, int *array_index) *array_index= 2; return "delta_scale"; #if 0 - case OB_LAY: // XXX EVIL BITFLAG ALERT! this one will need special attention... - // poin= &(ob->lay); *type= IPO_INT_BIT; break; - return NULL; - case OB_COL_R: poin= &(ob->col[0]); break; case OB_COL_G: @@ -421,8 +484,6 @@ static char *material_adrcodes_to_paths (int adrcode, int *array_index) poin= &(ma->spectra); break; case MA_IOR: poin= &(ma->ang); break; - case MA_MODE: - poin= &(ma->mode); *type= IPO_INT_BIT; break; // evil... dumping bitflags directly to user! case MA_HASIZE: poin= &(ma->hasize); break; case MA_TRANSLU: @@ -799,8 +860,9 @@ static ChannelDriver *idriver_to_cdriver (IpoDriver *idriver) */ static void icu_to_fcurves (ListBase *list, IpoCurve *icu, char *actname, char *constname) { + AdrBit2Path *abp; FCurve *fcu; - int i= 0; + int i=0, totbits; /* allocate memory for a new F-Curve */ fcu= MEM_callocN(sizeof(FCurve), "FCurve"); @@ -849,58 +911,127 @@ static void icu_to_fcurves (ListBase *list, IpoCurve *icu, char *actname, char * /* -------- */ - /* get rna-path - * - we will need to set the 'disabled' flag if no path is able to be made (for now) - */ - fcu->rna_path= get_rna_access(icu->blocktype, icu->adrcode, actname, constname, &fcu->array_index); - if (fcu->rna_path == NULL) - fcu->flag |= FCURVE_DISABLED; - - /* convert keyframes - * - beztriples and bpoints are mutually exclusive, so we won't have both at the same time - * - beztriples are more likely to be encountered as they are keyframes (the other type wasn't used yet) - */ - // XXX we need to cope with the nasty old 'bitflag' curves... that will be a task for later - // XXX we also need to correct values for object-rotation curves - fcu->totvert= icu->totvert; - - if (icu->bezt) { - BezTriple *dst, *src; + /* get adrcode <-> bitflags mapping to handle nasty bitflag curves? */ + abp= adrcode_bitmaps_to_paths(icu->blocktype, icu->adrcode, &totbits); + if (abp && totbits) { + FCurve *fcurve; + int b; + + printf("\tconvert bitflag ipocurve, totbits = %d \n", totbits); - /* allocate new array for keyframes/beztriples */ - fcu->bezt= MEM_callocN(sizeof(BezTriple)*fcu->totvert, "BezTriples"); + /* add the 'only int values' flag */ + fcu->flag |= FCURVE_INT_VALUES; - /* loop through copying all BezTriples individually, as we need to modify a few things */ - for (dst=fcu->bezt, src=icu->bezt; i < fcu->totvert; i++, dst++, src++) { - /* firstly, copy BezTriple data */ - *dst= *src; + /* for each bit we have to remap + check for: + * 1) we need to make copy the existing F-Curve data (fcu -> fcurve), + * except for the last one which will use the original + * 2) copy the relevant path info across + * 3) filter the keyframes for the flag of interest + */ + for (b=0; b < totbits; b++, abp++) { + /* make a copy of existing base-data if not the last curve */ + if (b < (totbits-1)) + fcurve= copy_fcurve(fcu); + else + fcurve= fcu; + + /* set path */ + fcurve->rna_path= MEM_dupallocN(abp->path); + fcurve->array_index= abp->array_index; + + /* convert keyframes + * - beztriples and bpoints are mutually exclusive, so we won't have both at the same time + * - beztriples are more likely to be encountered as they are keyframes (the other type wasn't used yet) + */ + fcurve->totvert= icu->totvert; - /* now copy interpolation from curve (if not already set) */ - if (icu->ipo != IPO_MIXED) - dst->ipo= icu->ipo; + if (icu->bezt) { + BezTriple *dst, *src; - /* correct values for object rotation curves - they were degrees/10 */ - // XXX for now, just make them into radians as RNA sets/reads directly in that form - if ((icu->blocktype == ID_OB) && ELEM3(icu->adrcode, OB_ROT_X, OB_ROT_Y, OB_ROT_Z)) { - const float fac= M_PI / 18.0f; //10.0f * M_PI/180.0f; + /* allocate new array for keyframes/beztriples */ + fcurve->bezt= MEM_callocN(sizeof(BezTriple)*fcurve->totvert, "BezTriples"); - dst->vec[0][1] *= fac; - dst->vec[1][1] *= fac; - dst->vec[2][1] *= fac; + /* loop through copying all BezTriples individually, as we need to modify a few things */ + for (dst=fcurve->bezt, src=icu->bezt; i < fcurve->totvert; i++, dst++, src++) { + /* firstly, copy BezTriple data */ + *dst= *src; + + /* interpolation can only be constant... */ + dst->ipo= BEZT_IPO_CONST; + + /* correct values, by checking if the flag of interest is set */ + if ( ((int)(dst->vec[1][1])) & (abp->bit) ) + dst->vec[0][1]= dst->vec[1][1]= dst->vec[2][1] = 1.0f; + else + dst->vec[0][1]= dst->vec[1][1]= dst->vec[2][1] = 0.0f; + } + } + else if (icu->bp) { + /* TODO: need to convert from BPoint type to the more compact FPoint type... but not priority, since no data used this */ + //BPoint *bp; + //FPoint *fpt; } + + /* add new F-Curve to list */ + BLI_addtail(list, fcurve); } - /* free this data now */ - MEM_freeN(icu->bezt); + /* free old data of curve now that it's no longer needed for converting any more curves */ + if (icu->bezt) MEM_freeN(icu->bezt); + if (icu->bp) MEM_freeN(icu->bezt); } - else if (icu->bp) { - /* TODO: need to convert from BPoint type to the more compact FPoint type... but not priority, since no data used this */ - //BPoint *bp; - //FPoint *fpt; + else { + /* get rna-path + * - we will need to set the 'disabled' flag if no path is able to be made (for now) + */ + fcu->rna_path= get_rna_access(icu->blocktype, icu->adrcode, actname, constname, &fcu->array_index); + if (fcu->rna_path == NULL) + fcu->flag |= FCURVE_DISABLED; + + /* convert keyframes + * - beztriples and bpoints are mutually exclusive, so we won't have both at the same time + * - beztriples are more likely to be encountered as they are keyframes (the other type wasn't used yet) + */ + fcu->totvert= icu->totvert; + + if (icu->bezt) { + BezTriple *dst, *src; + + /* allocate new array for keyframes/beztriples */ + fcu->bezt= MEM_callocN(sizeof(BezTriple)*fcu->totvert, "BezTriples"); + + /* loop through copying all BezTriples individually, as we need to modify a few things */ + for (dst=fcu->bezt, src=icu->bezt; i < fcu->totvert; i++, dst++, src++) { + /* firstly, copy BezTriple data */ + *dst= *src; + + /* now copy interpolation from curve (if not already set) */ + if (icu->ipo != IPO_MIXED) + dst->ipo= icu->ipo; + + /* correct values for object rotation curves - they were degrees/10 */ + // XXX for now, just make them into radians as RNA sets/reads directly in that form + if ((icu->blocktype == ID_OB) && ELEM3(icu->adrcode, OB_ROT_X, OB_ROT_Y, OB_ROT_Z)) { + const float fac= M_PI / 18.0f; //10.0f * M_PI/180.0f; + + dst->vec[0][1] *= fac; + dst->vec[1][1] *= fac; + dst->vec[2][1] *= fac; + } + } + + /* free this data now */ + MEM_freeN(icu->bezt); + } + else if (icu->bp) { + /* TODO: need to convert from BPoint type to the more compact FPoint type... but not priority, since no data used this */ + //BPoint *bp; + //FPoint *fpt; + } + + /* add new F-Curve to list */ + BLI_addtail(list, fcu); } - - /* add new F-Curve to list */ - BLI_addtail(list, fcu); } /* ------------------------- */ |