/* implementation */
-void *avi_converter_from_avi_rgb (AviMovie *movie, int stream, unsigned char *buffer, int *size) {
+void *avi_converter_from_avi_rgb (AviMovie *movie, int stream, unsigned char *buffer, int *size)
+{
int x, y,i, rowstride;
unsigned char *buf;
AviBitmapInfoHeader *bi;
}
}
-void *avi_converter_to_avi_rgb (AviMovie *movie, int stream, unsigned char *buffer, int *size) {
+void *avi_converter_to_avi_rgb (AviMovie *movie, int stream, unsigned char *buffer, int *size)
+{
int y, x, i, rowstride;
unsigned char *buf;
else
return 0;
}
-static BoidState *get_boid_state(BoidSettings *boids, ParticleData *pa) {
+static BoidState *get_boid_state(BoidSettings *boids, ParticleData *pa)
+{
BoidState *state = boids->states.first;
BoidParticle *bpa = pa->boid;
return collpair;
}
-static void machine_epsilon_offset(Cloth *cloth) {
+static void machine_epsilon_offset(Cloth *cloth)
+{
ClothVertex *cv;
int i, j;
static short CTI_INIT= 1; /* when non-zero, the list needs to be updated */
/* This function only gets called when CTI_INIT is non-zero */
-static void constraints_init_typeinfo (void) {
+static void constraints_init_typeinfo (void)
+{
constraintsTypeInfo[0]= NULL; /* 'Null' Constraint */
constraintsTypeInfo[1]= &CTI_CHILDOF; /* ChildOf Constraint */
constraintsTypeInfo[2]= &CTI_TRACKTO; /* TrackTo Constraint */
}
/* add Orco layer to the displist object which has got derived mesh and return orco */
-float *makeOrcoDispList(Scene *scene, Object *ob, DerivedMesh *derivedFinal, int forRender) {
+float *makeOrcoDispList(Scene *scene, Object *ob, DerivedMesh *derivedFinal, int forRender)
+{
float *orco;
if (derivedFinal == NULL)
return idtype_from_code(code)?1:0;
}
-int BKE_idcode_is_linkable(int code) {
+int BKE_idcode_is_linkable(int code)
+{
IDType *idt= idtype_from_code(code);
return idt?(idt->flags&IDTYPE_FLAGS_ISLINKABLE):0;
}
}
}
-float give_timeoffset(Object *ob) {
+float give_timeoffset(Object *ob)
+{
if ((ob->ipoflag & OB_OFFS_PARENTADD) && ob->parent) {
return ob->sf + give_timeoffset(ob->parent);
} else {
}
}
-int give_obdata_texspace(Object *ob, short **texflag, float **loc, float **size, float **rot) {
+int give_obdata_texspace(Object *ob, short **texflag, float **loc, float **size, float **rot)
+{
if (ob->data==NULL)
return 0;
sprintf(str, "%is", ((int)dtime) % 60);
}
-static void *ptcache_bake_thread(void *ptr) {
+static void *ptcache_bake_thread(void *ptr)
+{
int usetimer = 0, sfra, efra;
double stime, ptime, ctime, fetd;
char run[32], cur[32], etd[32];
left and right are the bounds at which the sequence is rendered,
start and end are from the start and fixed length of the sequence.
*/
-int seq_tx_get_start(Sequence *seq) {
+int seq_tx_get_start(Sequence *seq)
+{
return seq->start;
}
int seq_tx_get_end(Sequence *seq)
/*********************************/
/* Creates and adds a marker to the list maintaining sorted order */
-void txt_add_marker(Text *text, TextLine *line, int start, int end, const unsigned char color[4], int group, int flags) {
+void txt_add_marker(Text *text, TextLine *line, int start, int end, const unsigned char color[4], int group, int flags)
+{
TextMarker *tmp, *marker;
marker= MEM_mallocN(sizeof(TextMarker), "text_marker");
/* Clears all markers on the specified line between two points. If the group or
flags fields are non-zero the returned flag must be in the specified group
and have at least the specified flags set. */
-short txt_clear_marker_region(Text *text, TextLine *line, int start, int end, int group, int flags) {
+short txt_clear_marker_region(Text *text, TextLine *line, int start, int end, int group, int flags)
+{
TextMarker *marker, *next;
int lineno= txt_get_span(text->lines.first, line);
short cleared= 0;
/* Clears all markers in the specified group (if given) with at least the
specified flags set. Useful for clearing temporary markers (group=0,
flags=TMARK_TEMP) */
-short txt_clear_markers(Text *text, int group, int flags) {
+short txt_clear_markers(Text *text, int group, int flags)
+{
TextMarker *marker, *next;
short cleared= 0;
********************************************************************** */
/* Get the output filename-- similar to the other output formats */
-void filepath_ffmpeg(char* string, RenderData* rd) {
+void filepath_ffmpeg(char* string, RenderData* rd)
+{
char autosplit[20];
const char ** exts = get_file_extensions(rd->ffcodecdata.type);
int *passes;
};
-static unsigned int case_strhash(const void *ptr) {
+static unsigned int case_strhash(const void *ptr)
+{
const char *s= ptr;
unsigned int i= 0;
unsigned char c;
/***/
-DynStr *BLI_dynstr_new(void) {
+DynStr *BLI_dynstr_new(void)
+{
DynStr *ds= MEM_mallocN(sizeof(*ds), "DynStr");
ds->elems= ds->last= NULL;
ds->curlen= 0;
return ds;
}
-void BLI_dynstr_append(DynStr *ds, const char *cstr) {
+void BLI_dynstr_append(DynStr *ds, const char *cstr)
+{
DynStrElem *dse= malloc(sizeof(*dse));
int cstrlen= strlen(cstr);
}
}
-int BLI_dynstr_get_len(DynStr *ds) {
+int BLI_dynstr_get_len(DynStr *ds)
+{
return ds->curlen;
}
//after a call to this function you can expect one of:
// every node to left of a[n] are smaller or equal to it
// every node to the right of a[n] are greater or equal to it
-static int partition_nth_element(BVHNode **a, int _begin, int _end, int n, int axis){
+static int partition_nth_element(BVHNode **a, int _begin, int _end, int n, int axis)
+{
int begin = _begin, end = _end, cut;
while(end-begin > 3)
{
}
}
-int BLI_bpathIterator_isDone( struct BPathIterator *bpi) {
+int BLI_bpathIterator_isDone( struct BPathIterator *bpi)
+{
return bpi->type==BPATH_DONE;
}
}
/* high level function */
-void checkMissingFiles(Main *bmain, ReportList *reports) {
+void checkMissingFiles(Main *bmain, ReportList *reports)
+{
struct BPathIterator *bpi;
/* be sure there is low chance of the path being too short */
}
/* dont log any errors at the moment, should probably do this */
-void makeFilesRelative(Main *bmain, const char *basedir, ReportList *reports) {
+void makeFilesRelative(Main *bmain, const char *basedir, ReportList *reports)
+{
int tot= 0, changed= 0, failed= 0, linked= 0;
struct BPathIterator *bpi;
char filepath[FILE_MAX];
}
/* high level function - call from fileselector */
-void findMissingFiles(Main *bmain, const char *str) {
+void findMissingFiles(Main *bmain, const char *str)
+{
struct BPathIterator *bpi;
/* be sure there is low chance of the path being too short */
/* from python 3.1 floatobject.c
* ndigits must be between 0 and 21 */
-double double_round(double x, int ndigits) {
+double double_round(double x, int ndigits)
+{
double pow1, pow2, y, z;
if (ndigits >= 0) {
pow1 = pow(10.0, (double)ndigits);
/* This is now only used to really get the user's default document folder */
/* On Windows I chose the 'Users/<MyUserName>/Documents' since it's used
as default location to save documents */
-const char *BLI_getDefaultDocumentFolder(void) {
+const char *BLI_getDefaultDocumentFolder(void)
+{
#if !defined(WIN32)
return getenv("HOME");
}
}
-void BLI_make_exist(char *dir) {
+void BLI_make_exist(char *dir)
+{
int a;
BLI_char_switch(dir, ALTSEP, SEP);
return 1;
}
-char *BLI_first_slash(char *string) {
+char *BLI_first_slash(char *string)
+{
char *ffslash, *fbslash;
ffslash= strchr(string, '/');
else return fbslash;
}
-char *BLI_last_slash(const char *string) {
+char *BLI_last_slash(const char *string)
+{
char *lfslash, *lbslash;
lfslash= strrchr(string, '/');
}
/* adds a slash if there isnt one there already */
-int BLI_add_slash(char *string) {
+int BLI_add_slash(char *string)
+{
int len = strlen(string);
#ifdef WIN32
if (len==0 || string[len-1]!='\\') {
}
/* removes a slash if there is one */
-void BLI_del_slash(char *string) {
+void BLI_del_slash(char *string)
+{
int len = strlen(string);
while (len) {
#ifdef WIN32
}
/* would be better in fileops.c except that it needs stat.h so add here */
-int BLI_is_dir(const char *file) {
+int BLI_is_dir(const char *file)
+{
return S_ISDIR(BLI_exist(file));
}
#include "BLI_dynstr.h"
#include "BLI_string.h"
-char *BLI_strdupn(const char *str, const size_t len) {
+char *BLI_strdupn(const char *str, const size_t len)
+{
char *n= MEM_mallocN(len+1, "strdup");
memcpy(n, str, len);
n[len]= '\0';
return n;
}
-char *BLI_strdup(const char *str) {
+char *BLI_strdup(const char *str)
+{
return BLI_strdupn(str, strlen(str));
}
return n;
}
-char *BLI_strncpy(char *dst, const char *src, const size_t maxncpy) {
+char *BLI_strncpy(char *dst, const char *src, const size_t maxncpy)
+{
size_t srclen= strlen(src);
size_t cpylen= (srclen>(maxncpy-1))?(maxncpy-1):srclen;
if (n != -1 && n < count) {
buffer[n] = '\0';
- } else {
+ }
+ else {
buffer[count-1] = '\0';
}
}
-int BLI_strcasecmp(const char *s1, const char *s2) {
+int BLI_strcasecmp(const char *s1, const char *s2)
+{
int i;
for (i=0; ; i++) {
return 0;
}
-int BLI_strncasecmp(const char *s1, const char *s2, size_t len) {
+int BLI_strncasecmp(const char *s1, const char *s2, size_t len)
+{
int i;
for (i=0; i<len; i++) {
return tslot->do_thread(tslot->callerdata);
}
-int BLI_thread_is_main(void) {
+int BLI_thread_is_main(void)
+{
return pthread_equal(pthread_self(), mainid);
}
return names;
}
-void BLO_blendhandle_close(BlendHandle *bh) {
+void BLO_blendhandle_close(BlendHandle *bh)
+{
FileData *fd= (FileData*) bh;
blo_freefiledata(fd);
//sets the rna_path and array index to curve
-void AnimationImporter::modify_fcurve(std::vector<FCurve*>* curves , char* rna_path , int array_index )
+void AnimationImporter::modify_fcurve(std::vector<FCurve*>* curves , const char* rna_path , int array_index )
{
std::vector<FCurve*>::iterator it;
int i;
int setAnimType ( const COLLADAFW::Animatable * prop , int type, int addition);
- void modify_fcurve(std::vector<FCurve*>* curves , char* rna_path , int array_index );
+ void modify_fcurve(std::vector<FCurve*>* curves , const char* rna_path , int array_index );
// prerequisites:
// animlist_map - map animlist id -> animlist
// curve_map - map anim id -> curve(s)
return nu;
}
-static int curvesurf_prim_add(bContext *C, wmOperator *op, int type, int isSurf) {
-
+static int curvesurf_prim_add(bContext *C, wmOperator *op, int type, int isSurf)
+{
Object *obedit= CTX_data_edit_object(C);
ListBase *editnurb;
Nurb *nu;
return OPERATOR_FINISHED;
}
-static int curve_prim_add(bContext *C, wmOperator *op, int type) {
+static int curve_prim_add(bContext *C, wmOperator *op, int type)
+{
return curvesurf_prim_add(C, op, type, 0);
}
-static int surf_prim_add(bContext *C, wmOperator *op, int type) {
+static int surf_prim_add(bContext *C, wmOperator *op, int type)
+{
return curvesurf_prim_add(C, op, type, 1);
}
* otherwise return -1.
* (1<<findBitIndex(x))==x for powers of two.
*/
-static int findBitIndex(unsigned int x) {
+static int findBitIndex(unsigned int x)
+{
if (!x || (x&(x-1))!=0) { /* x&(x-1) strips lowest bit */
return -1;
} else {
finish_images(bkr);
}
-static int multiresbake_check(bContext *C, wmOperator *op) {
+static int multiresbake_check(bContext *C, wmOperator *op)
+{
Scene *scene= CTX_data_scene(C);
Object *ob;
Mesh *me;
It returns the number that it added (0-2)
It relies on verts having -1 for unassigned indices
*/
-static int tryToAddVerts(int *verts, int length, int a, int b) {
+static int tryToAddVerts(int *verts, int length, int a, int b)
+{
char containsA = FALSE;
char containsB = FALSE;
int added = 0;
count is an int passed by reference so it can be assigned the value of the length here.
*/
-static int* getSurroundingVerts(Mesh *me, int vert, int *count) {
+static int* getSurroundingVerts(Mesh *me, int vert, int *count)
+{
int length = 0;
int *tverts;
int *verts = NULL;
/* get a single point in space by averaging a point cloud (vectors of size 3)
coord is the place the average is stored, points is the point cloud, count is the number of points in the cloud
*/
-static void getSingleCoordinate(MVert *points, int count, float coord[3]) {
+static void getSingleCoordinate(MVert *points, int count, float coord[3])
+{
int i;
zero_v3(coord);
for(i = 0; i < count; i++) {
}
/* distance of two vectors a and b of size length */
-static float distance(float* a, float *b, int length) {
+static float distance(float* a, float *b, int length)
+{
int i;
float sum = 0;
for(i = 0; i < length; i++) {
compute the amount of vertical distance relative to the plane and store it in dists,
then get the horizontal and vertical change and store them in changes
*/
-static void getVerticalAndHorizontalChange(float *norm, float d, float *coord, float *start, float distToStart, float *end, float (*changes)[2], float *dists, int index) {
+static void getVerticalAndHorizontalChange(float *norm, float d, float *coord, float *start, float distToStart, float *end, float (*changes)[2], float *dists, int index)
+{
// A=Q-((Q-P).N)N
// D = (a*x0 + b*y0 +c*z0 +d)
float projA[3] = {0}, projB[3] = {0};
}
// I need the derived mesh to be forgotten so the positions are recalculated with weight changes (see dm_deform_recalc)
-static void dm_deform_clear(DerivedMesh *dm, Object *ob) {
+static void dm_deform_clear(DerivedMesh *dm, Object *ob)
+{
if(ob->derivedDeform && (ob->derivedDeform)==dm) {
ob->derivedDeform->needsFree = 1;
ob->derivedDeform->release(ob->derivedDeform);
}
// recalculate the deformation
-static DerivedMesh* dm_deform_recalc(Scene *scene, Object *ob) {
+static DerivedMesh* dm_deform_recalc(Scene *scene, Object *ob)
+{
return mesh_get_derived_deform(scene, ob, CD_MASK_BAREMESH);
}
norm and d are the plane's properties for the equation: ax + by + cz + d = 0
coord is a point on the plane
*/
-static void moveCloserToDistanceFromPlane(Scene *scene, Object *ob, Mesh *me, int index, float norm[3], float coord[3], float d, float distToBe, float strength, float cp) {
+static void moveCloserToDistanceFromPlane(Scene *scene, Object *ob, Mesh *me, int index, float norm[3], float coord[3], float d, float distToBe, float strength, float cp)
+{
DerivedMesh *dm;
MDeformWeight *dw;
MVert m;
set_inverted_drawing(0);
}
-void glutil_draw_filled_arc(float start, float angle, float radius, int nsegments) {
+void glutil_draw_filled_arc(float start, float angle, float radius, int nsegments)
+{
int i;
glBegin(GL_TRIANGLE_FAN);
glEnd();
}
-void glutil_draw_lined_arc(float start, float angle, float radius, int nsegments) {
+void glutil_draw_lined_arc(float start, float angle, float radius, int nsegments)
+{
int i;
glBegin(GL_LINE_STRIP);
}
}
-int bglPointHack(void) {
+int bglPointHack(void)
+{
float value[4];
int pointhack_px;
glGetFloatv(GL_POINT_SIZE_RANGE, value);
/* Clip the face by a bucket and set the uv-space bucket_bounds_uv
* so we have the clipped UV's to do pixel intersection tests with
* */
-static int float_z_sort_flip(const void *p1, const void *p2) {
+static int float_z_sort_flip(const void *p1, const void *p2)
+{
return (((float *)p1)[2] < ((float *)p2)[2] ? 1:-1);
}
-static int float_z_sort(const void *p1, const void *p2) {
+static int float_z_sort(const void *p1, const void *p2)
+{
return (((float *)p1)[2] < ((float *)p2)[2] ?-1:1);
}
}
}
-static void do_projectpaint_draw_f(ProjPaintState *ps, ProjPixel *projPixel, float *rgba, float alpha, float mask, int use_color_correction) {
+static void do_projectpaint_draw_f(ProjPaintState *ps, ProjPixel *projPixel, float *rgba, float alpha, float mask, int use_color_correction)
+{
if (ps->is_texbrush) {
/* rgba already holds a texture result here from higher level function */
float rgba_br[3];
else return BLI_natstrcmp(entry1->relname,entry2->relname);
}
-static int compare_extension(const void *a1, const void *a2) {
+static int compare_extension(const void *a1, const void *a2)
+{
const struct direntry *entry1=a1, *entry2=a2;
const char *sufix1, *sufix2;
const char *nil="";
}
/* ****************** Delete with reconnect ******************* */
-static int is_connected_to_input_socket(bNode* node, bNodeLink* link) {
+static int is_connected_to_input_socket(bNode* node, bNodeLink* link)
+{
bNodeSocket *sock;
if (link->tonode == node) {
for(sock= node->inputs.first; sock; sock= sock->next) {
/* run recursivly to select linked */
-static int select_more_less_seq__internal(Scene *scene, int sel, int linked) {
+static int select_more_less_seq__internal(Scene *scene, int sel, int linked)
+{
Editing *ed= seq_give_editing(scene, FALSE);
Sequence *seq, *neighbor;
int change=0;
}
}
-static void drawSelectedVertices(DerivedMesh *dm, Mesh *me) {
+static void drawSelectedVertices(DerivedMesh *dm, Mesh *me)
+{
glBegin(GL_POINTS);
dm->foreachMappedVert(dm, drawSelectedVertices__mapFunc, me->mvert);
glEnd();
recalcData(t);
}
-static void restoreElement(TransData *td) {
+static void restoreElement(TransData *td)
+{
/* TransData for crease has no loc */
if (td->loc) {
copy_v3_v3(td->loc, td->iloc);
output[1] *= mi->factor;
}
-static void InputHorizontalRatio(TransInfo *t, MouseInput *mi, const int mval[2], float output[3]) {
+static void InputHorizontalRatio(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
+{
float x, pad;
pad = t->ar->winx / 10;
output[0] = (x - pad) / (t->ar->winx - 2 * pad);
}
-static void InputHorizontalAbsolute(TransInfo *t, MouseInput *mi, const int mval[2], float output[3]) {
+static void InputHorizontalAbsolute(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
+{
float vec[3];
InputVector(t, mi, mval, vec);
output[0] = dot_v3v3(t->viewinv[0], vec) * 2.0f;
}
-static void InputVerticalRatio(TransInfo *t, MouseInput *mi, const int mval[2], float output[3]) {
+static void InputVerticalRatio(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
+{
float y, pad;
pad = t->ar->winy / 10;
output[0] = (y - pad) / (t->ar->winy - 2 * pad);
}
-static void InputVerticalAbsolute(TransInfo *t, MouseInput *mi, const int mval[2], float output[3]) {
+static void InputVerticalAbsolute(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
+{
float vec[3];
InputVector(t, mi, mval, vec);
return retval;
}
-static int snapObjects(Scene *scene, View3D *v3d, ARegion *ar, Object *obedit, float mval[2], int *dist, float *loc, float *no, SnapMode mode) {
+static int snapObjects(Scene *scene, View3D *v3d, ARegion *ar, Object *obedit, float mval[2], int *dist, float *loc, float *no, SnapMode mode)
+{
Base *base;
float depth = FLT_MAX;
int retval = 0;
static void applyGrid(TransInfo *t, float *val, int max_index, float fac[3], GearsType action);
-void snapGridAction(TransInfo *t, float *val, GearsType action) {
+void snapGridAction(TransInfo *t, float *val, GearsType action)
+{
float fac[3];
fac[NO_GEARS] = t->snap[0];
}
-void snapGrid(TransInfo *t, float *val) {
+void snapGrid(TransInfo *t, float *val)
+{
GearsType action;
// Only do something if using Snap to Grid
GLStates |= GPU_BUFFER_VERTEX_STATE;
}
-static int GPU_typesize(int type) {
+static int GPU_typesize(int type)
+{
switch(type) {
case GL_FLOAT:
return sizeof(float);
}
}
-int GPU_attrib_element_size(GPUAttrib data[], int numdata) {
+int GPU_attrib_element_size(GPUAttrib data[], int numdata)
+{
int i, elementsize = 0;
for(i = 0; i < numdata; i++) {
return elementsize;
}
-void GPU_interleaved_attrib_setup(GPUBuffer *buffer, GPUAttrib data[], int numdata) {
+void GPU_interleaved_attrib_setup(GPUBuffer *buffer, GPUAttrib data[], int numdata)
+{
int i;
int elementsize;
intptr_t offset = 0;
return(ret_val);
}
-int imb_is_a_bmp(unsigned char *buf) {
-
+int imb_is_a_bmp(unsigned char *buf)
+{
return checkbmp(buf);
}
}
/* Found write info at http://users.ece.gatech.edu/~slabaugh/personal/c/bitmapUnix.c */
-int imb_savebmp(struct ImBuf *ibuf, const char *name, int flags) {
-
+int imb_savebmp(struct ImBuf *ibuf, const char *name, int flags)
+{
BMPINFOHEADER infoheader;
int bytesize, extrabytes, x, y, t, ptr;
uchar *data;
*/
/* function assumes out to be zero'ed, only does RGBA */
-static float P(float k){
+static float P(float k)
+{
float p1, p2, p3, p4;
p1 = MAX2(k+2.0f,0);
p2 = MAX2(k+1.0f,0);
#if 0
/* older, slower function, works the same as above */
-static float P(float k){
+static float P(float k)
+{
return (float)(1.0f/6.0f)*( pow( MAX2(k+2.0f,0) , 3.0f ) - 4.0f * pow( MAX2(k+1.0f,0) , 3.0f ) + 6.0f * pow( MAX2(k,0) , 3.0f ) - 4.0f * pow( MAX2(k-1.0f,0) , 3.0f));
}
#endif
return rval;
}
-static int parse_num(indexer_dv_bitstream * b, int numbits) {
+static int parse_num(indexer_dv_bitstream * b, int numbits)
+{
return bitstream_get_bits(b, numbits);
}
static int jpeg_default_quality;
static int ibuf_ftype;
-int imb_is_a_jpeg(unsigned char *mem) {
-
+int imb_is_a_jpeg(unsigned char *mem)
+{
if ((mem[0]== 0xFF) && (mem[1] == 0xD8))return 1;
return 0;
}
return(1);
}
-int imb_is_a_targa(unsigned char *buf) {
+int imb_is_a_targa(unsigned char *buf)
+{
TARGA tga;
return checktarga(&tga, buf);
}
}
-static DerivedMesh * cutEdges(ExplodeModifierData *emd, DerivedMesh *dm){
+static DerivedMesh * cutEdges(ExplodeModifierData *emd, DerivedMesh *dm)
+{
DerivedMesh *splitdm;
MFace *mf=NULL,*df1=NULL;
MFace *mface=dm->getFaceArray(dm);
}
/* Adds the given vertex to the specified vertex group, with given weight. */
-static void defvert_add_to_group(MDeformVert *dv, int defgrp_idx, const float weight) {
+static void defvert_add_to_group(MDeformVert *dv, int defgrp_idx, const float weight)
+{
/* TODO, move into deform.c as a generic function. This assumes the vertex
* groups have already been checked, so this has to remain low level. */
MDeformWeight *newdw;
/* Removes the given vertex from the vertex group, specified either by its defgrp_idx,
* or directly by its MDeformWeight pointer, if dw is not NULL.
* WARNING: This function frees the given MDeformWeight, do not use it afterward! */
-static void defvert_remove_from_group(MDeformVert *dv, int defgrp_idx, MDeformWeight *dw) {
+static void defvert_remove_from_group(MDeformVert *dv, int defgrp_idx, MDeformWeight *dw)
+{
/* TODO, move this into deform.c as a generic function. */
MDeformWeight *newdw;
int i;
}
/* Free internal buffers */
-static void group_free_internal(bNodeTreeExec *gexec) {
+static void group_free_internal(bNodeTreeExec *gexec)
+{
bNodeStack *ns;
int i;
/* for debugging */
-void PyC_ObSpit(const char *name, PyObject *var) {
+void PyC_ObSpit(const char *name, PyObject *var)
+{
fprintf(stderr, "<%s> : ", name);
if (var==NULL) {
fprintf(stderr, "<NIL>");
fprintf(stderr, "\n");
}
-void PyC_LineSpit(void) {
+void PyC_LineSpit(void)
+{
const char *filename;
int lineno;
/* only needed for subtyping, so a new class gets a valid BPy_StructRNA
* todo - also accept useful args */
-static PyObject *pyrna_prop_new(PyTypeObject *type, PyObject *args, PyObject *UNUSED(kwds)) {
-
+static PyObject *pyrna_prop_new(PyTypeObject *type, PyObject *args, PyObject *UNUSED(kwds))
+{
BPy_PropertyRNA *base;
if (!PyArg_ParseTuple(args, "O!:bpy_prop.__new__", &pyrna_prop_Type, &base))
#define BEGIN_CURSOR_BLOCK {
#define END_CURSOR_BLOCK }
-void wm_init_cursor_data(void){
-
+void wm_init_cursor_data(void)
+{
/********************** NW_ARROW Cursor **************************/
BEGIN_CURSOR_BLOCK
static char nw_sbm[]={
RNA_def_boolean(ot->srna, "relative_path", (U.flag & USER_RELPATHS) ? 1:0, "Relative Path", "Select the file relative to the blend file");
}
-void WM_operator_properties_select_all(wmOperatorType *ot) {
+void WM_operator_properties_select_all(wmOperatorType *ot)
+{
static EnumPropertyItem select_all_actions[] = {
{SEL_TOGGLE, "TOGGLE", 0, N_("Toggle"), "Toggle selection for all elements"},
{SEL_SELECT, "SELECT", 0, N_("Select"), "Select all elements"},