forked from bartvdbraak/blender
style cleanup
This commit is contained in:
parent
93cb7fb97b
commit
1597ad9377
@ -115,23 +115,23 @@ public:
|
||||
void Replace(int pos, int num, rcSTR_String str);
|
||||
|
||||
// Substrings
|
||||
inline STR_String Left(int num) const { num = (num < Len ? num:Len ); return STR_String(pData, num); }
|
||||
inline STR_String Right(int num) const { num = (num < Len ? num:Len ); return STR_String(pData+Len-num, num); }
|
||||
inline STR_String Mid(int pos, int num = INT_MAX) const { pos = (pos < Len ? pos:Len ); num = (num < (Len - pos) ? num : (Len - pos)); return STR_String(pData+pos, num); }
|
||||
inline STR_String Left(int num) const { num = (num < Len ? num:Len ); return STR_String(pData, num); }
|
||||
inline STR_String Right(int num) const { num = (num < Len ? num:Len ); return STR_String(pData+Len-num, num); }
|
||||
inline STR_String Mid(int pos, int num = INT_MAX) const { pos = (pos < Len ? pos:Len ); num = (num < (Len - pos) ? num : (Len - pos)); return STR_String(pData+pos, num); }
|
||||
|
||||
// Comparison
|
||||
int Compare(rcSTR_String rhs) const;
|
||||
int CompareNoCase(rcSTR_String rhs) const;
|
||||
inline bool IsEqual(rcSTR_String rhs) const { return (Compare(rhs)==0); }
|
||||
inline bool IsEqualNoCase(rcSTR_String rhs) const { return (CompareNoCase(rhs)==0); }
|
||||
int Compare(rcSTR_String rhs) const;
|
||||
int CompareNoCase(rcSTR_String rhs) const;
|
||||
inline bool IsEqual(rcSTR_String rhs) const { return (Compare(rhs)==0); }
|
||||
inline bool IsEqualNoCase(rcSTR_String rhs) const { return (CompareNoCase(rhs)==0); }
|
||||
|
||||
// Search/replace
|
||||
int Find(char c, int pos = 0) const;
|
||||
int Find(const char *str, int pos = 0) const;
|
||||
int Find(rcSTR_String str, int pos = 0) const;
|
||||
int RFind(char c) const;
|
||||
int FindOneOf(const char *set, int pos = 0) const;
|
||||
int RFindOneOf(const char *set, int pos = 0) const;
|
||||
int Find(char c, int pos = 0) const;
|
||||
int Find(const char *str, int pos = 0) const;
|
||||
int Find(rcSTR_String str, int pos = 0) const;
|
||||
int RFind(char c) const;
|
||||
int FindOneOf(const char *set, int pos = 0) const;
|
||||
int RFindOneOf(const char *set, int pos = 0) const;
|
||||
|
||||
std::vector<STR_String> Explode(char c) const;
|
||||
|
||||
@ -148,42 +148,42 @@ public:
|
||||
STR_String& TrimQuotes();
|
||||
|
||||
// Conversions
|
||||
// inline operator char*() { return pData; }
|
||||
inline operator const char *() const { return pData; }
|
||||
inline char *Ptr() { return pData; }
|
||||
inline const char *ReadPtr() const { return pData; }
|
||||
inline float ToFloat() const { float x=(float)(atof(pData)); return x; }
|
||||
inline int ToInt() const { return atoi(pData); }
|
||||
// inline operator char*() { return pData; }
|
||||
inline operator const char *() const { return pData; }
|
||||
inline char *Ptr() { return pData; }
|
||||
inline const char *ReadPtr() const { return pData; }
|
||||
inline float ToFloat() const { float x=(float)(atof(pData)); return x; }
|
||||
inline int ToInt() const { return atoi(pData); }
|
||||
|
||||
// Operators
|
||||
inline rcSTR_String operator=(const byte *rhs) { return Copy((const char *)rhs, strlen((const char *)rhs)); }
|
||||
inline rcSTR_String operator=(rcSTR_String rhs) { return Copy(rhs.ReadPtr(), rhs.Length()); }
|
||||
inline rcSTR_String operator=(char rhs) { return Copy(&rhs, 1); }
|
||||
inline rcSTR_String operator=(const char *rhs) { return Copy(rhs, strlen(rhs)); }
|
||||
inline rcSTR_String operator=(const byte *rhs) { return Copy((const char *)rhs, strlen((const char *)rhs)); }
|
||||
inline rcSTR_String operator=(rcSTR_String rhs) { return Copy(rhs.ReadPtr(), rhs.Length()); }
|
||||
inline rcSTR_String operator=(char rhs) { return Copy(&rhs, 1); }
|
||||
inline rcSTR_String operator=(const char *rhs) { return Copy(rhs, strlen(rhs)); }
|
||||
|
||||
inline rcSTR_String operator+=(const char *rhs) { return Concat(rhs, strlen(rhs)); }
|
||||
inline rcSTR_String operator+=(rcSTR_String rhs) { return Concat(rhs.ReadPtr(), rhs.Length()); }
|
||||
inline rcSTR_String operator+=(char rhs) { return Concat(&rhs, 1); }
|
||||
inline rcSTR_String operator+=(const char *rhs) { return Concat(rhs, strlen(rhs)); }
|
||||
inline rcSTR_String operator+=(rcSTR_String rhs) { return Concat(rhs.ReadPtr(), rhs.Length()); }
|
||||
inline rcSTR_String operator+=(char rhs) { return Concat(&rhs, 1); }
|
||||
|
||||
|
||||
inline friend bool operator<(rcSTR_String lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)<0); }
|
||||
inline friend bool operator<(rcSTR_String lhs, const char *rhs) { return (strcmp(lhs, rhs)<0); };
|
||||
inline friend bool operator<(const char *lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)<0); }
|
||||
inline friend bool operator>(rcSTR_String lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)>0); }
|
||||
inline friend bool operator>(rcSTR_String lhs, const char *rhs) { return (strcmp(lhs, rhs)>0); }
|
||||
inline friend bool operator>(const char *lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)>0); }
|
||||
inline friend bool operator<=(rcSTR_String lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)<=0); }
|
||||
inline friend bool operator<=(rcSTR_String lhs, const char *rhs) { return (strcmp(lhs, rhs)<=0); }
|
||||
inline friend bool operator<=(const char *lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)<=0); }
|
||||
inline friend bool operator>=(rcSTR_String lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)>=0); }
|
||||
inline friend bool operator>=(rcSTR_String lhs, const char *rhs) { return (strcmp(lhs, rhs)>=0); }
|
||||
inline friend bool operator>=(const char *lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)>=0); }
|
||||
inline friend bool operator==(rcSTR_String lhs, rcSTR_String rhs) { return ((lhs.Length() == rhs.Length()) && (memcmp(lhs, rhs, lhs.Length())==0)); }
|
||||
inline friend bool operator==(rcSTR_String lhs, const char *rhs) { return (memcmp(lhs, rhs, lhs.Length()+1)==0); }
|
||||
inline friend bool operator==(const char *lhs, rcSTR_String rhs) { return (memcmp(lhs, rhs, rhs.Length()+1)==0); }
|
||||
inline friend bool operator!=(rcSTR_String lhs, rcSTR_String rhs) { return ((lhs.Length() != rhs.Length()) || (memcmp(lhs, rhs, lhs.Length())!=0)); }
|
||||
inline friend bool operator!=(rcSTR_String lhs, const char *rhs) { return (memcmp(lhs, rhs, lhs.Length()+1)!=0); }
|
||||
inline friend bool operator!=(const char *lhs, rcSTR_String rhs) { return (memcmp(lhs, rhs, rhs.Length()+1)!=0); }
|
||||
|
||||
inline friend bool operator<(rcSTR_String lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)<0); }
|
||||
inline friend bool operator<(rcSTR_String lhs, const char *rhs) { return (strcmp(lhs, rhs)<0); }
|
||||
inline friend bool operator<(const char *lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)<0); }
|
||||
inline friend bool operator>(rcSTR_String lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)>0); }
|
||||
inline friend bool operator>(rcSTR_String lhs, const char *rhs) { return (strcmp(lhs, rhs)>0); }
|
||||
inline friend bool operator>(const char *lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)>0); }
|
||||
inline friend bool operator<=(rcSTR_String lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)<=0); }
|
||||
inline friend bool operator<=(rcSTR_String lhs, const char *rhs) { return (strcmp(lhs, rhs)<=0); }
|
||||
inline friend bool operator<=(const char *lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)<=0); }
|
||||
inline friend bool operator>=(rcSTR_String lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)>=0); }
|
||||
inline friend bool operator>=(rcSTR_String lhs, const char *rhs) { return (strcmp(lhs, rhs)>=0); }
|
||||
inline friend bool operator>=(const char *lhs, rcSTR_String rhs) { return (strcmp(lhs, rhs)>=0); }
|
||||
inline friend bool operator==(rcSTR_String lhs, rcSTR_String rhs) { return ((lhs.Length() == rhs.Length()) && (memcmp(lhs, rhs, lhs.Length())==0)); }
|
||||
inline friend bool operator==(rcSTR_String lhs, const char *rhs) { return (memcmp(lhs, rhs, lhs.Length()+1)==0); }
|
||||
inline friend bool operator==(const char *lhs, rcSTR_String rhs) { return (memcmp(lhs, rhs, rhs.Length()+1)==0); }
|
||||
inline friend bool operator!=(rcSTR_String lhs, rcSTR_String rhs) { return ((lhs.Length() != rhs.Length()) || (memcmp(lhs, rhs, lhs.Length())!=0)); }
|
||||
inline friend bool operator!=(rcSTR_String lhs, const char *rhs) { return (memcmp(lhs, rhs, lhs.Length()+1)!=0); }
|
||||
inline friend bool operator!=(const char *lhs, rcSTR_String rhs) { return (memcmp(lhs, rhs, rhs.Length()+1)!=0); }
|
||||
|
||||
// serializing
|
||||
//int Serialize(pCStream stream);
|
||||
@ -198,7 +198,7 @@ protected:
|
||||
static bool isUpper(char c) { return (c>='A') && (c <= 'Z'); }
|
||||
static bool isSpace(char c) { return (c==' ') || (c=='\t'); }
|
||||
|
||||
char *pData; // -> STR_String data
|
||||
char *pData; // -> STR_String data
|
||||
int Len; // Data length
|
||||
int Max; // Space in data buffer
|
||||
|
||||
@ -209,10 +209,10 @@ protected:
|
||||
};
|
||||
|
||||
inline STR_String operator+(rcSTR_String lhs, rcSTR_String rhs) { return STR_String(lhs.ReadPtr(), lhs.Length(), rhs.ReadPtr(), rhs.Length()); }
|
||||
inline STR_String operator+(rcSTR_String lhs, char rhs) { return STR_String(lhs.ReadPtr(), lhs.Length(), &rhs, 1); }
|
||||
inline STR_String operator+(char lhs, rcSTR_String rhs) { return STR_String(&lhs, 1, rhs.ReadPtr(), rhs.Length()); }
|
||||
inline STR_String operator+(rcSTR_String lhs, const char *rhs) { return STR_String(lhs.ReadPtr(), lhs.Length(), rhs, strlen(rhs)); }
|
||||
inline STR_String operator+(const char *lhs, rcSTR_String rhs) { return STR_String(lhs, strlen(lhs), rhs.ReadPtr(), rhs.Length()); }
|
||||
inline STR_String operator+(rcSTR_String lhs, char rhs) { return STR_String(lhs.ReadPtr(), lhs.Length(), &rhs, 1); }
|
||||
inline STR_String operator+(char lhs, rcSTR_String rhs) { return STR_String(&lhs, 1, rhs.ReadPtr(), rhs.Length()); }
|
||||
inline STR_String operator+(rcSTR_String lhs, const char *rhs) { return STR_String(lhs.ReadPtr(), lhs.Length(), rhs, strlen(rhs)); }
|
||||
inline STR_String operator+(const char *lhs, rcSTR_String rhs) { return STR_String(lhs, strlen(lhs), rhs.ReadPtr(), rhs.Length()); }
|
||||
|
||||
|
||||
#endif //__STR_STRING_H__
|
||||
|
@ -39,10 +39,10 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#if defined(__sun__) || defined( __sun ) || defined (__sparc) || defined (__sparc__) || defined (_AIX)
|
||||
#if defined(__sun__) || defined(__sun) || defined(__sparc) || defined(__sparc__) || defined(_AIX)
|
||||
# include <strings.h>
|
||||
#endif
|
||||
#include "STR_String.h"
|
||||
@ -57,7 +57,7 @@
|
||||
// Construct an empty string
|
||||
//
|
||||
STR_String::STR_String() :
|
||||
pData(new char [32]),
|
||||
pData(new char[32]),
|
||||
Len(0),
|
||||
Max(32)
|
||||
{
|
||||
@ -70,7 +70,7 @@ STR_String::STR_String() :
|
||||
// Construct a string of one character
|
||||
//
|
||||
STR_String::STR_String(char c) :
|
||||
pData(new char [9]),
|
||||
pData(new char[9]),
|
||||
Len(1),
|
||||
Max(9)
|
||||
{
|
||||
@ -84,9 +84,9 @@ STR_String::STR_String(char c) :
|
||||
// Construct a string of multiple repeating characters
|
||||
//
|
||||
STR_String::STR_String(char c, int len) :
|
||||
pData(new char [len+8]),
|
||||
pData(new char[len + 8]),
|
||||
Len(len),
|
||||
Max(len+8)
|
||||
Max(len + 8)
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
memset(pData, c, len);
|
||||
@ -104,7 +104,7 @@ STR_String::STR_String(const char *str)
|
||||
if (str) {
|
||||
Len = ::strlen(str);
|
||||
Max = Len + 8;
|
||||
pData = new char [Max];
|
||||
pData = new char[Max];
|
||||
assertd(pData != NULL);
|
||||
::memcpy(pData, str, Len);
|
||||
pData[Len] = 0;
|
||||
@ -122,9 +122,9 @@ STR_String::STR_String(const char *str)
|
||||
// Construct a string from a pointer-to-ASCII-string and a length
|
||||
//
|
||||
STR_String::STR_String(const char *str, int len) :
|
||||
pData(new char [len+8]),
|
||||
pData(new char[len + 8]),
|
||||
Len(len),
|
||||
Max(len+8)
|
||||
Max(len + 8)
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
memcpy(pData, str, len);
|
||||
@ -137,9 +137,9 @@ STR_String::STR_String(const char *str, int len) :
|
||||
// Construct a string from another string
|
||||
//
|
||||
STR_String::STR_String(rcSTR_String str) :
|
||||
pData(new char [str.Length()+8]),
|
||||
pData(new char[str.Length() + 8]),
|
||||
Len(str.Length()),
|
||||
Max(str.Length()+8)
|
||||
Max(str.Length() + 8)
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
assertd(str.pData != NULL);
|
||||
@ -153,9 +153,9 @@ STR_String::STR_String(rcSTR_String str) :
|
||||
// Construct a string from the first number of characters in another string
|
||||
//
|
||||
STR_String::STR_String(rcSTR_String str, int len) :
|
||||
pData(new char [len+8]),
|
||||
pData(new char[len + 8]),
|
||||
Len(len),
|
||||
Max(len+8)
|
||||
Max(len + 8)
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
assertd(str.pData != NULL);
|
||||
@ -169,14 +169,14 @@ STR_String::STR_String(rcSTR_String str, int len) :
|
||||
// Create a string by concatenating two sources
|
||||
//
|
||||
STR_String::STR_String(const char *src1, int len1, const char *src2, int len2) :
|
||||
pData(new char [len1+len2+8]),
|
||||
Len(len1+len2),
|
||||
Max(len1+len2+8)
|
||||
pData(new char[len1 + len2 + 8]),
|
||||
Len(len1 + len2),
|
||||
Max(len1 + len2 + 8)
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
memcpy(pData, src1, len1);
|
||||
memcpy(pData+len1, src2, len2);
|
||||
pData[len1+len2] = 0;
|
||||
memcpy(pData + len1, src2, len2);
|
||||
pData[len1 + len2] = 0;
|
||||
}
|
||||
|
||||
|
||||
@ -185,13 +185,13 @@ STR_String::STR_String(const char *src1, int len1, const char *src2, int len2) :
|
||||
// Create a string with an integer value
|
||||
//
|
||||
STR_String::STR_String(int val) :
|
||||
pData(new char [32]),
|
||||
pData(new char[32]),
|
||||
Max(32)
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
Len=sprintf(pData, "%d", val);
|
||||
Len = sprintf(pData, "%d", val);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -199,11 +199,11 @@ STR_String::STR_String(int val) :
|
||||
// Create a string with a dword value
|
||||
//
|
||||
STR_String::STR_String(dword val) :
|
||||
pData(new char [32]),
|
||||
pData(new char[32]),
|
||||
Max(32)
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
Len=sprintf(pData, "%lu", val);
|
||||
Len = sprintf(pData, "%lu", val);
|
||||
}
|
||||
|
||||
|
||||
@ -212,11 +212,11 @@ STR_String::STR_String(dword val) :
|
||||
// Create a string with a floating point value
|
||||
//
|
||||
STR_String::STR_String(float val) :
|
||||
pData(new char [32]),
|
||||
pData(new char[32]),
|
||||
Max(32)
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
Len=sprintf(pData, "%g", val);
|
||||
Len = sprintf(pData, "%g", val);
|
||||
}
|
||||
|
||||
|
||||
@ -225,11 +225,11 @@ STR_String::STR_String(float val) :
|
||||
// Create a string with a double value
|
||||
//
|
||||
STR_String::STR_String(double val) :
|
||||
pData(new char [32]),
|
||||
pData(new char[32]),
|
||||
Max(32)
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
Len=sprintf(pData, "%g", val);
|
||||
Len = sprintf(pData, "%g", val);
|
||||
}
|
||||
|
||||
|
||||
@ -246,19 +246,19 @@ STR_String::STR_String(double val) :
|
||||
void STR_String::AllocBuffer(int len, bool keep_contents)
|
||||
{
|
||||
// Check if we have enough space
|
||||
if (len+1 <= Max) return;
|
||||
if (len + 1 <= Max) return;
|
||||
|
||||
// Reallocate string
|
||||
char *new_data = new char [len+8];
|
||||
char *new_data = new char[len + 8];
|
||||
if (keep_contents) memcpy(new_data, pData, Len);
|
||||
delete[] pData;
|
||||
|
||||
// Accept new data
|
||||
Max = len+8;
|
||||
Max = len + 8;
|
||||
pData = new_data;
|
||||
assertd(pData != NULL);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------------------------------
|
||||
@ -298,7 +298,7 @@ STR_String& STR_String::FormatAdd(const char *fmt, ...)
|
||||
// Expand arguments and format to string
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
Len += vsprintf(pData+Len, fmt, args);
|
||||
Len += vsprintf(pData + Len, fmt, args);
|
||||
assertd(Len <= 2048);
|
||||
va_end(args);
|
||||
|
||||
@ -318,7 +318,7 @@ STR_String& STR_String::FormatAdd(const char *fmt, ...)
|
||||
//
|
||||
bool STR_String::IsUpper() const
|
||||
{
|
||||
for (int i=0; i<Len; i++)
|
||||
for (int i = 0; i < Len; i++)
|
||||
if (isLower(pData[i]))
|
||||
return false;
|
||||
|
||||
@ -332,7 +332,7 @@ bool STR_String::IsUpper() const
|
||||
//
|
||||
bool STR_String::IsLower() const
|
||||
{
|
||||
for (int i=0; i<Len; i++)
|
||||
for (int i = 0; i < Len; i++)
|
||||
if (isUpper(pData[i]))
|
||||
return false;
|
||||
|
||||
@ -353,10 +353,10 @@ bool STR_String::IsLower() const
|
||||
int STR_String::Find(char c, int pos) const
|
||||
{
|
||||
assertd(pos >= 0);
|
||||
assertd(Len==0 || pos<Len);
|
||||
assertd(Len == 0 || pos < Len);
|
||||
assertd(pData != NULL);
|
||||
char *find_pos = strchr(pData+pos, c);
|
||||
return (find_pos) ? (find_pos-pData) : -1;
|
||||
char *find_pos = strchr(pData + pos, c);
|
||||
return (find_pos) ? (find_pos - pData) : -1;
|
||||
}
|
||||
|
||||
|
||||
@ -364,13 +364,13 @@ int STR_String::Find(char c, int pos) const
|
||||
//
|
||||
// Find the first occurrence of <str> in the string
|
||||
//
|
||||
int STR_String::Find(const char *str, int pos) const
|
||||
int STR_String::Find(const char *str, int pos) const
|
||||
{
|
||||
assertd(pos >= 0);
|
||||
assertd(Len==0 || pos<Len);
|
||||
assertd(Len == 0 || pos < Len);
|
||||
assertd(pData != NULL);
|
||||
char *find_pos = strstr(pData+pos, str);
|
||||
return (find_pos) ? (find_pos-pData) : -1;
|
||||
char *find_pos = strstr(pData + pos, str);
|
||||
return (find_pos) ? (find_pos - pData) : -1;
|
||||
}
|
||||
|
||||
|
||||
@ -378,13 +378,13 @@ int STR_String::Find(const char *str, int pos) const
|
||||
//
|
||||
// Find the first occurrence of <str> in the string
|
||||
//
|
||||
int STR_String::Find(rcSTR_String str, int pos) const
|
||||
int STR_String::Find(rcSTR_String str, int pos) const
|
||||
{
|
||||
assertd(pos >= 0);
|
||||
assertd(Len==0 || pos<Len);
|
||||
assertd(Len == 0 || pos < Len);
|
||||
assertd(pData != NULL);
|
||||
char *find_pos = strstr(pData+pos, str.ReadPtr());
|
||||
return (find_pos) ? (find_pos-pData) : -1;
|
||||
char *find_pos = strstr(pData + pos, str.ReadPtr());
|
||||
return (find_pos) ? (find_pos - pData) : -1;
|
||||
}
|
||||
|
||||
|
||||
@ -396,7 +396,7 @@ int STR_String::RFind(char c) const
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
char *pos = strrchr(pData, c);
|
||||
return (pos) ? (pos-pData) : -1;
|
||||
return (pos) ? (pos - pData) : -1;
|
||||
}
|
||||
|
||||
|
||||
@ -407,10 +407,10 @@ int STR_String::RFind(char c) const
|
||||
int STR_String::FindOneOf(const char *set, int pos) const
|
||||
{
|
||||
assertd(pos >= 0);
|
||||
assertd(Len==0 || pos<Len);
|
||||
assertd(Len == 0 || pos < Len);
|
||||
assertd(pData != NULL);
|
||||
char *find_pos = strpbrk(pData+pos, set);
|
||||
return (find_pos) ? (find_pos-pData) : -1;
|
||||
char *find_pos = strpbrk(pData + pos, set);
|
||||
return (find_pos) ? (find_pos - pData) : -1;
|
||||
}
|
||||
|
||||
|
||||
@ -425,17 +425,16 @@ void STR_String::Replace(int pos, rcSTR_String str)
|
||||
if (str.Length() < 1)
|
||||
{
|
||||
// Remove one character from the string
|
||||
memcpy(pData+pos, pData+pos+1, Len-pos);
|
||||
memcpy(pData + pos, pData + pos + 1, Len - pos);
|
||||
}
|
||||
else
|
||||
{
|
||||
else {
|
||||
// Insert zero or more characters into the string
|
||||
AllocBuffer(Len + str.Length() - 1, true);
|
||||
if (str.Length() != 1) memcpy(pData+pos+str.Length(), pData+pos+1, Length()-pos);
|
||||
memcpy(pData+pos, str.ReadPtr(), str.Length());
|
||||
if (str.Length() != 1) memcpy(pData + pos + str.Length(), pData + pos + 1, Length() - pos);
|
||||
memcpy(pData + pos, str.ReadPtr(), str.Length());
|
||||
}
|
||||
|
||||
Len += str.Length()-1;
|
||||
Len += str.Length() - 1;
|
||||
}
|
||||
|
||||
|
||||
@ -452,18 +451,17 @@ void STR_String::Replace(int pos, int num, rcSTR_String str)
|
||||
if (str.Length() < num)
|
||||
{
|
||||
// Remove some data from the string by replacement
|
||||
memcpy(pData+pos+str.Length(), pData+pos+num, Len-pos-num+1);
|
||||
memcpy(pData+pos, str.ReadPtr(), str.Length());
|
||||
memcpy(pData + pos + str.Length(), pData + pos + num, Len - pos - num + 1);
|
||||
memcpy(pData + pos, str.ReadPtr(), str.Length());
|
||||
}
|
||||
else
|
||||
{
|
||||
else {
|
||||
// Insert zero or more characters into the string
|
||||
AllocBuffer(Len + str.Length() - num, true);
|
||||
if (str.Length() != num) memcpy(pData+pos+str.Length(), pData+pos+num, Length()-pos-num+1);
|
||||
memcpy(pData+pos, str.ReadPtr(), str.Length());
|
||||
if (str.Length() != num) memcpy(pData + pos + str.Length(), pData + pos + num, Length() - pos - num + 1);
|
||||
memcpy(pData + pos, str.ReadPtr(), str.Length());
|
||||
}
|
||||
|
||||
Len += str.Length()-num;
|
||||
Len += str.Length() - num;
|
||||
}
|
||||
|
||||
|
||||
@ -477,7 +475,7 @@ void STR_String::Replace(int pos, int num, rcSTR_String str)
|
||||
//
|
||||
// Compare two strings and return the result, <0 if *this<rhs, >0 if *this>rhs or 0 if *this==rhs
|
||||
//
|
||||
int STR_String::Compare(rcSTR_String rhs) const
|
||||
int STR_String::Compare(rcSTR_String rhs) const
|
||||
{
|
||||
return strcmp(pData, rhs.pData);
|
||||
}
|
||||
@ -507,14 +505,14 @@ int STR_String::CompareNoCase(rcSTR_String rhs) const
|
||||
//
|
||||
// Capitalize string, "heLLo" -> "HELLO"
|
||||
//
|
||||
STR_String& STR_String::Upper()
|
||||
STR_String& STR_String::Upper()
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
#ifdef WIN32
|
||||
_strupr(pData);
|
||||
#else
|
||||
for (int i=0;i<Len;i++)
|
||||
pData[i] = (pData[i] >= 'a' && pData[i] <= 'z')?pData[i]+'A'-'a':pData[i];
|
||||
for (int i = 0; i < Len; i++)
|
||||
pData[i] = (pData[i] >= 'a' && pData[i] <= 'z') ? pData[i] + 'A' - 'a' : pData[i];
|
||||
#endif
|
||||
return *this;
|
||||
}
|
||||
@ -524,14 +522,14 @@ STR_String& STR_String::Upper()
|
||||
//
|
||||
// Lower string, "heLLo" -> "hello"
|
||||
//
|
||||
STR_String& STR_String::Lower()
|
||||
STR_String& STR_String::Lower()
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
#ifdef WIN32
|
||||
_strlwr(pData);
|
||||
#else
|
||||
for (int i=0;i<Len;i++)
|
||||
pData[i] = (pData[i] >= 'A' && pData[i] <= 'Z')?pData[i]+'a'-'A':pData[i];
|
||||
for (int i = 0; i < Len; i++)
|
||||
pData[i] = (pData[i] >= 'A' && pData[i] <= 'Z') ? pData[i] + 'a' - 'A' : pData[i];
|
||||
#endif
|
||||
return *this;
|
||||
}
|
||||
@ -541,17 +539,17 @@ STR_String& STR_String::Lower()
|
||||
//
|
||||
// Capitalize string, "heLLo" -> "Hello"
|
||||
//
|
||||
STR_String& STR_String::Capitalize()
|
||||
STR_String& STR_String::Capitalize()
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
#ifdef WIN32
|
||||
if (Len>0) pData[0] = toupper(pData[0]);
|
||||
if (Len>1) _strlwr(pData+1);
|
||||
if (Len > 0) pData[0] = toupper(pData[0]);
|
||||
if (Len > 1) _strlwr(pData + 1);
|
||||
#else
|
||||
if (Len > 0)
|
||||
pData[0] = (pData[0] >= 'A' && pData[0] <= 'A')?pData[0]+'a'-'A':pData[0];
|
||||
for (int i=1;i<Len;i++)
|
||||
pData[i] = (pData[i] >= 'a' && pData[i] <= 'z')?pData[i]+'A'-'a':pData[i];
|
||||
pData[0] = (pData[0] >= 'A' && pData[0] <= 'A') ? pData[0] + 'a' - 'A' : pData[0];
|
||||
for (int i = 1; i < Len; i++)
|
||||
pData[i] = (pData[i] >= 'a' && pData[i] <= 'z') ? pData[i] + 'A' - 'a' : pData[i];
|
||||
#endif
|
||||
return *this;
|
||||
}
|
||||
@ -561,13 +559,13 @@ STR_String& STR_String::Capitalize()
|
||||
//
|
||||
// Trim whitespace from the left side of the string
|
||||
//
|
||||
STR_String& STR_String::TrimLeft()
|
||||
STR_String& STR_String::TrimLeft()
|
||||
{
|
||||
int skip;
|
||||
assertd(pData != NULL);
|
||||
for (skip=0; isSpace(pData[skip]); skip++, Len--)
|
||||
{};
|
||||
memmove(pData, pData+skip, Len+1);
|
||||
for (skip = 0; isSpace(pData[skip]); skip++, Len--)
|
||||
{};
|
||||
memmove(pData, pData + skip, Len + 1);
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -576,11 +574,11 @@ STR_String& STR_String::TrimLeft()
|
||||
//
|
||||
// Trim whitespaces from the right side of the string
|
||||
//
|
||||
STR_String& STR_String::TrimRight()
|
||||
STR_String& STR_String::TrimRight()
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
while (Len && isSpace(pData[Len-1])) Len--;
|
||||
pData[Len]=0;
|
||||
while (Len && isSpace(pData[Len - 1])) Len--;
|
||||
pData[Len] = 0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -589,7 +587,7 @@ STR_String& STR_String::TrimRight()
|
||||
//
|
||||
// Trim spaces from both sides of the character set
|
||||
//
|
||||
STR_String& STR_String::Trim()
|
||||
STR_String& STR_String::Trim()
|
||||
{
|
||||
TrimRight();
|
||||
TrimLeft();
|
||||
@ -601,13 +599,13 @@ STR_String& STR_String::Trim()
|
||||
//
|
||||
// Trim characters from the character set <set> from the left side of the string
|
||||
//
|
||||
STR_String& STR_String::TrimLeft(char *set)
|
||||
STR_String& STR_String::TrimLeft(char *set)
|
||||
{
|
||||
int skip;
|
||||
assertd(pData != NULL);
|
||||
for (skip=0; Len && strchr(set, pData[skip]); skip++, Len--)
|
||||
{};
|
||||
memmove(pData, pData+skip, Len+1);
|
||||
for (skip = 0; Len && strchr(set, pData[skip]); skip++, Len--)
|
||||
{};
|
||||
memmove(pData, pData + skip, Len + 1);
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -616,11 +614,11 @@ STR_String& STR_String::TrimLeft(char *set)
|
||||
//
|
||||
// Trim characters from the character set <set> from the right side of the string
|
||||
//
|
||||
STR_String& STR_String::TrimRight(char *set)
|
||||
STR_String& STR_String::TrimRight(char *set)
|
||||
{
|
||||
assertd(pData != NULL);
|
||||
while (Len && strchr(set, pData[Len-1])) Len--;
|
||||
pData[Len]=0;
|
||||
while (Len && strchr(set, pData[Len - 1])) Len--;
|
||||
pData[Len] = 0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -629,7 +627,7 @@ STR_String& STR_String::TrimRight(char *set)
|
||||
//
|
||||
// Trim characters from the character set <set> from both sides of the character set
|
||||
//
|
||||
STR_String& STR_String::Trim(char *set)
|
||||
STR_String& STR_String::Trim(char *set)
|
||||
{
|
||||
TrimRight(set);
|
||||
TrimLeft(set);
|
||||
@ -641,14 +639,14 @@ STR_String& STR_String::Trim(char *set)
|
||||
//
|
||||
// Trim quotes from both sides of the string
|
||||
//
|
||||
STR_String& STR_String::TrimQuotes()
|
||||
STR_String& STR_String::TrimQuotes()
|
||||
{
|
||||
// Trim quotes if they are on both sides of the string
|
||||
assertd(pData != NULL);
|
||||
if ((Len >= 2) && (pData[0] == '\"') && (pData[Len-1] == '\"'))
|
||||
if ((Len >= 2) && (pData[0] == '\"') && (pData[Len - 1] == '\"'))
|
||||
{
|
||||
memmove(pData, pData+1, Len-2+1);
|
||||
Len-=2;
|
||||
memmove(pData, pData + 1, Len - 2 + 1);
|
||||
Len -= 2;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -666,7 +664,7 @@ STR_String& STR_String::TrimQuotes()
|
||||
//
|
||||
rcSTR_String STR_String::Copy(const char *src, int len)
|
||||
{
|
||||
assertd(len>=0);
|
||||
assertd(len >= 0);
|
||||
assertd(src);
|
||||
assertd(pData != NULL);
|
||||
|
||||
@ -685,23 +683,23 @@ rcSTR_String STR_String::Copy(const char *src, int len)
|
||||
//
|
||||
rcSTR_String STR_String::Concat(const char *data, int len)
|
||||
{
|
||||
assertd(Len>=0);
|
||||
assertd(len>=0);
|
||||
assertd(Len >= 0);
|
||||
assertd(len >= 0);
|
||||
assertd(data);
|
||||
assertd(pData != NULL);
|
||||
|
||||
AllocBuffer(Len+len, true);
|
||||
memcpy(pData+Len, data, len);
|
||||
Len+=len;
|
||||
AllocBuffer(Len + len, true);
|
||||
memcpy(pData + Len, data, len);
|
||||
Len += len;
|
||||
pData[Len] = 0;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
std::vector<STR_String> STR_String::Explode(char c) const
|
||||
std::vector<STR_String> STR_String::Explode(char c) const
|
||||
{
|
||||
STR_String lcv = *this;
|
||||
STR_String lcv = *this;
|
||||
std::vector<STR_String> uc;
|
||||
|
||||
while (lcv.Length())
|
||||
@ -713,7 +711,7 @@ std::vector<STR_String> STR_String::Explode(char c) const
|
||||
}
|
||||
else {
|
||||
uc.push_back(lcv.Left(pos));
|
||||
lcv = lcv.Mid(pos+1);
|
||||
lcv = lcv.Mid(pos + 1);
|
||||
}
|
||||
}
|
||||
|
||||
@ -723,25 +721,24 @@ std::vector<STR_String> STR_String::Explode(char c) const
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
#if 0
|
||||
|
||||
int STR_String::Serialize(pCStream stream)
|
||||
{
|
||||
if (stream->GetAccess() == CStream::Access_Read)
|
||||
{
|
||||
if (stream->GetAccess() == CStream::Access_Read) {
|
||||
int ln;
|
||||
stream->Read(&ln, sizeof(ln));
|
||||
AllocBuffer(ln, false);
|
||||
stream->Read(pData, ln);
|
||||
pData[ln] = '\0';
|
||||
Len = ln;
|
||||
} else
|
||||
{
|
||||
}
|
||||
else {
|
||||
stream->Write(&Len, sizeof(Len));
|
||||
stream->Write(pData, Len);
|
||||
}
|
||||
|
||||
return Len + sizeof(Len);
|
||||
}
|
||||
*/
|
||||
#endif
|
||||
|
||||
|
@ -67,7 +67,7 @@ int uopen(const char *filename, int oflag, int pmode)
|
||||
UTF16_UN_ENCODE(filename);
|
||||
|
||||
if (f == -1) {
|
||||
if ((f=open(filename,oflag, pmode)) != -1) {
|
||||
if ((f = open(filename,oflag, pmode)) != -1) {
|
||||
printf("WARNING: %s is not utf path. Please update it.\n",filename);
|
||||
}
|
||||
}
|
||||
|
@ -811,7 +811,7 @@ void calchandles_fcurve(FCurve *fcu)
|
||||
if (bezt->vec[2][0] < bezt->vec[1][0]) bezt->vec[2][0] = bezt->vec[1][0];
|
||||
|
||||
/* calculate auto-handles */
|
||||
BKE_nurb_handle_calc(bezt, prev, next, 1); /* 1==special autohandle */
|
||||
BKE_nurb_handle_calc(bezt, prev, next, 1); /* (1 == special) autohandle */
|
||||
|
||||
/* for automatic ease in and out */
|
||||
if (ELEM(bezt->h1, HD_AUTO, HD_AUTO_ANIM) && ELEM(bezt->h2, HD_AUTO, HD_AUTO_ANIM)) {
|
||||
|
@ -771,7 +771,7 @@ void do_rel_key(const int start, int end, const int tot, char *basispoin, Key *k
|
||||
|
||||
ofsp = ofs;
|
||||
|
||||
while (cp[0]) { /* cp[0]==amount */
|
||||
while (cp[0]) { /* (cp[0] == amount) */
|
||||
|
||||
switch (cp[1]) {
|
||||
case IPO_FLOAT:
|
||||
@ -936,7 +936,7 @@ static void do_key(const int start, int end, const int tot, char *poin, Key *key
|
||||
|
||||
ofsp = ofs;
|
||||
|
||||
while (cp[0]) { /* cp[0]==amount */
|
||||
while (cp[0]) { /* (cp[0] == amount) */
|
||||
|
||||
switch (cp[1]) {
|
||||
case IPO_FLOAT:
|
||||
|
@ -901,8 +901,8 @@ static int getLowestRoot(const float a, const float b, const float c, const floa
|
||||
|
||||
// If determinant is negative it means no solutions.
|
||||
if (determinant >= 0.0f) {
|
||||
// calculate the two roots: (if determinant == 0 then
|
||||
// x1==x2 but lets disregard that slight optimization)
|
||||
/* calculate the two roots: (if determinant == 0 then
|
||||
* x1==x2 but lets disregard that slight optimization) */
|
||||
float sqrtD = (float)sqrt(determinant);
|
||||
float r1 = (-b - sqrtD) / (2.0f * a);
|
||||
float r2 = (-b + sqrtD) / (2.0f * a);
|
||||
|
@ -1643,7 +1643,7 @@ int BLI_rebase_path(char *abs, size_t abs_len, char *rel, size_t rel_len, const
|
||||
strncat(rel, base, rel_len);
|
||||
}
|
||||
|
||||
/* return 2 if src=dest */
|
||||
/* return 2 if (src == dest) */
|
||||
if (BLI_path_cmp(path, dest_path) == 0) {
|
||||
// if (G.debug & G_DEBUG) printf("%s and %s are the same file\n", path, dest_path);
|
||||
return BLI_REBASE_IDENTITY;
|
||||
|
@ -288,7 +288,7 @@ static void mergepolysSimp(ScanFillContext *sf_ctx, PolyFill *pf1, PolyFill *pf2
|
||||
}
|
||||
|
||||
static short testedgeside(const float v1[2], const float v2[2], const float v3[2])
|
||||
/* is v3 to the right of v1-v2 ? With exception: v3==v1 || v3==v2 */
|
||||
/* is v3 to the right of v1-v2 ? With exception: v3 == v1 || v3 == v2 */
|
||||
{
|
||||
float inp;
|
||||
|
||||
|
@ -96,7 +96,7 @@ static void *thread_tls_data;
|
||||
* }
|
||||
* // conditions to exit loop
|
||||
* if (if escape loop event) {
|
||||
* if (BLI_available_threadslots(&lb)==maxthreads)
|
||||
* if (BLI_available_threadslots(&lb) == maxthreads)
|
||||
* break;
|
||||
* }
|
||||
* }
|
||||
|
@ -37,7 +37,7 @@
|
||||
|
||||
double PIL_check_seconds_timer(void)
|
||||
{
|
||||
static int hasperfcounter = -1; /* -1==unknown */
|
||||
static int hasperfcounter = -1; /* (-1 == unknown) */
|
||||
static double perffreq;
|
||||
|
||||
if (hasperfcounter == -1) {
|
||||
|
@ -270,7 +270,7 @@ static int object_select_linked_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
if (nr == 1) {
|
||||
// XXX old animation system
|
||||
//if (base->object->ipo==ipo) base->flag |= SELECT;
|
||||
//if (base->object->ipo == ipo) base->flag |= SELECT;
|
||||
//changed = 1;
|
||||
}
|
||||
else if (nr == 2) {
|
||||
|
@ -68,11 +68,11 @@ static void node_tag_recursive(bNode *node)
|
||||
bNodeSocket *input;
|
||||
|
||||
if (!node || (node->flag & NODE_TEST))
|
||||
return; /* in case of cycles */
|
||||
|
||||
return; /* in case of cycles */
|
||||
|
||||
node->flag |= NODE_TEST;
|
||||
|
||||
for (input=node->inputs.first; input; input=input->next)
|
||||
for (input = node->inputs.first; input; input = input->next)
|
||||
if (input->link)
|
||||
node_tag_recursive(input->link->fromnode);
|
||||
}
|
||||
@ -82,11 +82,11 @@ static void node_clear_recursive(bNode *node)
|
||||
bNodeSocket *input;
|
||||
|
||||
if (!node || !(node->flag & NODE_TEST))
|
||||
return; /* in case of cycles */
|
||||
|
||||
return; /* in case of cycles */
|
||||
|
||||
node->flag &= ~NODE_TEST;
|
||||
|
||||
for (input=node->inputs.first; input; input=input->next)
|
||||
for (input = node->inputs.first; input; input = input->next)
|
||||
if (input->link)
|
||||
node_clear_recursive(input->link->fromnode);
|
||||
}
|
||||
@ -100,20 +100,20 @@ static void node_remove_linked(bNodeTree *ntree, bNode *rem_node)
|
||||
return;
|
||||
|
||||
/* tag linked nodes to be removed */
|
||||
for (node=ntree->nodes.first; node; node=node->next)
|
||||
for (node = ntree->nodes.first; node; node = node->next)
|
||||
node->flag &= ~NODE_TEST;
|
||||
|
||||
|
||||
node_tag_recursive(rem_node);
|
||||
|
||||
/* clear tags on nodes that are still used by other nodes */
|
||||
for (node=ntree->nodes.first; node; node=node->next)
|
||||
for (node = ntree->nodes.first; node; node = node->next)
|
||||
if (!(node->flag & NODE_TEST))
|
||||
for (sock=node->inputs.first; sock; sock=sock->next)
|
||||
for (sock = node->inputs.first; sock; sock = sock->next)
|
||||
if (sock->link && sock->link->fromnode != rem_node)
|
||||
node_clear_recursive(sock->link->fromnode);
|
||||
|
||||
/* remove nodes */
|
||||
for (node=ntree->nodes.first; node; node=next) {
|
||||
for (node = ntree->nodes.first; node; node = next) {
|
||||
next = node->next;
|
||||
|
||||
if (node->flag & NODE_TEST) {
|
||||
@ -166,7 +166,7 @@ static void node_socket_add_replace(Main *bmain, bNodeTree *ntree, bNode *node_t
|
||||
}
|
||||
|
||||
/* find existing node that we can use */
|
||||
for (node_from=ntree->nodes.first; node_from; node_from=node_from->next)
|
||||
for (node_from = ntree->nodes.first; node_from; node_from = node_from->next)
|
||||
if (node_from->type == ntemp->type)
|
||||
break;
|
||||
|
||||
@ -181,7 +181,7 @@ static void node_socket_add_replace(Main *bmain, bNodeTree *ntree, bNode *node_t
|
||||
node_from = node_prev;
|
||||
}
|
||||
else if (!node_from) {
|
||||
node_from= nodeAddNode(ntree, ntemp);
|
||||
node_from = nodeAddNode(ntree, ntemp);
|
||||
node_from->locx = node_to->locx - (node_from->typeinfo->width + 50);
|
||||
node_from->locy = node_to->locy;
|
||||
|
||||
@ -199,11 +199,11 @@ static void node_socket_add_replace(Main *bmain, bNodeTree *ntree, bNode *node_t
|
||||
if (node_prev && node_from != node_prev) {
|
||||
bNodeSocket *sock_prev, *sock_from;
|
||||
|
||||
for (sock_prev=node_prev->inputs.first; sock_prev; sock_prev=sock_prev->next) {
|
||||
for (sock_from=node_from->inputs.first; sock_from; sock_from=sock_from->next) {
|
||||
for (sock_prev = node_prev->inputs.first; sock_prev; sock_prev = sock_prev->next) {
|
||||
for (sock_from = node_from->inputs.first; sock_from; sock_from = sock_from->next) {
|
||||
if (nodeCountSocketLinks(ntree, sock_from) >= sock_from->limit)
|
||||
continue;
|
||||
|
||||
|
||||
if (strcmp(sock_prev->name, sock_from->name) == 0 && sock_prev->type == sock_from->type) {
|
||||
bNodeLink *link = sock_prev->link;
|
||||
|
||||
@ -239,9 +239,9 @@ static void node_socket_add_replace(Main *bmain, bNodeTree *ntree, bNode *node_t
|
||||
|
||||
/****************************** Node Link Menu *******************************/
|
||||
|
||||
#define UI_NODE_LINK_ADD 0
|
||||
#define UI_NODE_LINK_DISCONNECT -1
|
||||
#define UI_NODE_LINK_REMOVE -2
|
||||
#define UI_NODE_LINK_ADD 0
|
||||
#define UI_NODE_LINK_DISCONNECT -1
|
||||
#define UI_NODE_LINK_REMOVE -2
|
||||
|
||||
typedef struct NodeLinkArg {
|
||||
Main *bmain;
|
||||
@ -259,7 +259,7 @@ typedef struct NodeLinkArg {
|
||||
|
||||
static void ui_node_link(bContext *C, void *arg_p, void *event_p)
|
||||
{
|
||||
NodeLinkArg *arg = (NodeLinkArg*)arg_p;
|
||||
NodeLinkArg *arg = (NodeLinkArg *)arg_p;
|
||||
Main *bmain = arg->bmain;
|
||||
bNode *node_to = arg->node;
|
||||
bNodeSocket *sock_to = arg->sock;
|
||||
@ -278,7 +278,7 @@ static void ui_node_link(bContext *C, void *arg_p, void *event_p)
|
||||
node_socket_remove(bmain, ntree, node_to, sock_to);
|
||||
else
|
||||
node_socket_add_replace(bmain, ntree, node_to, sock_to, &ntemp, arg->output);
|
||||
|
||||
|
||||
ED_undo_push(C, "Node input modify");
|
||||
}
|
||||
|
||||
@ -290,7 +290,7 @@ static void ui_node_sock_name(bNodeSocket *sock, char name[UI_MAX_NAME_STR])
|
||||
|
||||
if (node->type == NODE_GROUP) {
|
||||
if (node->id)
|
||||
BLI_strncpy(node_name, node->id->name+2, UI_MAX_NAME_STR);
|
||||
BLI_strncpy(node_name, node->id->name + 2, UI_MAX_NAME_STR);
|
||||
else
|
||||
BLI_strncpy(node_name, N_("Group"), UI_MAX_NAME_STR);
|
||||
}
|
||||
@ -331,17 +331,17 @@ static void ui_node_menu_column(NodeLinkArg *arg, int nclass, const char *cname)
|
||||
bNodeTree *ngroup;
|
||||
NodeLinkArg *argN;
|
||||
int first = 1;
|
||||
int compatibility= 0;
|
||||
int compatibility = 0;
|
||||
|
||||
if (ntree->type == NTREE_SHADER) {
|
||||
if (BKE_scene_use_new_shading_nodes(arg->scene))
|
||||
compatibility= NODE_NEW_SHADING;
|
||||
compatibility = NODE_NEW_SHADING;
|
||||
else
|
||||
compatibility= NODE_OLD_SHADING;
|
||||
compatibility = NODE_OLD_SHADING;
|
||||
}
|
||||
|
||||
if (nclass == NODE_CLASS_GROUP) {
|
||||
for (ngroup=bmain->nodetree.first; ngroup; ngroup=ngroup->id.next) {
|
||||
for (ngroup = bmain->nodetree.first; ngroup; ngroup = ngroup->id.next) {
|
||||
bNodeSocket *gsock;
|
||||
char name[UI_MAX_NAME_STR];
|
||||
int i, j, num = 0;
|
||||
@ -349,11 +349,11 @@ static void ui_node_menu_column(NodeLinkArg *arg, int nclass, const char *cname)
|
||||
if (ngroup->type != ntree->type)
|
||||
continue;
|
||||
|
||||
for (gsock=ngroup->inputs.first; gsock; gsock=gsock->next)
|
||||
for (gsock = ngroup->inputs.first; gsock; gsock = gsock->next)
|
||||
if (ui_compatible_sockets(gsock->type, sock->type))
|
||||
num++;
|
||||
|
||||
for (i=0, j=0, gsock=ngroup->outputs.first; gsock; gsock=gsock->next, i++) {
|
||||
for (i = 0, j = 0, gsock = ngroup->outputs.first; gsock; gsock = gsock->next, i++) {
|
||||
if (!ui_compatible_sockets(gsock->type, sock->type))
|
||||
continue;
|
||||
|
||||
@ -362,27 +362,27 @@ static void ui_node_menu_column(NodeLinkArg *arg, int nclass, const char *cname)
|
||||
uiBlockSetCurLayout(block, column);
|
||||
|
||||
uiItemL(column, IFACE_(cname), ICON_NODE);
|
||||
but= block->buttons.last;
|
||||
but->flag= UI_TEXT_LEFT;
|
||||
but = block->buttons.last;
|
||||
but->flag = UI_TEXT_LEFT;
|
||||
|
||||
first = 0;
|
||||
}
|
||||
|
||||
if (num > 1) {
|
||||
if (j == 0) {
|
||||
uiItemL(column, ngroup->id.name+2, ICON_NODE);
|
||||
but= block->buttons.last;
|
||||
but->flag= UI_TEXT_LEFT;
|
||||
uiItemL(column, ngroup->id.name + 2, ICON_NODE);
|
||||
but = block->buttons.last;
|
||||
but->flag = UI_TEXT_LEFT;
|
||||
}
|
||||
|
||||
BLI_snprintf(name, UI_MAX_NAME_STR, " %s", gsock->name);
|
||||
j++;
|
||||
}
|
||||
else
|
||||
BLI_strncpy(name, ngroup->id.name+2, UI_MAX_NAME_STR);
|
||||
BLI_strncpy(name, ngroup->id.name + 2, UI_MAX_NAME_STR);
|
||||
|
||||
but = uiDefBut(block, BUT, 0, ngroup->id.name+2, 0, 0, UI_UNIT_X*4, UI_UNIT_Y,
|
||||
NULL, 0.0, 0.0, 0.0, 0.0, TIP_("Add node to input"));
|
||||
but = uiDefBut(block, BUT, 0, ngroup->id.name + 2, 0, 0, UI_UNIT_X * 4, UI_UNIT_Y,
|
||||
NULL, 0.0, 0.0, 0.0, 0.0, TIP_("Add node to input"));
|
||||
|
||||
argN = MEM_dupallocN(arg);
|
||||
argN->type = NODE_GROUP;
|
||||
@ -393,9 +393,9 @@ static void ui_node_menu_column(NodeLinkArg *arg, int nclass, const char *cname)
|
||||
}
|
||||
}
|
||||
else {
|
||||
bNodeTreeType *ttype= ntreeGetType(ntree->type);
|
||||
bNodeTreeType *ttype = ntreeGetType(ntree->type);
|
||||
|
||||
for (ntype=ttype->node_types.first; ntype; ntype=ntype->next) {
|
||||
for (ntype = ttype->node_types.first; ntype; ntype = ntype->next) {
|
||||
bNodeSocketTemplate *stemp;
|
||||
char name[UI_MAX_NAME_STR];
|
||||
int i, j, num = 0;
|
||||
@ -406,11 +406,11 @@ static void ui_node_menu_column(NodeLinkArg *arg, int nclass, const char *cname)
|
||||
if (ntype->nclass != nclass)
|
||||
continue;
|
||||
|
||||
for (i=0, stemp=ntype->outputs; stemp && stemp->type != -1; stemp++, i++)
|
||||
for (i = 0, stemp = ntype->outputs; stemp && stemp->type != -1; stemp++, i++)
|
||||
if (ui_compatible_sockets(stemp->type, sock->type))
|
||||
num++;
|
||||
|
||||
for (i=0, j=0, stemp=ntype->outputs; stemp && stemp->type != -1; stemp++, i++) {
|
||||
for (i = 0, j = 0, stemp = ntype->outputs; stemp && stemp->type != -1; stemp++, i++) {
|
||||
if (!ui_compatible_sockets(stemp->type, sock->type))
|
||||
continue;
|
||||
|
||||
@ -419,8 +419,8 @@ static void ui_node_menu_column(NodeLinkArg *arg, int nclass, const char *cname)
|
||||
uiBlockSetCurLayout(block, column);
|
||||
|
||||
uiItemL(column, IFACE_(cname), ICON_NODE);
|
||||
but= block->buttons.last;
|
||||
but->flag= UI_TEXT_LEFT;
|
||||
but = block->buttons.last;
|
||||
but->flag = UI_TEXT_LEFT;
|
||||
|
||||
first = 0;
|
||||
}
|
||||
@ -428,8 +428,8 @@ static void ui_node_menu_column(NodeLinkArg *arg, int nclass, const char *cname)
|
||||
if (num > 1) {
|
||||
if (j == 0) {
|
||||
uiItemL(column, IFACE_(ntype->name), ICON_NODE);
|
||||
but= block->buttons.last;
|
||||
but->flag= UI_TEXT_LEFT;
|
||||
but = block->buttons.last;
|
||||
but->flag = UI_TEXT_LEFT;
|
||||
}
|
||||
|
||||
BLI_snprintf(name, UI_MAX_NAME_STR, " %s", IFACE_(stemp->name));
|
||||
@ -438,8 +438,8 @@ static void ui_node_menu_column(NodeLinkArg *arg, int nclass, const char *cname)
|
||||
else
|
||||
BLI_strncpy(name, IFACE_(ntype->name), UI_MAX_NAME_STR);
|
||||
|
||||
but = uiDefBut(block, BUT, 0, name, 0, 0, UI_UNIT_X*4, UI_UNIT_Y,
|
||||
NULL, 0.0, 0.0, 0.0, 0.0, TIP_("Add node to input"));
|
||||
but = uiDefBut(block, BUT, 0, name, 0, 0, UI_UNIT_X * 4, UI_UNIT_Y,
|
||||
NULL, 0.0, 0.0, 0.0, 0.0, TIP_("Add node to input"));
|
||||
|
||||
argN = MEM_dupallocN(arg);
|
||||
argN->type = ntype->type;
|
||||
@ -452,7 +452,7 @@ static void ui_node_menu_column(NodeLinkArg *arg, int nclass, const char *cname)
|
||||
|
||||
static void node_menu_column_foreach_cb(void *calldata, int nclass, const char *name)
|
||||
{
|
||||
NodeLinkArg *arg = (NodeLinkArg*)calldata;
|
||||
NodeLinkArg *arg = (NodeLinkArg *)calldata;
|
||||
|
||||
if (!ELEM(nclass, NODE_CLASS_GROUP, NODE_CLASS_LAYOUT))
|
||||
ui_node_menu_column(arg, nclass, name);
|
||||
@ -460,22 +460,22 @@ static void node_menu_column_foreach_cb(void *calldata, int nclass, const char *
|
||||
|
||||
static void ui_template_node_link_menu(bContext *C, uiLayout *layout, void *but_p)
|
||||
{
|
||||
Main *bmain= CTX_data_main(C);
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
uiBlock *block = uiLayoutGetBlock(layout);
|
||||
uiBut *but = (uiBut*)but_p;
|
||||
uiBut *but = (uiBut *)but_p;
|
||||
uiLayout *split, *column;
|
||||
NodeLinkArg *arg = (NodeLinkArg*)but->func_argN;
|
||||
NodeLinkArg *arg = (NodeLinkArg *)but->func_argN;
|
||||
bNodeSocket *sock = arg->sock;
|
||||
bNodeTreeType *ntreetype= ntreeGetType(arg->ntree->type);
|
||||
bNodeTreeType *ntreetype = ntreeGetType(arg->ntree->type);
|
||||
|
||||
uiBlockSetCurLayout(block, layout);
|
||||
split = uiLayoutSplit(layout, 0.0f, FALSE);
|
||||
|
||||
arg->bmain= bmain;
|
||||
arg->scene= scene;
|
||||
arg->layout= split;
|
||||
|
||||
arg->bmain = bmain;
|
||||
arg->scene = scene;
|
||||
arg->layout = split;
|
||||
|
||||
if (ntreetype && ntreetype->foreach_nodeclass)
|
||||
ntreetype->foreach_nodeclass(scene, arg, node_menu_column_foreach_cb);
|
||||
|
||||
@ -484,15 +484,15 @@ static void ui_template_node_link_menu(bContext *C, uiLayout *layout, void *but_
|
||||
|
||||
if (sock->link) {
|
||||
uiItemL(column, IFACE_("Link"), ICON_NONE);
|
||||
but= block->buttons.last;
|
||||
but->flag= UI_TEXT_LEFT;
|
||||
but = block->buttons.last;
|
||||
but->flag = UI_TEXT_LEFT;
|
||||
|
||||
but = uiDefBut(block, BUT, 0, IFACE_("Remove"), 0, 0, UI_UNIT_X*4, UI_UNIT_Y,
|
||||
NULL, 0.0, 0.0, 0.0, 0.0, TIP_("Remove nodes connected to the input"));
|
||||
but = uiDefBut(block, BUT, 0, IFACE_("Remove"), 0, 0, UI_UNIT_X * 4, UI_UNIT_Y,
|
||||
NULL, 0.0, 0.0, 0.0, 0.0, TIP_("Remove nodes connected to the input"));
|
||||
uiButSetNFunc(but, ui_node_link, MEM_dupallocN(arg), SET_INT_IN_POINTER(UI_NODE_LINK_REMOVE));
|
||||
|
||||
but = uiDefBut(block, BUT, 0, IFACE_("Disconnect"), 0, 0, UI_UNIT_X*4, UI_UNIT_Y,
|
||||
NULL, 0.0, 0.0, 0.0, 0.0, TIP_("Disconnect nodes connected to the input"));
|
||||
but = uiDefBut(block, BUT, 0, IFACE_("Disconnect"), 0, 0, UI_UNIT_X * 4, UI_UNIT_Y,
|
||||
NULL, 0.0, 0.0, 0.0, 0.0, TIP_("Disconnect nodes connected to the input"));
|
||||
uiButSetNFunc(but, ui_node_link, MEM_dupallocN(arg), SET_INT_IN_POINTER(UI_NODE_LINK_DISCONNECT));
|
||||
}
|
||||
|
||||
@ -517,14 +517,14 @@ void uiTemplateNodeLink(uiLayout *layout, bNodeTree *ntree, bNode *node, bNodeSo
|
||||
if (sock->link || sock->type == SOCK_SHADER || (sock->flag & SOCK_HIDE_VALUE)) {
|
||||
char name[UI_MAX_NAME_STR];
|
||||
ui_node_sock_name(sock, name);
|
||||
but = uiDefMenuBut(block, ui_template_node_link_menu, NULL, name, 0, 0, UI_UNIT_X*4, UI_UNIT_Y, "");
|
||||
but = uiDefMenuBut(block, ui_template_node_link_menu, NULL, name, 0, 0, UI_UNIT_X * 4, UI_UNIT_Y, "");
|
||||
}
|
||||
else
|
||||
but = uiDefIconMenuBut(block, ui_template_node_link_menu, NULL, ICON_NONE, 0, 0, UI_UNIT_X, UI_UNIT_Y, "");
|
||||
|
||||
but->type= MENU;
|
||||
but->flag |= UI_TEXT_LEFT|UI_BUT_NODE_LINK;
|
||||
but->poin= (char*)but;
|
||||
but->type = MENU;
|
||||
but->flag |= UI_TEXT_LEFT | UI_BUT_NODE_LINK;
|
||||
but->poin = (char *)but;
|
||||
but->func_argN = arg;
|
||||
|
||||
if (sock->link && sock->link->fromnode)
|
||||
@ -535,7 +535,7 @@ void uiTemplateNodeLink(uiLayout *layout, bNodeTree *ntree, bNode *node, bNodeSo
|
||||
/**************************** Node Tree Layout *******************************/
|
||||
|
||||
static void ui_node_draw_input(uiLayout *layout, bContext *C,
|
||||
bNodeTree *ntree, bNode *node, bNodeSocket *input, int depth);
|
||||
bNodeTree *ntree, bNode *node, bNodeSocket *input, int depth);
|
||||
|
||||
static void ui_node_draw_node(uiLayout *layout, bContext *C, bNodeTree *ntree, bNode *node, int depth)
|
||||
{
|
||||
@ -555,8 +555,8 @@ static void ui_node_draw_node(uiLayout *layout, bContext *C, bNodeTree *ntree, b
|
||||
}
|
||||
}
|
||||
|
||||
for (input=node->inputs.first; input; input=input->next)
|
||||
ui_node_draw_input(layout, C, ntree, node, input, depth+1);
|
||||
for (input = node->inputs.first; input; input = input->next)
|
||||
ui_node_draw_input(layout, C, ntree, node, input, depth + 1);
|
||||
}
|
||||
|
||||
static void ui_node_draw_input(uiLayout *layout, bContext *C, bNodeTree *ntree, bNode *node, bNodeSocket *input, int depth)
|
||||
@ -567,7 +567,7 @@ static void ui_node_draw_input(uiLayout *layout, bContext *C, bNodeTree *ntree,
|
||||
uiLayout *split, *row, *col;
|
||||
bNode *lnode;
|
||||
char label[UI_MAX_NAME_STR];
|
||||
int indent = (depth > 1)? 2*(depth - 1): 0;
|
||||
int indent = (depth > 1) ? 2 * (depth - 1) : 0;
|
||||
int dependency_loop;
|
||||
|
||||
if (input->flag & SOCK_UNAVAIL)
|
||||
@ -575,7 +575,7 @@ static void ui_node_draw_input(uiLayout *layout, bContext *C, bNodeTree *ntree,
|
||||
|
||||
/* to avoid eternal loops on cyclic dependencies */
|
||||
node->flag |= NODE_TEST;
|
||||
lnode = (input->link)? input->link->fromnode: NULL;
|
||||
lnode = (input->link) ? input->link->fromnode : NULL;
|
||||
|
||||
dependency_loop = (lnode && (lnode->flag & NODE_TEST));
|
||||
if (dependency_loop)
|
||||
@ -598,21 +598,21 @@ static void ui_node_draw_input(uiLayout *layout, bContext *C, bNodeTree *ntree,
|
||||
uiBlockSetEmboss(block, UI_EMBOSSN);
|
||||
|
||||
if (lnode && (lnode->inputs.first || (lnode->typeinfo->uifunc && lnode->type != NODE_GROUP))) {
|
||||
int icon = (input->flag & SOCK_COLLAPSED)? ICON_DISCLOSURE_TRI_RIGHT: ICON_DISCLOSURE_TRI_DOWN;
|
||||
int icon = (input->flag & SOCK_COLLAPSED) ? ICON_DISCLOSURE_TRI_RIGHT : ICON_DISCLOSURE_TRI_DOWN;
|
||||
uiItemR(row, &inputptr, "show_expanded", UI_ITEM_R_ICON_ONLY, "", icon);
|
||||
}
|
||||
else
|
||||
uiItemL(row, "", ICON_BLANK1);
|
||||
|
||||
bt = block->buttons.last;
|
||||
bt->x2 = UI_UNIT_X/2;
|
||||
bt->x2 = UI_UNIT_X / 2;
|
||||
|
||||
uiBlockSetEmboss(block, UI_EMBOSS);
|
||||
}
|
||||
|
||||
uiItemL(row, label, ICON_NONE);
|
||||
bt= block->buttons.last;
|
||||
bt->flag= UI_TEXT_LEFT;
|
||||
bt = block->buttons.last;
|
||||
bt->flag = UI_TEXT_LEFT;
|
||||
|
||||
if (dependency_loop) {
|
||||
row = uiLayoutRow(split, FALSE);
|
||||
@ -661,7 +661,7 @@ void uiTemplateNodeView(uiLayout *layout, bContext *C, bNodeTree *ntree, bNode *
|
||||
return;
|
||||
|
||||
/* clear for cycle check */
|
||||
for (tnode=ntree->nodes.first; tnode; tnode=tnode->next)
|
||||
for (tnode = ntree->nodes.first; tnode; tnode = tnode->next)
|
||||
tnode->flag &= ~NODE_TEST;
|
||||
|
||||
if (input)
|
||||
|
@ -4,7 +4,7 @@
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
@ -18,7 +18,7 @@
|
||||
* The Original Code is Copyright (C) 2008 Blender Foundation.
|
||||
* All rights reserved.
|
||||
*
|
||||
*
|
||||
*
|
||||
* Contributor(s): Blender Foundation
|
||||
*
|
||||
* ***** END GPL LICENSE BLOCK *****
|
||||
@ -63,7 +63,7 @@
|
||||
|
||||
#include "RNA_access.h"
|
||||
|
||||
#include "node_intern.h" // own include
|
||||
#include "node_intern.h" // own include
|
||||
|
||||
/* ******************** manage regions ********************* */
|
||||
|
||||
@ -71,23 +71,23 @@ ARegion *node_has_buttons_region(ScrArea *sa)
|
||||
{
|
||||
ARegion *ar, *arnew;
|
||||
|
||||
ar= BKE_area_find_region_type(sa, RGN_TYPE_UI);
|
||||
ar = BKE_area_find_region_type(sa, RGN_TYPE_UI);
|
||||
if (ar) return ar;
|
||||
|
||||
|
||||
/* add subdiv level; after header */
|
||||
ar= BKE_area_find_region_type(sa, RGN_TYPE_HEADER);
|
||||
ar = BKE_area_find_region_type(sa, RGN_TYPE_HEADER);
|
||||
|
||||
/* is error! */
|
||||
if (ar==NULL) return NULL;
|
||||
|
||||
arnew= MEM_callocN(sizeof(ARegion), "buttons for node");
|
||||
|
||||
if (ar == NULL) return NULL;
|
||||
|
||||
arnew = MEM_callocN(sizeof(ARegion), "buttons for node");
|
||||
|
||||
BLI_insertlinkafter(&sa->regionbase, ar, arnew);
|
||||
arnew->regiontype= RGN_TYPE_UI;
|
||||
arnew->alignment= RGN_ALIGN_RIGHT;
|
||||
|
||||
arnew->regiontype = RGN_TYPE_UI;
|
||||
arnew->alignment = RGN_ALIGN_RIGHT;
|
||||
|
||||
arnew->flag = RGN_FLAG_HIDDEN;
|
||||
|
||||
|
||||
return arnew;
|
||||
}
|
||||
|
||||
@ -97,64 +97,64 @@ static SpaceLink *node_new(const bContext *UNUSED(C))
|
||||
{
|
||||
ARegion *ar;
|
||||
SpaceNode *snode;
|
||||
|
||||
snode= MEM_callocN(sizeof(SpaceNode), "initnode");
|
||||
snode->spacetype= SPACE_NODE;
|
||||
|
||||
|
||||
snode = MEM_callocN(sizeof(SpaceNode), "initnode");
|
||||
snode->spacetype = SPACE_NODE;
|
||||
|
||||
/* backdrop */
|
||||
snode->zoom = 1.0f;
|
||||
|
||||
|
||||
/* header */
|
||||
ar= MEM_callocN(sizeof(ARegion), "header for node");
|
||||
|
||||
ar = MEM_callocN(sizeof(ARegion), "header for node");
|
||||
|
||||
BLI_addtail(&snode->regionbase, ar);
|
||||
ar->regiontype= RGN_TYPE_HEADER;
|
||||
ar->alignment= RGN_ALIGN_BOTTOM;
|
||||
|
||||
ar->regiontype = RGN_TYPE_HEADER;
|
||||
ar->alignment = RGN_ALIGN_BOTTOM;
|
||||
|
||||
/* buttons/list view */
|
||||
ar= MEM_callocN(sizeof(ARegion), "buttons for node");
|
||||
|
||||
ar = MEM_callocN(sizeof(ARegion), "buttons for node");
|
||||
|
||||
BLI_addtail(&snode->regionbase, ar);
|
||||
ar->regiontype= RGN_TYPE_UI;
|
||||
ar->alignment= RGN_ALIGN_RIGHT;
|
||||
ar->regiontype = RGN_TYPE_UI;
|
||||
ar->alignment = RGN_ALIGN_RIGHT;
|
||||
ar->flag = RGN_FLAG_HIDDEN;
|
||||
|
||||
|
||||
/* main area */
|
||||
ar= MEM_callocN(sizeof(ARegion), "main area for node");
|
||||
|
||||
ar = MEM_callocN(sizeof(ARegion), "main area for node");
|
||||
|
||||
BLI_addtail(&snode->regionbase, ar);
|
||||
ar->regiontype= RGN_TYPE_WINDOW;
|
||||
|
||||
ar->regiontype = RGN_TYPE_WINDOW;
|
||||
|
||||
ar->v2d.tot.xmin = -256.0f;
|
||||
ar->v2d.tot.ymin = -256.0f;
|
||||
ar->v2d.tot.xmax = 768.0f;
|
||||
ar->v2d.tot.ymax = 768.0f;
|
||||
|
||||
|
||||
ar->v2d.cur.xmin = -256.0f;
|
||||
ar->v2d.cur.ymin = -256.0f;
|
||||
ar->v2d.cur.xmax = 768.0f;
|
||||
ar->v2d.cur.ymax = 768.0f;
|
||||
|
||||
ar->v2d.min[0]= 1.0f;
|
||||
ar->v2d.min[1]= 1.0f;
|
||||
|
||||
ar->v2d.max[0]= 32000.0f;
|
||||
ar->v2d.max[1]= 32000.0f;
|
||||
|
||||
ar->v2d.minzoom= 0.09f;
|
||||
ar->v2d.maxzoom= 2.31f;
|
||||
|
||||
ar->v2d.scroll= (V2D_SCROLL_RIGHT|V2D_SCROLL_BOTTOM);
|
||||
ar->v2d.keepzoom= V2D_LIMITZOOM|V2D_KEEPASPECT;
|
||||
ar->v2d.keeptot= 0;
|
||||
|
||||
|
||||
ar->v2d.min[0] = 1.0f;
|
||||
ar->v2d.min[1] = 1.0f;
|
||||
|
||||
ar->v2d.max[0] = 32000.0f;
|
||||
ar->v2d.max[1] = 32000.0f;
|
||||
|
||||
ar->v2d.minzoom = 0.09f;
|
||||
ar->v2d.maxzoom = 2.31f;
|
||||
|
||||
ar->v2d.scroll = (V2D_SCROLL_RIGHT | V2D_SCROLL_BOTTOM);
|
||||
ar->v2d.keepzoom = V2D_LIMITZOOM | V2D_KEEPASPECT;
|
||||
ar->v2d.keeptot = 0;
|
||||
|
||||
return (SpaceLink *)snode;
|
||||
}
|
||||
|
||||
/* not spacelink itself */
|
||||
static void node_free(SpaceLink *UNUSED(sl))
|
||||
{
|
||||
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -167,10 +167,10 @@ static void node_init(struct wmWindowManager *UNUSED(wm), ScrArea *UNUSED(sa))
|
||||
static void node_area_listener(ScrArea *sa, wmNotifier *wmn)
|
||||
{
|
||||
/* note, ED_area_tag_refresh will re-execute compositor */
|
||||
SpaceNode *snode= sa->spacedata.first;
|
||||
int type= snode->treetype;
|
||||
SpaceNode *snode = sa->spacedata.first;
|
||||
int type = snode->treetype;
|
||||
short shader_type = snode->shaderfrom;
|
||||
|
||||
|
||||
/* preview renders */
|
||||
switch (wmn->category) {
|
||||
case NC_SCENE:
|
||||
@ -183,9 +183,9 @@ static void node_area_listener(ScrArea *sa, wmNotifier *wmn)
|
||||
ED_area_tag_redraw(sa);
|
||||
break;
|
||||
case ND_TRANSFORM_DONE:
|
||||
if (type==NTREE_COMPOSIT) {
|
||||
if (type == NTREE_COMPOSIT) {
|
||||
if (snode->flag & SNODE_AUTO_RENDER) {
|
||||
snode->recalc= 1;
|
||||
snode->recalc = 1;
|
||||
ED_area_tag_refresh(sa);
|
||||
}
|
||||
}
|
||||
@ -193,43 +193,43 @@ static void node_area_listener(ScrArea *sa, wmNotifier *wmn)
|
||||
}
|
||||
break;
|
||||
case NC_WM:
|
||||
if (wmn->data==ND_FILEREAD)
|
||||
if (wmn->data == ND_FILEREAD)
|
||||
ED_area_tag_refresh(sa);
|
||||
break;
|
||||
|
||||
|
||||
/* future: add ID checks? */
|
||||
case NC_MATERIAL:
|
||||
if (type==NTREE_SHADER) {
|
||||
if (wmn->data==ND_SHADING)
|
||||
if (type == NTREE_SHADER) {
|
||||
if (wmn->data == ND_SHADING)
|
||||
ED_area_tag_refresh(sa);
|
||||
else if (wmn->data==ND_SHADING_DRAW)
|
||||
else if (wmn->data == ND_SHADING_DRAW)
|
||||
ED_area_tag_refresh(sa);
|
||||
else if (wmn->action==NA_ADDED && snode->edittree)
|
||||
else if (wmn->action == NA_ADDED && snode->edittree)
|
||||
nodeSetActiveID(snode->edittree, ID_MA, wmn->reference);
|
||||
|
||||
|
||||
}
|
||||
break;
|
||||
case NC_TEXTURE:
|
||||
if (type==NTREE_SHADER || type==NTREE_TEXTURE) {
|
||||
if (wmn->data==ND_NODES)
|
||||
if (type == NTREE_SHADER || type == NTREE_TEXTURE) {
|
||||
if (wmn->data == ND_NODES)
|
||||
ED_area_tag_refresh(sa);
|
||||
}
|
||||
break;
|
||||
case NC_WORLD:
|
||||
if (type==NTREE_SHADER && shader_type==SNODE_SHADER_WORLD) {
|
||||
ED_area_tag_refresh(sa);
|
||||
if (type == NTREE_SHADER && shader_type == SNODE_SHADER_WORLD) {
|
||||
ED_area_tag_refresh(sa);
|
||||
}
|
||||
break;
|
||||
case NC_OBJECT:
|
||||
if (type==NTREE_SHADER) {
|
||||
if (wmn->data==ND_OB_SHADING)
|
||||
if (type == NTREE_SHADER) {
|
||||
if (wmn->data == ND_OB_SHADING)
|
||||
ED_area_tag_refresh(sa);
|
||||
}
|
||||
break;
|
||||
case NC_SPACE:
|
||||
if (wmn->data==ND_SPACE_NODE)
|
||||
if (wmn->data == ND_SPACE_NODE)
|
||||
ED_area_tag_refresh(sa);
|
||||
else if (wmn->data==ND_SPACE_NODE_VIEW)
|
||||
else if (wmn->data == ND_SPACE_NODE_VIEW)
|
||||
ED_area_tag_redraw(sa);
|
||||
break;
|
||||
case NC_NODE:
|
||||
@ -247,7 +247,7 @@ static void node_area_listener(ScrArea *sa, wmNotifier *wmn)
|
||||
break;
|
||||
case NC_MASK:
|
||||
if (wmn->action == NA_EDITED) {
|
||||
if (type==NTREE_COMPOSIT) {
|
||||
if (type == NTREE_COMPOSIT) {
|
||||
ED_area_tag_refresh(sa);
|
||||
}
|
||||
}
|
||||
@ -255,7 +255,7 @@ static void node_area_listener(ScrArea *sa, wmNotifier *wmn)
|
||||
|
||||
case NC_IMAGE:
|
||||
if (wmn->action == NA_EDITED) {
|
||||
if (type==NTREE_COMPOSIT) {
|
||||
if (type == NTREE_COMPOSIT) {
|
||||
/* note that nodeUpdateID is already called by BKE_image_signal() on all
|
||||
* scenes so really this is just to know if the images is used in the compo else
|
||||
* painting on images could become very slow when the compositor is open. */
|
||||
@ -270,42 +270,42 @@ static void node_area_listener(ScrArea *sa, wmNotifier *wmn)
|
||||
static void node_area_refresh(const struct bContext *C, struct ScrArea *sa)
|
||||
{
|
||||
/* default now: refresh node is starting preview */
|
||||
SpaceNode *snode= sa->spacedata.first;
|
||||
SpaceNode *snode = sa->spacedata.first;
|
||||
|
||||
snode_set_context(snode, CTX_data_scene(C));
|
||||
|
||||
|
||||
if (snode->nodetree) {
|
||||
if (snode->treetype==NTREE_SHADER) {
|
||||
if (snode->treetype == NTREE_SHADER) {
|
||||
if (GS(snode->id->name) == ID_MA) {
|
||||
Material *ma= (Material *)snode->id;
|
||||
Material *ma = (Material *)snode->id;
|
||||
if (ma->use_nodes)
|
||||
ED_preview_shader_job(C, sa, snode->id, NULL, NULL, 100, 100, PR_NODE_RENDER);
|
||||
}
|
||||
else if (GS(snode->id->name) == ID_LA) {
|
||||
Lamp *la= (Lamp *)snode->id;
|
||||
Lamp *la = (Lamp *)snode->id;
|
||||
if (la->use_nodes)
|
||||
ED_preview_shader_job(C, sa, snode->id, NULL, NULL, 100, 100, PR_NODE_RENDER);
|
||||
}
|
||||
else if (GS(snode->id->name) == ID_WO) {
|
||||
World *wo= (World *)snode->id;
|
||||
World *wo = (World *)snode->id;
|
||||
if (wo->use_nodes)
|
||||
ED_preview_shader_job(C, sa, snode->id, NULL, NULL, 100, 100, PR_NODE_RENDER);
|
||||
}
|
||||
}
|
||||
else if (snode->treetype==NTREE_COMPOSIT) {
|
||||
Scene *scene= (Scene *)snode->id;
|
||||
else if (snode->treetype == NTREE_COMPOSIT) {
|
||||
Scene *scene = (Scene *)snode->id;
|
||||
if (scene->use_nodes) {
|
||||
/* recalc is set on 3d view changes for auto compo */
|
||||
if (snode->recalc) {
|
||||
snode->recalc= 0;
|
||||
node_render_changed_exec((struct bContext*)C, NULL);
|
||||
snode->recalc = 0;
|
||||
node_render_changed_exec((struct bContext *)C, NULL);
|
||||
}
|
||||
else
|
||||
else
|
||||
snode_composite_job(C, sa);
|
||||
}
|
||||
}
|
||||
else if (snode->treetype==NTREE_TEXTURE) {
|
||||
Tex *tex= (Tex *)snode->id;
|
||||
else if (snode->treetype == NTREE_TEXTURE) {
|
||||
Tex *tex = (Tex *)snode->id;
|
||||
if (tex->use_nodes) {
|
||||
ED_preview_shader_job(C, sa, snode->id, NULL, NULL, 100, 100, PR_NODE_RENDER);
|
||||
}
|
||||
@ -315,12 +315,12 @@ static void node_area_refresh(const struct bContext *C, struct ScrArea *sa)
|
||||
|
||||
static SpaceLink *node_duplicate(SpaceLink *sl)
|
||||
{
|
||||
SpaceNode *snoden= MEM_dupallocN(sl);
|
||||
|
||||
SpaceNode *snoden = MEM_dupallocN(sl);
|
||||
|
||||
/* clear or remove stuff from old */
|
||||
snoden->nodetree= NULL;
|
||||
snoden->linkdrag.first= snoden->linkdrag.last= NULL;
|
||||
|
||||
snoden->nodetree = NULL;
|
||||
snoden->linkdrag.first = snoden->linkdrag.last = NULL;
|
||||
|
||||
return (SpaceLink *)snoden;
|
||||
}
|
||||
|
||||
@ -331,7 +331,7 @@ static void node_buttons_area_init(wmWindowManager *wm, ARegion *ar)
|
||||
wmKeyMap *keymap;
|
||||
|
||||
ED_region_panels_init(wm, ar);
|
||||
|
||||
|
||||
keymap = WM_keymap_find(wm->defaultconf, "Node Generic", SPACE_NODE, 0);
|
||||
WM_event_add_keymap_handler(&ar->handlers, keymap);
|
||||
}
|
||||
@ -343,12 +343,12 @@ static void node_buttons_area_draw(const bContext *C, ARegion *ar)
|
||||
|
||||
static void node_cursor(wmWindow *win, ScrArea *sa, ARegion *ar)
|
||||
{
|
||||
SpaceNode *snode= sa->spacedata.first;
|
||||
|
||||
SpaceNode *snode = sa->spacedata.first;
|
||||
|
||||
/* convert mouse coordinates to v2d space */
|
||||
UI_view2d_region_to_view(&ar->v2d, win->eventstate->x - ar->winrct.xmin, win->eventstate->y - ar->winrct.ymin,
|
||||
&snode->mx, &snode->my);
|
||||
|
||||
|
||||
node_set_cursor(win, snode);
|
||||
}
|
||||
|
||||
@ -357,26 +357,26 @@ static void node_main_area_init(wmWindowManager *wm, ARegion *ar)
|
||||
{
|
||||
wmKeyMap *keymap;
|
||||
ListBase *lb;
|
||||
|
||||
|
||||
UI_view2d_region_reinit(&ar->v2d, V2D_COMMONVIEW_CUSTOM, ar->winx, ar->winy);
|
||||
|
||||
|
||||
/* own keymaps */
|
||||
keymap = WM_keymap_find(wm->defaultconf, "Node Generic", SPACE_NODE, 0);
|
||||
WM_event_add_keymap_handler(&ar->handlers, keymap);
|
||||
|
||||
|
||||
keymap = WM_keymap_find(wm->defaultconf, "Node Editor", SPACE_NODE, 0);
|
||||
WM_event_add_keymap_handler_bb(&ar->handlers, keymap, &ar->v2d.mask, &ar->winrct);
|
||||
|
||||
|
||||
/* add drop boxes */
|
||||
lb = WM_dropboxmap_find("Node Editor", SPACE_NODE, RGN_TYPE_WINDOW);
|
||||
|
||||
|
||||
WM_event_add_dropbox_handler(&ar->handlers, lb);
|
||||
}
|
||||
|
||||
static void node_main_area_draw(const bContext *C, ARegion *ar)
|
||||
{
|
||||
View2D *v2d= &ar->v2d;
|
||||
|
||||
View2D *v2d = &ar->v2d;
|
||||
|
||||
drawnodespace(C, ar, v2d);
|
||||
}
|
||||
|
||||
@ -385,13 +385,13 @@ static void node_main_area_draw(const bContext *C, ARegion *ar)
|
||||
|
||||
static int node_drop_poll(bContext *UNUSED(C), wmDrag *drag, wmEvent *UNUSED(event))
|
||||
{
|
||||
if (drag->type==WM_DRAG_ID) {
|
||||
ID *id= (ID *)drag->poin;
|
||||
if ( GS(id->name)==ID_IM )
|
||||
if (drag->type == WM_DRAG_ID) {
|
||||
ID *id = (ID *)drag->poin;
|
||||
if (GS(id->name) == ID_IM)
|
||||
return 1;
|
||||
}
|
||||
else if (drag->type==WM_DRAG_PATH) {
|
||||
if (ELEM(drag->icon, 0, ICON_FILE_IMAGE)) /* rule might not work? */
|
||||
else if (drag->type == WM_DRAG_PATH) {
|
||||
if (ELEM(drag->icon, 0, ICON_FILE_IMAGE)) /* rule might not work? */
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
@ -399,10 +399,10 @@ static int node_drop_poll(bContext *UNUSED(C), wmDrag *drag, wmEvent *UNUSED(eve
|
||||
|
||||
static void node_id_path_drop_copy(wmDrag *drag, wmDropBox *drop)
|
||||
{
|
||||
ID *id= (ID *)drag->poin;
|
||||
|
||||
ID *id = (ID *)drag->poin;
|
||||
|
||||
if (id) {
|
||||
RNA_string_set(drop->ptr, "name", id->name+2);
|
||||
RNA_string_set(drop->ptr, "name", id->name + 2);
|
||||
}
|
||||
if (drag->path[0]) {
|
||||
RNA_string_set(drop->ptr, "filepath", drag->path);
|
||||
@ -412,10 +412,10 @@ static void node_id_path_drop_copy(wmDrag *drag, wmDropBox *drop)
|
||||
/* this region dropbox definition */
|
||||
static void node_dropboxes(void)
|
||||
{
|
||||
ListBase *lb= WM_dropboxmap_find("Node Editor", SPACE_NODE, RGN_TYPE_WINDOW);
|
||||
|
||||
ListBase *lb = WM_dropboxmap_find("Node Editor", SPACE_NODE, RGN_TYPE_WINDOW);
|
||||
|
||||
WM_dropbox_add(lb, "NODE_OT_add_file", node_drop_poll, node_id_path_drop_copy);
|
||||
|
||||
|
||||
}
|
||||
|
||||
/* ************* end drop *********** */
|
||||
@ -429,8 +429,8 @@ static void node_header_area_init(wmWindowManager *UNUSED(wm), ARegion *ar)
|
||||
|
||||
static void node_header_area_draw(const bContext *C, ARegion *ar)
|
||||
{
|
||||
SpaceNode *snode= CTX_wm_space_node(C);
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
SpaceNode *snode = CTX_wm_space_node(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
|
||||
/* find and set the context */
|
||||
snode_set_context(snode, scene);
|
||||
@ -444,11 +444,11 @@ static void node_region_listener(ARegion *ar, wmNotifier *wmn)
|
||||
/* context changes */
|
||||
switch (wmn->category) {
|
||||
case NC_SPACE:
|
||||
if (wmn->data==ND_SPACE_NODE)
|
||||
if (wmn->data == ND_SPACE_NODE)
|
||||
ED_region_tag_redraw(ar);
|
||||
break;
|
||||
case NC_SCREEN:
|
||||
if (wmn->data == ND_GPENCIL)
|
||||
if (wmn->data == ND_GPENCIL)
|
||||
ED_region_tag_redraw(ar);
|
||||
break;
|
||||
case NC_SCENE:
|
||||
@ -458,7 +458,7 @@ static void node_region_listener(ARegion *ar, wmNotifier *wmn)
|
||||
ED_region_tag_redraw(ar);
|
||||
break;
|
||||
case NC_OBJECT:
|
||||
if (wmn->data==ND_OB_SHADING)
|
||||
if (wmn->data == ND_OB_SHADING)
|
||||
ED_region_tag_redraw(ar);
|
||||
break;
|
||||
case NC_ID:
|
||||
@ -472,17 +472,17 @@ const char *node_context_dir[] = {"selected_nodes", "active_node", NULL};
|
||||
|
||||
static int node_context(const bContext *C, const char *member, bContextDataResult *result)
|
||||
{
|
||||
SpaceNode *snode= CTX_wm_space_node(C);
|
||||
|
||||
SpaceNode *snode = CTX_wm_space_node(C);
|
||||
|
||||
if (CTX_data_dir(member)) {
|
||||
CTX_data_dir_set(result, node_context_dir);
|
||||
return 1;
|
||||
}
|
||||
else if (CTX_data_equals(member, "selected_nodes")) {
|
||||
bNode *node;
|
||||
|
||||
|
||||
if (snode->edittree) {
|
||||
for (node=snode->edittree->nodes.last; node; node=node->prev) {
|
||||
for (node = snode->edittree->nodes.last; node; node = node->prev) {
|
||||
if (node->flag & NODE_SELECT) {
|
||||
CTX_data_list_add(result, &snode->edittree->id, &RNA_Node, node);
|
||||
}
|
||||
@ -500,67 +500,67 @@ static int node_context(const bContext *C, const char *member, bContextDataResul
|
||||
CTX_data_type_set(result, CTX_DATA_TYPE_POINTER);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* only called once, from space/spacetypes.c */
|
||||
void ED_spacetype_node(void)
|
||||
{
|
||||
SpaceType *st= MEM_callocN(sizeof(SpaceType), "spacetype node");
|
||||
SpaceType *st = MEM_callocN(sizeof(SpaceType), "spacetype node");
|
||||
ARegionType *art;
|
||||
|
||||
st->spaceid= SPACE_NODE;
|
||||
|
||||
st->spaceid = SPACE_NODE;
|
||||
strncpy(st->name, "Node", BKE_ST_MAXNAME);
|
||||
|
||||
st->new= node_new;
|
||||
st->free= node_free;
|
||||
st->init= node_init;
|
||||
st->duplicate= node_duplicate;
|
||||
st->operatortypes= node_operatortypes;
|
||||
st->keymap= node_keymap;
|
||||
st->listener= node_area_listener;
|
||||
st->refresh= node_area_refresh;
|
||||
st->context= node_context;
|
||||
|
||||
st->new = node_new;
|
||||
st->free = node_free;
|
||||
st->init = node_init;
|
||||
st->duplicate = node_duplicate;
|
||||
st->operatortypes = node_operatortypes;
|
||||
st->keymap = node_keymap;
|
||||
st->listener = node_area_listener;
|
||||
st->refresh = node_area_refresh;
|
||||
st->context = node_context;
|
||||
st->dropboxes = node_dropboxes;
|
||||
|
||||
|
||||
/* regions: main window */
|
||||
art= MEM_callocN(sizeof(ARegionType), "spacetype node region");
|
||||
art = MEM_callocN(sizeof(ARegionType), "spacetype node region");
|
||||
art->regionid = RGN_TYPE_WINDOW;
|
||||
art->init= node_main_area_init;
|
||||
art->draw= node_main_area_draw;
|
||||
art->listener= node_region_listener;
|
||||
art->init = node_main_area_init;
|
||||
art->draw = node_main_area_draw;
|
||||
art->listener = node_region_listener;
|
||||
art->cursor = node_cursor;
|
||||
art->event_cursor = TRUE;
|
||||
art->keymapflag= ED_KEYMAP_UI|ED_KEYMAP_VIEW2D|ED_KEYMAP_FRAMES|ED_KEYMAP_GPENCIL;
|
||||
art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_VIEW2D | ED_KEYMAP_FRAMES | ED_KEYMAP_GPENCIL;
|
||||
|
||||
BLI_addhead(&st->regiontypes, art);
|
||||
|
||||
|
||||
/* regions: header */
|
||||
art= MEM_callocN(sizeof(ARegionType), "spacetype node region");
|
||||
art = MEM_callocN(sizeof(ARegionType), "spacetype node region");
|
||||
art->regionid = RGN_TYPE_HEADER;
|
||||
art->prefsizey= HEADERY;
|
||||
art->keymapflag= ED_KEYMAP_UI|ED_KEYMAP_VIEW2D|ED_KEYMAP_FRAMES|ED_KEYMAP_HEADER;
|
||||
art->listener= node_region_listener;
|
||||
art->init= node_header_area_init;
|
||||
art->draw= node_header_area_draw;
|
||||
|
||||
art->prefsizey = HEADERY;
|
||||
art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_VIEW2D | ED_KEYMAP_FRAMES | ED_KEYMAP_HEADER;
|
||||
art->listener = node_region_listener;
|
||||
art->init = node_header_area_init;
|
||||
art->draw = node_header_area_draw;
|
||||
|
||||
BLI_addhead(&st->regiontypes, art);
|
||||
|
||||
node_menus_register();
|
||||
|
||||
|
||||
/* regions: listview/buttons */
|
||||
art= MEM_callocN(sizeof(ARegionType), "spacetype node region");
|
||||
art = MEM_callocN(sizeof(ARegionType), "spacetype node region");
|
||||
art->regionid = RGN_TYPE_UI;
|
||||
art->prefsizex= 180; // XXX
|
||||
art->keymapflag= ED_KEYMAP_UI|ED_KEYMAP_FRAMES;
|
||||
art->listener= node_region_listener;
|
||||
art->init= node_buttons_area_init;
|
||||
art->draw= node_buttons_area_draw;
|
||||
art->prefsizex = 180; // XXX
|
||||
art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_FRAMES;
|
||||
art->listener = node_region_listener;
|
||||
art->init = node_buttons_area_init;
|
||||
art->draw = node_buttons_area_draw;
|
||||
BLI_addhead(&st->regiontypes, art);
|
||||
|
||||
|
||||
node_buttons_register(art);
|
||||
|
||||
|
||||
BKE_spacetype_register(st);
|
||||
}
|
||||
|
||||
|
@ -21,7 +21,7 @@
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Original author: Benoit Bolsee
|
||||
* Contributor(s):
|
||||
* Contributor(s):
|
||||
*
|
||||
* ***** END GPL LICENSE BLOCK *****
|
||||
*/
|
||||
@ -30,7 +30,6 @@
|
||||
* \ingroup ikplugin
|
||||
*/
|
||||
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
#include "BIK_api.h"
|
||||
@ -75,25 +74,25 @@ static void initialize_posetree(struct Object *UNUSED(ob), bPoseChannel *pchan_t
|
||||
}
|
||||
}
|
||||
if (con == NULL) return;
|
||||
|
||||
|
||||
/* exclude tip from chain? */
|
||||
if (!(data->flag & CONSTRAINT_IK_TIP))
|
||||
pchan_tip = pchan_tip->parent;
|
||||
|
||||
|
||||
/* Find the chain's root & count the segments needed */
|
||||
for (curchan = pchan_tip; curchan; curchan = curchan->parent) {
|
||||
pchan_root = curchan;
|
||||
|
||||
|
||||
curchan->flag |= POSE_CHAIN; // don't forget to clear this
|
||||
chanlist[segcount] = curchan;
|
||||
segcount++;
|
||||
|
||||
|
||||
if (segcount == data->rootbone || segcount > 255) break; // 255 is weak
|
||||
}
|
||||
if (!segcount) return;
|
||||
|
||||
/* setup the chain data */
|
||||
|
||||
|
||||
/* we make tree-IK, unless all existing targets are in this chain */
|
||||
for (tree = pchan_root->iktree.first; tree; tree = tree->next) {
|
||||
for (target = tree->targets.first; target; target = target->next) {
|
||||
@ -116,11 +115,11 @@ static void initialize_posetree(struct Object *UNUSED(ob), bPoseChannel *pchan_t
|
||||
tree = MEM_callocN(sizeof(PoseTree), "posetree");
|
||||
|
||||
tree->type = CONSTRAINT_TYPE_KINEMATIC;
|
||||
|
||||
|
||||
tree->iterations = data->iterations;
|
||||
tree->totchannel = segcount;
|
||||
tree->stretch = (data->flag & CONSTRAINT_IK_STRETCH);
|
||||
|
||||
|
||||
tree->pchan = MEM_callocN(segcount * sizeof(void *), "ik tree pchan");
|
||||
tree->parent = MEM_callocN(segcount * sizeof(int), "ik tree parent");
|
||||
for (a = 0; a < segcount; a++) {
|
||||
@ -128,7 +127,7 @@ static void initialize_posetree(struct Object *UNUSED(ob), bPoseChannel *pchan_t
|
||||
tree->parent[a] = a - 1;
|
||||
}
|
||||
target->tip = segcount - 1;
|
||||
|
||||
|
||||
/* AND! link the tree to the root */
|
||||
BLI_addtail(&pchan_root->iktree, tree);
|
||||
}
|
||||
@ -154,7 +153,7 @@ static void initialize_posetree(struct Object *UNUSED(ob), bPoseChannel *pchan_t
|
||||
for (parent = a - 1; parent < tree->totchannel; parent++)
|
||||
if (tree->pchan[parent] == chanlist[segcount - 1]->parent)
|
||||
break;
|
||||
|
||||
|
||||
/* shouldn't happen, but could with dependency cycles */
|
||||
if (parent == tree->totchannel)
|
||||
parent = a - 1;
|
||||
@ -177,7 +176,7 @@ static void initialize_posetree(struct Object *UNUSED(ob), bPoseChannel *pchan_t
|
||||
tree->parent[tree->totchannel + a] = tree->totchannel + a - 1;
|
||||
}
|
||||
tree->parent[tree->totchannel] = parent;
|
||||
|
||||
|
||||
tree->totchannel = newsize;
|
||||
}
|
||||
|
||||
@ -210,12 +209,12 @@ static void make_dmats(bPoseChannel *pchan)
|
||||
static void where_is_ik_bone(bPoseChannel *pchan, float ik_mat[][3]) // nr = to detect if this is first bone
|
||||
{
|
||||
float vec[3], ikmat[4][4];
|
||||
|
||||
|
||||
copy_m4_m3(ikmat, ik_mat);
|
||||
|
||||
|
||||
if (pchan->parent)
|
||||
mul_serie_m4(pchan->pose_mat, pchan->parent->pose_mat, pchan->chan_mat, ikmat, NULL, NULL, NULL, NULL, NULL);
|
||||
else
|
||||
else
|
||||
mult_m4_m4m4(pchan->pose_mat, pchan->chan_mat, ikmat);
|
||||
|
||||
/* calculate head */
|
||||
@ -253,13 +252,13 @@ static void execute_posetree(struct Scene *scene, Object *ob, PoseTree *tree)
|
||||
|
||||
if (tree->totchannel == 0)
|
||||
return;
|
||||
|
||||
|
||||
iktree = MEM_mallocN(sizeof(void *) * tree->totchannel, "ik tree");
|
||||
|
||||
for (a = 0; a < tree->totchannel; a++) {
|
||||
pchan = tree->pchan[a];
|
||||
bone = pchan->bone;
|
||||
|
||||
|
||||
/* set DoF flag */
|
||||
flag = 0;
|
||||
if (!(pchan->ikflag & BONE_IK_NO_XDOF) && !(pchan->ikflag & BONE_IK_NO_XDOF_TEMP))
|
||||
@ -268,72 +267,72 @@ static void execute_posetree(struct Scene *scene, Object *ob, PoseTree *tree)
|
||||
flag |= IK_YDOF;
|
||||
if (!(pchan->ikflag & BONE_IK_NO_ZDOF) && !(pchan->ikflag & BONE_IK_NO_ZDOF_TEMP))
|
||||
flag |= IK_ZDOF;
|
||||
|
||||
|
||||
if (tree->stretch && (pchan->ikstretch > 0.0f)) {
|
||||
flag |= IK_TRANS_YDOF;
|
||||
hasstretch = 1;
|
||||
}
|
||||
|
||||
|
||||
seg = iktree[a] = IK_CreateSegment(flag);
|
||||
|
||||
|
||||
/* find parent */
|
||||
if (a == 0)
|
||||
parent = NULL;
|
||||
else
|
||||
parent = iktree[tree->parent[a]];
|
||||
|
||||
|
||||
IK_SetParent(seg, parent);
|
||||
|
||||
|
||||
/* get the matrix that transforms from prevbone into this bone */
|
||||
copy_m3_m4(R_bonemat, pchan->pose_mat);
|
||||
|
||||
|
||||
/* gather transformations for this IK segment */
|
||||
|
||||
|
||||
if (pchan->parent)
|
||||
copy_m3_m4(R_parmat, pchan->parent->pose_mat);
|
||||
else
|
||||
unit_m3(R_parmat);
|
||||
|
||||
|
||||
/* bone offset */
|
||||
if (pchan->parent && (a > 0))
|
||||
sub_v3_v3v3(start, pchan->pose_head, pchan->parent->pose_tail);
|
||||
else
|
||||
/* only root bone (a = 0) has no parent */
|
||||
start[0] = start[1] = start[2] = 0.0f;
|
||||
|
||||
|
||||
/* change length based on bone size */
|
||||
length = bone->length * len_v3(R_bonemat[1]);
|
||||
|
||||
|
||||
/* compute rest basis and its inverse */
|
||||
copy_m3_m3(rest_basis, bone->bone_mat);
|
||||
copy_m3_m3(irest_basis, bone->bone_mat);
|
||||
transpose_m3(irest_basis);
|
||||
|
||||
|
||||
/* compute basis with rest_basis removed */
|
||||
invert_m3_m3(iR_parmat, R_parmat);
|
||||
mul_m3_m3m3(full_basis, iR_parmat, R_bonemat);
|
||||
mul_m3_m3m3(basis, irest_basis, full_basis);
|
||||
|
||||
|
||||
/* basis must be pure rotation */
|
||||
normalize_m3(basis);
|
||||
|
||||
|
||||
/* transform offset into local bone space */
|
||||
normalize_m3(iR_parmat);
|
||||
mul_m3_v3(iR_parmat, start);
|
||||
|
||||
|
||||
IK_SetTransform(seg, start, rest_basis, basis, length);
|
||||
|
||||
|
||||
if (pchan->ikflag & BONE_IK_XLIMIT)
|
||||
IK_SetLimit(seg, IK_X, pchan->limitmin[0], pchan->limitmax[0]);
|
||||
if (pchan->ikflag & BONE_IK_YLIMIT)
|
||||
IK_SetLimit(seg, IK_Y, pchan->limitmin[1], pchan->limitmax[1]);
|
||||
if (pchan->ikflag & BONE_IK_ZLIMIT)
|
||||
IK_SetLimit(seg, IK_Z, pchan->limitmin[2], pchan->limitmax[2]);
|
||||
|
||||
|
||||
IK_SetStiffness(seg, IK_X, pchan->stiffness[0]);
|
||||
IK_SetStiffness(seg, IK_Y, pchan->stiffness[1]);
|
||||
IK_SetStiffness(seg, IK_Z, pchan->stiffness[2]);
|
||||
|
||||
|
||||
if (tree->stretch && (pchan->ikstretch > 0.0f)) {
|
||||
float ikstretch = pchan->ikstretch * pchan->ikstretch;
|
||||
IK_SetStiffness(seg, IK_TRANS_Y, MIN2(1.0f - ikstretch, 0.99f));
|
||||
@ -359,31 +358,31 @@ static void execute_posetree(struct Scene *scene, Object *ob, PoseTree *tree)
|
||||
else
|
||||
unit_m4(rootmat);
|
||||
copy_v3_v3(rootmat[3], pchan->pose_head);
|
||||
|
||||
|
||||
mult_m4_m4m4(imat, ob->obmat, rootmat);
|
||||
invert_m4_m4(goalinv, imat);
|
||||
|
||||
|
||||
for (target = tree->targets.first; target; target = target->next) {
|
||||
float polepos[3];
|
||||
int poleconstrain = 0;
|
||||
|
||||
|
||||
data = (bKinematicConstraint *)target->con->data;
|
||||
|
||||
|
||||
/* 1.0=ctime, we pass on object for auto-ik (owner-type here is object, even though
|
||||
* strictly speaking, it is a posechannel)
|
||||
*/
|
||||
get_constraint_target_matrix(scene, target->con, 0, CONSTRAINT_OBTYPE_OBJECT, ob, rootmat, 1.0);
|
||||
|
||||
|
||||
/* and set and transform goal */
|
||||
mult_m4_m4m4(goal, goalinv, rootmat);
|
||||
|
||||
|
||||
copy_v3_v3(goalpos, goal[3]);
|
||||
copy_m3_m4(goalrot, goal);
|
||||
|
||||
|
||||
/* same for pole vector target */
|
||||
if (data->poletar) {
|
||||
get_constraint_target_matrix(scene, target->con, 1, CONSTRAINT_OBTYPE_OBJECT, ob, rootmat, 1.0);
|
||||
|
||||
|
||||
if (data->flag & CONSTRAINT_IK_SETANGLE) {
|
||||
/* don't solve IK when we are setting the pole angle */
|
||||
break;
|
||||
@ -398,7 +397,7 @@ static void execute_posetree(struct Scene *scene, Object *ob, PoseTree *tree)
|
||||
* a smooth transition */
|
||||
resultblend = 1;
|
||||
resultinf = target->con->enforce;
|
||||
|
||||
|
||||
if (data->flag & CONSTRAINT_IK_GETANGLE) {
|
||||
poleangledata = data;
|
||||
data->flag &= ~CONSTRAINT_IK_GETANGLE;
|
||||
@ -411,28 +410,28 @@ static void execute_posetree(struct Scene *scene, Object *ob, PoseTree *tree)
|
||||
float q1[4], q2[4], q[4];
|
||||
float fac = target->con->enforce;
|
||||
float mfac = 1.0f - fac;
|
||||
|
||||
|
||||
pchan = tree->pchan[target->tip];
|
||||
|
||||
|
||||
/* end effector in world space */
|
||||
copy_m4_m4(end_pose, pchan->pose_mat);
|
||||
copy_v3_v3(end_pose[3], pchan->pose_tail);
|
||||
mul_serie_m4(world_pose, goalinv, ob->obmat, end_pose, NULL, NULL, NULL, NULL, NULL);
|
||||
|
||||
|
||||
/* blend position */
|
||||
goalpos[0] = fac * goalpos[0] + mfac * world_pose[3][0];
|
||||
goalpos[1] = fac * goalpos[1] + mfac * world_pose[3][1];
|
||||
goalpos[2] = fac * goalpos[2] + mfac * world_pose[3][2];
|
||||
|
||||
|
||||
/* blend rotation */
|
||||
mat3_to_quat(q1, goalrot);
|
||||
mat4_to_quat(q2, world_pose);
|
||||
interp_qt_qtqt(q, q1, q2, mfac);
|
||||
quat_to_mat3(goalrot, q);
|
||||
}
|
||||
|
||||
|
||||
iktarget = iktree[target->tip];
|
||||
|
||||
|
||||
if (data->weight != 0.0f) {
|
||||
if (poleconstrain)
|
||||
IK_SolverSetPoleVectorConstraint(solver, iktarget, goalpos,
|
||||
@ -457,30 +456,30 @@ static void execute_posetree(struct Scene *scene, Object *ob, PoseTree *tree)
|
||||
tree->basis_change = MEM_mallocN(sizeof(float[3][3]) * tree->totchannel, "ik basis change");
|
||||
if (hasstretch)
|
||||
ikstretch = MEM_mallocN(sizeof(float) * tree->totchannel, "ik stretch");
|
||||
|
||||
|
||||
for (a = 0; a < tree->totchannel; a++) {
|
||||
IK_GetBasisChange(iktree[a], tree->basis_change[a]);
|
||||
|
||||
|
||||
if (hasstretch) {
|
||||
/* have to compensate for scaling received from parent */
|
||||
float parentstretch, stretch;
|
||||
|
||||
|
||||
pchan = tree->pchan[a];
|
||||
parentstretch = (tree->parent[a] >= 0) ? ikstretch[tree->parent[a]] : 1.0f;
|
||||
|
||||
|
||||
if (tree->stretch && (pchan->ikstretch > 0.0f)) {
|
||||
float trans[3], length;
|
||||
|
||||
|
||||
IK_GetTranslationChange(iktree[a], trans);
|
||||
length = pchan->bone->length * len_v3(pchan->pose_mat[1]);
|
||||
|
||||
|
||||
ikstretch[a] = (length == 0.0f) ? 1.0f : (trans[1] + length) / length;
|
||||
}
|
||||
else
|
||||
ikstretch[a] = 1.0;
|
||||
|
||||
|
||||
stretch = (parentstretch == 0.0f) ? 1.0f : ikstretch[a] / parentstretch;
|
||||
|
||||
|
||||
mul_v3_fl(tree->basis_change[a][0], stretch);
|
||||
mul_v3_fl(tree->basis_change[a][1], stretch);
|
||||
mul_v3_fl(tree->basis_change[a][2], stretch);
|
||||
@ -491,10 +490,10 @@ static void execute_posetree(struct Scene *scene, Object *ob, PoseTree *tree)
|
||||
blend_m3_m3m3(tree->basis_change[a], identity,
|
||||
tree->basis_change[a], resultinf);
|
||||
}
|
||||
|
||||
|
||||
IK_FreeSegment(iktree[a]);
|
||||
}
|
||||
|
||||
|
||||
MEM_freeN(iktree);
|
||||
if (ikstretch) MEM_freeN(ikstretch);
|
||||
}
|
||||
@ -514,7 +513,7 @@ static void free_posetree(PoseTree *tree)
|
||||
void iksolver_initialize_tree(struct Scene *UNUSED(scene), struct Object *ob, float UNUSED(ctime))
|
||||
{
|
||||
bPoseChannel *pchan;
|
||||
|
||||
|
||||
for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
|
||||
if (pchan->constflag & PCHAN_HAS_IK) // flag is set on editing constraints
|
||||
initialize_posetree(ob, pchan); // will attach it to root!
|
||||
@ -527,11 +526,11 @@ void iksolver_execute_tree(struct Scene *scene, struct Object *ob, struct bPose
|
||||
while (pchan->iktree.first) {
|
||||
PoseTree *tree = pchan->iktree.first;
|
||||
int a;
|
||||
|
||||
|
||||
/* stop on the first tree that isn't a standard IK chain */
|
||||
if (tree->type != CONSTRAINT_TYPE_KINEMATIC)
|
||||
return;
|
||||
|
||||
|
||||
/* 4. walk over the tree for regular solving */
|
||||
for (a = 0; a < tree->totchannel; a++) {
|
||||
if (!(tree->pchan[a]->flag & POSE_DONE)) // successive trees can set the flag
|
||||
@ -541,18 +540,18 @@ void iksolver_execute_tree(struct Scene *scene, struct Object *ob, struct bPose
|
||||
}
|
||||
/* 5. execute the IK solver */
|
||||
execute_posetree(scene, ob, tree);
|
||||
|
||||
/* 6. apply the differences to the channels,
|
||||
|
||||
/* 6. apply the differences to the channels,
|
||||
* we need to calculate the original differences first */
|
||||
for (a = 0; a < tree->totchannel; a++) {
|
||||
make_dmats(tree->pchan[a]);
|
||||
}
|
||||
|
||||
|
||||
for (a = 0; a < tree->totchannel; a++) {
|
||||
/* sets POSE_DONE */
|
||||
where_is_ik_bone(tree->pchan[a], tree->basis_change[a]);
|
||||
}
|
||||
|
||||
|
||||
/* 7. and free */
|
||||
BLI_remlink(&pchan->iktree, tree);
|
||||
free_posetree(tree);
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -406,7 +406,7 @@ CValue* CValue::GetProperty(int inIndex)
|
||||
std::map<STR_String,CValue*>::iterator it;
|
||||
for (it= m_pNamedPropertyArray->begin(); (it != m_pNamedPropertyArray->end()); it++)
|
||||
{
|
||||
if (count++==inIndex)
|
||||
if (count++ == inIndex)
|
||||
{
|
||||
result = (*it).second;
|
||||
break;
|
||||
|
Loading…
Reference in New Issue
Block a user