Enable missing-declarations warning (#643)
Finish ensuring symbols use headers correctly
This commit is contained in:
parent
0f12b3ee16
commit
8c6c57f1b4
78 changed files with 334 additions and 262 deletions
|
@ -336,9 +336,11 @@ set(CXX_WARNINGS)
|
|||
if(CMAKE_COMPILER_IS_GNUCC)
|
||||
ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_WRITE_STRINGS -Wwrite-strings)
|
||||
ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_UNDEF -Wundef)
|
||||
ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_MISSING_DECLARATIONS -Wmissing-declarations)
|
||||
|
||||
ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_WRITE_STRINGS -Wwrite-strings)
|
||||
ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_UNDEF -Wundef)
|
||||
ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_MISSING_DECLARATIONS -Wmissing-declarations)
|
||||
endif()
|
||||
|
||||
|
||||
|
|
|
@ -661,7 +661,7 @@ double ShadowStyle2::getParamValue(TColorStyle::double_tag, int index) const {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
int nbDiffVerts(const std::vector<TPointD> &pv) {
|
||||
static int nbDiffVerts(const std::vector<TPointD> &pv) {
|
||||
std::vector<TPointD> lpv;
|
||||
bool isMissing[4] = {true, true, true, true};
|
||||
if (pv.size() == 0) return 0;
|
||||
|
|
|
@ -23,9 +23,9 @@
|
|||
|
||||
#include "tgrammar.h"
|
||||
|
||||
const double PI = 4 * atan(1.0);
|
||||
const double toDeg(double rad) { return rad * 180.0 / PI; }
|
||||
const double toRad(double deg) { return deg / 180.0 * PI; }
|
||||
static const double PI = 4 * atan(1.0);
|
||||
static const double toDeg(double rad) { return rad * 180.0 / PI; }
|
||||
static const double toRad(double deg) { return deg / 180.0 * PI; }
|
||||
|
||||
namespace TSyntax {
|
||||
|
||||
|
|
|
@ -41,7 +41,7 @@ void readKey(FILE *f, struct dictentry *parent, TPSDLayerInfo *li);
|
|||
void readLayer16(FILE *f, struct dictentry *parent, TPSDLayerInfo *li);
|
||||
//----end forward declarations
|
||||
|
||||
char swapByte(unsigned char src) {
|
||||
static char swapByte(unsigned char src) {
|
||||
unsigned char out = 0;
|
||||
for (int i = 0; i < 8; ++i) {
|
||||
out = out << 1;
|
||||
|
|
|
@ -744,7 +744,7 @@ void RangeQualifier::fetch(int index, int &argc, char *argv[]) {
|
|||
}
|
||||
}
|
||||
|
||||
std::ostream &operator<<(std::ostream &out, const RangeQualifier &range) {
|
||||
static std::ostream &operator<<(std::ostream &out, const RangeQualifier &range) {
|
||||
return out << "[" << range.getFrom() << ", " << range.getTo() << "]";
|
||||
}
|
||||
|
||||
|
|
|
@ -456,7 +456,7 @@ assert(areAlmostEqual(a*v*v*v+b*v*v+c*v+d, 0.0));
|
|||
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
void clusterize(ClusterContainer &clusters, int clustersCount) {
|
||||
static void clusterize(ClusterContainer &clusters, int clustersCount) {
|
||||
unsigned int clustersSize = clusters.size();
|
||||
assert(clustersSize >= 1);
|
||||
|
||||
|
@ -737,7 +737,7 @@ void Cluster::getMeanAxis(KEYER_FLOAT axis[3]) {
|
|||
|
||||
//#define METODO_USATO_SU_TOONZ46
|
||||
|
||||
void buildPaletteForBlendedImages(std::set<TPixel32> &palette,
|
||||
static void buildPaletteForBlendedImages(std::set<TPixel32> &palette,
|
||||
const TRaster32P &raster, int maxColorCount) {
|
||||
int lx = raster->getLx();
|
||||
int ly = raster->getLy();
|
||||
|
|
|
@ -47,17 +47,17 @@ const TPixelGR8 TPixelGR8::Black(0);
|
|||
const TPixelGR16 TPixelGR16::White(maxChannelValue);
|
||||
const TPixelGR16 TPixelGR16::Black(0);
|
||||
|
||||
std::ostream &operator<<(std::ostream &out, const TPixel32 &pixel) {
|
||||
static std::ostream &operator<<(std::ostream &out, const TPixel32 &pixel) {
|
||||
return out << "PixRGBM32(" << (int)pixel.r << ", " << (int)pixel.g << ", "
|
||||
<< (int)pixel.b << ", " << (int)pixel.m << ")";
|
||||
}
|
||||
|
||||
std::ostream &operator<<(std::ostream &out, const TPixel64 &pixel) {
|
||||
static std::ostream &operator<<(std::ostream &out, const TPixel64 &pixel) {
|
||||
return out << "PixRGBM64(" << pixel.r << ", " << pixel.g << ", " << pixel.b
|
||||
<< ", " << pixel.m << ")";
|
||||
}
|
||||
|
||||
std::ostream &operator<<(std::ostream &out, const TPixelD &pixel) {
|
||||
static std::ostream &operator<<(std::ostream &out, const TPixelD &pixel) {
|
||||
return out << "PixD(" << pixel.r << ", " << pixel.g << ", " << pixel.b << ", "
|
||||
<< pixel.m << ")";
|
||||
}
|
||||
|
|
|
@ -83,7 +83,7 @@ inline QString getStr(const TFrameId &id) {
|
|||
|
||||
const QString Fmt = "dd MMM yy hh:mm";
|
||||
|
||||
QString getLine(int counter, const QDateTime &date,
|
||||
static QString getLine(int counter, const QDateTime &date,
|
||||
const set<TFrameId> &frames) {
|
||||
static QString user;
|
||||
static QString machine;
|
||||
|
@ -127,7 +127,7 @@ QString getLine(int counter, const QDateTime &date,
|
|||
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
int getCurrentCount(const QString &str) {
|
||||
static int getCurrentCount(const QString &str) {
|
||||
if (str == "") return 0;
|
||||
|
||||
int from = str.lastIndexOf('#') + 1;
|
||||
|
|
|
@ -29,9 +29,11 @@ const std::string Tiio::JpgWriterProperties::QUALITY("Quality");
|
|||
|
||||
//=========================================================
|
||||
|
||||
extern "C" void tnz_error_exit(j_common_ptr cinfo) {
|
||||
extern "C" {
|
||||
static void tnz_error_exit(j_common_ptr cinfo) {
|
||||
// throw "merda";
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CICCIO
|
||||
JMETHOD(void, error_exit, (j_common_ptr cinfo));
|
||||
|
|
|
@ -527,7 +527,7 @@ void TImageWriter::setProperties(const TPropertyGroup *g) {
|
|||
|
||||
//-----------------------------------------------------------
|
||||
|
||||
void convertForWriting(TRasterP &ras, const TRasterP &rin, int bpp) {
|
||||
static void convertForWriting(TRasterP &ras, const TRasterP &rin, int bpp) {
|
||||
switch (bpp) {
|
||||
case 1:
|
||||
case 8:
|
||||
|
|
|
@ -34,7 +34,7 @@ static TTextureMeshP cloneMesh_(const TTextureMeshP &other) {
|
|||
return TTextureMeshP(new TTextureMesh(*other));
|
||||
}
|
||||
|
||||
void static_check() {
|
||||
static void static_check() {
|
||||
/* input iterator */
|
||||
static_assert(
|
||||
std::is_same<std::iterator_traits<
|
||||
|
|
|
@ -103,7 +103,7 @@ inline double getLinearValue(const TActualDoubleKeyframe &k0,
|
|||
|
||||
//---------------------------------------------------------
|
||||
|
||||
void truncateSpeeds(double aFrame, double bFrame, TPointD &aSpeedTrunc,
|
||||
static void truncateSpeeds(double aFrame, double bFrame, TPointD &aSpeedTrunc,
|
||||
TPointD &bSpeedTrunc) {
|
||||
double deltaX = bFrame - aFrame;
|
||||
if (aSpeedTrunc.x < 0) aSpeedTrunc.x = 0;
|
||||
|
|
|
@ -50,7 +50,7 @@ TToneCurveParam::TToneCurveParam() : TParam() {
|
|||
|
||||
//---------------------------------------------------------
|
||||
|
||||
TParamSetP getClonedParamSet(TParamSetP srcParamSet) {
|
||||
static TParamSetP getClonedParamSet(TParamSetP srcParamSet) {
|
||||
TParamSetP dstParamSet = new TParamSet(srcParamSet->getName());
|
||||
int i;
|
||||
for (i = 0; i < srcParamSet->getParamCount(); i++) {
|
||||
|
|
|
@ -3,6 +3,7 @@
|
|||
#include "trop.h"
|
||||
#include "loop_macros.h"
|
||||
#include "tpixelutils.h"
|
||||
#include "quickputP.h"
|
||||
|
||||
#ifndef TNZCORE_LIGHT
|
||||
#include "tpalette.h"
|
||||
|
|
|
@ -11,6 +11,11 @@ void quickPut(const TRasterP &dn, const TRasterP &up, const TAffine &aff,
|
|||
bool doPremultiply = false, bool whiteTransp = false,
|
||||
bool firstColumn = false, bool doRasterDarkenBlendedView = false);
|
||||
|
||||
void quickPut(const TRasterP &dn, const TRasterP &up, const TAffine &aff,
|
||||
TRop::ResampleFilterType filterType, const TPixel32 &colorScale,
|
||||
bool doPremultiply, bool whiteTransp, bool firstColumn,
|
||||
bool doRasterDarkenBlendedView);
|
||||
|
||||
void quickResample(const TRasterP &dn, const TRasterP &up, const TAffine &aff,
|
||||
TRop::ResampleFilterType filterType);
|
||||
|
||||
|
|
|
@ -11,7 +11,7 @@
|
|||
// Conversion functions
|
||||
//******************************************************************
|
||||
|
||||
void do_convert(const TRaster64P &dst, const TRaster32P &src) {
|
||||
static void do_convert(const TRaster64P &dst, const TRaster32P &src) {
|
||||
assert(dst->getSize() == src->getSize());
|
||||
int lx = src->getLx();
|
||||
for (int y = 0; y < src->getLy(); y++) {
|
||||
|
@ -29,7 +29,7 @@ void do_convert(const TRaster64P &dst, const TRaster32P &src) {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void do_convert(const TRasterGR8P &dst, const TRaster32P &src) {
|
||||
static void do_convert(const TRasterGR8P &dst, const TRaster32P &src) {
|
||||
assert(dst->getSize() == src->getSize());
|
||||
|
||||
int lx = src->getLx();
|
||||
|
@ -45,7 +45,7 @@ void do_convert(const TRasterGR8P &dst, const TRaster32P &src) {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void do_convert(const TRasterGR16P &dst, const TRaster32P &src) {
|
||||
static void do_convert(const TRasterGR16P &dst, const TRaster32P &src) {
|
||||
assert(dst->getSize() == src->getSize());
|
||||
|
||||
int lx = src->getLx();
|
||||
|
@ -62,7 +62,7 @@ void do_convert(const TRasterGR16P &dst, const TRaster32P &src) {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void do_convert(const TRasterGR16P &dst, const TRaster64P &src) {
|
||||
static void do_convert(const TRasterGR16P &dst, const TRaster64P &src) {
|
||||
assert(dst->getSize() == src->getSize());
|
||||
int lx = src->getLx();
|
||||
for (int y = 0; y < src->getLy(); y++) {
|
||||
|
@ -79,7 +79,7 @@ void do_convert(const TRasterGR16P &dst, const TRaster64P &src) {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void do_convert(const TRaster32P &dst, const TRasterGR8P &src) {
|
||||
static void do_convert(const TRaster32P &dst, const TRasterGR8P &src) {
|
||||
assert(dst->getSize() == src->getSize());
|
||||
int lx = src->getLx();
|
||||
for (int y = 0; y < src->getLy(); y++) {
|
||||
|
@ -150,7 +150,7 @@ inline void ditherConvert(TRaster64P inRas, TRaster32P outRas) {
|
|||
// Obsolete conversion functions
|
||||
//******************************************************************
|
||||
|
||||
void do_convert(const TRasterCM32P &dst, const TRasterGR8P &src) {
|
||||
static void do_convert(const TRasterCM32P &dst, const TRasterGR8P &src) {
|
||||
assert(dst->getSize() == src->getSize());
|
||||
TPixelCM32 bg = TPixelCM32(0, 0, TPixelCM32::getMaxTone());
|
||||
|
||||
|
@ -169,7 +169,7 @@ void do_convert(const TRasterCM32P &dst, const TRasterGR8P &src) {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void do_convert(const TRasterCM32P &dst, const TRaster32P &src) {
|
||||
static void do_convert(const TRasterCM32P &dst, const TRaster32P &src) {
|
||||
assert(dst->getSize() == src->getSize());
|
||||
TPixelCM32 bg = TPixelCM32(0, 0, TPixelCM32::getMaxTone());
|
||||
|
||||
|
@ -220,7 +220,7 @@ void do_convert(const TRasterCM32P &dst, const TRaster32P &src) {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void do_convert(const TRasterYUV422P &dst, const TRaster32P &src) {
|
||||
static void do_convert(const TRasterYUV422P &dst, const TRaster32P &src) {
|
||||
assert(src->getLx() & 0);
|
||||
long y1, y2, u, v, u1, u2, v1, v2;
|
||||
TPixel32 *pix = (TPixel32 *)src->pixels();
|
||||
|
@ -271,7 +271,7 @@ void do_convert(const TRasterYUV422P &dst, const TRaster32P &src) {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void do_convert(const TRaster32P &dst, const TRasterYUV422P &src) {
|
||||
static void do_convert(const TRaster32P &dst, const TRasterYUV422P &src) {
|
||||
int long r, g, b, y1, y2, u, v;
|
||||
TPixel32 *buf = dst->pixels();
|
||||
const UCHAR *in = src->getRawData();
|
||||
|
|
|
@ -444,7 +444,7 @@ void doDespeckleGR(const TRasterPT<PIXEL> &ras, int sizeThreshold) {
|
|||
|
||||
//----------------------------------------------------
|
||||
|
||||
void doDespeckleCM32(const TRasterPT<TPixelCM32> &ras, int sizeThreshold,
|
||||
static void doDespeckleCM32(const TRasterPT<TPixelCM32> &ras, int sizeThreshold,
|
||||
bool check) {
|
||||
TRasterCM32P rasCM(ras);
|
||||
rasCM->lock();
|
||||
|
|
|
@ -250,7 +250,7 @@ void do_over(TRasterGR8P rout, const TRaster32P &rup) {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void do_over(TRaster32P rout, const TRasterGR8P &rup, const TPixel32 &color) {
|
||||
static void do_over(TRaster32P rout, const TRasterGR8P &rup, const TPixel32 &color) {
|
||||
assert(rout->getSize() == rup->getSize());
|
||||
for (int y = rout->getLy(); --y >= 0;) {
|
||||
TPixel32 *out_pix = rout->pixels(y);
|
||||
|
|
|
@ -212,7 +212,7 @@ paints[i] = TPixelFloat(paints2[i]);
|
|||
|
||||
//-----------------------------------------------------------------------------------------------
|
||||
|
||||
void do_convert(const TTile &dst, const TTile &src, const TPaletteP palette,
|
||||
static void do_convert(const TTile &dst, const TTile &src, const TPaletteP palette,
|
||||
bool transparencyCheck, bool applyFx) {
|
||||
// assert(palette);
|
||||
// assert(_rasOut && _rasIn);
|
||||
|
|
|
@ -107,7 +107,7 @@ public:
|
|||
|
||||
extern "C" {
|
||||
|
||||
void sdl_fill_audio(void *udata, Uint8 *stream, int len) {
|
||||
static void sdl_fill_audio(void *udata, Uint8 *stream, int len) {
|
||||
TSoundOutputDeviceImp *_this = (TSoundOutputDeviceImp *)udata;
|
||||
MyData *myData = _this->m_data;
|
||||
|
||||
|
|
|
@ -24,7 +24,7 @@ double VerticalCameraFldUnitConverter::m_factor = 1;
|
|||
|
||||
namespace UnitParameters {
|
||||
|
||||
std::pair<double, double> dummyCurrentDpiGetter() {
|
||||
static std::pair<double, double> dummyCurrentDpiGetter() {
|
||||
return std::make_pair<double, double>(72, 72);
|
||||
}
|
||||
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
|
||||
|
||||
#include "tgeometry.h"
|
||||
#include "cornerdetector.h"
|
||||
|
||||
//======================================================================
|
||||
|
||||
|
@ -39,7 +40,7 @@ public:
|
|||
};
|
||||
|
||||
//! Definisce l'operatore meno tra due AlgorithmPointI
|
||||
AlgorithmPointI operator-(const AlgorithmPointI &op1,
|
||||
static AlgorithmPointI operator-(const AlgorithmPointI &op1,
|
||||
const AlgorithmPointI &op2) {
|
||||
return AlgorithmPointI(op1.operator-(op2), 0);
|
||||
}
|
||||
|
@ -75,7 +76,7 @@ point_container gPoints;
|
|||
|
||||
\param points Vettore di T3DPoints
|
||||
*/
|
||||
bool interpolate(const std::vector<T3DPointD> &points) {
|
||||
static bool interpolate(const std::vector<T3DPointD> &points) {
|
||||
unsigned int curr, next;
|
||||
|
||||
TPointI currStep, xStep, yStep, guideLine;
|
||||
|
@ -193,7 +194,7 @@ inline bool isAdmissibleCorner(int currIndex, int precIndex, int nextIndex) {
|
|||
//----------------------------------------------------------------------
|
||||
|
||||
//! Trova i possibili angoli tra i punti di gPoints
|
||||
void findCornerCandidates() {
|
||||
static void findCornerCandidates() {
|
||||
unsigned int curr, prec, next;
|
||||
curr = gMaxDist;
|
||||
|
||||
|
@ -229,7 +230,7 @@ void findCornerCandidates() {
|
|||
//----------------------------------------------------------------------
|
||||
|
||||
//! Trova gli angoli tra i punti di gPoints
|
||||
void findCorners(int neighborLimit, std::vector<int> &cornerIndexes) {
|
||||
static void findCorners(int neighborLimit, std::vector<int> &cornerIndexes) {
|
||||
unsigned int curr, prec, next;
|
||||
curr = gMaxDist;
|
||||
|
||||
|
|
10
toonz/sources/common/tvectorimage/cornerdetector.h
Normal file
10
toonz/sources/common/tvectorimage/cornerdetector.h
Normal file
|
@ -0,0 +1,10 @@
|
|||
#pragma once
|
||||
|
||||
#ifndef CORNERDETECTOR_H
|
||||
#define CORNERDETECTOR_H
|
||||
|
||||
void detectCorners(const std::vector<T3DPointD> &inputPoints, int minSampleNum,
|
||||
int minDist, int maxDist, double maxAngle,
|
||||
std::vector<int> &cornerIndexes);
|
||||
|
||||
#endif // CORNERDETECTOR_H
|
|
@ -537,7 +537,7 @@ void drawQuadratic(const TQuadratic &quad, double pixelSize) {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void makeOutline(const TStroke *stroke, int startQuad, int endQuad,
|
||||
static void makeOutline(const TStroke *stroke, int startQuad, int endQuad,
|
||||
outlineBoundary &ob, double error2) {
|
||||
// std::ofstream cout("c:\\temp\\outline.txt");
|
||||
|
||||
|
@ -628,7 +628,7 @@ void makeOutline(const TStroke *stroke, int startQuad, int endQuad,
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void drawOutline(const outlineBoundary &ob, double pixelSize) {
|
||||
static void drawOutline(const outlineBoundary &ob, double pixelSize) {
|
||||
for (UINT i = 0; i < ob.size(); ++i) {
|
||||
drawQuadratic(*ob[i].first, pixelSize);
|
||||
drawQuadratic(*ob[i].second, pixelSize);
|
||||
|
|
|
@ -14,6 +14,7 @@
|
|||
#include "tdebugmessage.h"
|
||||
#include "tthreadmessage.h"
|
||||
#include "tl2lautocloser.h"
|
||||
#include "tcomputeregions.h"
|
||||
#include <vector>
|
||||
|
||||
#include "tcurveutil.h"
|
||||
|
@ -46,7 +47,7 @@ inline TThickPoint myRound(const TThickPoint &p) {
|
|||
return TThickPoint(myRound(p.x), myRound(p.y), p.thick);
|
||||
}
|
||||
|
||||
void roundStroke(TStroke *s) {
|
||||
static void roundStroke(TStroke *s) {
|
||||
int size = s->getControlPointCount();
|
||||
|
||||
for (int j = 0; j < (int)s->getControlPointCount(); j++) {
|
||||
|
@ -411,13 +412,13 @@ void addIntersection(IntersectionData &intData, const vector<VIStroke *> &s,
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
bool sortBBox(const TStroke *s1, const TStroke *s2) {
|
||||
static bool sortBBox(const TStroke *s1, const TStroke *s2) {
|
||||
return s1->getBBox().x0 < s2->getBBox().x0;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void cleanIntersectionMarks(const VIList<Intersection> &interList) {
|
||||
static void cleanIntersectionMarks(const VIList<Intersection> &interList) {
|
||||
Intersection *p;
|
||||
IntersectedStroke *q;
|
||||
for (p = interList.first(); p; p = p->next())
|
||||
|
@ -435,7 +436,7 @@ void cleanIntersectionMarks(const VIList<Intersection> &interList) {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void cleanNextIntersection(const VIList<Intersection> &interList, TStroke *s) {
|
||||
static void cleanNextIntersection(const VIList<Intersection> &interList, TStroke *s) {
|
||||
Intersection *p;
|
||||
IntersectedStroke *q;
|
||||
|
||||
|
@ -903,7 +904,7 @@ void TVectorImage::Imp::eraseIntersection(int index) {
|
|||
}
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void findNearestIntersection(VIList<Intersection> &interList) {
|
||||
static void findNearestIntersection(VIList<Intersection> &interList) {
|
||||
Intersection *p1;
|
||||
IntersectedStroke *p2;
|
||||
|
||||
|
@ -1026,7 +1027,7 @@ void markDeadIntersections(VIList<Intersection> &intList, Intersection *p) {
|
|||
|
||||
// se cross val era 0, cerco di spostarmi un po' su w per vedere come sono
|
||||
// orientate le tangenti agli stroke...
|
||||
double nearCrossVal(TStroke *s0, double w0, TStroke *s1, double w1) {
|
||||
static double nearCrossVal(TStroke *s0, double w0, TStroke *s1, double w1) {
|
||||
double ltot0 = s0->getLength();
|
||||
double ltot1 = s1->getLength();
|
||||
double dl = std::min(ltot1, ltot0) / 1000;
|
||||
|
@ -1066,7 +1067,7 @@ inline void insertBranch(Intersection &in, IntersectedStroke &item,
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
double getAngle(const TPointD &p0, const TPointD &p1) {
|
||||
static double getAngle(const TPointD &p0, const TPointD &p1) {
|
||||
double angle1 = atan2(p0.x, p0.y) * M_180_PI;
|
||||
double angle2 = atan2(p1.x, p1.y) * M_180_PI;
|
||||
|
||||
|
@ -1079,7 +1080,7 @@ double getAngle(const TPointD &p0, const TPointD &p1) {
|
|||
//-----------------------------------------------------------------------------
|
||||
// nel caso l'angolo tra due stroke in un certo w sia nullo,
|
||||
// si va un po' avanti per vedere come sono orientate....
|
||||
double getNearAngle(const TStroke *s1, double w1, bool out1, const TStroke *s2,
|
||||
static double getNearAngle(const TStroke *s1, double w1, bool out1, const TStroke *s2,
|
||||
double w2, bool out2) {
|
||||
bool verse1 = (out1 && w1 < 1) || (!out1 && w1 == 0);
|
||||
bool verse2 = (out2 && w2 < 1) || (!out2 && w2 == 0);
|
||||
|
@ -1105,7 +1106,7 @@ double getNearAngle(const TStroke *s1, double w1, bool out1, const TStroke *s2,
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
bool makeEdgeIntersection(Intersection &interList, IntersectedStroke &item1,
|
||||
static bool makeEdgeIntersection(Intersection &interList, IntersectedStroke &item1,
|
||||
IntersectedStroke &item2, const TPointD &p1a,
|
||||
const TPointD &p1b, const TPointD &p2a,
|
||||
const TPointD &p2b) {
|
||||
|
@ -1215,7 +1216,7 @@ bool makeEdgeIntersection(Intersection &interList, IntersectedStroke &item1,
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
bool makeIntersection(IntersectionData &intData, const vector<VIStroke *> &s,
|
||||
static bool makeIntersection(IntersectionData &intData, const vector<VIStroke *> &s,
|
||||
int ii, int jj, DoublePair inter, int strokeSize,
|
||||
Intersection &interList) {
|
||||
IntersectedStroke item1, item2;
|
||||
|
@ -1336,7 +1337,7 @@ areAlmostEqual(q->getP2(), p->getP0(), 1e-2))
|
|||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
bool addAutocloseIntersection(IntersectionData &intData, vector<VIStroke *> &s,
|
||||
static bool addAutocloseIntersection(IntersectionData &intData, vector<VIStroke *> &s,
|
||||
int ii, int jj, double w0, double w1,
|
||||
int strokeSize, bool isVectorized) {
|
||||
assert(s[ii]->m_groupId == s[jj]->m_groupId);
|
||||
|
@ -1418,7 +1419,7 @@ bool addAutocloseIntersection(IntersectionData &intData, vector<VIStroke *> &s,
|
|||
|
||||
// double g_autocloseTolerance = c_newAutocloseTolerance;
|
||||
|
||||
bool isCloseEnoughP2P(double facMin, double facMax, TStroke *s1, double w0,
|
||||
static bool isCloseEnoughP2P(double facMin, double facMax, TStroke *s1, double w0,
|
||||
TStroke *s2, double w1) {
|
||||
double autoDistMin, autoDistMax;
|
||||
|
||||
|
@ -1495,7 +1496,7 @@ return false;
|
|||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
double getCurlW(TStroke *s, bool isBegin) // trova il punto di split su una
|
||||
static double getCurlW(TStroke *s, bool isBegin) // trova il punto di split su una
|
||||
// stroke, in prossimita di un
|
||||
// ricciolo;
|
||||
// un ricciolo c'e' se la curva ha un min o max relativo su x seguito da uno su
|
||||
|
@ -1570,7 +1571,7 @@ return -1;
|
|||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
bool isCloseEnoughP2L(double facMin, double facMax, TStroke *s1, double w1,
|
||||
static bool isCloseEnoughP2L(double facMin, double facMax, TStroke *s1, double w1,
|
||||
TStroke *s2, double &w) {
|
||||
if (s1->isSelfLoop()) return false;
|
||||
|
||||
|
@ -1880,7 +1881,7 @@ void getClosingPoints(const TRectD &rect, double fac, const TVectorImageP &vi,
|
|||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
|
||||
void autoclose(double factor, vector<VIStroke *> &s, int ii, int jj,
|
||||
static void autoclose(double factor, vector<VIStroke *> &s, int ii, int jj,
|
||||
IntersectionData &IntData, int strokeSize,
|
||||
TL2LAutocloser &l2lautocloser, vector<DoublePair> *intersections,
|
||||
bool isVectorized) {
|
||||
|
@ -1938,7 +1939,7 @@ TPointD inline getTangent(const IntersectedStroke &item) {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void addBranch(IntersectionData &intData, VIList<IntersectedStroke> &strokeList,
|
||||
static void addBranch(IntersectionData &intData, VIList<IntersectedStroke> &strokeList,
|
||||
const vector<VIStroke *> &s, int ii, double w, int strokeSize,
|
||||
bool gettingOut) {
|
||||
IntersectedStroke *p1, *p2;
|
||||
|
@ -2055,7 +2056,7 @@ return;
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void addBranches(IntersectionData &intData, Intersection &intersection,
|
||||
static void addBranches(IntersectionData &intData, Intersection &intersection,
|
||||
const vector<VIStroke *> &s, int ii, int jj,
|
||||
DoublePair intersectionPair, int strokeSize) {
|
||||
bool foundS1 = false, foundS2 = false;
|
||||
|
@ -2127,7 +2128,7 @@ IntersectedStroke app;
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void addIntersections(IntersectionData &intData, const vector<VIStroke *> &s,
|
||||
static void addIntersections(IntersectionData &intData, const vector<VIStroke *> &s,
|
||||
int ii, int jj, vector<DoublePair> &intersections,
|
||||
int strokeSize, bool isVectorized) {
|
||||
for (int k = 0; k < (int)intersections.size(); k++) {
|
||||
|
@ -2446,7 +2447,7 @@ if (tdistance2(p01, p11)< 2*0.06*0.06)
|
|||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Trova una possibile regione data una lista di punti di intersezione
|
||||
TRegion *findRegion(VIList<Intersection> &intList, Intersection *p1,
|
||||
static TRegion *findRegion(VIList<Intersection> &intList, Intersection *p1,
|
||||
IntersectedStroke *p2, bool minimizeEdges) {
|
||||
TRegion *r = new TRegion();
|
||||
int currStyle = 0;
|
||||
|
@ -2662,7 +2663,7 @@ void computeRegionFeature(const TRegion &r, TRegionFeatureFormula &formula) {
|
|||
|
||||
//----------------------------------------------------------------------------------
|
||||
|
||||
bool isValidArea(const TRegion &r) {
|
||||
static bool isValidArea(const TRegion &r) {
|
||||
TRegionClockWiseFormula formula;
|
||||
computeRegionFeature(r, formula);
|
||||
return formula.isClockwise();
|
||||
|
@ -2759,7 +2760,7 @@ void transferColors(const list<TEdge *> &oldList, const list<TEdge *> &newList,
|
|||
bool isStrokeChanged, bool isFlipped, bool overwriteColor);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
void printStrokes1(vector<VIStroke *> &v, int size) {
|
||||
static void printStrokes1(vector<VIStroke *> &v, int size) {
|
||||
UINT i = 0;
|
||||
ofstream of("C:\\temp\\strokes.txt");
|
||||
|
||||
|
|
9
toonz/sources/common/tvectorimage/tcomputeregions.h
Normal file
9
toonz/sources/common/tvectorimage/tcomputeregions.h
Normal file
|
@ -0,0 +1,9 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#ifndef T_COMPUTEREGIONS_H
|
||||
#define T_COMPUTEREGIONS_H
|
||||
|
||||
void invalidateRegionPropAndBBox(TRegion *reg);
|
||||
|
||||
#endif // T_COMPUTEREGIONS_H
|
|
@ -34,7 +34,7 @@ void foo()
|
|||
|
||||
//=============================================================================
|
||||
|
||||
bool compareEdge(const TEdge &a, const TEdge &b) { return a.m_s == b.m_s; }
|
||||
static bool compareEdge(const TEdge &a, const TEdge &b) { return a.m_s == b.m_s; }
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
@ -527,7 +527,7 @@ void TRegion::draw(const TVectorRenderData &rd)
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void checkPolyline(const std::vector<T3DPointD> &p) {
|
||||
static void checkPolyline(const std::vector<T3DPointD> &p) {
|
||||
int ret;
|
||||
|
||||
if (p.size() < 3) return;
|
||||
|
|
|
@ -8,6 +8,7 @@
|
|||
#include "tbezier.h"
|
||||
#include "tzerofinder.h"
|
||||
#include "tcurveutil.h"
|
||||
#include "cornerdetector.h"
|
||||
|
||||
#include <limits>
|
||||
|
||||
|
@ -32,10 +33,6 @@ typedef std::vector<TThickQuadratic *> QuadStrokeChunkArray;
|
|||
|
||||
static int numSaved = 0;
|
||||
|
||||
void detectCorners(const std::vector<T3DPointD> &points, int minSampleNum,
|
||||
int minDist, int maxDist, double maxAngle,
|
||||
std::vector<int> &corners);
|
||||
|
||||
namespace {
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
|
|
|
@ -174,7 +174,7 @@ typedef list<TQuadratic> QuadraticList;
|
|||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
void splitCircularArcIntoQuadraticCurves(const TPointD &Center,
|
||||
static void splitCircularArcIntoQuadraticCurves(const TPointD &Center,
|
||||
const TPointD &Pstart,
|
||||
const TPointD &Pend,
|
||||
vector<TQuadratic *> &quadArray) {
|
||||
|
@ -365,7 +365,7 @@ inline void drawPointCross(const TPointD &point, double R, double G, double B) {
|
|||
|
||||
//-------------------------------------------------------------------
|
||||
|
||||
TStroke *getOutStroke(LinkedQuadraticList &inputBoundaries) {
|
||||
static TStroke *getOutStroke(LinkedQuadraticList &inputBoundaries) {
|
||||
vector<TPointD> aux;
|
||||
LinkedQuadraticList::iterator it = inputBoundaries.begin();
|
||||
|
||||
|
@ -427,7 +427,7 @@ inline bool getOutputOutlines(LinkedQuadraticList &inputBoundaries,
|
|||
|
||||
//-------------------------------------------------------------------
|
||||
|
||||
bool computeBoundaryStroke(const TStroke &_stroke,
|
||||
static bool computeBoundaryStroke(const TStroke &_stroke,
|
||||
vector<TStroke *> &sweepStrokes) {
|
||||
// if(!outlines.empty()) return false;
|
||||
|
||||
|
|
|
@ -14,6 +14,7 @@
|
|||
#include "tpaletteutil.h"
|
||||
#include "tthreadmessage.h"
|
||||
#include "tsimplecolorstyles.h"
|
||||
#include "tcomputeregions.h"
|
||||
|
||||
#include <memory>
|
||||
|
||||
|
@ -246,7 +247,7 @@ TRectD TVectorImage::addStroke(const std::vector<TThickPoint> &points)
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
bool isRegionWithStroke(TRegion *region, TStroke *s) {
|
||||
static bool isRegionWithStroke(TRegion *region, TStroke *s) {
|
||||
for (UINT i = 0; i < region->getEdgeCount(); i++)
|
||||
if (region->getEdge(i)->m_s == s) return true;
|
||||
return false;
|
||||
|
@ -254,7 +255,7 @@ bool isRegionWithStroke(TRegion *region, TStroke *s) {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void deleteSubRegionWithStroke(TRegion *region, TStroke *s) {
|
||||
static void deleteSubRegionWithStroke(TRegion *region, TStroke *s) {
|
||||
for (int i = 0; i < (int)region->getSubregionCount(); i++) {
|
||||
deleteSubRegionWithStroke(region->getSubregion(i), s);
|
||||
if (isRegionWithStroke(region->getSubregion(i), s)) {
|
||||
|
@ -1044,7 +1045,6 @@ bool TVectorImage::Imp::areWholeGroups(const std::vector<int> &indexes) const {
|
|||
//-----------------------------------------------------------------------------
|
||||
|
||||
//-------------------------------------------------------------------
|
||||
void invalidateRegionPropAndBBox(TRegion *reg);
|
||||
|
||||
void TVectorImage::Imp::notifyChangedStrokes(
|
||||
const std::vector<int> &strokeIndexArray,
|
||||
|
@ -1938,7 +1938,7 @@ assert(m_strokes[strokeIndex-wSize+1]->m_edgeList.empty());*/
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void computeEdgeList(TStroke *newS, const std::list<TEdge *> &edgeList1,
|
||||
static void computeEdgeList(TStroke *newS, const std::list<TEdge *> &edgeList1,
|
||||
bool join1AtBegin, const std::list<TEdge *> &edgeList2,
|
||||
bool join2AtBegin, std::list<TEdge *> &edgeList) {
|
||||
std::list<TEdge *>::const_iterator it;
|
||||
|
|
|
@ -264,7 +264,14 @@ private:
|
|||
Imp &operator=(const Imp &);
|
||||
};
|
||||
|
||||
// Functions
|
||||
|
||||
void addRegion(std::vector<TRegion *> ®ionArray, TRegion *region);
|
||||
|
||||
void transferColors(const std::list<TEdge *> &oldList,
|
||||
const std::list<TEdge *> &newList, bool isStrokeChanged,
|
||||
bool isFlipped, bool overwriteColor);
|
||||
|
||||
//=============================================================================
|
||||
|
||||
#endif
|
||||
|
|
|
@ -451,7 +451,7 @@ void TColorStyle::declare(TColorStyle *style) {
|
|||
|
||||
//===================================================================
|
||||
|
||||
double computeAverageThickness(const TStroke *s, double &minThickness,
|
||||
static double computeAverageThickness(const TStroke *s, double &minThickness,
|
||||
double &maxThickness) {
|
||||
int count = s->getControlPointCount();
|
||||
|
||||
|
|
|
@ -32,13 +32,13 @@ TNZ_LITTLE_ENDIAN undefined !!
|
|||
|
||||
int Tw = 0;
|
||||
|
||||
bool areTwEqual(double x, double y) {
|
||||
static bool areTwEqual(double x, double y) {
|
||||
assert(Tw != 0);
|
||||
|
||||
return (int)(Tw * x) == (int)(Tw * y);
|
||||
}
|
||||
|
||||
bool areTwEqual(TPointD p0, TPointD p1) {
|
||||
static bool areTwEqual(TPointD p0, TPointD p1) {
|
||||
assert(Tw != 0);
|
||||
|
||||
return areTwEqual(p0.x, p1.x) && areTwEqual(p0.y, p1.y);
|
||||
|
@ -184,7 +184,7 @@ public:
|
|||
TImageP m_img;
|
||||
};
|
||||
|
||||
double computeAverageThickness(const TStroke *s) {
|
||||
static double computeAverageThickness(const TStroke *s) {
|
||||
int count = s->getControlPointCount();
|
||||
double resThick = 0;
|
||||
int i;
|
||||
|
@ -198,7 +198,7 @@ double computeAverageThickness(const TStroke *s) {
|
|||
return resThick / (s->getControlPointCount() - 4);
|
||||
}
|
||||
|
||||
void putquads(const TStroke *s, double w0, double w1,
|
||||
static void putquads(const TStroke *s, double w0, double w1,
|
||||
std::vector<TQuadratic *> &quads) {
|
||||
int chunkIndex0, chunkIndex1, i;
|
||||
double dummy;
|
||||
|
@ -216,7 +216,7 @@ void putquads(const TStroke *s, double w0, double w1,
|
|||
|
||||
//-------------------------------------------------------------------
|
||||
|
||||
void computeOutlineBoundary(std::vector<TStroke *> &outlines,
|
||||
static void computeOutlineBoundary(std::vector<TStroke *> &outlines,
|
||||
std::list<FlashPolyline> &polylinesArray,
|
||||
const TPixel &color) {
|
||||
UINT size = polylinesArray.size();
|
||||
|
@ -273,7 +273,7 @@ bool PolyStyle::operator==(const PolyStyle &p) const {
|
|||
|
||||
//-------------------------------------------------------------------
|
||||
|
||||
bool affineMinorThen(const TAffine &m0, const TAffine &m1) {
|
||||
static bool affineMinorThen(const TAffine &m0, const TAffine &m1) {
|
||||
if (m0.a11 == m1.a11) {
|
||||
if (m0.a12 == m1.a12) {
|
||||
if (m0.a13 == m1.a13) {
|
||||
|
@ -323,7 +323,7 @@ bool PolyStyle::operator<(const PolyStyle &p) const {
|
|||
|
||||
//-------------------------------------------------------------------
|
||||
|
||||
void computeQuadChain(const TEdge &e, std::vector<TQuadratic *> &quadArray,
|
||||
static void computeQuadChain(const TEdge &e, std::vector<TQuadratic *> &quadArray,
|
||||
std::vector<TQuadratic *> &toBeDeleted) {
|
||||
int chunk_b, chunk_e, chunk = -1;
|
||||
double t_b, t_e, w0, w1;
|
||||
|
|
|
@ -436,7 +436,7 @@ void tglDraw(const TVectorRenderData &rd, const TStroke *s, bool pushAttribs) {
|
|||
|
||||
//------------------------------------------------------------------------------------
|
||||
|
||||
void tglDoDraw(const TVectorRenderData &rd, TRegion *r) {
|
||||
static void tglDoDraw(const TVectorRenderData &rd, TRegion *r) {
|
||||
bool visible = false;
|
||||
int colorCount = 0;
|
||||
if (!r) return;
|
||||
|
@ -462,7 +462,7 @@ void tglDoDraw(const TVectorRenderData &rd, TRegion *r) {
|
|||
|
||||
//------------------------------------------------------------------------------------
|
||||
|
||||
void tglDoDraw(const TVectorRenderData &rd, const TStroke *s) {
|
||||
static void tglDoDraw(const TVectorRenderData &rd, const TStroke *s) {
|
||||
bool visible = false;
|
||||
int colorCount = 0;
|
||||
|
||||
|
|
|
@ -18,7 +18,7 @@
|
|||
//#include "tdebugmessage.h"
|
||||
//--------------------------------------------------------------------------------------
|
||||
|
||||
double average(std::vector<double> &values, double range = 2.5) {
|
||||
static double average(std::vector<double> &values, double range = 2.5) {
|
||||
UINT size = values.size();
|
||||
if (size == 0) return std::numeric_limits<double>::signaling_NaN();
|
||||
|
||||
|
@ -56,7 +56,7 @@ double average(std::vector<double> &values, double range = 2.5) {
|
|||
|
||||
//--------------------------------------------------------------------------------------
|
||||
|
||||
double weightedAverage(std::vector<double> &values,
|
||||
static double weightedAverage(std::vector<double> &values,
|
||||
std::vector<double> &weights, double range = 2.5) {
|
||||
UINT size = values.size();
|
||||
if (size == 0) return std::numeric_limits<double>::signaling_NaN();
|
||||
|
@ -162,7 +162,7 @@ n^r <= 2^(s-1) < (2^s)-1
|
|||
|
||||
//--------------------------------------------------------------------------------------
|
||||
|
||||
void eraseSmallAngles(std::vector<std::pair<int, double>> &corners,
|
||||
static void eraseSmallAngles(std::vector<std::pair<int, double>> &corners,
|
||||
double angle) {
|
||||
std::vector<std::pair<int, double>>::iterator it = corners.begin();
|
||||
|
||||
|
@ -180,7 +180,7 @@ void eraseSmallAngles(std::vector<std::pair<int, double>> &corners,
|
|||
// of the corners)
|
||||
// max is tha maximum angle greater or equal to minDegree
|
||||
|
||||
void detectCorners(const TStroke *stroke, double minDegree,
|
||||
static void detectCorners(const TStroke *stroke, double minDegree,
|
||||
std::vector<std::pair<int, double>> &corners, double &min,
|
||||
double &max) {
|
||||
const double minSin = fabs(sin(minDegree * M_PI_180));
|
||||
|
@ -330,7 +330,7 @@ void detectCorners(const TStroke *stroke, double minDegree,
|
|||
|
||||
//--------------------------------------------------------------------------------------
|
||||
|
||||
double variance(std::vector<double> &values) {
|
||||
static double variance(std::vector<double> &values) {
|
||||
UINT size = values.size();
|
||||
if (size == 0) return std::numeric_limits<double>::signaling_NaN();
|
||||
|
||||
|
@ -352,7 +352,7 @@ double variance(std::vector<double> &values) {
|
|||
|
||||
//--------------------------------------------------------------------------------------
|
||||
|
||||
void findBestSolution(const TStroke *stroke1, const TStroke *stroke2,
|
||||
static void findBestSolution(const TStroke *stroke1, const TStroke *stroke2,
|
||||
std::pair<int, double> *partialAngles1,
|
||||
UINT partialAngles1Size,
|
||||
const std::vector<std::pair<int, double>> &angles2,
|
||||
|
@ -499,7 +499,7 @@ TDebugMessage::flush();
|
|||
|
||||
//--------------------------------------------------------------------------------------
|
||||
|
||||
void findBestSolution(const TStroke *stroke1, const TStroke *stroke2,
|
||||
static void findBestSolution(const TStroke *stroke1, const TStroke *stroke2,
|
||||
std::vector<std::pair<int, double>> &angles1,
|
||||
const std::vector<std::pair<int, double>> &angles2,
|
||||
double &bestValue, std::vector<int> &bestVector) {
|
||||
|
@ -513,7 +513,7 @@ void findBestSolution(const TStroke *stroke1, const TStroke *stroke2,
|
|||
|
||||
//--------------------------------------------------------------------------------------
|
||||
|
||||
void trivialSolution(const TStroke *stroke1, const TStroke *stroke2,
|
||||
static void trivialSolution(const TStroke *stroke1, const TStroke *stroke2,
|
||||
const std::vector<std::pair<int, double>> &angles1,
|
||||
const std::vector<std::pair<int, double>> &angles2,
|
||||
std::vector<int> &solution) {
|
||||
|
@ -578,7 +578,7 @@ void trivialSolution(const TStroke *stroke1, const TStroke *stroke2,
|
|||
|
||||
//--------------------------------------------------------------------------------------
|
||||
|
||||
TStroke *extract(const TStroke *source, UINT firstQuad, UINT lastQuad) {
|
||||
static TStroke *extract(const TStroke *source, UINT firstQuad, UINT lastQuad) {
|
||||
UINT quadCount = source->getChunkCount();
|
||||
if (firstQuad >= quadCount) {
|
||||
assert(!"bad quadric index");
|
||||
|
@ -607,7 +607,7 @@ TStroke *extract(const TStroke *source, UINT firstQuad, UINT lastQuad) {
|
|||
|
||||
//--------------------------------------------------------------------------------------
|
||||
|
||||
void sample(const TStroke *stroke, int samplingSize,
|
||||
static void sample(const TStroke *stroke, int samplingSize,
|
||||
std::vector<TPointD> &sampledPoint) {
|
||||
double samplingFrequency = 1.0 / (double)samplingSize;
|
||||
sampledPoint.resize(samplingSize);
|
||||
|
|
|
@ -485,7 +485,7 @@ Bool ret = glXMakeCurrent(m_dpy,
|
|||
int getLy() const { return m_raster->getLy(); }
|
||||
};
|
||||
|
||||
std::shared_ptr<TOfflineGL::Imp> defaultOfflineGLGenerator(
|
||||
static std::shared_ptr<TOfflineGL::Imp> defaultOfflineGLGenerator(
|
||||
const TDimension &dim, std::shared_ptr<TOfflineGL::Imp> shared) {
|
||||
return std::make_shared<QtOfflineGL>(dim, shared);
|
||||
}
|
||||
|
|
|
@ -40,7 +40,7 @@ TFilePath TVectorImagePatternStrokeStyle::m_rootDir = TFilePath();
|
|||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef NDEBUG
|
||||
void checkGlError() {
|
||||
static void checkGlError() {
|
||||
GLenum err = glGetError();
|
||||
assert(err != GL_INVALID_ENUM);
|
||||
assert(err != GL_INVALID_VALUE);
|
||||
|
|
|
@ -53,20 +53,23 @@ TglTessellator::GLTess::~GLTess() { gluDeleteTess(m_tess); }
|
|||
|
||||
namespace {
|
||||
|
||||
extern "C" void CALLBACK tessellateTexture(const GLdouble *tex) {
|
||||
extern "C" {
|
||||
static void CALLBACK tessellateTexture(const GLdouble *tex) {
|
||||
double u = tex[0] * 0.01;
|
||||
double v = tex[1] * 0.01;
|
||||
glTexCoord2d(u, v);
|
||||
glVertex2dv(tex);
|
||||
}
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------
|
||||
|
||||
TThread::Mutex CombineDataGuard;
|
||||
|
||||
std::list<GLdouble *> Combine_data;
|
||||
static std::list<GLdouble *> Combine_data;
|
||||
|
||||
extern "C" void CALLBACK myCombine(GLdouble coords[3], GLdouble *d[4],
|
||||
extern "C" {
|
||||
static void CALLBACK myCombine(GLdouble coords[3], GLdouble *d[4],
|
||||
GLfloat w[4], GLdouble **dataOut) {
|
||||
GLdouble *newCoords = new GLdouble[3];
|
||||
|
||||
|
@ -76,6 +79,7 @@ extern "C" void CALLBACK myCombine(GLdouble coords[3], GLdouble *d[4],
|
|||
Combine_data.push_back(newCoords);
|
||||
*dataOut = newCoords;
|
||||
}
|
||||
}
|
||||
|
||||
//===================================================================
|
||||
|
||||
|
|
|
@ -67,7 +67,7 @@ inline double doubleFromUlong1(TUINT32 hi, TUINT32 lo) {
|
|||
|
||||
/*=====================================================================*/
|
||||
|
||||
TThickPoint operator*(const TAffine &aff, const TThickPoint &p) {
|
||||
static TThickPoint operator*(const TAffine &aff, const TThickPoint &p) {
|
||||
TPointD p1(p.x, p.y);
|
||||
return TThickPoint(aff * p1, p.thick);
|
||||
}
|
||||
|
|
|
@ -277,7 +277,7 @@ TImageP TImageReaderPli::load() {
|
|||
|
||||
//===========================================================================
|
||||
|
||||
void readRegionVersion4x(IntersectionDataTag *tag, TVectorImage *img) {
|
||||
static void readRegionVersion4x(IntersectionDataTag *tag, TVectorImage *img) {
|
||||
#ifndef NEW_REGION_FILL
|
||||
img->setFillData(tag->m_branchArray, tag->m_branchCount);
|
||||
#endif
|
||||
|
@ -316,7 +316,7 @@ void createStroke(ThickQuadraticChainTag *quadTag, TVectorImage *outVectImage,
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void createGroup(GroupTag *groupTag, TVectorImage *vi, CreateStrokeData &data) {
|
||||
static void createGroup(GroupTag *groupTag, TVectorImage *vi, CreateStrokeData &data) {
|
||||
int count = vi->getStrokeCount();
|
||||
for (int j = 0; j < groupTag->m_numObjects; j++) {
|
||||
if (groupTag->m_object[j]->m_type == PliTag::COLOR_NGOBJ)
|
||||
|
@ -443,7 +443,7 @@ TImageWriterPli::TImageWriterPli(const TFilePath &f, const TFrameId &frameId,
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void putStroke(TStroke *stroke, int &currStyleId,
|
||||
static void putStroke(TStroke *stroke, int &currStyleId,
|
||||
std::vector<PliObjectTag *> &tags) {
|
||||
double maxThickness = 0;
|
||||
assert(stroke);
|
||||
|
|
|
@ -7,6 +7,7 @@
|
|||
|
||||
#include "tlevel_io.h"
|
||||
|
||||
class GroupTag;
|
||||
class ParsedPli;
|
||||
class ImageTag;
|
||||
class TImageWriterPli;
|
||||
|
@ -149,4 +150,9 @@ private:
|
|||
TLevelReaderPli *m_lrp;
|
||||
};
|
||||
|
||||
// Functions
|
||||
|
||||
TPalette *readPalette(GroupTag *paletteTag, int majorVersion,
|
||||
int minorVersion);
|
||||
|
||||
#endif // TTIO_PLI_INCLUDED
|
||||
|
|
|
@ -20,9 +20,9 @@ using namespace std;
|
|||
|
||||
extern "C" {
|
||||
|
||||
void tnz_abort(jmp_buf, int) {}
|
||||
static void tnz_abort(jmp_buf, int) {}
|
||||
|
||||
void tnz_error_fun(png_structp pngPtr, png_const_charp error_message) {
|
||||
static void tnz_error_fun(png_structp pngPtr, png_const_charp error_message) {
|
||||
*(int *)png_get_error_ptr(pngPtr) = 0;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -722,7 +722,7 @@ static TINT32 img_rle_compact(unsigned short *expbuf, int ibpp,
|
|||
|
||||
/*-----------------------------------------------------------------------------*/
|
||||
|
||||
void iclose(IMAGERGB *image) {
|
||||
static void iclose(IMAGERGB *image) {
|
||||
TINT32 tablesize;
|
||||
|
||||
iflush(image);
|
||||
|
|
|
@ -1809,7 +1809,7 @@ TLevelWriterSvg::TLevelWriterSvg(const TFilePath &path, TPropertyGroup *winfo)
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void writeRegion(TRegion *r, TPalette *plt, QTextStream &out, double ly) {
|
||||
static void writeRegion(TRegion *r, TPalette *plt, QTextStream &out, double ly) {
|
||||
if (r->getEdgeCount() == 0) return;
|
||||
std::vector<const TQuadratic *> quadsOutline;
|
||||
|
||||
|
@ -1872,7 +1872,7 @@ void writeRegion(TRegion *r, TPalette *plt, QTextStream &out, double ly) {
|
|||
|
||||
//--------------------------------------------------------------------------------------
|
||||
|
||||
void writeOutlineStroke(TStroke *s, TPalette *plt, QTextStream &out, double ly,
|
||||
static void writeOutlineStroke(TStroke *s, TPalette *plt, QTextStream &out, double ly,
|
||||
double quality) {
|
||||
if (s->getChunkCount() == 0) return;
|
||||
if (s->getMaxThickness() == 0) return;
|
||||
|
@ -1898,7 +1898,7 @@ void writeOutlineStroke(TStroke *s, TPalette *plt, QTextStream &out, double ly,
|
|||
|
||||
//----------------------------------------------------------
|
||||
|
||||
double computeAverageThickness(const TStroke *s) {
|
||||
static double computeAverageThickness(const TStroke *s) {
|
||||
int count = s->getControlPointCount();
|
||||
|
||||
double resThick = 0;
|
||||
|
@ -1914,7 +1914,7 @@ double computeAverageThickness(const TStroke *s) {
|
|||
|
||||
//----------------------------------------------------------------
|
||||
|
||||
void writeCenterlineStroke(TStroke *s, TPalette *plt, QTextStream &out,
|
||||
static void writeCenterlineStroke(TStroke *s, TPalette *plt, QTextStream &out,
|
||||
double ly) {
|
||||
if (s->getChunkCount() == 0) return;
|
||||
if (s->getMaxThickness() == 0) return;
|
||||
|
|
|
@ -70,7 +70,7 @@ struct TgaHeader {
|
|||
|
||||
//============================================================
|
||||
|
||||
void readTgaHeader(TgaHeader &header, FILE *chan) {
|
||||
static void readTgaHeader(TgaHeader &header, FILE *chan) {
|
||||
header.IdentificationField = fgetc(chan);
|
||||
header.ColorMapType = fgetc(chan);
|
||||
header.ImageTypeCode = fgetc(chan);
|
||||
|
@ -87,7 +87,7 @@ void readTgaHeader(TgaHeader &header, FILE *chan) {
|
|||
|
||||
//------------------------------------------------------------
|
||||
|
||||
void writeTgaHeader(TgaHeader &header, FILE *chan) {
|
||||
static void writeTgaHeader(TgaHeader &header, FILE *chan) {
|
||||
fputc(header.IdentificationField, chan);
|
||||
fputc(header.ColorMapType, chan);
|
||||
fputc(header.ImageTypeCode, chan);
|
||||
|
|
|
@ -42,15 +42,15 @@ char *reverse(char *buffer, int size) {
|
|||
}
|
||||
}
|
||||
|
||||
int tfwrite(const char *data, const unsigned int count, FILE *f) {
|
||||
static int tfwrite(const char *data, const unsigned int count, FILE *f) {
|
||||
return fwrite(data, sizeof(char), count, f);
|
||||
}
|
||||
|
||||
int tfwrite(UCHAR *data, const unsigned int count, FILE *f) {
|
||||
static int tfwrite(UCHAR *data, const unsigned int count, FILE *f) {
|
||||
return fwrite(data, sizeof(char), count, f);
|
||||
}
|
||||
|
||||
int tfwrite(TINT32 *data, const unsigned int count, FILE *f) {
|
||||
static int tfwrite(TINT32 *data, const unsigned int count, FILE *f) {
|
||||
if (count == 1) {
|
||||
#if !TNZ_LITTLE_ENDIAN
|
||||
TUINT32 dataToWrite = swapTINT32(*data);
|
||||
|
@ -63,7 +63,7 @@ int tfwrite(TINT32 *data, const unsigned int count, FILE *f) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int tfwrite(TUINT32 *data, const unsigned int count, FILE *f) {
|
||||
static int tfwrite(TUINT32 *data, const unsigned int count, FILE *f) {
|
||||
if (count == 1) {
|
||||
#if !TNZ_LITTLE_ENDIAN
|
||||
TUINT32 dataToWrite = swapTINT32(*data);
|
||||
|
@ -76,7 +76,7 @@ int tfwrite(TUINT32 *data, const unsigned int count, FILE *f) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int tfwrite(double *data, unsigned int count, FILE *f) {
|
||||
static int tfwrite(double *data, unsigned int count, FILE *f) {
|
||||
if (count == 1) {
|
||||
double v = *data;
|
||||
char *ptr = (char *)&v;
|
||||
|
@ -286,7 +286,7 @@ bool readHeaderAndOffsets(FILE *chan, TzlOffsetMap &frameOffsTable,
|
|||
}
|
||||
}
|
||||
|
||||
bool adjustIconAspectRatio(TDimension &outDimension, TDimension inDimension,
|
||||
static bool adjustIconAspectRatio(TDimension &outDimension, TDimension inDimension,
|
||||
TDimension imageRes) {
|
||||
TINT32 iconLx = inDimension.lx, iconLy = inDimension.ly;
|
||||
assert(iconLx > 0 && iconLy > 0);
|
||||
|
@ -305,7 +305,7 @@ bool adjustIconAspectRatio(TDimension &outDimension, TDimension inDimension,
|
|||
return true;
|
||||
}
|
||||
|
||||
void getThumbnail(TRasterP ras, int shrink, TRasterP &thumbnail) {
|
||||
static void getThumbnail(TRasterP ras, int shrink, TRasterP &thumbnail) {
|
||||
int j = 0;
|
||||
int y = 0;
|
||||
TPixel32 *pix2 = (TPixel32 *)thumbnail->getRawData();
|
||||
|
@ -1995,7 +1995,7 @@ TImageP TImageReaderTzl::load13() {
|
|||
}
|
||||
|
||||
// Restituisce la regione del raster shrinkata e la relativa savebox.
|
||||
TRect applyShrinkAndRegion(TRasterP &ras, int shrink, TRect region,
|
||||
static TRect applyShrinkAndRegion(TRasterP &ras, int shrink, TRect region,
|
||||
TRect savebox) {
|
||||
// estraggo la regione solo se essa ha coordinate valide.
|
||||
if (!region.isEmpty() && region != TRect() && region.getLx() > 0 &&
|
||||
|
|
|
@ -76,7 +76,7 @@ PltReader::~PltReader() { delete m_stripBuffer; }
|
|||
|
||||
//------------------------------------------------------------
|
||||
|
||||
int decode_group_name(char group_name[], char **name, int *key,
|
||||
static int decode_group_name(char group_name[], char **name, int *key,
|
||||
int *sister_index) {
|
||||
char *s, *t;
|
||||
*key = 0;
|
||||
|
|
|
@ -156,6 +156,10 @@ public:
|
|||
std::string getValueAlias(double frame, int precision) override;
|
||||
};
|
||||
|
||||
DV_IMPORT_API void splitSpeedInOutSegment(TDoubleKeyframe &k,
|
||||
TDoubleKeyframe &k0,
|
||||
TDoubleKeyframe &k1);
|
||||
|
||||
//---------------------------------------------------------
|
||||
|
||||
DEFINE_PARAM_SMARTPOINTER(TDoubleParam, double)
|
||||
|
|
|
@ -172,6 +172,8 @@ updateTable(sampleCount);
|
|||
}
|
||||
};
|
||||
|
||||
DVAPI TSpectrumT<TPixel64> convert(const TSpectrumT<TPixel32> &s);
|
||||
|
||||
#ifdef _WIN32
|
||||
template class DVAPI TSpectrumT<TPixel32>;
|
||||
template class DVAPI TSpectrumT<TPixel64>;
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
#include "tsound_t.h"
|
||||
#include "tsystem.h"
|
||||
#include "tfilepath_io.h"
|
||||
#include "tfilepath_io.h"
|
||||
#include "tsioutils.h"
|
||||
#include <math.h>
|
||||
|
||||
#define DEFAULT_OFFSET 0
|
||||
|
@ -21,7 +21,6 @@ TNZ_LITTLE_ENDIAN undefined !!
|
|||
|
||||
using namespace std;
|
||||
|
||||
void swapAndCopySamples(short *srcBuffer, short *dstBuffer, TINT32 sampleCount);
|
||||
|
||||
TUINT32 convertToLong(UCHAR *buffer);
|
||||
void storeFloat(unsigned char *buffer, TUINT32 value);
|
||||
|
@ -136,7 +135,7 @@ public:
|
|||
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
ostream &operator<<(ostream &os, const TCOMMChunk &commChunk) {
|
||||
static ostream &operator<<(ostream &os, const TCOMMChunk &commChunk) {
|
||||
commChunk.print(os);
|
||||
return os;
|
||||
}
|
||||
|
@ -191,7 +190,7 @@ public:
|
|||
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
ostream &operator<<(ostream &os, const TSSNDChunk &ssndChunk) {
|
||||
static ostream &operator<<(ostream &os, const TSSNDChunk &ssndChunk) {
|
||||
os << "name = '" << ssndChunk.m_name << endl;
|
||||
os << "length = '" << ssndChunk.m_length << endl;
|
||||
os << "offset = '" << (unsigned int)ssndChunk.m_offset << endl;
|
||||
|
@ -208,7 +207,7 @@ ostream &operator<<(ostream &os, const TSSNDChunk &ssndChunk) {
|
|||
|
||||
//==========================================================
|
||||
|
||||
void flipLong(unsigned char *ptrc) {
|
||||
static void flipLong(unsigned char *ptrc) {
|
||||
unsigned char val;
|
||||
|
||||
val = *(ptrc);
|
||||
|
@ -222,7 +221,7 @@ void flipLong(unsigned char *ptrc) {
|
|||
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
TUINT32 fetchLong(TUINT32 *ptrl) { return (*ptrl); }
|
||||
static TUINT32 fetchLong(TUINT32 *ptrl) { return (*ptrl); }
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
|
@ -249,7 +248,7 @@ TUINT32 convertToLong(UCHAR *buffer) {
|
|||
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
void storeLong(TUINT32 val, TUINT32 *ptr) { *ptr = val; }
|
||||
static void storeLong(TUINT32 val, TUINT32 *ptr) { *ptr = val; }
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
|
|
|
@ -2,6 +2,8 @@
|
|||
|
||||
#include "tcommon.h"
|
||||
|
||||
#include "tsioutils.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void swapAndCopySamples(short *srcBuffer, short *dstBuffer,
|
||||
TINT32 sampleCount) {
|
||||
|
|
9
toonz/sources/sound/tsioutils.h
Normal file
9
toonz/sources/sound/tsioutils.h
Normal file
|
@ -0,0 +1,9 @@
|
|||
#pragma once
|
||||
|
||||
#ifndef TSIOUTILS_INCLUDED
|
||||
#define TSIOUTILS_INCLUDED
|
||||
|
||||
void swapAndCopySamples(short *srcBuffer, short *dstBuffer,
|
||||
TINT32 sampleCount);
|
||||
|
||||
#endif
|
|
@ -11,7 +11,7 @@
|
|||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
void backlit(TRaster32P lighted, TRaster32P light, TRaster32P out, double blur,
|
||||
static void backlit(TRaster32P lighted, TRaster32P light, TRaster32P out, double blur,
|
||||
const TPixel &color, double fade, double scale) {
|
||||
assert(light && lighted && out);
|
||||
|
||||
|
@ -92,7 +92,7 @@ void backlit(TRaster32P lighted, TRaster32P light, TRaster32P out, double blur,
|
|||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
void backlit(TRaster64P lighted, TRaster64P light, TRaster64P out, double blur,
|
||||
static void backlit(TRaster64P lighted, TRaster64P light, TRaster64P out, double blur,
|
||||
const TPixel &color32, double fade, double scale) {
|
||||
assert(light && lighted && out);
|
||||
|
||||
|
|
|
@ -135,7 +135,7 @@ public:
|
|||
void doCompute(TTile &tile, double frame, const TRenderSettings &ri) override;
|
||||
};
|
||||
|
||||
double normalize_h(double h) {
|
||||
static double normalize_h(double h) {
|
||||
if (h < 0) h += 360;
|
||||
if (h > 360) h -= 360;
|
||||
return h;
|
||||
|
|
|
@ -4,6 +4,9 @@
|
|||
#include "traster.h"
|
||||
|
||||
#include "tspectrumparam.h"
|
||||
|
||||
#include "gradients.h"
|
||||
|
||||
//------------------------------------------------------------------
|
||||
|
||||
namespace {
|
||||
|
|
|
@ -1347,7 +1347,7 @@ void Iwa_Particles_Engine::fill_single_region(
|
|||
まだ出発していない粒子情報を初期化
|
||||
----------------------------------------------------------------*/
|
||||
|
||||
bool potentialLessThan(const ParticleOrigin &po1, const ParticleOrigin &po2) {
|
||||
static bool potentialLessThan(const ParticleOrigin &po1, const ParticleOrigin &po2) {
|
||||
return po1.potential < po2.potential;
|
||||
}
|
||||
|
||||
|
|
|
@ -326,7 +326,7 @@ void directionalBlur(TRasterPT<T> rout, TRasterPT<T> rin, const TPointD &blur,
|
|||
|
||||
} // namespace
|
||||
|
||||
void enlargeDir(TRectD &r, TPointD p, bool bidirectional) {
|
||||
static void enlargeDir(TRectD &r, TPointD p, bool bidirectional) {
|
||||
if (bidirectional) {
|
||||
r.x1 += fabs(p.x);
|
||||
r.x0 -= fabs(p.x);
|
||||
|
@ -345,7 +345,7 @@ void enlargeDir(TRectD &r, TPointD p, bool bidirectional) {
|
|||
}
|
||||
}
|
||||
|
||||
void reduceDir(TRectD &r, TPointD p, bool bidirectional) {
|
||||
static void reduceDir(TRectD &r, TPointD p, bool bidirectional) {
|
||||
if (bidirectional) {
|
||||
r.x1 -= fabs(p.x);
|
||||
r.x0 += fabs(p.x);
|
||||
|
|
|
@ -33,7 +33,7 @@
|
|||
Particles_Engine::Particles_Engine(ParticlesFx *parent, double frame)
|
||||
: m_parent(parent), m_frame(frame) {}
|
||||
|
||||
void printTime(TStopWatch &sw, std::string name) {
|
||||
static void printTime(TStopWatch &sw, std::string name) {
|
||||
std::ostrstream ss;
|
||||
ss << name << " : ";
|
||||
sw.print(ss);
|
||||
|
|
|
@ -428,7 +428,7 @@ void subdivision(const TPointD &p00, const TPointD &p10, const TPointD &p11,
|
|||
// ------------------------------------------------------------------------
|
||||
#define TINY 1.0e-20
|
||||
|
||||
int splitMatrix(double **a, int n, int *index) {
|
||||
static int splitMatrix(double **a, int n, int *index) {
|
||||
int i, imax = 0, j, k;
|
||||
double big, dum, sum, temp;
|
||||
double *vv, d;
|
||||
|
@ -488,7 +488,7 @@ int splitMatrix(double **a, int n, int *index) {
|
|||
|
||||
/*-----------------------------------------------------------------*/
|
||||
|
||||
void buildMatrixes(const FourPoints &ss, const FourPoints &dd, double **a,
|
||||
static void buildMatrixes(const FourPoints &ss, const FourPoints &dd, double **a,
|
||||
double *b) {
|
||||
int i;
|
||||
TPointD s[4], d[4];
|
||||
|
@ -515,7 +515,7 @@ void buildMatrixes(const FourPoints &ss, const FourPoints &dd, double **a,
|
|||
|
||||
/*-----------------------------------------------------------------*/
|
||||
|
||||
void computeSolutions(double **a, int *index, double *b) {
|
||||
static void computeSolutions(double **a, int *index, double *b) {
|
||||
int i, ii = 0, ip, j;
|
||||
double sum;
|
||||
|
||||
|
@ -538,7 +538,7 @@ void computeSolutions(double **a, int *index, double *b) {
|
|||
|
||||
/*-----------------------------------------------------------------*/
|
||||
|
||||
void solveSystems(double **a, double *bx) {
|
||||
static void solveSystems(double **a, double *bx) {
|
||||
int index[255], i, count = 0, bad_line;
|
||||
double **atmp;
|
||||
int n = 8;
|
||||
|
@ -568,7 +568,7 @@ void solveSystems(double **a, double *bx) {
|
|||
|
||||
/*-----------------------------------------------------------------*/
|
||||
|
||||
void computeTransformation(const FourPoints &s, const FourPoints &d,
|
||||
static void computeTransformation(const FourPoints &s, const FourPoints &d,
|
||||
TAffine &aff, TPointD &perspectDen) {
|
||||
double **a, *b;
|
||||
|
||||
|
|
|
@ -687,4 +687,7 @@ return &info;
|
|||
|
||||
*/
|
||||
|
||||
/* TODO, move to header */
|
||||
DV_EXPORT_API void initStdFx();
|
||||
|
||||
DV_EXPORT_API void initStdFx() {}
|
||||
|
|
|
@ -61,4 +61,6 @@ public:
|
|||
|
||||
bool isAlmostIsotropic(const TAffine &aff);
|
||||
|
||||
DV_EXPORT_API void initStdFx();
|
||||
|
||||
#endif
|
||||
|
|
|
@ -195,7 +195,7 @@ TFilePath setToonzFolder(const TFilePath &filename, std::string toonzVar) {
|
|||
|
||||
//==============================================================================================
|
||||
|
||||
void prepareToCleanup(TXshSimpleLevel *xl, TPalette *cleanupPalette) {
|
||||
static void prepareToCleanup(TXshSimpleLevel *xl, TPalette *cleanupPalette) {
|
||||
assert(xl->getScene());
|
||||
if (xl->getProperties()->getSubsampling() != 1) {
|
||||
xl->getProperties()->setSubsampling(1);
|
||||
|
@ -241,7 +241,7 @@ string TaskId;
|
|||
//
|
||||
//------------------------------------------------------------------------
|
||||
|
||||
void searchLevelsToCleanup(
|
||||
static void searchLevelsToCleanup(
|
||||
std::vector<std::pair<TXshSimpleLevel *, std::set<TFrameId>>> &levels,
|
||||
TXsheet *xsh, bool selectedOnly) {
|
||||
std::map<wstring, TXshSimpleLevel *> levelTable;
|
||||
|
@ -308,7 +308,7 @@ void searchLevelsToCleanup(
|
|||
|
||||
//------------------------------------------------------------------------------
|
||||
/*- CleanupDefaultパレットを追加する -*/
|
||||
void addCleanupDefaultPalette(TXshSimpleLevel *sl) {
|
||||
static void addCleanupDefaultPalette(TXshSimpleLevel *sl) {
|
||||
/*- 元となるパレットはStudioPaletteフォルダに置く -*/
|
||||
TFilePath palettePath =
|
||||
ToonzFolder::getStudioPaletteFolder() + "cleanup_default.tpl";
|
||||
|
@ -384,7 +384,7 @@ void addCleanupDefaultPalette(TXshSimpleLevel *sl) {
|
|||
//
|
||||
//------------------------------------------------------------------------
|
||||
|
||||
void cleanupLevel(TXshSimpleLevel *xl, std::set<TFrameId> fidsInXsheet,
|
||||
static void cleanupLevel(TXshSimpleLevel *xl, std::set<TFrameId> fidsInXsheet,
|
||||
ToonzScene *scene, bool overwrite,
|
||||
TUserLogAppend &m_userLog) {
|
||||
prepareToCleanup(xl, scene->getProperties()
|
||||
|
@ -847,4 +847,4 @@ namespace {
|
|||
const char *toonzVersion = "Toonz 7.1";
|
||||
} // namespace
|
||||
|
||||
string getToonzVersion() { return toonzVersion; }
|
||||
static string getToonzVersion() { return toonzVersion; }
|
||||
|
|
|
@ -394,7 +394,7 @@ bool MyMultimediaRenderListener::onFrameFailed(int frame, int column,
|
|||
|
||||
//==================================================================================
|
||||
|
||||
std::pair<int, int> generateMovie(ToonzScene *scene, const TFilePath &fp,
|
||||
static std::pair<int, int> generateMovie(ToonzScene *scene, const TFilePath &fp,
|
||||
int r0, int r1, int step, int shrink,
|
||||
int threadCount, int maxTileSize) {
|
||||
QWaitCondition renderCompleted;
|
||||
|
|
|
@ -18,8 +18,8 @@
|
|||
|
||||
using namespace TScannerUtil;
|
||||
|
||||
void sense(bool) {}
|
||||
int scsi_maxlen() {
|
||||
static void sense(bool) {}
|
||||
static int scsi_maxlen() {
|
||||
assert(0);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -9,15 +9,17 @@ using namespace TScannerUtil;
|
|||
|
||||
extern "C" {
|
||||
#include "../common/twain/ttwain_util.h"
|
||||
#include "../common/twain/ttwain_global_def.h" /* forward declare functions */
|
||||
}
|
||||
|
||||
/* callback used to handle TTWAIN done/error status*/
|
||||
|
||||
void throwIT(const char *msg) { throw TException(msg); }
|
||||
static void throwIT(const char *msg) { throw TException(msg); }
|
||||
|
||||
extern "C" void TTWAIN_ErrorBox(const char *msg) { throwIT(msg); }
|
||||
|
||||
extern "C" int onDoneCB(UCHAR *buffer, TTWAIN_PIXTYPE pixelType, int lx, int ly,
|
||||
extern "C" {
|
||||
static int onDoneCB(UCHAR *buffer, TTWAIN_PIXTYPE pixelType, int lx, int ly,
|
||||
int wrap, float xdpi, float ydpi, void *usrData) {
|
||||
TRasterP ras;
|
||||
switch (pixelType) {
|
||||
|
@ -69,13 +71,16 @@ extern "C" int onDoneCB(UCHAR *buffer, TTWAIN_PIXTYPE pixelType, int lx, int ly,
|
|||
scannerDevice->decrementPaperLeftCount();
|
||||
return scannerDevice->getPaperLeftCount();
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
extern "C" void onErrorCB(void *usrData, void *alwaysZero) {
|
||||
extern "C" {
|
||||
static void onErrorCB(void *usrData, void *alwaysZero) {
|
||||
TScanner *scannerDevice = reinterpret_cast<TScanner *>(usrData);
|
||||
scannerDevice->notifyError();
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
@ -218,7 +223,7 @@ param.m_version = string(TTWAIN_GetVersion());
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void setupParameters(const TScannerParameters ¶ms, bool isAreaSupported) {
|
||||
static void setupParameters(const TScannerParameters ¶ms, bool isAreaSupported) {
|
||||
if (isAreaSupported) {
|
||||
TRectD scanArea = params.getScanArea();
|
||||
float L = (float)(scanArea.getP00().x / 25.4);
|
||||
|
@ -259,7 +264,7 @@ void setupParameters(const TScannerParameters ¶ms, bool isAreaSupported) {
|
|||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
void openAndSetupTwain() {
|
||||
static void openAndSetupTwain() {
|
||||
int rc = TTWAIN_OpenDefaultSource();
|
||||
if (rc) {
|
||||
TTWAIN_SetTwainUsage(TTWAIN_MODE_UNLEASHED);
|
||||
|
|
|
@ -55,7 +55,7 @@ extern "C" {
|
|||
|
||||
//========================================================================================
|
||||
|
||||
void sum(int n, const double *x, double *&y) {
|
||||
static void sum(int n, const double *x, double *&y) {
|
||||
/*
|
||||
void cblas_daxpy(blasint n, double a, double *x, blasint incx, double *y,
|
||||
blasint incy);
|
||||
|
|
|
@ -89,7 +89,7 @@ TEnv::DoubleVar RasterBrushHardness("RasterBrushHardness", 100);
|
|||
// note: stroke is unchanged
|
||||
//
|
||||
|
||||
void split(TStroke *stroke, const std::vector<double> ¶meterValues,
|
||||
static void split(TStroke *stroke, const std::vector<double> ¶meterValues,
|
||||
std::vector<TStroke *> &strokes) {
|
||||
TThickPoint p2;
|
||||
std::vector<TThickPoint> points;
|
||||
|
@ -199,7 +199,7 @@ void split(TStroke *stroke, const std::vector<double> ¶meterValues,
|
|||
// Note: if the curve is a single point (that's dp=0) or it is a straight
|
||||
// line (that's ddp=0) return 0
|
||||
|
||||
double curvature(TPointD dp, TPointD ddp) {
|
||||
static double curvature(TPointD dp, TPointD ddp) {
|
||||
if (dp == TPointD(0, 0))
|
||||
return 0;
|
||||
else
|
||||
|
@ -217,7 +217,7 @@ double curvature(TPointD dp, TPointD ddp) {
|
|||
// Output:
|
||||
// parameterValues = vector of max curvature parameter points
|
||||
|
||||
void findMaxCurvPoints(TStroke *stroke, const float &angoloLim,
|
||||
static void findMaxCurvPoints(TStroke *stroke, const float &angoloLim,
|
||||
const float &curvMaxLim,
|
||||
std::vector<double> ¶meterValues) {
|
||||
TPointD tg1, tg2; // Tangent vectors
|
||||
|
@ -320,7 +320,7 @@ void findMaxCurvPoints(TStroke *stroke, const float &angoloLim,
|
|||
}
|
||||
}
|
||||
|
||||
void addStroke(TTool::Application *application, const TVectorImageP &vi,
|
||||
static void addStroke(TTool::Application *application, const TVectorImageP &vi,
|
||||
TStroke *stroke, bool breakAngles, bool frameCreated,
|
||||
bool levelCreated) {
|
||||
QMutexLocker lock(vi->getMutex());
|
||||
|
|
|
@ -65,7 +65,7 @@ TEnv::IntVar GeometricMiterValue("InknpaintGeometricMiterValue", 4);
|
|||
// Utility Functions
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
TPointD rectify(const TPointD &oldPos, const TPointD &pos) {
|
||||
static TPointD rectify(const TPointD &oldPos, const TPointD &pos) {
|
||||
const double h = sqrt(2.0) / 2.0;
|
||||
const TPointD directions[] = {TPointD(1, 0), TPointD(h, h), TPointD(0, 1),
|
||||
TPointD(-h, h), TPointD(-1, 0), TPointD(-h, -h),
|
||||
|
@ -85,14 +85,14 @@ TPointD rectify(const TPointD &oldPos, const TPointD &pos) {
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
TPointD computeSpeed(TPointD p0, TPointD p1, double factor) {
|
||||
static TPointD computeSpeed(TPointD p0, TPointD p1, double factor) {
|
||||
TPointD d = p1 - p0;
|
||||
return (d == TPointD()) ? TPointD() : d * (factor / norm(d));
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
TRect drawBluredBrush(const TRasterImageP &ri, TStroke *stroke, int thick,
|
||||
static TRect drawBluredBrush(const TRasterImageP &ri, TStroke *stroke, int thick,
|
||||
double hardness, double opacity) {
|
||||
TStroke *s = new TStroke(*stroke);
|
||||
TPointD riCenter = ri->getRaster()->getCenterD();
|
||||
|
@ -135,7 +135,7 @@ TRect drawBluredBrush(const TRasterImageP &ri, TStroke *stroke, int thick,
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
TRect drawBluredBrush(const TToonzImageP &ti, TStroke *stroke, int thick,
|
||||
static TRect drawBluredBrush(const TToonzImageP &ti, TStroke *stroke, int thick,
|
||||
double hardness, bool selective) {
|
||||
TStroke *s = new TStroke(*stroke);
|
||||
TPointD riCenter = ti->getRaster()->getCenterD();
|
||||
|
|
|
@ -616,7 +616,7 @@ refStroke, count, refStroke+count)>commonDepth(vimg, refStroke, count, prev))
|
|||
if(count==0) return;
|
||||
*/
|
||||
|
||||
int doMoveGroup(UCHAR moveType, TVectorImage *vimg,
|
||||
static int doMoveGroup(UCHAR moveType, TVectorImage *vimg,
|
||||
const std::vector<std::pair<TStroke *, int>> &selectedGroups,
|
||||
int index) {
|
||||
int refStroke = vimg->getStrokeIndex(selectedGroups[index].first);
|
||||
|
|
|
@ -1682,7 +1682,7 @@ void drawFullSquare(const TPointD &pos, double radius) {
|
|||
|
||||
//------------------------------------------------------------------------
|
||||
|
||||
void drawFilledSquare(const TPointD &pos, double radius) {
|
||||
static void drawFilledSquare(const TPointD &pos, double radius) {
|
||||
glBegin(GL_QUADS);
|
||||
glVertex2d(pos.x - radius, pos.y - radius);
|
||||
glVertex2d(pos.x + radius, pos.y - radius);
|
||||
|
@ -1693,7 +1693,7 @@ void drawFilledSquare(const TPointD &pos, double radius) {
|
|||
|
||||
//------------------------------------------------------------------------
|
||||
|
||||
void drawHandle(const TPointD &pos, double radius, const TPixel32 &color) {
|
||||
static void drawHandle(const TPointD &pos, double radius, const TPixel32 &color) {
|
||||
glColor4ub(0, 0, 0, color.m); // Black border
|
||||
glLineWidth(4.0f);
|
||||
drawSquare(pos, radius);
|
||||
|
@ -1705,7 +1705,7 @@ void drawHandle(const TPointD &pos, double radius, const TPixel32 &color) {
|
|||
|
||||
//------------------------------------------------------------------------
|
||||
|
||||
void drawFilledHandle(const TPointD &pos, double radius, double pixelSize,
|
||||
static void drawFilledHandle(const TPointD &pos, double radius, double pixelSize,
|
||||
const TPixel32 &color) {
|
||||
glColor4ub(0, 0, 0, color.m);
|
||||
drawFilledSquare(pos, radius + pixelSize);
|
||||
|
@ -1716,7 +1716,7 @@ void drawFilledHandle(const TPointD &pos, double radius, double pixelSize,
|
|||
|
||||
//------------------------------------------------------------------------
|
||||
|
||||
void drawText(const TPointD &pos, const QString &text, double fontScale) {
|
||||
static void drawText(const TPointD &pos, const QString &text, double fontScale) {
|
||||
// Get the world-to-window affine
|
||||
double matrix[16];
|
||||
|
||||
|
|
|
@ -155,7 +155,7 @@ struct Closer {
|
|||
|
||||
//==============================================================================
|
||||
|
||||
std::pair<double, int> closestVertex(const TTextureMesh &mesh,
|
||||
static std::pair<double, int> closestVertex(const TTextureMesh &mesh,
|
||||
const TPointD &pos) {
|
||||
Closer closer = {mesh, pos};
|
||||
int vIdx = int(
|
||||
|
@ -167,7 +167,7 @@ std::pair<double, int> closestVertex(const TTextureMesh &mesh,
|
|||
|
||||
//------------------------------------------------------------------------
|
||||
|
||||
std::pair<double, int> closestEdge(const TTextureMesh &mesh,
|
||||
static std::pair<double, int> closestEdge(const TTextureMesh &mesh,
|
||||
const TPointD &pos) {
|
||||
Closer closer = {mesh, pos};
|
||||
int eIdx =
|
||||
|
|
|
@ -80,7 +80,7 @@ inline std::string removeTrailingH(std::string handle) {
|
|||
|
||||
// return true iff column ancestorIndex is column descentIndex or its parent or
|
||||
// the parent of the parent, etc.
|
||||
bool isAncestorOf(int ancestorIndex, int descendentIndex) {
|
||||
static bool isAncestorOf(int ancestorIndex, int descendentIndex) {
|
||||
TStageObjectId ancestorId = TStageObjectId::ColumnId(ancestorIndex);
|
||||
TStageObjectId descendentId = TStageObjectId::ColumnId(descendentIndex);
|
||||
TXsheet *xsh = TTool::getApplication()->getCurrentXsheet()->getXsheet();
|
||||
|
@ -91,7 +91,7 @@ bool isAncestorOf(int ancestorIndex, int descendentIndex) {
|
|||
|
||||
//------------------------------------------------------------
|
||||
|
||||
void getHooks(std::vector<HookData> &hooks, TXsheet *xsh, int row, int col,
|
||||
static void getHooks(std::vector<HookData> &hooks, TXsheet *xsh, int row, int col,
|
||||
TPointD dpiScale) {
|
||||
// nota. hook position is in the coordinate system of the parent object.
|
||||
// a inch is Stage::inch
|
||||
|
@ -138,7 +138,7 @@ void getHooks(std::vector<HookData> &hooks, TXsheet *xsh, int row, int col,
|
|||
|
||||
//-------------------------------------------------------------------
|
||||
|
||||
void getConnectedColumns(std::set<int> &connectedColumns, TXsheet *xsh,
|
||||
static void getConnectedColumns(std::set<int> &connectedColumns, TXsheet *xsh,
|
||||
int col) {
|
||||
TStageObjectId id;
|
||||
// insert col and all column ancestors
|
||||
|
@ -165,7 +165,7 @@ void getConnectedColumns(std::set<int> &connectedColumns, TXsheet *xsh,
|
|||
}
|
||||
}
|
||||
|
||||
bool canShowBone(Skeleton::Bone *bone, TXsheet *xsh, int row) {
|
||||
static bool canShowBone(Skeleton::Bone *bone, TXsheet *xsh, int row) {
|
||||
TStageObjectId id = bone->getStageObject()->getId();
|
||||
if (!xsh->getCell(row, id.getIndex()).isEmpty() &&
|
||||
xsh->getColumn(id.getIndex())->isCamstandVisible())
|
||||
|
|
|
@ -103,7 +103,7 @@ void ToolHandle::setToolBusy(bool value) {
|
|||
|
||||
QIcon currentIcon;
|
||||
|
||||
QIcon getCurrentIcon() { return currentIcon; }
|
||||
static QIcon getCurrentIcon() { return currentIcon; }
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
|
|
@ -849,7 +849,7 @@ void TrackerTool::onDeactivate() {
|
|||
|
||||
//=============================================================================
|
||||
|
||||
TTool *getTrackerToolTool() { return &trackerTool; }
|
||||
static TTool *getTrackerToolTool() { return &trackerTool; }
|
||||
|
||||
//=============================================================================
|
||||
|
||||
|
|
|
@ -1645,7 +1645,7 @@ void TypeTool::onImageChanged() { stopEditing(); }
|
|||
|
||||
//=========================================================
|
||||
|
||||
TTool *getTypeTool() { return &typeTool; }
|
||||
static TTool *getTypeTool() { return &typeTool; }
|
||||
|
||||
/*void resetTypetTool(TTool*tool)
|
||||
{
|
||||
|
|
|
@ -9,10 +9,6 @@
|
|||
#include <QString>
|
||||
#include <map>
|
||||
|
||||
DV_IMPORT_API void splitSpeedInOutSegment(TDoubleKeyframe &k,
|
||||
TDoubleKeyframe &k0,
|
||||
TDoubleKeyframe &k1);
|
||||
|
||||
//=============================================================================
|
||||
//
|
||||
// Keyframes Undo
|
||||
|
|
|
@ -24,6 +24,7 @@
|
|||
#include "SDef.h"
|
||||
#include "CallCircle.h"
|
||||
#include "CallParam.h"
|
||||
#include "calligraph.h"
|
||||
//#include "tmsg.h"
|
||||
|
||||
using namespace std;
|
||||
|
|
|
@ -38,6 +38,7 @@
|
|||
#include "toonz/levelset.h"
|
||||
#include "toonz/txshchildlevel.h"
|
||||
#include "toonz/fxdag.h"
|
||||
#include "toonz/tcolumnfx.h"
|
||||
#include "toonz/tcolumnfxset.h"
|
||||
#include "toonz/stage.h"
|
||||
#include "toonz/fill.h"
|
||||
|
|
Loading…
Reference in a new issue